@aws-sdk/client-redshift 3.34.0 → 3.37.0

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

@@ -0,0 +1,3641 @@
+import { MetadataBearer as $MetadataBearer, SmithyException as __SmithyException } from "@aws-sdk/types";
+export interface AcceptReservedNodeExchangeInputMessage {
+    
+    ReservedNodeId: string | undefined;
+    
+    TargetReservedNodeOfferingId: string | undefined;
+}
+export declare namespace AcceptReservedNodeExchangeInputMessage {
+    
+    const filterSensitiveLog: (obj: AcceptReservedNodeExchangeInputMessage) => any;
+}
+
+export interface RecurringCharge {
+    
+    RecurringChargeAmount?: number;
+    
+    RecurringChargeFrequency?: string;
+}
+export declare namespace RecurringCharge {
+    
+    const filterSensitiveLog: (obj: RecurringCharge) => any;
+}
+export declare type ReservedNodeOfferingType = "Regular" | "Upgradable";
+
+export interface ReservedNode {
+    
+    ReservedNodeId?: string;
+    
+    ReservedNodeOfferingId?: string;
+    
+    NodeType?: string;
+    
+    StartTime?: Date;
+    
+    Duration?: number;
+    
+    FixedPrice?: number;
+    
+    UsagePrice?: number;
+    
+    CurrencyCode?: string;
+    
+    NodeCount?: number;
+    
+    State?: string;
+    
+    OfferingType?: string;
+    
+    RecurringCharges?: RecurringCharge[];
+    
+    ReservedNodeOfferingType?: ReservedNodeOfferingType | string;
+}
+export declare namespace ReservedNode {
+    
+    const filterSensitiveLog: (obj: ReservedNode) => any;
+}
+export interface AcceptReservedNodeExchangeOutputMessage {
+    
+    ExchangedReservedNode?: ReservedNode;
+}
+export declare namespace AcceptReservedNodeExchangeOutputMessage {
+    
+    const filterSensitiveLog: (obj: AcceptReservedNodeExchangeOutputMessage) => any;
+}
+
+export interface DependentServiceUnavailableFault extends __SmithyException, $MetadataBearer {
+    name: "DependentServiceUnavailableFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace DependentServiceUnavailableFault {
+    
+    const filterSensitiveLog: (obj: DependentServiceUnavailableFault) => any;
+}
+
+export interface InvalidReservedNodeStateFault extends __SmithyException, $MetadataBearer {
+    name: "InvalidReservedNodeStateFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace InvalidReservedNodeStateFault {
+    
+    const filterSensitiveLog: (obj: InvalidReservedNodeStateFault) => any;
+}
+
+export interface ReservedNodeAlreadyExistsFault extends __SmithyException, $MetadataBearer {
+    name: "ReservedNodeAlreadyExistsFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace ReservedNodeAlreadyExistsFault {
+    
+    const filterSensitiveLog: (obj: ReservedNodeAlreadyExistsFault) => any;
+}
+
+export interface ReservedNodeAlreadyMigratedFault extends __SmithyException, $MetadataBearer {
+    name: "ReservedNodeAlreadyMigratedFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace ReservedNodeAlreadyMigratedFault {
+    
+    const filterSensitiveLog: (obj: ReservedNodeAlreadyMigratedFault) => any;
+}
+
+export interface ReservedNodeNotFoundFault extends __SmithyException, $MetadataBearer {
+    name: "ReservedNodeNotFoundFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace ReservedNodeNotFoundFault {
+    
+    const filterSensitiveLog: (obj: ReservedNodeNotFoundFault) => any;
+}
+
+export interface ReservedNodeOfferingNotFoundFault extends __SmithyException, $MetadataBearer {
+    name: "ReservedNodeOfferingNotFoundFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace ReservedNodeOfferingNotFoundFault {
+    
+    const filterSensitiveLog: (obj: ReservedNodeOfferingNotFoundFault) => any;
+}
+
+export interface UnsupportedOperationFault extends __SmithyException, $MetadataBearer {
+    name: "UnsupportedOperationFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace UnsupportedOperationFault {
+    
+    const filterSensitiveLog: (obj: UnsupportedOperationFault) => any;
+}
+
+export interface AccessToClusterDeniedFault extends __SmithyException, $MetadataBearer {
+    name: "AccessToClusterDeniedFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace AccessToClusterDeniedFault {
+    
+    const filterSensitiveLog: (obj: AccessToClusterDeniedFault) => any;
+}
+
+export interface AccessToSnapshotDeniedFault extends __SmithyException, $MetadataBearer {
+    name: "AccessToSnapshotDeniedFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace AccessToSnapshotDeniedFault {
+    
+    const filterSensitiveLog: (obj: AccessToSnapshotDeniedFault) => any;
+}
+
+export interface AttributeValueTarget {
+    
+    AttributeValue?: string;
+}
+export declare namespace AttributeValueTarget {
+    
+    const filterSensitiveLog: (obj: AttributeValueTarget) => any;
+}
+
+export interface AccountAttribute {
+    
+    AttributeName?: string;
+    
+    AttributeValues?: AttributeValueTarget[];
+}
+export declare namespace AccountAttribute {
+    
+    const filterSensitiveLog: (obj: AccountAttribute) => any;
+}
+export interface AccountAttributeList {
+    
+    AccountAttributes?: AccountAttribute[];
+}
+export declare namespace AccountAttributeList {
+    
+    const filterSensitiveLog: (obj: AccountAttributeList) => any;
+}
+
+export interface AccountWithRestoreAccess {
+    
+    AccountId?: string;
+    
+    AccountAlias?: string;
+}
+export declare namespace AccountWithRestoreAccess {
+    
+    const filterSensitiveLog: (obj: AccountWithRestoreAccess) => any;
+}
+export declare enum ActionType {
+    RECOMMEND_NODE_CONFIG = "recommend-node-config",
+    RESIZE_CLUSTER = "resize-cluster",
+    RESTORE_CLUSTER = "restore-cluster"
+}
+
+export interface ClusterNotFoundFault extends __SmithyException, $MetadataBearer {
+    name: "ClusterNotFoundFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace ClusterNotFoundFault {
+    
+    const filterSensitiveLog: (obj: ClusterNotFoundFault) => any;
+}
+export interface PartnerIntegrationInputMessage {
+    
+    AccountId: string | undefined;
+    
+    ClusterIdentifier: string | undefined;
+    
+    DatabaseName: string | undefined;
+    
+    PartnerName: string | undefined;
+}
+export declare namespace PartnerIntegrationInputMessage {
+    
+    const filterSensitiveLog: (obj: PartnerIntegrationInputMessage) => any;
+}
+export interface PartnerIntegrationOutputMessage {
+    
+    DatabaseName?: string;
+    
+    PartnerName?: string;
+}
+export declare namespace PartnerIntegrationOutputMessage {
+    
+    const filterSensitiveLog: (obj: PartnerIntegrationOutputMessage) => any;
+}
+
+export interface PartnerNotFoundFault extends __SmithyException, $MetadataBearer {
+    name: "PartnerNotFoundFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace PartnerNotFoundFault {
+    
+    const filterSensitiveLog: (obj: PartnerNotFoundFault) => any;
+}
+
+export interface UnauthorizedPartnerIntegrationFault extends __SmithyException, $MetadataBearer {
+    name: "UnauthorizedPartnerIntegrationFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace UnauthorizedPartnerIntegrationFault {
+    
+    const filterSensitiveLog: (obj: UnauthorizedPartnerIntegrationFault) => any;
+}
+export declare enum AquaConfigurationStatus {
+    AUTO = "auto",
+    DISABLED = "disabled",
+    ENABLED = "enabled"
+}
+export declare enum AquaStatus {
+    APPLYING = "applying",
+    DISABLED = "disabled",
+    ENABLED = "enabled"
+}
+
+export interface AquaConfiguration {
+    
+    AquaStatus?: AquaStatus | string;
+    
+    AquaConfigurationStatus?: AquaConfigurationStatus | string;
+}
+export declare namespace AquaConfiguration {
+    
+    const filterSensitiveLog: (obj: AquaConfiguration) => any;
+}
+export interface AssociateDataShareConsumerMessage {
+    
+    DataShareArn: string | undefined;
+    
+    AssociateEntireAccount?: boolean;
+    
+    ConsumerArn?: string;
+}
+export declare namespace AssociateDataShareConsumerMessage {
+    
+    const filterSensitiveLog: (obj: AssociateDataShareConsumerMessage) => any;
+}
+export declare enum DataShareStatus {
+    ACTIVE = "ACTIVE",
+    AUTHORIZED = "AUTHORIZED",
+    AVAILABLE = "AVAILABLE",
+    DEAUTHORIZED = "DEAUTHORIZED",
+    PENDING_AUTHORIZATION = "PENDING_AUTHORIZATION",
+    REJECTED = "REJECTED"
+}
+
+export interface DataShareAssociation {
+    
+    ConsumerIdentifier?: string;
+    
+    Status?: DataShareStatus | string;
+    
+    CreatedDate?: Date;
+    
+    StatusChangeDate?: Date;
+}
+export declare namespace DataShareAssociation {
+    
+    const filterSensitiveLog: (obj: DataShareAssociation) => any;
+}
+export interface DataShare {
+    
+    DataShareArn?: string;
+    
+    ProducerArn?: string;
+    
+    AllowPubliclyAccessibleConsumers?: boolean;
+    
+    DataShareAssociations?: DataShareAssociation[];
+}
+export declare namespace DataShare {
+    
+    const filterSensitiveLog: (obj: DataShare) => any;
+}
+
+export interface InvalidDataShareFault extends __SmithyException, $MetadataBearer {
+    name: "InvalidDataShareFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace InvalidDataShareFault {
+    
+    const filterSensitiveLog: (obj: InvalidDataShareFault) => any;
+}
+
+export interface InvalidNamespaceFault extends __SmithyException, $MetadataBearer {
+    name: "InvalidNamespaceFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace InvalidNamespaceFault {
+    
+    const filterSensitiveLog: (obj: InvalidNamespaceFault) => any;
+}
+export declare type ScheduleState = "ACTIVE" | "FAILED" | "MODIFYING";
+
+export interface ClusterAssociatedToSchedule {
+    
+    ClusterIdentifier?: string;
+    
+    ScheduleAssociationState?: ScheduleState | string;
+}
+export declare namespace ClusterAssociatedToSchedule {
+    
+    const filterSensitiveLog: (obj: ClusterAssociatedToSchedule) => any;
+}
+
+export interface AuthenticationProfile {
+    
+    AuthenticationProfileName?: string;
+    
+    AuthenticationProfileContent?: string;
+}
+export declare namespace AuthenticationProfile {
+    
+    const filterSensitiveLog: (obj: AuthenticationProfile) => any;
+}
+
+export interface AuthenticationProfileAlreadyExistsFault extends __SmithyException, $MetadataBearer {
+    name: "AuthenticationProfileAlreadyExistsFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace AuthenticationProfileAlreadyExistsFault {
+    
+    const filterSensitiveLog: (obj: AuthenticationProfileAlreadyExistsFault) => any;
+}
+
+export interface AuthenticationProfileNotFoundFault extends __SmithyException, $MetadataBearer {
+    name: "AuthenticationProfileNotFoundFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace AuthenticationProfileNotFoundFault {
+    
+    const filterSensitiveLog: (obj: AuthenticationProfileNotFoundFault) => any;
+}
+
+export interface AuthenticationProfileQuotaExceededFault extends __SmithyException, $MetadataBearer {
+    name: "AuthenticationProfileQuotaExceededFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace AuthenticationProfileQuotaExceededFault {
+    
+    const filterSensitiveLog: (obj: AuthenticationProfileQuotaExceededFault) => any;
+}
+
+export interface AuthorizationAlreadyExistsFault extends __SmithyException, $MetadataBearer {
+    name: "AuthorizationAlreadyExistsFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace AuthorizationAlreadyExistsFault {
+    
+    const filterSensitiveLog: (obj: AuthorizationAlreadyExistsFault) => any;
+}
+
+export interface AuthorizationNotFoundFault extends __SmithyException, $MetadataBearer {
+    name: "AuthorizationNotFoundFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace AuthorizationNotFoundFault {
+    
+    const filterSensitiveLog: (obj: AuthorizationNotFoundFault) => any;
+}
+
+export interface AuthorizationQuotaExceededFault extends __SmithyException, $MetadataBearer {
+    name: "AuthorizationQuotaExceededFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace AuthorizationQuotaExceededFault {
+    
+    const filterSensitiveLog: (obj: AuthorizationQuotaExceededFault) => any;
+}
+export declare enum AuthorizationStatus {
+    AUTHORIZED = "Authorized",
+    REVOKING = "Revoking"
+}
+
+export interface AuthorizeClusterSecurityGroupIngressMessage {
+    
+    ClusterSecurityGroupName: string | undefined;
+    
+    CIDRIP?: string;
+    
+    EC2SecurityGroupName?: string;
+    
+    EC2SecurityGroupOwnerId?: string;
+}
+export declare namespace AuthorizeClusterSecurityGroupIngressMessage {
+    
+    const filterSensitiveLog: (obj: AuthorizeClusterSecurityGroupIngressMessage) => any;
+}
+
+export interface Tag {
+    
+    Key?: string;
+    
+    Value?: string;
+}
+export declare namespace Tag {
+    
+    const filterSensitiveLog: (obj: Tag) => any;
+}
+
+export interface EC2SecurityGroup {
+    
+    Status?: string;
+    
+    EC2SecurityGroupName?: string;
+    
+    EC2SecurityGroupOwnerId?: string;
+    
+    Tags?: Tag[];
+}
+export declare namespace EC2SecurityGroup {
+    
+    const filterSensitiveLog: (obj: EC2SecurityGroup) => any;
+}
+
+export interface IPRange {
+    
+    Status?: string;
+    
+    CIDRIP?: string;
+    
+    Tags?: Tag[];
+}
+export declare namespace IPRange {
+    
+    const filterSensitiveLog: (obj: IPRange) => any;
+}
+
+export interface ClusterSecurityGroup {
+    
+    ClusterSecurityGroupName?: string;
+    
+    Description?: string;
+    
+    EC2SecurityGroups?: EC2SecurityGroup[];
+    
+    IPRanges?: IPRange[];
+    
+    Tags?: Tag[];
+}
+export declare namespace ClusterSecurityGroup {
+    
+    const filterSensitiveLog: (obj: ClusterSecurityGroup) => any;
+}
+export interface AuthorizeClusterSecurityGroupIngressResult {
+    
+    ClusterSecurityGroup?: ClusterSecurityGroup;
+}
+export declare namespace AuthorizeClusterSecurityGroupIngressResult {
+    
+    const filterSensitiveLog: (obj: AuthorizeClusterSecurityGroupIngressResult) => any;
+}
+
+export interface ClusterSecurityGroupNotFoundFault extends __SmithyException, $MetadataBearer {
+    name: "ClusterSecurityGroupNotFoundFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace ClusterSecurityGroupNotFoundFault {
+    
+    const filterSensitiveLog: (obj: ClusterSecurityGroupNotFoundFault) => any;
+}
+
+export interface InvalidClusterSecurityGroupStateFault extends __SmithyException, $MetadataBearer {
+    name: "InvalidClusterSecurityGroupStateFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace InvalidClusterSecurityGroupStateFault {
+    
+    const filterSensitiveLog: (obj: InvalidClusterSecurityGroupStateFault) => any;
+}
+export interface AuthorizeDataShareMessage {
+    
+    DataShareArn: string | undefined;
+    
+    ConsumerIdentifier: string | undefined;
+}
+export declare namespace AuthorizeDataShareMessage {
+    
+    const filterSensitiveLog: (obj: AuthorizeDataShareMessage) => any;
+}
+export interface AuthorizeEndpointAccessMessage {
+    
+    ClusterIdentifier?: string;
+    
+    Account: string | undefined;
+    
+    VpcIds?: string[];
+}
+export declare namespace AuthorizeEndpointAccessMessage {
+    
+    const filterSensitiveLog: (obj: AuthorizeEndpointAccessMessage) => any;
+}
+
+export interface EndpointAuthorization {
+    
+    Grantor?: string;
+    
+    Grantee?: string;
+    
+    ClusterIdentifier?: string;
+    
+    AuthorizeTime?: Date;
+    
+    ClusterStatus?: string;
+    
+    Status?: AuthorizationStatus | string;
+    
+    AllowedAllVPCs?: boolean;
+    
+    AllowedVPCs?: string[];
+    
+    EndpointCount?: number;
+}
+export declare namespace EndpointAuthorization {
+    
+    const filterSensitiveLog: (obj: EndpointAuthorization) => any;
+}
+
+export interface EndpointAuthorizationAlreadyExistsFault extends __SmithyException, $MetadataBearer {
+    name: "EndpointAuthorizationAlreadyExistsFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace EndpointAuthorizationAlreadyExistsFault {
+    
+    const filterSensitiveLog: (obj: EndpointAuthorizationAlreadyExistsFault) => any;
+}
+
+export interface EndpointAuthorizationsPerClusterLimitExceededFault extends __SmithyException, $MetadataBearer {
+    name: "EndpointAuthorizationsPerClusterLimitExceededFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace EndpointAuthorizationsPerClusterLimitExceededFault {
+    
+    const filterSensitiveLog: (obj: EndpointAuthorizationsPerClusterLimitExceededFault) => any;
+}
+
+export interface InvalidAuthorizationStateFault extends __SmithyException, $MetadataBearer {
+    name: "InvalidAuthorizationStateFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace InvalidAuthorizationStateFault {
+    
+    const filterSensitiveLog: (obj: InvalidAuthorizationStateFault) => any;
+}
+
+export interface InvalidClusterStateFault extends __SmithyException, $MetadataBearer {
+    name: "InvalidClusterStateFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace InvalidClusterStateFault {
+    
+    const filterSensitiveLog: (obj: InvalidClusterStateFault) => any;
+}
+
+export interface AuthorizeSnapshotAccessMessage {
+    
+    SnapshotIdentifier: string | undefined;
+    
+    SnapshotClusterIdentifier?: string;
+    
+    AccountWithRestoreAccess: string | undefined;
+}
+export declare namespace AuthorizeSnapshotAccessMessage {
+    
+    const filterSensitiveLog: (obj: AuthorizeSnapshotAccessMessage) => any;
+}
+
+export interface Snapshot {
+    
+    SnapshotIdentifier?: string;
+    
+    ClusterIdentifier?: string;
+    
+    SnapshotCreateTime?: Date;
+    
+    Status?: string;
+    
+    Port?: number;
+    
+    AvailabilityZone?: string;
+    
+    ClusterCreateTime?: Date;
+    
+    MasterUsername?: string;
+    
+    ClusterVersion?: string;
+    
+    EngineFullVersion?: string;
+    
+    SnapshotType?: string;
+    
+    NodeType?: string;
+    
+    NumberOfNodes?: number;
+    
+    DBName?: string;
+    
+    VpcId?: string;
+    
+    Encrypted?: boolean;
+    
+    KmsKeyId?: string;
+    
+    EncryptedWithHSM?: boolean;
+    
+    AccountsWithRestoreAccess?: AccountWithRestoreAccess[];
+    
+    OwnerAccount?: string;
+    
+    TotalBackupSizeInMegaBytes?: number;
+    
+    ActualIncrementalBackupSizeInMegaBytes?: number;
+    
+    BackupProgressInMegaBytes?: number;
+    
+    CurrentBackupRateInMegaBytesPerSecond?: number;
+    
+    EstimatedSecondsToCompletion?: number;
+    
+    ElapsedTimeInSeconds?: number;
+    
+    SourceRegion?: string;
+    
+    Tags?: Tag[];
+    
+    RestorableNodeTypes?: string[];
+    
+    EnhancedVpcRouting?: boolean;
+    
+    MaintenanceTrackName?: string;
+    
+    ManualSnapshotRetentionPeriod?: number;
+    
+    ManualSnapshotRemainingDays?: number;
+    
+    SnapshotRetentionStartTime?: Date;
+}
+export declare namespace Snapshot {
+    
+    const filterSensitiveLog: (obj: Snapshot) => any;
+}
+export interface AuthorizeSnapshotAccessResult {
+    
+    Snapshot?: Snapshot;
+}
+export declare namespace AuthorizeSnapshotAccessResult {
+    
+    const filterSensitiveLog: (obj: AuthorizeSnapshotAccessResult) => any;
+}
+
+export interface ClusterSnapshotNotFoundFault extends __SmithyException, $MetadataBearer {
+    name: "ClusterSnapshotNotFoundFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace ClusterSnapshotNotFoundFault {
+    
+    const filterSensitiveLog: (obj: ClusterSnapshotNotFoundFault) => any;
+}
+
+export interface DependentServiceRequestThrottlingFault extends __SmithyException, $MetadataBearer {
+    name: "DependentServiceRequestThrottlingFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace DependentServiceRequestThrottlingFault {
+    
+    const filterSensitiveLog: (obj: DependentServiceRequestThrottlingFault) => any;
+}
+
+export interface InvalidClusterSnapshotStateFault extends __SmithyException, $MetadataBearer {
+    name: "InvalidClusterSnapshotStateFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace InvalidClusterSnapshotStateFault {
+    
+    const filterSensitiveLog: (obj: InvalidClusterSnapshotStateFault) => any;
+}
+
+export interface LimitExceededFault extends __SmithyException, $MetadataBearer {
+    name: "LimitExceededFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace LimitExceededFault {
+    
+    const filterSensitiveLog: (obj: LimitExceededFault) => any;
+}
+
+export interface SupportedPlatform {
+    
+    Name?: string;
+}
+export declare namespace SupportedPlatform {
+    
+    const filterSensitiveLog: (obj: SupportedPlatform) => any;
+}
+
+export interface AvailabilityZone {
+    
+    Name?: string;
+    
+    SupportedPlatforms?: SupportedPlatform[];
+}
+export declare namespace AvailabilityZone {
+    
+    const filterSensitiveLog: (obj: AvailabilityZone) => any;
+}
+
+export interface DeleteClusterSnapshotMessage {
+    
+    SnapshotIdentifier: string | undefined;
+    
+    SnapshotClusterIdentifier?: string;
+}
+export declare namespace DeleteClusterSnapshotMessage {
+    
+    const filterSensitiveLog: (obj: DeleteClusterSnapshotMessage) => any;
+}
+export interface BatchDeleteClusterSnapshotsRequest {
+    
+    Identifiers: DeleteClusterSnapshotMessage[] | undefined;
+}
+export declare namespace BatchDeleteClusterSnapshotsRequest {
+    
+    const filterSensitiveLog: (obj: BatchDeleteClusterSnapshotsRequest) => any;
+}
+
+export interface SnapshotErrorMessage {
+    
+    SnapshotIdentifier?: string;
+    
+    SnapshotClusterIdentifier?: string;
+    
+    FailureCode?: string;
+    
+    FailureReason?: string;
+}
+export declare namespace SnapshotErrorMessage {
+    
+    const filterSensitiveLog: (obj: SnapshotErrorMessage) => any;
+}
+export interface BatchDeleteClusterSnapshotsResult {
+    
+    Resources?: string[];
+    
+    Errors?: SnapshotErrorMessage[];
+}
+export declare namespace BatchDeleteClusterSnapshotsResult {
+    
+    const filterSensitiveLog: (obj: BatchDeleteClusterSnapshotsResult) => any;
+}
+
+export interface BatchDeleteRequestSizeExceededFault extends __SmithyException, $MetadataBearer {
+    name: "BatchDeleteRequestSizeExceededFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace BatchDeleteRequestSizeExceededFault {
+    
+    const filterSensitiveLog: (obj: BatchDeleteRequestSizeExceededFault) => any;
+}
+
+export interface BatchModifyClusterSnapshotsLimitExceededFault extends __SmithyException, $MetadataBearer {
+    name: "BatchModifyClusterSnapshotsLimitExceededFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace BatchModifyClusterSnapshotsLimitExceededFault {
+    
+    const filterSensitiveLog: (obj: BatchModifyClusterSnapshotsLimitExceededFault) => any;
+}
+export interface BatchModifyClusterSnapshotsMessage {
+    
+    SnapshotIdentifierList: string[] | undefined;
+    
+    ManualSnapshotRetentionPeriod?: number;
+    
+    Force?: boolean;
+}
+export declare namespace BatchModifyClusterSnapshotsMessage {
+    
+    const filterSensitiveLog: (obj: BatchModifyClusterSnapshotsMessage) => any;
+}
+export interface BatchModifyClusterSnapshotsOutputMessage {
+    
+    Resources?: string[];
+    
+    Errors?: SnapshotErrorMessage[];
+}
+export declare namespace BatchModifyClusterSnapshotsOutputMessage {
+    
+    const filterSensitiveLog: (obj: BatchModifyClusterSnapshotsOutputMessage) => any;
+}
+
+export interface InvalidRetentionPeriodFault extends __SmithyException, $MetadataBearer {
+    name: "InvalidRetentionPeriodFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace InvalidRetentionPeriodFault {
+    
+    const filterSensitiveLog: (obj: InvalidRetentionPeriodFault) => any;
+}
+
+export interface BucketNotFoundFault extends __SmithyException, $MetadataBearer {
+    name: "BucketNotFoundFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace BucketNotFoundFault {
+    
+    const filterSensitiveLog: (obj: BucketNotFoundFault) => any;
+}
+export interface CancelResizeMessage {
+    
+    ClusterIdentifier: string | undefined;
+}
+export declare namespace CancelResizeMessage {
+    
+    const filterSensitiveLog: (obj: CancelResizeMessage) => any;
+}
+
+export interface ResizeNotFoundFault extends __SmithyException, $MetadataBearer {
+    name: "ResizeNotFoundFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace ResizeNotFoundFault {
+    
+    const filterSensitiveLog: (obj: ResizeNotFoundFault) => any;
+}
+
+export interface ResizeProgressMessage {
+    
+    TargetNodeType?: string;
+    
+    TargetNumberOfNodes?: number;
+    
+    TargetClusterType?: string;
+    
+    Status?: string;
+    
+    ImportTablesCompleted?: string[];
+    
+    ImportTablesInProgress?: string[];
+    
+    ImportTablesNotStarted?: string[];
+    
+    AvgResizeRateInMegaBytesPerSecond?: number;
+    
+    TotalResizeDataInMegaBytes?: number;
+    
+    ProgressInMegaBytes?: number;
+    
+    ElapsedTimeInSeconds?: number;
+    
+    EstimatedTimeToCompletionInSeconds?: number;
+    
+    ResizeType?: string;
+    
+    Message?: string;
+    
+    TargetEncryptionType?: string;
+    
+    DataTransferProgressPercent?: number;
+}
+export declare namespace ResizeProgressMessage {
+    
+    const filterSensitiveLog: (obj: ResizeProgressMessage) => any;
+}
+
+export interface ClusterNode {
+    
+    NodeRole?: string;
+    
+    PrivateIPAddress?: string;
+    
+    PublicIPAddress?: string;
+}
+export declare namespace ClusterNode {
+    
+    const filterSensitiveLog: (obj: ClusterNode) => any;
+}
+
+export interface ClusterParameterStatus {
+    
+    ParameterName?: string;
+    
+    ParameterApplyStatus?: string;
+    
+    ParameterApplyErrorDescription?: string;
+}
+export declare namespace ClusterParameterStatus {
+    
+    const filterSensitiveLog: (obj: ClusterParameterStatus) => any;
+}
+
+export interface ClusterParameterGroupStatus {
+    
+    ParameterGroupName?: string;
+    
+    ParameterApplyStatus?: string;
+    
+    ClusterParameterStatusList?: ClusterParameterStatus[];
+}
+export declare namespace ClusterParameterGroupStatus {
+    
+    const filterSensitiveLog: (obj: ClusterParameterGroupStatus) => any;
+}
+
+export interface ClusterSecurityGroupMembership {
+    
+    ClusterSecurityGroupName?: string;
+    
+    Status?: string;
+}
+export declare namespace ClusterSecurityGroupMembership {
+    
+    const filterSensitiveLog: (obj: ClusterSecurityGroupMembership) => any;
+}
+
+export interface ClusterSnapshotCopyStatus {
+    
+    DestinationRegion?: string;
+    
+    RetentionPeriod?: number;
+    
+    ManualSnapshotRetentionPeriod?: number;
+    
+    SnapshotCopyGrantName?: string;
+}
+export declare namespace ClusterSnapshotCopyStatus {
+    
+    const filterSensitiveLog: (obj: ClusterSnapshotCopyStatus) => any;
+}
+
+export interface DataTransferProgress {
+    
+    Status?: string;
+    
+    CurrentRateInMegaBytesPerSecond?: number;
+    
+    TotalDataInMegaBytes?: number;
+    
+    DataTransferredInMegaBytes?: number;
+    
+    EstimatedTimeToCompletionInSeconds?: number;
+    
+    ElapsedTimeInSeconds?: number;
+}
+export declare namespace DataTransferProgress {
+    
+    const filterSensitiveLog: (obj: DataTransferProgress) => any;
+}
+
+export interface DeferredMaintenanceWindow {
+    
+    DeferMaintenanceIdentifier?: string;
+    
+    DeferMaintenanceStartTime?: Date;
+    
+    DeferMaintenanceEndTime?: Date;
+}
+export declare namespace DeferredMaintenanceWindow {
+    
+    const filterSensitiveLog: (obj: DeferredMaintenanceWindow) => any;
+}
+
+export interface ElasticIpStatus {
+    
+    ElasticIp?: string;
+    
+    Status?: string;
+}
+export declare namespace ElasticIpStatus {
+    
+    const filterSensitiveLog: (obj: ElasticIpStatus) => any;
+}
+
+export interface NetworkInterface {
+    
+    NetworkInterfaceId?: string;
+    
+    SubnetId?: string;
+    
+    PrivateIpAddress?: string;
+    
+    AvailabilityZone?: string;
+}
+export declare namespace NetworkInterface {
+    
+    const filterSensitiveLog: (obj: NetworkInterface) => any;
+}
+
+export interface VpcEndpoint {
+    
+    VpcEndpointId?: string;
+    
+    VpcId?: string;
+    
+    NetworkInterfaces?: NetworkInterface[];
+}
+export declare namespace VpcEndpoint {
+    
+    const filterSensitiveLog: (obj: VpcEndpoint) => any;
+}
+
+export interface Endpoint {
+    
+    Address?: string;
+    
+    Port?: number;
+    
+    VpcEndpoints?: VpcEndpoint[];
+}
+export declare namespace Endpoint {
+    
+    const filterSensitiveLog: (obj: Endpoint) => any;
+}
+
+export interface HsmStatus {
+    
+    HsmClientCertificateIdentifier?: string;
+    
+    HsmConfigurationIdentifier?: string;
+    
+    Status?: string;
+}
+export declare namespace HsmStatus {
+    
+    const filterSensitiveLog: (obj: HsmStatus) => any;
+}
+
+export interface ClusterIamRole {
+    
+    IamRoleArn?: string;
+    
+    ApplyStatus?: string;
+}
+export declare namespace ClusterIamRole {
+    
+    const filterSensitiveLog: (obj: ClusterIamRole) => any;
+}
+
+export interface PendingModifiedValues {
+    
+    MasterUserPassword?: string;
+    
+    NodeType?: string;
+    
+    NumberOfNodes?: number;
+    
+    ClusterType?: string;
+    
+    ClusterVersion?: string;
+    
+    AutomatedSnapshotRetentionPeriod?: number;
+    
+    ClusterIdentifier?: string;
+    
+    PubliclyAccessible?: boolean;
+    
+    EnhancedVpcRouting?: boolean;
+    
+    MaintenanceTrackName?: string;
+    
+    EncryptionType?: string;
+}
+export declare namespace PendingModifiedValues {
+    
+    const filterSensitiveLog: (obj: PendingModifiedValues) => any;
+}
+
+export interface ResizeInfo {
+    
+    ResizeType?: string;
+    
+    AllowCancelResize?: boolean;
+}
+export declare namespace ResizeInfo {
+    
+    const filterSensitiveLog: (obj: ResizeInfo) => any;
+}
+
+export interface RestoreStatus {
+    
+    Status?: string;
+    
+    CurrentRestoreRateInMegaBytesPerSecond?: number;
+    
+    SnapshotSizeInMegaBytes?: number;
+    
+    ProgressInMegaBytes?: number;
+    
+    ElapsedTimeInSeconds?: number;
+    
+    EstimatedTimeToCompletionInSeconds?: number;
+}
+export declare namespace RestoreStatus {
+    
+    const filterSensitiveLog: (obj: RestoreStatus) => any;
+}
+
+export interface VpcSecurityGroupMembership {
+    
+    VpcSecurityGroupId?: string;
+    
+    Status?: string;
+}
+export declare namespace VpcSecurityGroupMembership {
+    
+    const filterSensitiveLog: (obj: VpcSecurityGroupMembership) => any;
+}
+
+export interface Cluster {
+    
+    ClusterIdentifier?: string;
+    
+    NodeType?: string;
+    
+    ClusterStatus?: string;
+    
+    ClusterAvailabilityStatus?: string;
+    
+    ModifyStatus?: string;
+    
+    MasterUsername?: string;
+    
+    DBName?: string;
+    
+    Endpoint?: Endpoint;
+    
+    ClusterCreateTime?: Date;
+    
+    AutomatedSnapshotRetentionPeriod?: number;
+    
+    ManualSnapshotRetentionPeriod?: number;
+    
+    ClusterSecurityGroups?: ClusterSecurityGroupMembership[];
+    
+    VpcSecurityGroups?: VpcSecurityGroupMembership[];
+    
+    ClusterParameterGroups?: ClusterParameterGroupStatus[];
+    
+    ClusterSubnetGroupName?: string;
+    
+    VpcId?: string;
+    
+    AvailabilityZone?: string;
+    
+    PreferredMaintenanceWindow?: string;
+    
+    PendingModifiedValues?: PendingModifiedValues;
+    
+    ClusterVersion?: string;
+    
+    AllowVersionUpgrade?: boolean;
+    
+    NumberOfNodes?: number;
+    
+    PubliclyAccessible?: boolean;
+    
+    Encrypted?: boolean;
+    
+    RestoreStatus?: RestoreStatus;
+    
+    DataTransferProgress?: DataTransferProgress;
+    
+    HsmStatus?: HsmStatus;
+    
+    ClusterSnapshotCopyStatus?: ClusterSnapshotCopyStatus;
+    
+    ClusterPublicKey?: string;
+    
+    ClusterNodes?: ClusterNode[];
+    
+    ElasticIpStatus?: ElasticIpStatus;
+    
+    ClusterRevisionNumber?: string;
+    
+    Tags?: Tag[];
+    
+    KmsKeyId?: string;
+    
+    EnhancedVpcRouting?: boolean;
+    
+    IamRoles?: ClusterIamRole[];
+    
+    PendingActions?: string[];
+    
+    MaintenanceTrackName?: string;
+    
+    ElasticResizeNumberOfNodeOptions?: string;
+    
+    DeferredMaintenanceWindows?: DeferredMaintenanceWindow[];
+    
+    SnapshotScheduleIdentifier?: string;
+    
+    SnapshotScheduleState?: ScheduleState | string;
+    
+    ExpectedNextSnapshotScheduleTime?: Date;
+    
+    ExpectedNextSnapshotScheduleTimeStatus?: string;
+    
+    NextMaintenanceWindowStartTime?: Date;
+    
+    ResizeInfo?: ResizeInfo;
+    
+    AvailabilityZoneRelocationStatus?: string;
+    
+    ClusterNamespaceArn?: string;
+    
+    TotalStorageCapacityInMegaBytes?: number;
+    
+    AquaConfiguration?: AquaConfiguration;
+}
+export declare namespace Cluster {
+    
+    const filterSensitiveLog: (obj: Cluster) => any;
+}
+
+export interface ClusterAlreadyExistsFault extends __SmithyException, $MetadataBearer {
+    name: "ClusterAlreadyExistsFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace ClusterAlreadyExistsFault {
+    
+    const filterSensitiveLog: (obj: ClusterAlreadyExistsFault) => any;
+}
+
+export interface ClusterCredentials {
+    
+    DbUser?: string;
+    
+    DbPassword?: string;
+    
+    Expiration?: Date;
+}
+export declare namespace ClusterCredentials {
+    
+    const filterSensitiveLog: (obj: ClusterCredentials) => any;
+}
+
+export interface RevisionTarget {
+    
+    DatabaseRevision?: string;
+    
+    Description?: string;
+    
+    DatabaseRevisionReleaseDate?: Date;
+}
+export declare namespace RevisionTarget {
+    
+    const filterSensitiveLog: (obj: RevisionTarget) => any;
+}
+
+export interface ClusterDbRevision {
+    
+    ClusterIdentifier?: string;
+    
+    CurrentDatabaseRevision?: string;
+    
+    DatabaseRevisionReleaseDate?: Date;
+    
+    RevisionTargets?: RevisionTarget[];
+}
+export declare namespace ClusterDbRevision {
+    
+    const filterSensitiveLog: (obj: ClusterDbRevision) => any;
+}
+export interface ClusterDbRevisionsMessage {
+    
+    Marker?: string;
+    
+    ClusterDbRevisions?: ClusterDbRevision[];
+}
+export declare namespace ClusterDbRevisionsMessage {
+    
+    const filterSensitiveLog: (obj: ClusterDbRevisionsMessage) => any;
+}
+
+export interface ClusterOnLatestRevisionFault extends __SmithyException, $MetadataBearer {
+    name: "ClusterOnLatestRevisionFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace ClusterOnLatestRevisionFault {
+    
+    const filterSensitiveLog: (obj: ClusterOnLatestRevisionFault) => any;
+}
+
+export interface ClusterParameterGroup {
+    
+    ParameterGroupName?: string;
+    
+    ParameterGroupFamily?: string;
+    
+    Description?: string;
+    
+    Tags?: Tag[];
+}
+export declare namespace ClusterParameterGroup {
+    
+    const filterSensitiveLog: (obj: ClusterParameterGroup) => any;
+}
+
+export interface ClusterParameterGroupAlreadyExistsFault extends __SmithyException, $MetadataBearer {
+    name: "ClusterParameterGroupAlreadyExistsFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace ClusterParameterGroupAlreadyExistsFault {
+    
+    const filterSensitiveLog: (obj: ClusterParameterGroupAlreadyExistsFault) => any;
+}
+export declare type ParameterApplyType = "dynamic" | "static";
+
+export interface Parameter {
+    
+    ParameterName?: string;
+    
+    ParameterValue?: string;
+    
+    Description?: string;
+    
+    Source?: string;
+    
+    DataType?: string;
+    
+    AllowedValues?: string;
+    
+    ApplyType?: ParameterApplyType | string;
+    
+    IsModifiable?: boolean;
+    
+    MinimumEngineVersion?: string;
+}
+export declare namespace Parameter {
+    
+    const filterSensitiveLog: (obj: Parameter) => any;
+}
+
+export interface ClusterParameterGroupDetails {
+    
+    Parameters?: Parameter[];
+    
+    Marker?: string;
+}
+export declare namespace ClusterParameterGroupDetails {
+    
+    const filterSensitiveLog: (obj: ClusterParameterGroupDetails) => any;
+}
+
+export interface ClusterParameterGroupNameMessage {
+    
+    ParameterGroupName?: string;
+    
+    ParameterGroupStatus?: string;
+}
+export declare namespace ClusterParameterGroupNameMessage {
+    
+    const filterSensitiveLog: (obj: ClusterParameterGroupNameMessage) => any;
+}
+
+export interface ClusterParameterGroupNotFoundFault extends __SmithyException, $MetadataBearer {
+    name: "ClusterParameterGroupNotFoundFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace ClusterParameterGroupNotFoundFault {
+    
+    const filterSensitiveLog: (obj: ClusterParameterGroupNotFoundFault) => any;
+}
+
+export interface ClusterParameterGroupQuotaExceededFault extends __SmithyException, $MetadataBearer {
+    name: "ClusterParameterGroupQuotaExceededFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace ClusterParameterGroupQuotaExceededFault {
+    
+    const filterSensitiveLog: (obj: ClusterParameterGroupQuotaExceededFault) => any;
+}
+
+export interface ClusterParameterGroupsMessage {
+    
+    Marker?: string;
+    
+    ParameterGroups?: ClusterParameterGroup[];
+}
+export declare namespace ClusterParameterGroupsMessage {
+    
+    const filterSensitiveLog: (obj: ClusterParameterGroupsMessage) => any;
+}
+
+export interface ClusterQuotaExceededFault extends __SmithyException, $MetadataBearer {
+    name: "ClusterQuotaExceededFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace ClusterQuotaExceededFault {
+    
+    const filterSensitiveLog: (obj: ClusterQuotaExceededFault) => any;
+}
+
+export interface ClusterSecurityGroupAlreadyExistsFault extends __SmithyException, $MetadataBearer {
+    name: "ClusterSecurityGroupAlreadyExistsFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace ClusterSecurityGroupAlreadyExistsFault {
+    
+    const filterSensitiveLog: (obj: ClusterSecurityGroupAlreadyExistsFault) => any;
+}
+
+export interface ClusterSecurityGroupMessage {
+    
+    Marker?: string;
+    
+    ClusterSecurityGroups?: ClusterSecurityGroup[];
+}
+export declare namespace ClusterSecurityGroupMessage {
+    
+    const filterSensitiveLog: (obj: ClusterSecurityGroupMessage) => any;
+}
+
+export interface ClusterSecurityGroupQuotaExceededFault extends __SmithyException, $MetadataBearer {
+    name: "ClusterSecurityGroupQuotaExceededFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace ClusterSecurityGroupQuotaExceededFault {
+    
+    const filterSensitiveLog: (obj: ClusterSecurityGroupQuotaExceededFault) => any;
+}
+
+export interface ClustersMessage {
+    
+    Marker?: string;
+    
+    Clusters?: Cluster[];
+}
+export declare namespace ClustersMessage {
+    
+    const filterSensitiveLog: (obj: ClustersMessage) => any;
+}
+
+export interface ClusterSnapshotAlreadyExistsFault extends __SmithyException, $MetadataBearer {
+    name: "ClusterSnapshotAlreadyExistsFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace ClusterSnapshotAlreadyExistsFault {
+    
+    const filterSensitiveLog: (obj: ClusterSnapshotAlreadyExistsFault) => any;
+}
+
+export interface ClusterSnapshotQuotaExceededFault extends __SmithyException, $MetadataBearer {
+    name: "ClusterSnapshotQuotaExceededFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace ClusterSnapshotQuotaExceededFault {
+    
+    const filterSensitiveLog: (obj: ClusterSnapshotQuotaExceededFault) => any;
+}
+
+export interface Subnet {
+    
+    SubnetIdentifier?: string;
+    
+    SubnetAvailabilityZone?: AvailabilityZone;
+    
+    SubnetStatus?: string;
+}
+export declare namespace Subnet {
+    
+    const filterSensitiveLog: (obj: Subnet) => any;
+}
+
+export interface ClusterSubnetGroup {
+    
+    ClusterSubnetGroupName?: string;
+    
+    Description?: string;
+    
+    VpcId?: string;
+    
+    SubnetGroupStatus?: string;
+    
+    Subnets?: Subnet[];
+    
+    Tags?: Tag[];
+}
+export declare namespace ClusterSubnetGroup {
+    
+    const filterSensitiveLog: (obj: ClusterSubnetGroup) => any;
+}
+
+export interface ClusterSubnetGroupAlreadyExistsFault extends __SmithyException, $MetadataBearer {
+    name: "ClusterSubnetGroupAlreadyExistsFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace ClusterSubnetGroupAlreadyExistsFault {
+    
+    const filterSensitiveLog: (obj: ClusterSubnetGroupAlreadyExistsFault) => any;
+}
+
+export interface ClusterSubnetGroupMessage {
+    
+    Marker?: string;
+    
+    ClusterSubnetGroups?: ClusterSubnetGroup[];
+}
+export declare namespace ClusterSubnetGroupMessage {
+    
+    const filterSensitiveLog: (obj: ClusterSubnetGroupMessage) => any;
+}
+
+export interface ClusterSubnetGroupNotFoundFault extends __SmithyException, $MetadataBearer {
+    name: "ClusterSubnetGroupNotFoundFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace ClusterSubnetGroupNotFoundFault {
+    
+    const filterSensitiveLog: (obj: ClusterSubnetGroupNotFoundFault) => any;
+}
+
+export interface ClusterSubnetGroupQuotaExceededFault extends __SmithyException, $MetadataBearer {
+    name: "ClusterSubnetGroupQuotaExceededFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace ClusterSubnetGroupQuotaExceededFault {
+    
+    const filterSensitiveLog: (obj: ClusterSubnetGroupQuotaExceededFault) => any;
+}
+
+export interface ClusterSubnetQuotaExceededFault extends __SmithyException, $MetadataBearer {
+    name: "ClusterSubnetQuotaExceededFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace ClusterSubnetQuotaExceededFault {
+    
+    const filterSensitiveLog: (obj: ClusterSubnetQuotaExceededFault) => any;
+}
+
+export interface ClusterVersion {
+    
+    ClusterVersion?: string;
+    
+    ClusterParameterGroupFamily?: string;
+    
+    Description?: string;
+}
+export declare namespace ClusterVersion {
+    
+    const filterSensitiveLog: (obj: ClusterVersion) => any;
+}
+
+export interface ClusterVersionsMessage {
+    
+    Marker?: string;
+    
+    ClusterVersions?: ClusterVersion[];
+}
+export declare namespace ClusterVersionsMessage {
+    
+    const filterSensitiveLog: (obj: ClusterVersionsMessage) => any;
+}
+
+export interface CopyClusterSnapshotMessage {
+    
+    SourceSnapshotIdentifier: string | undefined;
+    
+    SourceSnapshotClusterIdentifier?: string;
+    
+    TargetSnapshotIdentifier: string | undefined;
+    
+    ManualSnapshotRetentionPeriod?: number;
+}
+export declare namespace CopyClusterSnapshotMessage {
+    
+    const filterSensitiveLog: (obj: CopyClusterSnapshotMessage) => any;
+}
+export interface CopyClusterSnapshotResult {
+    
+    Snapshot?: Snapshot;
+}
+export declare namespace CopyClusterSnapshotResult {
+    
+    const filterSensitiveLog: (obj: CopyClusterSnapshotResult) => any;
+}
+
+export interface CopyToRegionDisabledFault extends __SmithyException, $MetadataBearer {
+    name: "CopyToRegionDisabledFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace CopyToRegionDisabledFault {
+    
+    const filterSensitiveLog: (obj: CopyToRegionDisabledFault) => any;
+}
+export interface CreateAuthenticationProfileMessage {
+    
+    AuthenticationProfileName: string | undefined;
+    
+    AuthenticationProfileContent: string | undefined;
+}
+export declare namespace CreateAuthenticationProfileMessage {
+    
+    const filterSensitiveLog: (obj: CreateAuthenticationProfileMessage) => any;
+}
+export interface CreateAuthenticationProfileResult {
+    
+    AuthenticationProfileName?: string;
+    
+    AuthenticationProfileContent?: string;
+}
+export declare namespace CreateAuthenticationProfileResult {
+    
+    const filterSensitiveLog: (obj: CreateAuthenticationProfileResult) => any;
+}
+
+export interface InvalidAuthenticationProfileRequestFault extends __SmithyException, $MetadataBearer {
+    name: "InvalidAuthenticationProfileRequestFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace InvalidAuthenticationProfileRequestFault {
+    
+    const filterSensitiveLog: (obj: InvalidAuthenticationProfileRequestFault) => any;
+}
+
+export interface CreateClusterMessage {
+    
+    DBName?: string;
+    
+    ClusterIdentifier: string | undefined;
+    
+    ClusterType?: string;
+    
+    NodeType: string | undefined;
+    
+    MasterUsername: string | undefined;
+    
+    MasterUserPassword: string | undefined;
+    
+    ClusterSecurityGroups?: string[];
+    
+    VpcSecurityGroupIds?: string[];
+    
+    ClusterSubnetGroupName?: string;
+    
+    AvailabilityZone?: string;
+    
+    PreferredMaintenanceWindow?: string;
+    
+    ClusterParameterGroupName?: string;
+    
+    AutomatedSnapshotRetentionPeriod?: number;
+    
+    ManualSnapshotRetentionPeriod?: number;
+    
+    Port?: number;
+    
+    ClusterVersion?: string;
+    
+    AllowVersionUpgrade?: boolean;
+    
+    NumberOfNodes?: number;
+    
+    PubliclyAccessible?: boolean;
+    
+    Encrypted?: boolean;
+    
+    HsmClientCertificateIdentifier?: string;
+    
+    HsmConfigurationIdentifier?: string;
+    
+    ElasticIp?: string;
+    
+    Tags?: Tag[];
+    
+    KmsKeyId?: string;
+    
+    EnhancedVpcRouting?: boolean;
+    
+    AdditionalInfo?: string;
+    
+    IamRoles?: string[];
+    
+    MaintenanceTrackName?: string;
+    
+    SnapshotScheduleIdentifier?: string;
+    
+    AvailabilityZoneRelocation?: boolean;
+    
+    AquaConfigurationStatus?: AquaConfigurationStatus | string;
+}
+export declare namespace CreateClusterMessage {
+    
+    const filterSensitiveLog: (obj: CreateClusterMessage) => any;
+}
+export interface CreateClusterResult {
+    
+    Cluster?: Cluster;
+}
+export declare namespace CreateClusterResult {
+    
+    const filterSensitiveLog: (obj: CreateClusterResult) => any;
+}
+
+export interface HsmClientCertificateNotFoundFault extends __SmithyException, $MetadataBearer {
+    name: "HsmClientCertificateNotFoundFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace HsmClientCertificateNotFoundFault {
+    
+    const filterSensitiveLog: (obj: HsmClientCertificateNotFoundFault) => any;
+}
+
+export interface HsmConfigurationNotFoundFault extends __SmithyException, $MetadataBearer {
+    name: "HsmConfigurationNotFoundFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace HsmConfigurationNotFoundFault {
+    
+    const filterSensitiveLog: (obj: HsmConfigurationNotFoundFault) => any;
+}
+
+export interface InsufficientClusterCapacityFault extends __SmithyException, $MetadataBearer {
+    name: "InsufficientClusterCapacityFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace InsufficientClusterCapacityFault {
+    
+    const filterSensitiveLog: (obj: InsufficientClusterCapacityFault) => any;
+}
+
+export interface InvalidClusterSubnetGroupStateFault extends __SmithyException, $MetadataBearer {
+    name: "InvalidClusterSubnetGroupStateFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace InvalidClusterSubnetGroupStateFault {
+    
+    const filterSensitiveLog: (obj: InvalidClusterSubnetGroupStateFault) => any;
+}
+
+export interface InvalidClusterTrackFault extends __SmithyException, $MetadataBearer {
+    name: "InvalidClusterTrackFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace InvalidClusterTrackFault {
+    
+    const filterSensitiveLog: (obj: InvalidClusterTrackFault) => any;
+}
+
+export interface InvalidElasticIpFault extends __SmithyException, $MetadataBearer {
+    name: "InvalidElasticIpFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace InvalidElasticIpFault {
+    
+    const filterSensitiveLog: (obj: InvalidElasticIpFault) => any;
+}
+
+export interface InvalidSubnet extends __SmithyException, $MetadataBearer {
+    name: "InvalidSubnet";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace InvalidSubnet {
+    
+    const filterSensitiveLog: (obj: InvalidSubnet) => any;
+}
+
+export interface InvalidTagFault extends __SmithyException, $MetadataBearer {
+    name: "InvalidTagFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace InvalidTagFault {
+    
+    const filterSensitiveLog: (obj: InvalidTagFault) => any;
+}
+
+export interface InvalidVPCNetworkStateFault extends __SmithyException, $MetadataBearer {
+    name: "InvalidVPCNetworkStateFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace InvalidVPCNetworkStateFault {
+    
+    const filterSensitiveLog: (obj: InvalidVPCNetworkStateFault) => any;
+}
+
+export interface NumberOfNodesPerClusterLimitExceededFault extends __SmithyException, $MetadataBearer {
+    name: "NumberOfNodesPerClusterLimitExceededFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace NumberOfNodesPerClusterLimitExceededFault {
+    
+    const filterSensitiveLog: (obj: NumberOfNodesPerClusterLimitExceededFault) => any;
+}
+
+export interface NumberOfNodesQuotaExceededFault extends __SmithyException, $MetadataBearer {
+    name: "NumberOfNodesQuotaExceededFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace NumberOfNodesQuotaExceededFault {
+    
+    const filterSensitiveLog: (obj: NumberOfNodesQuotaExceededFault) => any;
+}
+
+export interface SnapshotScheduleNotFoundFault extends __SmithyException, $MetadataBearer {
+    name: "SnapshotScheduleNotFoundFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace SnapshotScheduleNotFoundFault {
+    
+    const filterSensitiveLog: (obj: SnapshotScheduleNotFoundFault) => any;
+}
+
+export interface TagLimitExceededFault extends __SmithyException, $MetadataBearer {
+    name: "TagLimitExceededFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace TagLimitExceededFault {
+    
+    const filterSensitiveLog: (obj: TagLimitExceededFault) => any;
+}
+
+export interface UnauthorizedOperation extends __SmithyException, $MetadataBearer {
+    name: "UnauthorizedOperation";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace UnauthorizedOperation {
+    
+    const filterSensitiveLog: (obj: UnauthorizedOperation) => any;
+}
+
+export interface CreateClusterParameterGroupMessage {
+    
+    ParameterGroupName: string | undefined;
+    
+    ParameterGroupFamily: string | undefined;
+    
+    Description: string | undefined;
+    
+    Tags?: Tag[];
+}
+export declare namespace CreateClusterParameterGroupMessage {
+    
+    const filterSensitiveLog: (obj: CreateClusterParameterGroupMessage) => any;
+}
+export interface CreateClusterParameterGroupResult {
+    
+    ClusterParameterGroup?: ClusterParameterGroup;
+}
+export declare namespace CreateClusterParameterGroupResult {
+    
+    const filterSensitiveLog: (obj: CreateClusterParameterGroupResult) => any;
+}
+
+export interface CreateClusterSecurityGroupMessage {
+    
+    ClusterSecurityGroupName: string | undefined;
+    
+    Description: string | undefined;
+    
+    Tags?: Tag[];
+}
+export declare namespace CreateClusterSecurityGroupMessage {
+    
+    const filterSensitiveLog: (obj: CreateClusterSecurityGroupMessage) => any;
+}
+export interface CreateClusterSecurityGroupResult {
+    
+    ClusterSecurityGroup?: ClusterSecurityGroup;
+}
+export declare namespace CreateClusterSecurityGroupResult {
+    
+    const filterSensitiveLog: (obj: CreateClusterSecurityGroupResult) => any;
+}
+
+export interface CreateClusterSnapshotMessage {
+    
+    SnapshotIdentifier: string | undefined;
+    
+    ClusterIdentifier: string | undefined;
+    
+    ManualSnapshotRetentionPeriod?: number;
+    
+    Tags?: Tag[];
+}
+export declare namespace CreateClusterSnapshotMessage {
+    
+    const filterSensitiveLog: (obj: CreateClusterSnapshotMessage) => any;
+}
+export interface CreateClusterSnapshotResult {
+    
+    Snapshot?: Snapshot;
+}
+export declare namespace CreateClusterSnapshotResult {
+    
+    const filterSensitiveLog: (obj: CreateClusterSnapshotResult) => any;
+}
+
+export interface CreateClusterSubnetGroupMessage {
+    
+    ClusterSubnetGroupName: string | undefined;
+    
+    Description: string | undefined;
+    
+    SubnetIds: string[] | undefined;
+    
+    Tags?: Tag[];
+}
+export declare namespace CreateClusterSubnetGroupMessage {
+    
+    const filterSensitiveLog: (obj: CreateClusterSubnetGroupMessage) => any;
+}
+export interface CreateClusterSubnetGroupResult {
+    
+    ClusterSubnetGroup?: ClusterSubnetGroup;
+}
+export declare namespace CreateClusterSubnetGroupResult {
+    
+    const filterSensitiveLog: (obj: CreateClusterSubnetGroupResult) => any;
+}
+export interface CreateEndpointAccessMessage {
+    
+    ClusterIdentifier?: string;
+    
+    ResourceOwner?: string;
+    
+    EndpointName: string | undefined;
+    
+    SubnetGroupName: string | undefined;
+    
+    VpcSecurityGroupIds?: string[];
+}
+export declare namespace CreateEndpointAccessMessage {
+    
+    const filterSensitiveLog: (obj: CreateEndpointAccessMessage) => any;
+}
+
+export interface EndpointAccess {
+    
+    ClusterIdentifier?: string;
+    
+    ResourceOwner?: string;
+    
+    SubnetGroupName?: string;
+    
+    EndpointStatus?: string;
+    
+    EndpointName?: string;
+    
+    EndpointCreateTime?: Date;
+    
+    Port?: number;
+    
+    Address?: string;
+    
+    VpcSecurityGroups?: VpcSecurityGroupMembership[];
+    
+    VpcEndpoint?: VpcEndpoint;
+}
+export declare namespace EndpointAccess {
+    
+    const filterSensitiveLog: (obj: EndpointAccess) => any;
+}
+
+export interface EndpointAlreadyExistsFault extends __SmithyException, $MetadataBearer {
+    name: "EndpointAlreadyExistsFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace EndpointAlreadyExistsFault {
+    
+    const filterSensitiveLog: (obj: EndpointAlreadyExistsFault) => any;
+}
+
+export interface EndpointsPerAuthorizationLimitExceededFault extends __SmithyException, $MetadataBearer {
+    name: "EndpointsPerAuthorizationLimitExceededFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace EndpointsPerAuthorizationLimitExceededFault {
+    
+    const filterSensitiveLog: (obj: EndpointsPerAuthorizationLimitExceededFault) => any;
+}
+
+export interface EndpointsPerClusterLimitExceededFault extends __SmithyException, $MetadataBearer {
+    name: "EndpointsPerClusterLimitExceededFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace EndpointsPerClusterLimitExceededFault {
+    
+    const filterSensitiveLog: (obj: EndpointsPerClusterLimitExceededFault) => any;
+}
+
+export interface CreateEventSubscriptionMessage {
+    
+    SubscriptionName: string | undefined;
+    
+    SnsTopicArn: string | undefined;
+    
+    SourceType?: string;
+    
+    SourceIds?: string[];
+    
+    EventCategories?: string[];
+    
+    Severity?: string;
+    
+    Enabled?: boolean;
+    
+    Tags?: Tag[];
+}
+export declare namespace CreateEventSubscriptionMessage {
+    
+    const filterSensitiveLog: (obj: CreateEventSubscriptionMessage) => any;
+}
+
+export interface EventSubscription {
+    
+    CustomerAwsId?: string;
+    
+    CustSubscriptionId?: string;
+    
+    SnsTopicArn?: string;
+    
+    Status?: string;
+    
+    SubscriptionCreationTime?: Date;
+    
+    SourceType?: string;
+    
+    SourceIdsList?: string[];
+    
+    EventCategoriesList?: string[];
+    
+    Severity?: string;
+    
+    Enabled?: boolean;
+    
+    Tags?: Tag[];
+}
+export declare namespace EventSubscription {
+    
+    const filterSensitiveLog: (obj: EventSubscription) => any;
+}
+export interface CreateEventSubscriptionResult {
+    
+    EventSubscription?: EventSubscription;
+}
+export declare namespace CreateEventSubscriptionResult {
+    
+    const filterSensitiveLog: (obj: CreateEventSubscriptionResult) => any;
+}
+
+export interface EventSubscriptionQuotaExceededFault extends __SmithyException, $MetadataBearer {
+    name: "EventSubscriptionQuotaExceededFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace EventSubscriptionQuotaExceededFault {
+    
+    const filterSensitiveLog: (obj: EventSubscriptionQuotaExceededFault) => any;
+}
+
+export interface SNSInvalidTopicFault extends __SmithyException, $MetadataBearer {
+    name: "SNSInvalidTopicFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace SNSInvalidTopicFault {
+    
+    const filterSensitiveLog: (obj: SNSInvalidTopicFault) => any;
+}
+
+export interface SNSNoAuthorizationFault extends __SmithyException, $MetadataBearer {
+    name: "SNSNoAuthorizationFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace SNSNoAuthorizationFault {
+    
+    const filterSensitiveLog: (obj: SNSNoAuthorizationFault) => any;
+}
+
+export interface SNSTopicArnNotFoundFault extends __SmithyException, $MetadataBearer {
+    name: "SNSTopicArnNotFoundFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace SNSTopicArnNotFoundFault {
+    
+    const filterSensitiveLog: (obj: SNSTopicArnNotFoundFault) => any;
+}
+
+export interface SourceNotFoundFault extends __SmithyException, $MetadataBearer {
+    name: "SourceNotFoundFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace SourceNotFoundFault {
+    
+    const filterSensitiveLog: (obj: SourceNotFoundFault) => any;
+}
+
+export interface SubscriptionAlreadyExistFault extends __SmithyException, $MetadataBearer {
+    name: "SubscriptionAlreadyExistFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace SubscriptionAlreadyExistFault {
+    
+    const filterSensitiveLog: (obj: SubscriptionAlreadyExistFault) => any;
+}
+
+export interface SubscriptionCategoryNotFoundFault extends __SmithyException, $MetadataBearer {
+    name: "SubscriptionCategoryNotFoundFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace SubscriptionCategoryNotFoundFault {
+    
+    const filterSensitiveLog: (obj: SubscriptionCategoryNotFoundFault) => any;
+}
+
+export interface SubscriptionEventIdNotFoundFault extends __SmithyException, $MetadataBearer {
+    name: "SubscriptionEventIdNotFoundFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace SubscriptionEventIdNotFoundFault {
+    
+    const filterSensitiveLog: (obj: SubscriptionEventIdNotFoundFault) => any;
+}
+
+export interface SubscriptionSeverityNotFoundFault extends __SmithyException, $MetadataBearer {
+    name: "SubscriptionSeverityNotFoundFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace SubscriptionSeverityNotFoundFault {
+    
+    const filterSensitiveLog: (obj: SubscriptionSeverityNotFoundFault) => any;
+}
+
+export interface CreateHsmClientCertificateMessage {
+    
+    HsmClientCertificateIdentifier: string | undefined;
+    
+    Tags?: Tag[];
+}
+export declare namespace CreateHsmClientCertificateMessage {
+    
+    const filterSensitiveLog: (obj: CreateHsmClientCertificateMessage) => any;
+}
+
+export interface HsmClientCertificate {
+    
+    HsmClientCertificateIdentifier?: string;
+    
+    HsmClientCertificatePublicKey?: string;
+    
+    Tags?: Tag[];
+}
+export declare namespace HsmClientCertificate {
+    
+    const filterSensitiveLog: (obj: HsmClientCertificate) => any;
+}
+export interface CreateHsmClientCertificateResult {
+    
+    HsmClientCertificate?: HsmClientCertificate;
+}
+export declare namespace CreateHsmClientCertificateResult {
+    
+    const filterSensitiveLog: (obj: CreateHsmClientCertificateResult) => any;
+}
+
+export interface HsmClientCertificateAlreadyExistsFault extends __SmithyException, $MetadataBearer {
+    name: "HsmClientCertificateAlreadyExistsFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace HsmClientCertificateAlreadyExistsFault {
+    
+    const filterSensitiveLog: (obj: HsmClientCertificateAlreadyExistsFault) => any;
+}
+
+export interface HsmClientCertificateQuotaExceededFault extends __SmithyException, $MetadataBearer {
+    name: "HsmClientCertificateQuotaExceededFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace HsmClientCertificateQuotaExceededFault {
+    
+    const filterSensitiveLog: (obj: HsmClientCertificateQuotaExceededFault) => any;
+}
+
+export interface CreateHsmConfigurationMessage {
+    
+    HsmConfigurationIdentifier: string | undefined;
+    
+    Description: string | undefined;
+    
+    HsmIpAddress: string | undefined;
+    
+    HsmPartitionName: string | undefined;
+    
+    HsmPartitionPassword: string | undefined;
+    
+    HsmServerPublicCertificate: string | undefined;
+    
+    Tags?: Tag[];
+}
+export declare namespace CreateHsmConfigurationMessage {
+    
+    const filterSensitiveLog: (obj: CreateHsmConfigurationMessage) => any;
+}
+
+export interface HsmConfiguration {
+    
+    HsmConfigurationIdentifier?: string;
+    
+    Description?: string;
+    
+    HsmIpAddress?: string;
+    
+    HsmPartitionName?: string;
+    
+    Tags?: Tag[];
+}
+export declare namespace HsmConfiguration {
+    
+    const filterSensitiveLog: (obj: HsmConfiguration) => any;
+}
+export interface CreateHsmConfigurationResult {
+    
+    HsmConfiguration?: HsmConfiguration;
+}
+export declare namespace CreateHsmConfigurationResult {
+    
+    const filterSensitiveLog: (obj: CreateHsmConfigurationResult) => any;
+}
+
+export interface HsmConfigurationAlreadyExistsFault extends __SmithyException, $MetadataBearer {
+    name: "HsmConfigurationAlreadyExistsFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace HsmConfigurationAlreadyExistsFault {
+    
+    const filterSensitiveLog: (obj: HsmConfigurationAlreadyExistsFault) => any;
+}
+
+export interface HsmConfigurationQuotaExceededFault extends __SmithyException, $MetadataBearer {
+    name: "HsmConfigurationQuotaExceededFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace HsmConfigurationQuotaExceededFault {
+    
+    const filterSensitiveLog: (obj: HsmConfigurationQuotaExceededFault) => any;
+}
+
+export interface PauseClusterMessage {
+    
+    ClusterIdentifier: string | undefined;
+}
+export declare namespace PauseClusterMessage {
+    
+    const filterSensitiveLog: (obj: PauseClusterMessage) => any;
+}
+
+export interface ResizeClusterMessage {
+    
+    ClusterIdentifier: string | undefined;
+    
+    ClusterType?: string;
+    
+    NodeType?: string;
+    
+    NumberOfNodes?: number;
+    
+    Classic?: boolean;
+}
+export declare namespace ResizeClusterMessage {
+    
+    const filterSensitiveLog: (obj: ResizeClusterMessage) => any;
+}
+
+export interface ResumeClusterMessage {
+    
+    ClusterIdentifier: string | undefined;
+}
+export declare namespace ResumeClusterMessage {
+    
+    const filterSensitiveLog: (obj: ResumeClusterMessage) => any;
+}
+
+export interface ScheduledActionType {
+    
+    ResizeCluster?: ResizeClusterMessage;
+    
+    PauseCluster?: PauseClusterMessage;
+    
+    ResumeCluster?: ResumeClusterMessage;
+}
+export declare namespace ScheduledActionType {
+    
+    const filterSensitiveLog: (obj: ScheduledActionType) => any;
+}
+export interface CreateScheduledActionMessage {
+    
+    ScheduledActionName: string | undefined;
+    
+    TargetAction: ScheduledActionType | undefined;
+    
+    Schedule: string | undefined;
+    
+    IamRole: string | undefined;
+    
+    ScheduledActionDescription?: string;
+    
+    StartTime?: Date;
+    
+    EndTime?: Date;
+    
+    Enable?: boolean;
+}
+export declare namespace CreateScheduledActionMessage {
+    
+    const filterSensitiveLog: (obj: CreateScheduledActionMessage) => any;
+}
+
+export interface InvalidScheduledActionFault extends __SmithyException, $MetadataBearer {
+    name: "InvalidScheduledActionFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace InvalidScheduledActionFault {
+    
+    const filterSensitiveLog: (obj: InvalidScheduledActionFault) => any;
+}
+
+export interface InvalidScheduleFault extends __SmithyException, $MetadataBearer {
+    name: "InvalidScheduleFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace InvalidScheduleFault {
+    
+    const filterSensitiveLog: (obj: InvalidScheduleFault) => any;
+}
+export declare enum ScheduledActionState {
+    ACTIVE = "ACTIVE",
+    DISABLED = "DISABLED"
+}
+
+export interface ScheduledAction {
+    
+    ScheduledActionName?: string;
+    
+    TargetAction?: ScheduledActionType;
+    
+    Schedule?: string;
+    
+    IamRole?: string;
+    
+    ScheduledActionDescription?: string;
+    
+    State?: ScheduledActionState | string;
+    
+    NextInvocations?: Date[];
+    
+    StartTime?: Date;
+    
+    EndTime?: Date;
+}
+export declare namespace ScheduledAction {
+    
+    const filterSensitiveLog: (obj: ScheduledAction) => any;
+}
+
+export interface ScheduledActionAlreadyExistsFault extends __SmithyException, $MetadataBearer {
+    name: "ScheduledActionAlreadyExistsFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace ScheduledActionAlreadyExistsFault {
+    
+    const filterSensitiveLog: (obj: ScheduledActionAlreadyExistsFault) => any;
+}
+
+export interface ScheduledActionQuotaExceededFault extends __SmithyException, $MetadataBearer {
+    name: "ScheduledActionQuotaExceededFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace ScheduledActionQuotaExceededFault {
+    
+    const filterSensitiveLog: (obj: ScheduledActionQuotaExceededFault) => any;
+}
+
+export interface ScheduledActionTypeUnsupportedFault extends __SmithyException, $MetadataBearer {
+    name: "ScheduledActionTypeUnsupportedFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace ScheduledActionTypeUnsupportedFault {
+    
+    const filterSensitiveLog: (obj: ScheduledActionTypeUnsupportedFault) => any;
+}
+
+export interface CreateSnapshotCopyGrantMessage {
+    
+    SnapshotCopyGrantName: string | undefined;
+    
+    KmsKeyId?: string;
+    
+    Tags?: Tag[];
+}
+export declare namespace CreateSnapshotCopyGrantMessage {
+    
+    const filterSensitiveLog: (obj: CreateSnapshotCopyGrantMessage) => any;
+}
+
+export interface SnapshotCopyGrant {
+    
+    SnapshotCopyGrantName?: string;
+    
+    KmsKeyId?: string;
+    
+    Tags?: Tag[];
+}
+export declare namespace SnapshotCopyGrant {
+    
+    const filterSensitiveLog: (obj: SnapshotCopyGrant) => any;
+}
+export interface CreateSnapshotCopyGrantResult {
+    
+    SnapshotCopyGrant?: SnapshotCopyGrant;
+}
+export declare namespace CreateSnapshotCopyGrantResult {
+    
+    const filterSensitiveLog: (obj: CreateSnapshotCopyGrantResult) => any;
+}
+
+export interface SnapshotCopyGrantAlreadyExistsFault extends __SmithyException, $MetadataBearer {
+    name: "SnapshotCopyGrantAlreadyExistsFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace SnapshotCopyGrantAlreadyExistsFault {
+    
+    const filterSensitiveLog: (obj: SnapshotCopyGrantAlreadyExistsFault) => any;
+}
+
+export interface SnapshotCopyGrantQuotaExceededFault extends __SmithyException, $MetadataBearer {
+    name: "SnapshotCopyGrantQuotaExceededFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace SnapshotCopyGrantQuotaExceededFault {
+    
+    const filterSensitiveLog: (obj: SnapshotCopyGrantQuotaExceededFault) => any;
+}
+export interface CreateSnapshotScheduleMessage {
+    
+    ScheduleDefinitions?: string[];
+    
+    ScheduleIdentifier?: string;
+    
+    ScheduleDescription?: string;
+    
+    Tags?: Tag[];
+    
+    DryRun?: boolean;
+    
+    NextInvocations?: number;
+}
+export declare namespace CreateSnapshotScheduleMessage {
+    
+    const filterSensitiveLog: (obj: CreateSnapshotScheduleMessage) => any;
+}
+
+export interface ScheduleDefinitionTypeUnsupportedFault extends __SmithyException, $MetadataBearer {
+    name: "ScheduleDefinitionTypeUnsupportedFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace ScheduleDefinitionTypeUnsupportedFault {
+    
+    const filterSensitiveLog: (obj: ScheduleDefinitionTypeUnsupportedFault) => any;
+}
+
+export interface SnapshotSchedule {
+    
+    ScheduleDefinitions?: string[];
+    
+    ScheduleIdentifier?: string;
+    
+    ScheduleDescription?: string;
+    
+    Tags?: Tag[];
+    
+    NextInvocations?: Date[];
+    
+    AssociatedClusterCount?: number;
+    
+    AssociatedClusters?: ClusterAssociatedToSchedule[];
+}
+export declare namespace SnapshotSchedule {
+    
+    const filterSensitiveLog: (obj: SnapshotSchedule) => any;
+}
+
+export interface SnapshotScheduleAlreadyExistsFault extends __SmithyException, $MetadataBearer {
+    name: "SnapshotScheduleAlreadyExistsFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace SnapshotScheduleAlreadyExistsFault {
+    
+    const filterSensitiveLog: (obj: SnapshotScheduleAlreadyExistsFault) => any;
+}
+
+export interface SnapshotScheduleQuotaExceededFault extends __SmithyException, $MetadataBearer {
+    name: "SnapshotScheduleQuotaExceededFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace SnapshotScheduleQuotaExceededFault {
+    
+    const filterSensitiveLog: (obj: SnapshotScheduleQuotaExceededFault) => any;
+}
+
+export interface CreateTagsMessage {
+    
+    ResourceName: string | undefined;
+    
+    Tags: Tag[] | undefined;
+}
+export declare namespace CreateTagsMessage {
+    
+    const filterSensitiveLog: (obj: CreateTagsMessage) => any;
+}
+
+export interface ResourceNotFoundFault extends __SmithyException, $MetadataBearer {
+    name: "ResourceNotFoundFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace ResourceNotFoundFault {
+    
+    const filterSensitiveLog: (obj: ResourceNotFoundFault) => any;
+}
+export declare enum UsageLimitBreachAction {
+    DISABLE = "disable",
+    EMIT_METRIC = "emit-metric",
+    LOG = "log"
+}
+export declare enum UsageLimitFeatureType {
+    CONCURRENCY_SCALING = "concurrency-scaling",
+    SPECTRUM = "spectrum"
+}
+export declare enum UsageLimitLimitType {
+    DATA_SCANNED = "data-scanned",
+    TIME = "time"
+}
+export declare enum UsageLimitPeriod {
+    DAILY = "daily",
+    MONTHLY = "monthly",
+    WEEKLY = "weekly"
+}
+export interface CreateUsageLimitMessage {
+    
+    ClusterIdentifier: string | undefined;
+    
+    FeatureType: UsageLimitFeatureType | string | undefined;
+    
+    LimitType: UsageLimitLimitType | string | undefined;
+    
+    Amount: number | undefined;
+    
+    Period?: UsageLimitPeriod | string;
+    
+    BreachAction?: UsageLimitBreachAction | string;
+    
+    Tags?: Tag[];
+}
+export declare namespace CreateUsageLimitMessage {
+    
+    const filterSensitiveLog: (obj: CreateUsageLimitMessage) => any;
+}
+
+export interface InvalidUsageLimitFault extends __SmithyException, $MetadataBearer {
+    name: "InvalidUsageLimitFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace InvalidUsageLimitFault {
+    
+    const filterSensitiveLog: (obj: InvalidUsageLimitFault) => any;
+}
+
+export interface UsageLimit {
+    
+    UsageLimitId?: string;
+    
+    ClusterIdentifier?: string;
+    
+    FeatureType?: UsageLimitFeatureType | string;
+    
+    LimitType?: UsageLimitLimitType | string;
+    
+    Amount?: number;
+    
+    Period?: UsageLimitPeriod | string;
+    
+    BreachAction?: UsageLimitBreachAction | string;
+    
+    Tags?: Tag[];
+}
+export declare namespace UsageLimit {
+    
+    const filterSensitiveLog: (obj: UsageLimit) => any;
+}
+
+export interface UsageLimitAlreadyExistsFault extends __SmithyException, $MetadataBearer {
+    name: "UsageLimitAlreadyExistsFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace UsageLimitAlreadyExistsFault {
+    
+    const filterSensitiveLog: (obj: UsageLimitAlreadyExistsFault) => any;
+}
+export interface CustomerStorageMessage {
+    
+    TotalBackupSizeInMegaBytes?: number;
+    
+    TotalProvisionedStorageInMegaBytes?: number;
+}
+export declare namespace CustomerStorageMessage {
+    
+    const filterSensitiveLog: (obj: CustomerStorageMessage) => any;
+}
+export declare enum DataShareStatusForConsumer {
+    ACTIVE = "ACTIVE",
+    AVAILABLE = "AVAILABLE"
+}
+export declare enum DataShareStatusForProducer {
+    ACTIVE = "ACTIVE",
+    AUTHORIZED = "AUTHORIZED",
+    DEAUTHORIZED = "DEAUTHORIZED",
+    PENDING_AUTHORIZATION = "PENDING_AUTHORIZATION",
+    REJECTED = "REJECTED"
+}
+export interface DeauthorizeDataShareMessage {
+    
+    DataShareArn: string | undefined;
+    
+    ConsumerIdentifier: string | undefined;
+}
+export declare namespace DeauthorizeDataShareMessage {
+    
+    const filterSensitiveLog: (obj: DeauthorizeDataShareMessage) => any;
+}
+
+export interface DefaultClusterParameters {
+    
+    ParameterGroupFamily?: string;
+    
+    Marker?: string;
+    
+    Parameters?: Parameter[];
+}
+export declare namespace DefaultClusterParameters {
+    
+    const filterSensitiveLog: (obj: DefaultClusterParameters) => any;
+}
+export interface DeleteAuthenticationProfileMessage {
+    
+    AuthenticationProfileName: string | undefined;
+}
+export declare namespace DeleteAuthenticationProfileMessage {
+    
+    const filterSensitiveLog: (obj: DeleteAuthenticationProfileMessage) => any;
+}
+export interface DeleteAuthenticationProfileResult {
+    
+    AuthenticationProfileName?: string;
+}
+export declare namespace DeleteAuthenticationProfileResult {
+    
+    const filterSensitiveLog: (obj: DeleteAuthenticationProfileResult) => any;
+}
+
+export interface DeleteClusterMessage {
+    
+    ClusterIdentifier: string | undefined;
+    
+    SkipFinalClusterSnapshot?: boolean;
+    
+    FinalClusterSnapshotIdentifier?: string;
+    
+    FinalClusterSnapshotRetentionPeriod?: number;
+}
+export declare namespace DeleteClusterMessage {
+    
+    const filterSensitiveLog: (obj: DeleteClusterMessage) => any;
+}
+export interface DeleteClusterResult {
+    
+    Cluster?: Cluster;
+}
+export declare namespace DeleteClusterResult {
+    
+    const filterSensitiveLog: (obj: DeleteClusterResult) => any;
+}
+
+export interface DeleteClusterParameterGroupMessage {
+    
+    ParameterGroupName: string | undefined;
+}
+export declare namespace DeleteClusterParameterGroupMessage {
+    
+    const filterSensitiveLog: (obj: DeleteClusterParameterGroupMessage) => any;
+}
+
+export interface InvalidClusterParameterGroupStateFault extends __SmithyException, $MetadataBearer {
+    name: "InvalidClusterParameterGroupStateFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace InvalidClusterParameterGroupStateFault {
+    
+    const filterSensitiveLog: (obj: InvalidClusterParameterGroupStateFault) => any;
+}
+
+export interface DeleteClusterSecurityGroupMessage {
+    
+    ClusterSecurityGroupName: string | undefined;
+}
+export declare namespace DeleteClusterSecurityGroupMessage {
+    
+    const filterSensitiveLog: (obj: DeleteClusterSecurityGroupMessage) => any;
+}
+export interface DeleteClusterSnapshotResult {
+    
+    Snapshot?: Snapshot;
+}
+export declare namespace DeleteClusterSnapshotResult {
+    
+    const filterSensitiveLog: (obj: DeleteClusterSnapshotResult) => any;
+}
+
+export interface DeleteClusterSubnetGroupMessage {
+    
+    ClusterSubnetGroupName: string | undefined;
+}
+export declare namespace DeleteClusterSubnetGroupMessage {
+    
+    const filterSensitiveLog: (obj: DeleteClusterSubnetGroupMessage) => any;
+}
+
+export interface InvalidClusterSubnetStateFault extends __SmithyException, $MetadataBearer {
+    name: "InvalidClusterSubnetStateFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace InvalidClusterSubnetStateFault {
+    
+    const filterSensitiveLog: (obj: InvalidClusterSubnetStateFault) => any;
+}
+export interface DeleteEndpointAccessMessage {
+    
+    EndpointName: string | undefined;
+}
+export declare namespace DeleteEndpointAccessMessage {
+    
+    const filterSensitiveLog: (obj: DeleteEndpointAccessMessage) => any;
+}
+
+export interface EndpointNotFoundFault extends __SmithyException, $MetadataBearer {
+    name: "EndpointNotFoundFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace EndpointNotFoundFault {
+    
+    const filterSensitiveLog: (obj: EndpointNotFoundFault) => any;
+}
+
+export interface InvalidEndpointStateFault extends __SmithyException, $MetadataBearer {
+    name: "InvalidEndpointStateFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace InvalidEndpointStateFault {
+    
+    const filterSensitiveLog: (obj: InvalidEndpointStateFault) => any;
+}
+
+export interface DeleteEventSubscriptionMessage {
+    
+    SubscriptionName: string | undefined;
+}
+export declare namespace DeleteEventSubscriptionMessage {
+    
+    const filterSensitiveLog: (obj: DeleteEventSubscriptionMessage) => any;
+}
+
+export interface InvalidSubscriptionStateFault extends __SmithyException, $MetadataBearer {
+    name: "InvalidSubscriptionStateFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace InvalidSubscriptionStateFault {
+    
+    const filterSensitiveLog: (obj: InvalidSubscriptionStateFault) => any;
+}
+
+export interface SubscriptionNotFoundFault extends __SmithyException, $MetadataBearer {
+    name: "SubscriptionNotFoundFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace SubscriptionNotFoundFault {
+    
+    const filterSensitiveLog: (obj: SubscriptionNotFoundFault) => any;
+}
+
+export interface DeleteHsmClientCertificateMessage {
+    
+    HsmClientCertificateIdentifier: string | undefined;
+}
+export declare namespace DeleteHsmClientCertificateMessage {
+    
+    const filterSensitiveLog: (obj: DeleteHsmClientCertificateMessage) => any;
+}
+
+export interface InvalidHsmClientCertificateStateFault extends __SmithyException, $MetadataBearer {
+    name: "InvalidHsmClientCertificateStateFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace InvalidHsmClientCertificateStateFault {
+    
+    const filterSensitiveLog: (obj: InvalidHsmClientCertificateStateFault) => any;
+}
+
+export interface DeleteHsmConfigurationMessage {
+    
+    HsmConfigurationIdentifier: string | undefined;
+}
+export declare namespace DeleteHsmConfigurationMessage {
+    
+    const filterSensitiveLog: (obj: DeleteHsmConfigurationMessage) => any;
+}
+
+export interface InvalidHsmConfigurationStateFault extends __SmithyException, $MetadataBearer {
+    name: "InvalidHsmConfigurationStateFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace InvalidHsmConfigurationStateFault {
+    
+    const filterSensitiveLog: (obj: InvalidHsmConfigurationStateFault) => any;
+}
+export interface DeleteScheduledActionMessage {
+    
+    ScheduledActionName: string | undefined;
+}
+export declare namespace DeleteScheduledActionMessage {
+    
+    const filterSensitiveLog: (obj: DeleteScheduledActionMessage) => any;
+}
+
+export interface ScheduledActionNotFoundFault extends __SmithyException, $MetadataBearer {
+    name: "ScheduledActionNotFoundFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace ScheduledActionNotFoundFault {
+    
+    const filterSensitiveLog: (obj: ScheduledActionNotFoundFault) => any;
+}
+
+export interface DeleteSnapshotCopyGrantMessage {
+    
+    SnapshotCopyGrantName: string | undefined;
+}
+export declare namespace DeleteSnapshotCopyGrantMessage {
+    
+    const filterSensitiveLog: (obj: DeleteSnapshotCopyGrantMessage) => any;
+}
+
+export interface InvalidSnapshotCopyGrantStateFault extends __SmithyException, $MetadataBearer {
+    name: "InvalidSnapshotCopyGrantStateFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace InvalidSnapshotCopyGrantStateFault {
+    
+    const filterSensitiveLog: (obj: InvalidSnapshotCopyGrantStateFault) => any;
+}
+
+export interface SnapshotCopyGrantNotFoundFault extends __SmithyException, $MetadataBearer {
+    name: "SnapshotCopyGrantNotFoundFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace SnapshotCopyGrantNotFoundFault {
+    
+    const filterSensitiveLog: (obj: SnapshotCopyGrantNotFoundFault) => any;
+}
+export interface DeleteSnapshotScheduleMessage {
+    
+    ScheduleIdentifier: string | undefined;
+}
+export declare namespace DeleteSnapshotScheduleMessage {
+    
+    const filterSensitiveLog: (obj: DeleteSnapshotScheduleMessage) => any;
+}
+
+export interface InvalidClusterSnapshotScheduleStateFault extends __SmithyException, $MetadataBearer {
+    name: "InvalidClusterSnapshotScheduleStateFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace InvalidClusterSnapshotScheduleStateFault {
+    
+    const filterSensitiveLog: (obj: InvalidClusterSnapshotScheduleStateFault) => any;
+}
+
+export interface DeleteTagsMessage {
+    
+    ResourceName: string | undefined;
+    
+    TagKeys: string[] | undefined;
+}
+export declare namespace DeleteTagsMessage {
+    
+    const filterSensitiveLog: (obj: DeleteTagsMessage) => any;
+}
+export interface DeleteUsageLimitMessage {
+    
+    UsageLimitId: string | undefined;
+}
+export declare namespace DeleteUsageLimitMessage {
+    
+    const filterSensitiveLog: (obj: DeleteUsageLimitMessage) => any;
+}
+
+export interface UsageLimitNotFoundFault extends __SmithyException, $MetadataBearer {
+    name: "UsageLimitNotFoundFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace UsageLimitNotFoundFault {
+    
+    const filterSensitiveLog: (obj: UsageLimitNotFoundFault) => any;
+}
+export interface DescribeAccountAttributesMessage {
+    
+    AttributeNames?: string[];
+}
+export declare namespace DescribeAccountAttributesMessage {
+    
+    const filterSensitiveLog: (obj: DescribeAccountAttributesMessage) => any;
+}
+export interface DescribeAuthenticationProfilesMessage {
+    
+    AuthenticationProfileName?: string;
+}
+export declare namespace DescribeAuthenticationProfilesMessage {
+    
+    const filterSensitiveLog: (obj: DescribeAuthenticationProfilesMessage) => any;
+}
+export interface DescribeAuthenticationProfilesResult {
+    
+    AuthenticationProfiles?: AuthenticationProfile[];
+}
+export declare namespace DescribeAuthenticationProfilesResult {
+    
+    const filterSensitiveLog: (obj: DescribeAuthenticationProfilesResult) => any;
+}
+export interface DescribeClusterDbRevisionsMessage {
+    
+    ClusterIdentifier?: string;
+    
+    MaxRecords?: number;
+    
+    Marker?: string;
+}
+export declare namespace DescribeClusterDbRevisionsMessage {
+    
+    const filterSensitiveLog: (obj: DescribeClusterDbRevisionsMessage) => any;
+}
+
+export interface DescribeClusterParameterGroupsMessage {
+    
+    ParameterGroupName?: string;
+    
+    MaxRecords?: number;
+    
+    Marker?: string;
+    
+    TagKeys?: string[];
+    
+    TagValues?: string[];
+}
+export declare namespace DescribeClusterParameterGroupsMessage {
+    
+    const filterSensitiveLog: (obj: DescribeClusterParameterGroupsMessage) => any;
+}
+
+export interface DescribeClusterParametersMessage {
+    
+    ParameterGroupName: string | undefined;
+    
+    Source?: string;
+    
+    MaxRecords?: number;
+    
+    Marker?: string;
+}
+export declare namespace DescribeClusterParametersMessage {
+    
+    const filterSensitiveLog: (obj: DescribeClusterParametersMessage) => any;
+}
+
+export interface DescribeClustersMessage {
+    
+    ClusterIdentifier?: string;
+    
+    MaxRecords?: number;
+    
+    Marker?: string;
+    
+    TagKeys?: string[];
+    
+    TagValues?: string[];
+}
+export declare namespace DescribeClustersMessage {
+    
+    const filterSensitiveLog: (obj: DescribeClustersMessage) => any;
+}
+
+export interface DescribeClusterSecurityGroupsMessage {
+    
+    ClusterSecurityGroupName?: string;
+    
+    MaxRecords?: number;
+    
+    Marker?: string;
+    
+    TagKeys?: string[];
+    
+    TagValues?: string[];
+}
+export declare namespace DescribeClusterSecurityGroupsMessage {
+    
+    const filterSensitiveLog: (obj: DescribeClusterSecurityGroupsMessage) => any;
+}
+export declare enum SnapshotAttributeToSortBy {
+    CREATE_TIME = "CREATE_TIME",
+    SOURCE_TYPE = "SOURCE_TYPE",
+    TOTAL_SIZE = "TOTAL_SIZE"
+}
+export declare enum SortByOrder {
+    ASCENDING = "ASC",
+    DESCENDING = "DESC"
+}
+
+export interface SnapshotSortingEntity {
+    
+    Attribute: SnapshotAttributeToSortBy | string | undefined;
+    
+    SortOrder?: SortByOrder | string;
+}
+export declare namespace SnapshotSortingEntity {
+    
+    const filterSensitiveLog: (obj: SnapshotSortingEntity) => any;
+}
+
+export interface DescribeClusterSnapshotsMessage {
+    
+    ClusterIdentifier?: string;
+    
+    SnapshotIdentifier?: string;
+    
+    SnapshotType?: string;
+    
+    StartTime?: Date;
+    
+    EndTime?: Date;
+    
+    MaxRecords?: number;
+    
+    Marker?: string;
+    
+    OwnerAccount?: string;
+    
+    TagKeys?: string[];
+    
+    TagValues?: string[];
+    
+    ClusterExists?: boolean;
+    
+    SortingEntities?: SnapshotSortingEntity[];
+}
+export declare namespace DescribeClusterSnapshotsMessage {
+    
+    const filterSensitiveLog: (obj: DescribeClusterSnapshotsMessage) => any;
+}
+
+export interface SnapshotMessage {
+    
+    Marker?: string;
+    
+    Snapshots?: Snapshot[];
+}
+export declare namespace SnapshotMessage {
+    
+    const filterSensitiveLog: (obj: SnapshotMessage) => any;
+}
+
+export interface DescribeClusterSubnetGroupsMessage {
+    
+    ClusterSubnetGroupName?: string;
+    
+    MaxRecords?: number;
+    
+    Marker?: string;
+    
+    TagKeys?: string[];
+    
+    TagValues?: string[];
+}
+export declare namespace DescribeClusterSubnetGroupsMessage {
+    
+    const filterSensitiveLog: (obj: DescribeClusterSubnetGroupsMessage) => any;
+}
+export interface DescribeClusterTracksMessage {
+    
+    MaintenanceTrackName?: string;
+    
+    MaxRecords?: number;
+    
+    Marker?: string;
+}
+export declare namespace DescribeClusterTracksMessage {
+    
+    const filterSensitiveLog: (obj: DescribeClusterTracksMessage) => any;
+}
+
+export interface SupportedOperation {
+    
+    OperationName?: string;
+}
+export declare namespace SupportedOperation {
+    
+    const filterSensitiveLog: (obj: SupportedOperation) => any;
+}
+
+export interface UpdateTarget {
+    
+    MaintenanceTrackName?: string;
+    
+    DatabaseVersion?: string;
+    
+    SupportedOperations?: SupportedOperation[];
+}
+export declare namespace UpdateTarget {
+    
+    const filterSensitiveLog: (obj: UpdateTarget) => any;
+}
+
+export interface MaintenanceTrack {
+    
+    MaintenanceTrackName?: string;
+    
+    DatabaseVersion?: string;
+    
+    UpdateTargets?: UpdateTarget[];
+}
+export declare namespace MaintenanceTrack {
+    
+    const filterSensitiveLog: (obj: MaintenanceTrack) => any;
+}
+export interface TrackListMessage {
+    
+    MaintenanceTracks?: MaintenanceTrack[];
+    
+    Marker?: string;
+}
+export declare namespace TrackListMessage {
+    
+    const filterSensitiveLog: (obj: TrackListMessage) => any;
+}
+
+export interface DescribeClusterVersionsMessage {
+    
+    ClusterVersion?: string;
+    
+    ClusterParameterGroupFamily?: string;
+    
+    MaxRecords?: number;
+    
+    Marker?: string;
+}
+export declare namespace DescribeClusterVersionsMessage {
+    
+    const filterSensitiveLog: (obj: DescribeClusterVersionsMessage) => any;
+}
+export interface DescribeDataSharesMessage {
+    
+    DataShareArn?: string;
+    
+    MaxRecords?: number;
+    
+    Marker?: string;
+}
+export declare namespace DescribeDataSharesMessage {
+    
+    const filterSensitiveLog: (obj: DescribeDataSharesMessage) => any;
+}
+export interface DescribeDataSharesResult {
+    
+    DataShares?: DataShare[];
+    
+    Marker?: string;
+}
+export declare namespace DescribeDataSharesResult {
+    
+    const filterSensitiveLog: (obj: DescribeDataSharesResult) => any;
+}
+export interface DescribeDataSharesForConsumerMessage {
+    
+    ConsumerArn?: string;
+    
+    Status?: DataShareStatusForConsumer | string;
+    
+    MaxRecords?: number;
+    
+    Marker?: string;
+}
+export declare namespace DescribeDataSharesForConsumerMessage {
+    
+    const filterSensitiveLog: (obj: DescribeDataSharesForConsumerMessage) => any;
+}
+export interface DescribeDataSharesForConsumerResult {
+    
+    DataShares?: DataShare[];
+    
+    Marker?: string;
+}
+export declare namespace DescribeDataSharesForConsumerResult {
+    
+    const filterSensitiveLog: (obj: DescribeDataSharesForConsumerResult) => any;
+}
+export interface DescribeDataSharesForProducerMessage {
+    
+    ProducerArn?: string;
+    
+    Status?: DataShareStatusForProducer | string;
+    
+    MaxRecords?: number;
+    
+    Marker?: string;
+}
+export declare namespace DescribeDataSharesForProducerMessage {
+    
+    const filterSensitiveLog: (obj: DescribeDataSharesForProducerMessage) => any;
+}
+export interface DescribeDataSharesForProducerResult {
+    
+    DataShares?: DataShare[];
+    
+    Marker?: string;
+}
+export declare namespace DescribeDataSharesForProducerResult {
+    
+    const filterSensitiveLog: (obj: DescribeDataSharesForProducerResult) => any;
+}
+
+export interface DescribeDefaultClusterParametersMessage {
+    
+    ParameterGroupFamily: string | undefined;
+    
+    MaxRecords?: number;
+    
+    Marker?: string;
+}
+export declare namespace DescribeDefaultClusterParametersMessage {
+    
+    const filterSensitiveLog: (obj: DescribeDefaultClusterParametersMessage) => any;
+}
+export interface DescribeDefaultClusterParametersResult {
+    
+    DefaultClusterParameters?: DefaultClusterParameters;
+}
+export declare namespace DescribeDefaultClusterParametersResult {
+    
+    const filterSensitiveLog: (obj: DescribeDefaultClusterParametersResult) => any;
+}
+export interface DescribeEndpointAccessMessage {
+    
+    ClusterIdentifier?: string;
+    
+    ResourceOwner?: string;
+    
+    EndpointName?: string;
+    
+    VpcId?: string;
+    
+    MaxRecords?: number;
+    
+    Marker?: string;
+}
+export declare namespace DescribeEndpointAccessMessage {
+    
+    const filterSensitiveLog: (obj: DescribeEndpointAccessMessage) => any;
+}
+export interface EndpointAccessList {
+    
+    EndpointAccessList?: EndpointAccess[];
+    
+    Marker?: string;
+}
+export declare namespace EndpointAccessList {
+    
+    const filterSensitiveLog: (obj: EndpointAccessList) => any;
+}
+export interface DescribeEndpointAuthorizationMessage {
+    
+    ClusterIdentifier?: string;
+    
+    Account?: string;
+    
+    Grantee?: boolean;
+    
+    MaxRecords?: number;
+    
+    Marker?: string;
+}
+export declare namespace DescribeEndpointAuthorizationMessage {
+    
+    const filterSensitiveLog: (obj: DescribeEndpointAuthorizationMessage) => any;
+}
+export interface EndpointAuthorizationList {
+    
+    EndpointAuthorizationList?: EndpointAuthorization[];
+    
+    Marker?: string;
+}
+export declare namespace EndpointAuthorizationList {
+    
+    const filterSensitiveLog: (obj: EndpointAuthorizationList) => any;
+}
+
+export interface DescribeEventCategoriesMessage {
+    
+    SourceType?: string;
+}
+export declare namespace DescribeEventCategoriesMessage {
+    
+    const filterSensitiveLog: (obj: DescribeEventCategoriesMessage) => any;
+}
+
+export interface EventInfoMap {
+    
+    EventId?: string;
+    
+    EventCategories?: string[];
+    
+    EventDescription?: string;
+    
+    Severity?: string;
+}
+export declare namespace EventInfoMap {
+    
+    const filterSensitiveLog: (obj: EventInfoMap) => any;
+}
+
+export interface EventCategoriesMap {
+    
+    SourceType?: string;
+    
+    Events?: EventInfoMap[];
+}
+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 = "cluster" | "cluster-parameter-group" | "cluster-security-group" | "cluster-snapshot" | "scheduled-action";
+
+export interface DescribeEventsMessage {
+    
+    SourceIdentifier?: string;
+    
+    SourceType?: SourceType | string;
+    
+    StartTime?: Date;
+    
+    EndTime?: Date;
+    
+    Duration?: number;
+    
+    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[];
+    
+    Severity?: string;
+    
+    Date?: Date;
+    
+    EventId?: 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;
+    
+    MaxRecords?: number;
+    
+    Marker?: string;
+    
+    TagKeys?: string[];
+    
+    TagValues?: 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 DescribeHsmClientCertificatesMessage {
+    
+    HsmClientCertificateIdentifier?: string;
+    
+    MaxRecords?: number;
+    
+    Marker?: string;
+    
+    TagKeys?: string[];
+    
+    TagValues?: string[];
+}
+export declare namespace DescribeHsmClientCertificatesMessage {
+    
+    const filterSensitiveLog: (obj: DescribeHsmClientCertificatesMessage) => any;
+}
+
+export interface HsmClientCertificateMessage {
+    
+    Marker?: string;
+    
+    HsmClientCertificates?: HsmClientCertificate[];
+}
+export declare namespace HsmClientCertificateMessage {
+    
+    const filterSensitiveLog: (obj: HsmClientCertificateMessage) => any;
+}
+
+export interface DescribeHsmConfigurationsMessage {
+    
+    HsmConfigurationIdentifier?: string;
+    
+    MaxRecords?: number;
+    
+    Marker?: string;
+    
+    TagKeys?: string[];
+    
+    TagValues?: string[];
+}
+export declare namespace DescribeHsmConfigurationsMessage {
+    
+    const filterSensitiveLog: (obj: DescribeHsmConfigurationsMessage) => any;
+}
+
+export interface HsmConfigurationMessage {
+    
+    Marker?: string;
+    
+    HsmConfigurations?: HsmConfiguration[];
+}
+export declare namespace HsmConfigurationMessage {
+    
+    const filterSensitiveLog: (obj: HsmConfigurationMessage) => any;
+}
+
+export interface DescribeLoggingStatusMessage {
+    
+    ClusterIdentifier: string | undefined;
+}
+export declare namespace DescribeLoggingStatusMessage {
+    
+    const filterSensitiveLog: (obj: DescribeLoggingStatusMessage) => any;
+}