@aws-sdk/client-redshift 3.50.0 → 3.53.0

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

@@ -0,0 +1,3351 @@
+import { ExceptionOptionType as __ExceptionOptionType } from "@aws-sdk/smithy-client";
+import { RedshiftServiceException as __BaseException } from "./RedshiftServiceException";
+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 declare class DependentServiceUnavailableFault extends __BaseException {
+    readonly name: "DependentServiceUnavailableFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<DependentServiceUnavailableFault, __BaseException>);
+}
+
+export declare class InvalidReservedNodeStateFault extends __BaseException {
+    readonly name: "InvalidReservedNodeStateFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<InvalidReservedNodeStateFault, __BaseException>);
+}
+
+export declare class ReservedNodeAlreadyExistsFault extends __BaseException {
+    readonly name: "ReservedNodeAlreadyExistsFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<ReservedNodeAlreadyExistsFault, __BaseException>);
+}
+
+export declare class ReservedNodeAlreadyMigratedFault extends __BaseException {
+    readonly name: "ReservedNodeAlreadyMigratedFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<ReservedNodeAlreadyMigratedFault, __BaseException>);
+}
+
+export declare class ReservedNodeNotFoundFault extends __BaseException {
+    readonly name: "ReservedNodeNotFoundFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<ReservedNodeNotFoundFault, __BaseException>);
+}
+
+export declare class ReservedNodeOfferingNotFoundFault extends __BaseException {
+    readonly name: "ReservedNodeOfferingNotFoundFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<ReservedNodeOfferingNotFoundFault, __BaseException>);
+}
+
+export declare class UnsupportedOperationFault extends __BaseException {
+    readonly name: "UnsupportedOperationFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<UnsupportedOperationFault, __BaseException>);
+}
+
+export declare class AccessToClusterDeniedFault extends __BaseException {
+    readonly name: "AccessToClusterDeniedFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<AccessToClusterDeniedFault, __BaseException>);
+}
+
+export declare class AccessToSnapshotDeniedFault extends __BaseException {
+    readonly name: "AccessToSnapshotDeniedFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<AccessToSnapshotDeniedFault, __BaseException>);
+}
+
+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 declare class ClusterNotFoundFault extends __BaseException {
+    readonly name: "ClusterNotFoundFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<ClusterNotFoundFault, __BaseException>);
+}
+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 declare class PartnerNotFoundFault extends __BaseException {
+    readonly name: "PartnerNotFoundFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<PartnerNotFoundFault, __BaseException>);
+}
+
+export declare class UnauthorizedPartnerIntegrationFault extends __BaseException {
+    readonly name: "UnauthorizedPartnerIntegrationFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<UnauthorizedPartnerIntegrationFault, __BaseException>);
+}
+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;
+    
+    ConsumerRegion?: 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;
+    
+    ConsumerRegion?: 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[];
+    
+    ManagedBy?: string;
+}
+export declare namespace DataShare {
+    
+    const filterSensitiveLog: (obj: DataShare) => any;
+}
+
+export declare class InvalidDataShareFault extends __BaseException {
+    readonly name: "InvalidDataShareFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<InvalidDataShareFault, __BaseException>);
+}
+
+export declare class InvalidNamespaceFault extends __BaseException {
+    readonly name: "InvalidNamespaceFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<InvalidNamespaceFault, __BaseException>);
+}
+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 declare class AuthenticationProfileAlreadyExistsFault extends __BaseException {
+    readonly name: "AuthenticationProfileAlreadyExistsFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<AuthenticationProfileAlreadyExistsFault, __BaseException>);
+}
+
+export declare class AuthenticationProfileNotFoundFault extends __BaseException {
+    readonly name: "AuthenticationProfileNotFoundFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<AuthenticationProfileNotFoundFault, __BaseException>);
+}
+
+export declare class AuthenticationProfileQuotaExceededFault extends __BaseException {
+    readonly name: "AuthenticationProfileQuotaExceededFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<AuthenticationProfileQuotaExceededFault, __BaseException>);
+}
+
+export declare class AuthorizationAlreadyExistsFault extends __BaseException {
+    readonly name: "AuthorizationAlreadyExistsFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<AuthorizationAlreadyExistsFault, __BaseException>);
+}
+
+export declare class AuthorizationNotFoundFault extends __BaseException {
+    readonly name: "AuthorizationNotFoundFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<AuthorizationNotFoundFault, __BaseException>);
+}
+
+export declare class AuthorizationQuotaExceededFault extends __BaseException {
+    readonly name: "AuthorizationQuotaExceededFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<AuthorizationQuotaExceededFault, __BaseException>);
+}
+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 declare class ClusterSecurityGroupNotFoundFault extends __BaseException {
+    readonly name: "ClusterSecurityGroupNotFoundFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<ClusterSecurityGroupNotFoundFault, __BaseException>);
+}
+
+export declare class InvalidClusterSecurityGroupStateFault extends __BaseException {
+    readonly name: "InvalidClusterSecurityGroupStateFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<InvalidClusterSecurityGroupStateFault, __BaseException>);
+}
+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 declare class EndpointAuthorizationAlreadyExistsFault extends __BaseException {
+    readonly name: "EndpointAuthorizationAlreadyExistsFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<EndpointAuthorizationAlreadyExistsFault, __BaseException>);
+}
+
+export declare class EndpointAuthorizationsPerClusterLimitExceededFault extends __BaseException {
+    readonly name: "EndpointAuthorizationsPerClusterLimitExceededFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<EndpointAuthorizationsPerClusterLimitExceededFault, __BaseException>);
+}
+
+export declare class InvalidAuthorizationStateFault extends __BaseException {
+    readonly name: "InvalidAuthorizationStateFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<InvalidAuthorizationStateFault, __BaseException>);
+}
+
+export declare class InvalidClusterStateFault extends __BaseException {
+    readonly name: "InvalidClusterStateFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<InvalidClusterStateFault, __BaseException>);
+}
+
+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 declare class ClusterSnapshotNotFoundFault extends __BaseException {
+    readonly name: "ClusterSnapshotNotFoundFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<ClusterSnapshotNotFoundFault, __BaseException>);
+}
+
+export declare class DependentServiceRequestThrottlingFault extends __BaseException {
+    readonly name: "DependentServiceRequestThrottlingFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<DependentServiceRequestThrottlingFault, __BaseException>);
+}
+
+export declare class InvalidClusterSnapshotStateFault extends __BaseException {
+    readonly name: "InvalidClusterSnapshotStateFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<InvalidClusterSnapshotStateFault, __BaseException>);
+}
+
+export declare class LimitExceededFault extends __BaseException {
+    readonly name: "LimitExceededFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<LimitExceededFault, __BaseException>);
+}
+
+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 declare class BatchDeleteRequestSizeExceededFault extends __BaseException {
+    readonly name: "BatchDeleteRequestSizeExceededFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<BatchDeleteRequestSizeExceededFault, __BaseException>);
+}
+
+export declare class BatchModifyClusterSnapshotsLimitExceededFault extends __BaseException {
+    readonly name: "BatchModifyClusterSnapshotsLimitExceededFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<BatchModifyClusterSnapshotsLimitExceededFault, __BaseException>);
+}
+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 declare class InvalidRetentionPeriodFault extends __BaseException {
+    readonly name: "InvalidRetentionPeriodFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<InvalidRetentionPeriodFault, __BaseException>);
+}
+
+export declare class BucketNotFoundFault extends __BaseException {
+    readonly name: "BucketNotFoundFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<BucketNotFoundFault, __BaseException>);
+}
+export interface CancelResizeMessage {
+    
+    ClusterIdentifier: string | undefined;
+}
+export declare namespace CancelResizeMessage {
+    
+    const filterSensitiveLog: (obj: CancelResizeMessage) => any;
+}
+
+export declare class ResizeNotFoundFault extends __BaseException {
+    readonly name: "ResizeNotFoundFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<ResizeNotFoundFault, __BaseException>);
+}
+
+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 declare enum ReservedNodeExchangeStatusType {
+    FAILED = "FAILED",
+    IN_PROGRESS = "IN_PROGRESS",
+    PENDING = "PENDING",
+    REQUESTED = "REQUESTED",
+    RETRYING = "RETRYING",
+    SUCCEEDED = "SUCCEEDED"
+}
+
+export interface ReservedNodeExchangeStatus {
+    
+    ReservedNodeExchangeRequestId?: string;
+    
+    Status?: ReservedNodeExchangeStatusType | string;
+    
+    RequestTime?: Date;
+    
+    SourceReservedNodeId?: string;
+    
+    SourceReservedNodeType?: string;
+    
+    SourceReservedNodeCount?: number;
+    
+    TargetReservedNodeOfferingId?: string;
+    
+    TargetReservedNodeType?: string;
+    
+    TargetReservedNodeCount?: number;
+}
+export declare namespace ReservedNodeExchangeStatus {
+    
+    const filterSensitiveLog: (obj: ReservedNodeExchangeStatus) => 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;
+    
+    DefaultIamRoleArn?: string;
+    
+    ReservedNodeExchangeStatus?: ReservedNodeExchangeStatus;
+}
+export declare namespace Cluster {
+    
+    const filterSensitiveLog: (obj: Cluster) => any;
+}
+
+export declare class ClusterAlreadyExistsFault extends __BaseException {
+    readonly name: "ClusterAlreadyExistsFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<ClusterAlreadyExistsFault, __BaseException>);
+}
+
+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 declare class ClusterOnLatestRevisionFault extends __BaseException {
+    readonly name: "ClusterOnLatestRevisionFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<ClusterOnLatestRevisionFault, __BaseException>);
+}
+
+export interface ClusterParameterGroup {
+    
+    ParameterGroupName?: string;
+    
+    ParameterGroupFamily?: string;
+    
+    Description?: string;
+    
+    Tags?: Tag[];
+}
+export declare namespace ClusterParameterGroup {
+    
+    const filterSensitiveLog: (obj: ClusterParameterGroup) => any;
+}
+
+export declare class ClusterParameterGroupAlreadyExistsFault extends __BaseException {
+    readonly name: "ClusterParameterGroupAlreadyExistsFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<ClusterParameterGroupAlreadyExistsFault, __BaseException>);
+}
+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 declare class ClusterParameterGroupNotFoundFault extends __BaseException {
+    readonly name: "ClusterParameterGroupNotFoundFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<ClusterParameterGroupNotFoundFault, __BaseException>);
+}
+
+export declare class ClusterParameterGroupQuotaExceededFault extends __BaseException {
+    readonly name: "ClusterParameterGroupQuotaExceededFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<ClusterParameterGroupQuotaExceededFault, __BaseException>);
+}
+
+export interface ClusterParameterGroupsMessage {
+    
+    Marker?: string;
+    
+    ParameterGroups?: ClusterParameterGroup[];
+}
+export declare namespace ClusterParameterGroupsMessage {
+    
+    const filterSensitiveLog: (obj: ClusterParameterGroupsMessage) => any;
+}
+
+export declare class ClusterQuotaExceededFault extends __BaseException {
+    readonly name: "ClusterQuotaExceededFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<ClusterQuotaExceededFault, __BaseException>);
+}
+
+export declare class ClusterSecurityGroupAlreadyExistsFault extends __BaseException {
+    readonly name: "ClusterSecurityGroupAlreadyExistsFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<ClusterSecurityGroupAlreadyExistsFault, __BaseException>);
+}
+
+export interface ClusterSecurityGroupMessage {
+    
+    Marker?: string;
+    
+    ClusterSecurityGroups?: ClusterSecurityGroup[];
+}
+export declare namespace ClusterSecurityGroupMessage {
+    
+    const filterSensitiveLog: (obj: ClusterSecurityGroupMessage) => any;
+}
+
+export declare class ClusterSecurityGroupQuotaExceededFault extends __BaseException {
+    readonly name: "ClusterSecurityGroupQuotaExceededFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<ClusterSecurityGroupQuotaExceededFault, __BaseException>);
+}
+
+export interface ClustersMessage {
+    
+    Marker?: string;
+    
+    Clusters?: Cluster[];
+}
+export declare namespace ClustersMessage {
+    
+    const filterSensitiveLog: (obj: ClustersMessage) => any;
+}
+
+export declare class ClusterSnapshotAlreadyExistsFault extends __BaseException {
+    readonly name: "ClusterSnapshotAlreadyExistsFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<ClusterSnapshotAlreadyExistsFault, __BaseException>);
+}
+
+export declare class ClusterSnapshotQuotaExceededFault extends __BaseException {
+    readonly name: "ClusterSnapshotQuotaExceededFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<ClusterSnapshotQuotaExceededFault, __BaseException>);
+}
+
+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 declare class ClusterSubnetGroupAlreadyExistsFault extends __BaseException {
+    readonly name: "ClusterSubnetGroupAlreadyExistsFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<ClusterSubnetGroupAlreadyExistsFault, __BaseException>);
+}
+
+export interface ClusterSubnetGroupMessage {
+    
+    Marker?: string;
+    
+    ClusterSubnetGroups?: ClusterSubnetGroup[];
+}
+export declare namespace ClusterSubnetGroupMessage {
+    
+    const filterSensitiveLog: (obj: ClusterSubnetGroupMessage) => any;
+}
+
+export declare class ClusterSubnetGroupNotFoundFault extends __BaseException {
+    readonly name: "ClusterSubnetGroupNotFoundFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<ClusterSubnetGroupNotFoundFault, __BaseException>);
+}
+
+export declare class ClusterSubnetGroupQuotaExceededFault extends __BaseException {
+    readonly name: "ClusterSubnetGroupQuotaExceededFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<ClusterSubnetGroupQuotaExceededFault, __BaseException>);
+}
+
+export declare class ClusterSubnetQuotaExceededFault extends __BaseException {
+    readonly name: "ClusterSubnetQuotaExceededFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<ClusterSubnetQuotaExceededFault, __BaseException>);
+}
+
+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 declare class CopyToRegionDisabledFault extends __BaseException {
+    readonly name: "CopyToRegionDisabledFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<CopyToRegionDisabledFault, __BaseException>);
+}
+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 declare class InvalidAuthenticationProfileRequestFault extends __BaseException {
+    readonly name: "InvalidAuthenticationProfileRequestFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<InvalidAuthenticationProfileRequestFault, __BaseException>);
+}
+
+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;
+    
+    DefaultIamRoleArn?: 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 declare class HsmClientCertificateNotFoundFault extends __BaseException {
+    readonly name: "HsmClientCertificateNotFoundFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<HsmClientCertificateNotFoundFault, __BaseException>);
+}
+
+export declare class HsmConfigurationNotFoundFault extends __BaseException {
+    readonly name: "HsmConfigurationNotFoundFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<HsmConfigurationNotFoundFault, __BaseException>);
+}
+
+export declare class InsufficientClusterCapacityFault extends __BaseException {
+    readonly name: "InsufficientClusterCapacityFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<InsufficientClusterCapacityFault, __BaseException>);
+}
+
+export declare class InvalidClusterSubnetGroupStateFault extends __BaseException {
+    readonly name: "InvalidClusterSubnetGroupStateFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<InvalidClusterSubnetGroupStateFault, __BaseException>);
+}
+
+export declare class InvalidClusterTrackFault extends __BaseException {
+    readonly name: "InvalidClusterTrackFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<InvalidClusterTrackFault, __BaseException>);
+}
+
+export declare class InvalidElasticIpFault extends __BaseException {
+    readonly name: "InvalidElasticIpFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<InvalidElasticIpFault, __BaseException>);
+}
+
+export declare class InvalidSubnet extends __BaseException {
+    readonly name: "InvalidSubnet";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<InvalidSubnet, __BaseException>);
+}
+
+export declare class InvalidTagFault extends __BaseException {
+    readonly name: "InvalidTagFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<InvalidTagFault, __BaseException>);
+}
+
+export declare class InvalidVPCNetworkStateFault extends __BaseException {
+    readonly name: "InvalidVPCNetworkStateFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<InvalidVPCNetworkStateFault, __BaseException>);
+}
+
+export declare class NumberOfNodesPerClusterLimitExceededFault extends __BaseException {
+    readonly name: "NumberOfNodesPerClusterLimitExceededFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<NumberOfNodesPerClusterLimitExceededFault, __BaseException>);
+}
+
+export declare class NumberOfNodesQuotaExceededFault extends __BaseException {
+    readonly name: "NumberOfNodesQuotaExceededFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<NumberOfNodesQuotaExceededFault, __BaseException>);
+}
+
+export declare class SnapshotScheduleNotFoundFault extends __BaseException {
+    readonly name: "SnapshotScheduleNotFoundFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<SnapshotScheduleNotFoundFault, __BaseException>);
+}
+
+export declare class TagLimitExceededFault extends __BaseException {
+    readonly name: "TagLimitExceededFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<TagLimitExceededFault, __BaseException>);
+}
+
+export declare class UnauthorizedOperation extends __BaseException {
+    readonly name: "UnauthorizedOperation";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<UnauthorizedOperation, __BaseException>);
+}
+
+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 declare class EndpointAlreadyExistsFault extends __BaseException {
+    readonly name: "EndpointAlreadyExistsFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<EndpointAlreadyExistsFault, __BaseException>);
+}
+
+export declare class EndpointsPerAuthorizationLimitExceededFault extends __BaseException {
+    readonly name: "EndpointsPerAuthorizationLimitExceededFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<EndpointsPerAuthorizationLimitExceededFault, __BaseException>);
+}
+
+export declare class EndpointsPerClusterLimitExceededFault extends __BaseException {
+    readonly name: "EndpointsPerClusterLimitExceededFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<EndpointsPerClusterLimitExceededFault, __BaseException>);
+}
+
+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 declare class EventSubscriptionQuotaExceededFault extends __BaseException {
+    readonly name: "EventSubscriptionQuotaExceededFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<EventSubscriptionQuotaExceededFault, __BaseException>);
+}
+
+export declare class SNSInvalidTopicFault extends __BaseException {
+    readonly name: "SNSInvalidTopicFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<SNSInvalidTopicFault, __BaseException>);
+}
+
+export declare class SNSNoAuthorizationFault extends __BaseException {
+    readonly name: "SNSNoAuthorizationFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<SNSNoAuthorizationFault, __BaseException>);
+}
+
+export declare class SNSTopicArnNotFoundFault extends __BaseException {
+    readonly name: "SNSTopicArnNotFoundFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<SNSTopicArnNotFoundFault, __BaseException>);
+}
+
+export declare class SourceNotFoundFault extends __BaseException {
+    readonly name: "SourceNotFoundFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<SourceNotFoundFault, __BaseException>);
+}
+
+export declare class SubscriptionAlreadyExistFault extends __BaseException {
+    readonly name: "SubscriptionAlreadyExistFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<SubscriptionAlreadyExistFault, __BaseException>);
+}
+
+export declare class SubscriptionCategoryNotFoundFault extends __BaseException {
+    readonly name: "SubscriptionCategoryNotFoundFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<SubscriptionCategoryNotFoundFault, __BaseException>);
+}
+
+export declare class SubscriptionEventIdNotFoundFault extends __BaseException {
+    readonly name: "SubscriptionEventIdNotFoundFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<SubscriptionEventIdNotFoundFault, __BaseException>);
+}
+
+export declare class SubscriptionSeverityNotFoundFault extends __BaseException {
+    readonly name: "SubscriptionSeverityNotFoundFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<SubscriptionSeverityNotFoundFault, __BaseException>);
+}
+
+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 declare class HsmClientCertificateAlreadyExistsFault extends __BaseException {
+    readonly name: "HsmClientCertificateAlreadyExistsFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<HsmClientCertificateAlreadyExistsFault, __BaseException>);
+}
+
+export declare class HsmClientCertificateQuotaExceededFault extends __BaseException {
+    readonly name: "HsmClientCertificateQuotaExceededFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<HsmClientCertificateQuotaExceededFault, __BaseException>);
+}
+
+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 declare class HsmConfigurationAlreadyExistsFault extends __BaseException {
+    readonly name: "HsmConfigurationAlreadyExistsFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<HsmConfigurationAlreadyExistsFault, __BaseException>);
+}
+
+export declare class HsmConfigurationQuotaExceededFault extends __BaseException {
+    readonly name: "HsmConfigurationQuotaExceededFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<HsmConfigurationQuotaExceededFault, __BaseException>);
+}
+
+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;
+    
+    ReservedNodeId?: string;
+    
+    TargetReservedNodeOfferingId?: string;
+}
+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 declare class InvalidScheduledActionFault extends __BaseException {
+    readonly name: "InvalidScheduledActionFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<InvalidScheduledActionFault, __BaseException>);
+}
+
+export declare class InvalidScheduleFault extends __BaseException {
+    readonly name: "InvalidScheduleFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<InvalidScheduleFault, __BaseException>);
+}
+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 declare class ScheduledActionAlreadyExistsFault extends __BaseException {
+    readonly name: "ScheduledActionAlreadyExistsFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<ScheduledActionAlreadyExistsFault, __BaseException>);
+}
+
+export declare class ScheduledActionQuotaExceededFault extends __BaseException {
+    readonly name: "ScheduledActionQuotaExceededFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<ScheduledActionQuotaExceededFault, __BaseException>);
+}
+
+export declare class ScheduledActionTypeUnsupportedFault extends __BaseException {
+    readonly name: "ScheduledActionTypeUnsupportedFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<ScheduledActionTypeUnsupportedFault, __BaseException>);
+}
+
+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 declare class SnapshotCopyGrantAlreadyExistsFault extends __BaseException {
+    readonly name: "SnapshotCopyGrantAlreadyExistsFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<SnapshotCopyGrantAlreadyExistsFault, __BaseException>);
+}
+
+export declare class SnapshotCopyGrantQuotaExceededFault extends __BaseException {
+    readonly name: "SnapshotCopyGrantQuotaExceededFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<SnapshotCopyGrantQuotaExceededFault, __BaseException>);
+}
+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 declare class ScheduleDefinitionTypeUnsupportedFault extends __BaseException {
+    readonly name: "ScheduleDefinitionTypeUnsupportedFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<ScheduleDefinitionTypeUnsupportedFault, __BaseException>);
+}
+
+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 declare class SnapshotScheduleAlreadyExistsFault extends __BaseException {
+    readonly name: "SnapshotScheduleAlreadyExistsFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<SnapshotScheduleAlreadyExistsFault, __BaseException>);
+}
+
+export declare class SnapshotScheduleQuotaExceededFault extends __BaseException {
+    readonly name: "SnapshotScheduleQuotaExceededFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<SnapshotScheduleQuotaExceededFault, __BaseException>);
+}
+
+export interface CreateTagsMessage {
+    
+    ResourceName: string | undefined;
+    
+    Tags: Tag[] | undefined;
+}
+export declare namespace CreateTagsMessage {
+    
+    const filterSensitiveLog: (obj: CreateTagsMessage) => any;
+}
+
+export declare class ResourceNotFoundFault extends __BaseException {
+    readonly name: "ResourceNotFoundFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<ResourceNotFoundFault, __BaseException>);
+}
+export declare enum UsageLimitBreachAction {
+    DISABLE = "disable",
+    EMIT_METRIC = "emit-metric",
+    LOG = "log"
+}
+export declare enum UsageLimitFeatureType {
+    CONCURRENCY_SCALING = "concurrency-scaling",
+    CROSS_REGION_DATASHARING = "cross-region-datasharing",
+    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 declare class InvalidUsageLimitFault extends __BaseException {
+    readonly name: "InvalidUsageLimitFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<InvalidUsageLimitFault, __BaseException>);
+}
+
+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 declare class UsageLimitAlreadyExistsFault extends __BaseException {
+    readonly name: "UsageLimitAlreadyExistsFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<UsageLimitAlreadyExistsFault, __BaseException>);
+}
+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 declare class InvalidClusterParameterGroupStateFault extends __BaseException {
+    readonly name: "InvalidClusterParameterGroupStateFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<InvalidClusterParameterGroupStateFault, __BaseException>);
+}
+
+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 declare class InvalidClusterSubnetStateFault extends __BaseException {
+    readonly name: "InvalidClusterSubnetStateFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<InvalidClusterSubnetStateFault, __BaseException>);
+}
+export interface DeleteEndpointAccessMessage {
+    
+    EndpointName: string | undefined;
+}
+export declare namespace DeleteEndpointAccessMessage {
+    
+    const filterSensitiveLog: (obj: DeleteEndpointAccessMessage) => any;
+}
+
+export declare class EndpointNotFoundFault extends __BaseException {
+    readonly name: "EndpointNotFoundFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<EndpointNotFoundFault, __BaseException>);
+}
+
+export declare class InvalidEndpointStateFault extends __BaseException {
+    readonly name: "InvalidEndpointStateFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<InvalidEndpointStateFault, __BaseException>);
+}
+
+export interface DeleteEventSubscriptionMessage {
+    
+    SubscriptionName: string | undefined;
+}
+export declare namespace DeleteEventSubscriptionMessage {
+    
+    const filterSensitiveLog: (obj: DeleteEventSubscriptionMessage) => any;
+}
+
+export declare class InvalidSubscriptionStateFault extends __BaseException {
+    readonly name: "InvalidSubscriptionStateFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<InvalidSubscriptionStateFault, __BaseException>);
+}
+
+export declare class SubscriptionNotFoundFault extends __BaseException {
+    readonly name: "SubscriptionNotFoundFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<SubscriptionNotFoundFault, __BaseException>);
+}
+
+export interface DeleteHsmClientCertificateMessage {
+    
+    HsmClientCertificateIdentifier: string | undefined;
+}
+export declare namespace DeleteHsmClientCertificateMessage {
+    
+    const filterSensitiveLog: (obj: DeleteHsmClientCertificateMessage) => any;
+}
+
+export declare class InvalidHsmClientCertificateStateFault extends __BaseException {
+    readonly name: "InvalidHsmClientCertificateStateFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<InvalidHsmClientCertificateStateFault, __BaseException>);
+}
+
+export interface DeleteHsmConfigurationMessage {
+    
+    HsmConfigurationIdentifier: string | undefined;
+}
+export declare namespace DeleteHsmConfigurationMessage {
+    
+    const filterSensitiveLog: (obj: DeleteHsmConfigurationMessage) => any;
+}
+
+export declare class InvalidHsmConfigurationStateFault extends __BaseException {
+    readonly name: "InvalidHsmConfigurationStateFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<InvalidHsmConfigurationStateFault, __BaseException>);
+}
+export interface DeleteScheduledActionMessage {
+    
+    ScheduledActionName: string | undefined;
+}
+export declare namespace DeleteScheduledActionMessage {
+    
+    const filterSensitiveLog: (obj: DeleteScheduledActionMessage) => any;
+}
+
+export declare class ScheduledActionNotFoundFault extends __BaseException {
+    readonly name: "ScheduledActionNotFoundFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<ScheduledActionNotFoundFault, __BaseException>);
+}
+
+export interface DeleteSnapshotCopyGrantMessage {
+    
+    SnapshotCopyGrantName: string | undefined;
+}
+export declare namespace DeleteSnapshotCopyGrantMessage {
+    
+    const filterSensitiveLog: (obj: DeleteSnapshotCopyGrantMessage) => any;
+}
+
+export declare class InvalidSnapshotCopyGrantStateFault extends __BaseException {
+    readonly name: "InvalidSnapshotCopyGrantStateFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<InvalidSnapshotCopyGrantStateFault, __BaseException>);
+}
+
+export declare class SnapshotCopyGrantNotFoundFault extends __BaseException {
+    readonly name: "SnapshotCopyGrantNotFoundFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<SnapshotCopyGrantNotFoundFault, __BaseException>);
+}
+export interface DeleteSnapshotScheduleMessage {
+    
+    ScheduleIdentifier: string | undefined;
+}
+export declare namespace DeleteSnapshotScheduleMessage {
+    
+    const filterSensitiveLog: (obj: DeleteSnapshotScheduleMessage) => any;
+}
+
+export declare class InvalidClusterSnapshotScheduleStateFault extends __BaseException {
+    readonly name: "InvalidClusterSnapshotScheduleStateFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<InvalidClusterSnapshotScheduleStateFault, __BaseException>);
+}
+
+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 declare class UsageLimitNotFoundFault extends __BaseException {
+    readonly name: "UsageLimitNotFoundFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<UsageLimitNotFoundFault, __BaseException>);
+}
+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;
+}