@aws-sdk/client-redshift 3.34.0 → 3.37.0

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

@@ -0,0 +1,1423 @@
+import { MetadataBearer as $MetadataBearer, SmithyException as __SmithyException } from "@aws-sdk/types";
+import { ActionType, AquaConfiguration, AquaConfigurationStatus, AvailabilityZone, Cluster, ClusterSecurityGroup, ClusterSubnetGroup, EventSubscription, Parameter, RecurringCharge, ReservedNode, ReservedNodeOfferingType, ScheduledAction, ScheduledActionType, Snapshot, SnapshotCopyGrant, SnapshotSchedule, Tag, UsageLimit, UsageLimitBreachAction, UsageLimitFeatureType } from "./models_0";
+
+export interface LoggingStatus {
+    
+    LoggingEnabled?: boolean;
+    
+    BucketName?: string;
+    
+    S3KeyPrefix?: string;
+    
+    LastSuccessfulDeliveryTime?: Date;
+    
+    LastFailureTime?: Date;
+    
+    LastFailureMessage?: string;
+}
+export declare namespace LoggingStatus {
+    
+    const filterSensitiveLog: (obj: LoggingStatus) => any;
+}
+export declare enum NodeConfigurationOptionsFilterName {
+    ESTIMATED_DISK_UTILIZATION_PERCENT = "EstimatedDiskUtilizationPercent",
+    MODE = "Mode",
+    NODE_TYPE = "NodeType",
+    NUM_NODES = "NumberOfNodes"
+}
+export declare enum OperatorType {
+    BETWEEN = "between",
+    EQ = "eq",
+    GE = "ge",
+    GT = "gt",
+    IN = "in",
+    LE = "le",
+    LT = "lt"
+}
+
+export interface NodeConfigurationOptionsFilter {
+    
+    Name?: NodeConfigurationOptionsFilterName | string;
+    
+    Operator?: OperatorType | string;
+    
+    Values?: string[];
+}
+export declare namespace NodeConfigurationOptionsFilter {
+    
+    const filterSensitiveLog: (obj: NodeConfigurationOptionsFilter) => any;
+}
+export interface DescribeNodeConfigurationOptionsMessage {
+    
+    ActionType: ActionType | string | undefined;
+    
+    ClusterIdentifier?: string;
+    
+    SnapshotIdentifier?: string;
+    
+    OwnerAccount?: string;
+    
+    Filters?: NodeConfigurationOptionsFilter[];
+    
+    Marker?: string;
+    
+    MaxRecords?: number;
+}
+export declare namespace DescribeNodeConfigurationOptionsMessage {
+    
+    const filterSensitiveLog: (obj: DescribeNodeConfigurationOptionsMessage) => any;
+}
+export declare enum Mode {
+    HIGH_PERFORMANCE = "high-performance",
+    STANDARD = "standard"
+}
+
+export interface NodeConfigurationOption {
+    
+    NodeType?: string;
+    
+    NumberOfNodes?: number;
+    
+    EstimatedDiskUtilizationPercent?: number;
+    
+    Mode?: Mode | string;
+}
+export declare namespace NodeConfigurationOption {
+    
+    const filterSensitiveLog: (obj: NodeConfigurationOption) => any;
+}
+export interface NodeConfigurationOptionsMessage {
+    
+    NodeConfigurationOptionList?: NodeConfigurationOption[];
+    
+    Marker?: string;
+}
+export declare namespace NodeConfigurationOptionsMessage {
+    
+    const filterSensitiveLog: (obj: NodeConfigurationOptionsMessage) => any;
+}
+
+export interface DescribeOrderableClusterOptionsMessage {
+    
+    ClusterVersion?: string;
+    
+    NodeType?: string;
+    
+    MaxRecords?: number;
+    
+    Marker?: string;
+}
+export declare namespace DescribeOrderableClusterOptionsMessage {
+    
+    const filterSensitiveLog: (obj: DescribeOrderableClusterOptionsMessage) => any;
+}
+
+export interface OrderableClusterOption {
+    
+    ClusterVersion?: string;
+    
+    ClusterType?: string;
+    
+    NodeType?: string;
+    
+    AvailabilityZones?: AvailabilityZone[];
+}
+export declare namespace OrderableClusterOption {
+    
+    const filterSensitiveLog: (obj: OrderableClusterOption) => any;
+}
+
+export interface OrderableClusterOptionsMessage {
+    
+    OrderableClusterOptions?: OrderableClusterOption[];
+    
+    Marker?: string;
+}
+export declare namespace OrderableClusterOptionsMessage {
+    
+    const filterSensitiveLog: (obj: OrderableClusterOptionsMessage) => any;
+}
+export interface DescribePartnersInputMessage {
+    
+    AccountId: string | undefined;
+    
+    ClusterIdentifier: string | undefined;
+    
+    DatabaseName?: string;
+    
+    PartnerName?: string;
+}
+export declare namespace DescribePartnersInputMessage {
+    
+    const filterSensitiveLog: (obj: DescribePartnersInputMessage) => any;
+}
+export declare enum PartnerIntegrationStatus {
+    Active = "Active",
+    ConnectionFailure = "ConnectionFailure",
+    Inactive = "Inactive",
+    RuntimeFailure = "RuntimeFailure"
+}
+
+export interface PartnerIntegrationInfo {
+    
+    DatabaseName?: string;
+    
+    PartnerName?: string;
+    
+    Status?: PartnerIntegrationStatus | string;
+    
+    StatusMessage?: string;
+    
+    CreatedAt?: Date;
+    
+    UpdatedAt?: Date;
+}
+export declare namespace PartnerIntegrationInfo {
+    
+    const filterSensitiveLog: (obj: PartnerIntegrationInfo) => any;
+}
+export interface DescribePartnersOutputMessage {
+    
+    PartnerIntegrationInfoList?: PartnerIntegrationInfo[];
+}
+export declare namespace DescribePartnersOutputMessage {
+    
+    const filterSensitiveLog: (obj: DescribePartnersOutputMessage) => any;
+}
+
+export interface DescribeReservedNodeOfferingsMessage {
+    
+    ReservedNodeOfferingId?: string;
+    
+    MaxRecords?: number;
+    
+    Marker?: string;
+}
+export declare namespace DescribeReservedNodeOfferingsMessage {
+    
+    const filterSensitiveLog: (obj: DescribeReservedNodeOfferingsMessage) => any;
+}
+
+export interface ReservedNodeOffering {
+    
+    ReservedNodeOfferingId?: string;
+    
+    NodeType?: string;
+    
+    Duration?: number;
+    
+    FixedPrice?: number;
+    
+    UsagePrice?: number;
+    
+    CurrencyCode?: string;
+    
+    OfferingType?: string;
+    
+    RecurringCharges?: RecurringCharge[];
+    
+    ReservedNodeOfferingType?: ReservedNodeOfferingType | string;
+}
+export declare namespace ReservedNodeOffering {
+    
+    const filterSensitiveLog: (obj: ReservedNodeOffering) => any;
+}
+
+export interface ReservedNodeOfferingsMessage {
+    
+    Marker?: string;
+    
+    ReservedNodeOfferings?: ReservedNodeOffering[];
+}
+export declare namespace ReservedNodeOfferingsMessage {
+    
+    const filterSensitiveLog: (obj: ReservedNodeOfferingsMessage) => any;
+}
+
+export interface DescribeReservedNodesMessage {
+    
+    ReservedNodeId?: string;
+    
+    MaxRecords?: number;
+    
+    Marker?: string;
+}
+export declare namespace DescribeReservedNodesMessage {
+    
+    const filterSensitiveLog: (obj: DescribeReservedNodesMessage) => any;
+}
+
+export interface ReservedNodesMessage {
+    
+    Marker?: string;
+    
+    ReservedNodes?: ReservedNode[];
+}
+export declare namespace ReservedNodesMessage {
+    
+    const filterSensitiveLog: (obj: ReservedNodesMessage) => any;
+}
+
+export interface DescribeResizeMessage {
+    
+    ClusterIdentifier: string | undefined;
+}
+export declare namespace DescribeResizeMessage {
+    
+    const filterSensitiveLog: (obj: DescribeResizeMessage) => any;
+}
+export declare enum ScheduledActionFilterName {
+    CLUSTER_IDENTIFIER = "cluster-identifier",
+    IAM_ROLE = "iam-role"
+}
+
+export interface ScheduledActionFilter {
+    
+    Name: ScheduledActionFilterName | string | undefined;
+    
+    Values: string[] | undefined;
+}
+export declare namespace ScheduledActionFilter {
+    
+    const filterSensitiveLog: (obj: ScheduledActionFilter) => any;
+}
+export declare enum ScheduledActionTypeValues {
+    PAUSE_CLUSTER = "PauseCluster",
+    RESIZE_CLUSTER = "ResizeCluster",
+    RESUME_CLUSTER = "ResumeCluster"
+}
+export interface DescribeScheduledActionsMessage {
+    
+    ScheduledActionName?: string;
+    
+    TargetActionType?: ScheduledActionTypeValues | string;
+    
+    StartTime?: Date;
+    
+    EndTime?: Date;
+    
+    Active?: boolean;
+    
+    Filters?: ScheduledActionFilter[];
+    
+    Marker?: string;
+    
+    MaxRecords?: number;
+}
+export declare namespace DescribeScheduledActionsMessage {
+    
+    const filterSensitiveLog: (obj: DescribeScheduledActionsMessage) => any;
+}
+export interface ScheduledActionsMessage {
+    
+    Marker?: string;
+    
+    ScheduledActions?: ScheduledAction[];
+}
+export declare namespace ScheduledActionsMessage {
+    
+    const filterSensitiveLog: (obj: ScheduledActionsMessage) => any;
+}
+
+export interface DescribeSnapshotCopyGrantsMessage {
+    
+    SnapshotCopyGrantName?: string;
+    
+    MaxRecords?: number;
+    
+    Marker?: string;
+    
+    TagKeys?: string[];
+    
+    TagValues?: string[];
+}
+export declare namespace DescribeSnapshotCopyGrantsMessage {
+    
+    const filterSensitiveLog: (obj: DescribeSnapshotCopyGrantsMessage) => any;
+}
+
+export interface SnapshotCopyGrantMessage {
+    
+    Marker?: string;
+    
+    SnapshotCopyGrants?: SnapshotCopyGrant[];
+}
+export declare namespace SnapshotCopyGrantMessage {
+    
+    const filterSensitiveLog: (obj: SnapshotCopyGrantMessage) => any;
+}
+export interface DescribeSnapshotSchedulesMessage {
+    
+    ClusterIdentifier?: string;
+    
+    ScheduleIdentifier?: string;
+    
+    TagKeys?: string[];
+    
+    TagValues?: string[];
+    
+    Marker?: string;
+    
+    MaxRecords?: number;
+}
+export declare namespace DescribeSnapshotSchedulesMessage {
+    
+    const filterSensitiveLog: (obj: DescribeSnapshotSchedulesMessage) => any;
+}
+export interface DescribeSnapshotSchedulesOutputMessage {
+    
+    SnapshotSchedules?: SnapshotSchedule[];
+    
+    Marker?: string;
+}
+export declare namespace DescribeSnapshotSchedulesOutputMessage {
+    
+    const filterSensitiveLog: (obj: DescribeSnapshotSchedulesOutputMessage) => any;
+}
+
+export interface DescribeTableRestoreStatusMessage {
+    
+    ClusterIdentifier?: string;
+    
+    TableRestoreRequestId?: string;
+    
+    MaxRecords?: number;
+    
+    Marker?: string;
+}
+export declare namespace DescribeTableRestoreStatusMessage {
+    
+    const filterSensitiveLog: (obj: DescribeTableRestoreStatusMessage) => any;
+}
+
+export interface TableRestoreNotFoundFault extends __SmithyException, $MetadataBearer {
+    name: "TableRestoreNotFoundFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace TableRestoreNotFoundFault {
+    
+    const filterSensitiveLog: (obj: TableRestoreNotFoundFault) => any;
+}
+export declare type TableRestoreStatusType = "CANCELED" | "FAILED" | "IN_PROGRESS" | "PENDING" | "SUCCEEDED";
+
+export interface TableRestoreStatus {
+    
+    TableRestoreRequestId?: string;
+    
+    Status?: TableRestoreStatusType | string;
+    
+    Message?: string;
+    
+    RequestTime?: Date;
+    
+    ProgressInMegaBytes?: number;
+    
+    TotalDataInMegaBytes?: number;
+    
+    ClusterIdentifier?: string;
+    
+    SnapshotIdentifier?: string;
+    
+    SourceDatabaseName?: string;
+    
+    SourceSchemaName?: string;
+    
+    SourceTableName?: string;
+    
+    TargetDatabaseName?: string;
+    
+    TargetSchemaName?: string;
+    
+    NewTableName?: string;
+}
+export declare namespace TableRestoreStatus {
+    
+    const filterSensitiveLog: (obj: TableRestoreStatus) => any;
+}
+
+export interface TableRestoreStatusMessage {
+    
+    TableRestoreStatusDetails?: TableRestoreStatus[];
+    
+    Marker?: string;
+}
+export declare namespace TableRestoreStatusMessage {
+    
+    const filterSensitiveLog: (obj: TableRestoreStatusMessage) => any;
+}
+
+export interface DescribeTagsMessage {
+    
+    ResourceName?: string;
+    
+    ResourceType?: string;
+    
+    MaxRecords?: number;
+    
+    Marker?: string;
+    
+    TagKeys?: string[];
+    
+    TagValues?: string[];
+}
+export declare namespace DescribeTagsMessage {
+    
+    const filterSensitiveLog: (obj: DescribeTagsMessage) => any;
+}
+
+export interface TaggedResource {
+    
+    Tag?: Tag;
+    
+    ResourceName?: string;
+    
+    ResourceType?: string;
+}
+export declare namespace TaggedResource {
+    
+    const filterSensitiveLog: (obj: TaggedResource) => any;
+}
+
+export interface TaggedResourceListMessage {
+    
+    TaggedResources?: TaggedResource[];
+    
+    Marker?: string;
+}
+export declare namespace TaggedResourceListMessage {
+    
+    const filterSensitiveLog: (obj: TaggedResourceListMessage) => any;
+}
+export interface DescribeUsageLimitsMessage {
+    
+    UsageLimitId?: string;
+    
+    ClusterIdentifier?: string;
+    
+    FeatureType?: UsageLimitFeatureType | string;
+    
+    MaxRecords?: number;
+    
+    Marker?: string;
+    
+    TagKeys?: string[];
+    
+    TagValues?: string[];
+}
+export declare namespace DescribeUsageLimitsMessage {
+    
+    const filterSensitiveLog: (obj: DescribeUsageLimitsMessage) => any;
+}
+export interface UsageLimitList {
+    
+    UsageLimits?: UsageLimit[];
+    
+    Marker?: string;
+}
+export declare namespace UsageLimitList {
+    
+    const filterSensitiveLog: (obj: UsageLimitList) => any;
+}
+
+export interface DisableLoggingMessage {
+    
+    ClusterIdentifier: string | undefined;
+}
+export declare namespace DisableLoggingMessage {
+    
+    const filterSensitiveLog: (obj: DisableLoggingMessage) => any;
+}
+
+export interface DisableSnapshotCopyMessage {
+    
+    ClusterIdentifier: string | undefined;
+}
+export declare namespace DisableSnapshotCopyMessage {
+    
+    const filterSensitiveLog: (obj: DisableSnapshotCopyMessage) => any;
+}
+export interface DisableSnapshotCopyResult {
+    
+    Cluster?: Cluster;
+}
+export declare namespace DisableSnapshotCopyResult {
+    
+    const filterSensitiveLog: (obj: DisableSnapshotCopyResult) => any;
+}
+
+export interface SnapshotCopyAlreadyDisabledFault extends __SmithyException, $MetadataBearer {
+    name: "SnapshotCopyAlreadyDisabledFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace SnapshotCopyAlreadyDisabledFault {
+    
+    const filterSensitiveLog: (obj: SnapshotCopyAlreadyDisabledFault) => any;
+}
+export interface DisassociateDataShareConsumerMessage {
+    
+    DataShareArn: string | undefined;
+    
+    DisassociateEntireAccount?: boolean;
+    
+    ConsumerArn?: string;
+}
+export declare namespace DisassociateDataShareConsumerMessage {
+    
+    const filterSensitiveLog: (obj: DisassociateDataShareConsumerMessage) => any;
+}
+
+export interface EnableLoggingMessage {
+    
+    ClusterIdentifier: string | undefined;
+    
+    BucketName: string | undefined;
+    
+    S3KeyPrefix?: string;
+}
+export declare namespace EnableLoggingMessage {
+    
+    const filterSensitiveLog: (obj: EnableLoggingMessage) => any;
+}
+
+export interface InsufficientS3BucketPolicyFault extends __SmithyException, $MetadataBearer {
+    name: "InsufficientS3BucketPolicyFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace InsufficientS3BucketPolicyFault {
+    
+    const filterSensitiveLog: (obj: InsufficientS3BucketPolicyFault) => any;
+}
+
+export interface InvalidS3BucketNameFault extends __SmithyException, $MetadataBearer {
+    name: "InvalidS3BucketNameFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace InvalidS3BucketNameFault {
+    
+    const filterSensitiveLog: (obj: InvalidS3BucketNameFault) => any;
+}
+
+export interface InvalidS3KeyPrefixFault extends __SmithyException, $MetadataBearer {
+    name: "InvalidS3KeyPrefixFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace InvalidS3KeyPrefixFault {
+    
+    const filterSensitiveLog: (obj: InvalidS3KeyPrefixFault) => any;
+}
+
+export interface EnableSnapshotCopyMessage {
+    
+    ClusterIdentifier: string | undefined;
+    
+    DestinationRegion: string | undefined;
+    
+    RetentionPeriod?: number;
+    
+    SnapshotCopyGrantName?: string;
+    
+    ManualSnapshotRetentionPeriod?: number;
+}
+export declare namespace EnableSnapshotCopyMessage {
+    
+    const filterSensitiveLog: (obj: EnableSnapshotCopyMessage) => any;
+}
+export interface EnableSnapshotCopyResult {
+    
+    Cluster?: Cluster;
+}
+export declare namespace EnableSnapshotCopyResult {
+    
+    const filterSensitiveLog: (obj: EnableSnapshotCopyResult) => any;
+}
+
+export interface IncompatibleOrderableOptions extends __SmithyException, $MetadataBearer {
+    name: "IncompatibleOrderableOptions";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace IncompatibleOrderableOptions {
+    
+    const filterSensitiveLog: (obj: IncompatibleOrderableOptions) => any;
+}
+
+export interface SnapshotCopyAlreadyEnabledFault extends __SmithyException, $MetadataBearer {
+    name: "SnapshotCopyAlreadyEnabledFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace SnapshotCopyAlreadyEnabledFault {
+    
+    const filterSensitiveLog: (obj: SnapshotCopyAlreadyEnabledFault) => any;
+}
+
+export interface UnknownSnapshotCopyRegionFault extends __SmithyException, $MetadataBearer {
+    name: "UnknownSnapshotCopyRegionFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace UnknownSnapshotCopyRegionFault {
+    
+    const filterSensitiveLog: (obj: UnknownSnapshotCopyRegionFault) => any;
+}
+
+export interface EndpointAuthorizationNotFoundFault extends __SmithyException, $MetadataBearer {
+    name: "EndpointAuthorizationNotFoundFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace EndpointAuthorizationNotFoundFault {
+    
+    const filterSensitiveLog: (obj: EndpointAuthorizationNotFoundFault) => any;
+}
+
+export interface GetClusterCredentialsMessage {
+    
+    DbUser: string | undefined;
+    
+    DbName?: string;
+    
+    ClusterIdentifier: string | undefined;
+    
+    DurationSeconds?: number;
+    
+    AutoCreate?: boolean;
+    
+    DbGroups?: string[];
+}
+export declare namespace GetClusterCredentialsMessage {
+    
+    const filterSensitiveLog: (obj: GetClusterCredentialsMessage) => any;
+}
+
+export interface GetReservedNodeExchangeOfferingsInputMessage {
+    
+    ReservedNodeId: string | undefined;
+    
+    MaxRecords?: number;
+    
+    Marker?: string;
+}
+export declare namespace GetReservedNodeExchangeOfferingsInputMessage {
+    
+    const filterSensitiveLog: (obj: GetReservedNodeExchangeOfferingsInputMessage) => any;
+}
+export interface GetReservedNodeExchangeOfferingsOutputMessage {
+    
+    Marker?: string;
+    
+    ReservedNodeOfferings?: ReservedNodeOffering[];
+}
+export declare namespace GetReservedNodeExchangeOfferingsOutputMessage {
+    
+    const filterSensitiveLog: (obj: GetReservedNodeExchangeOfferingsOutputMessage) => any;
+}
+
+export interface InProgressTableRestoreQuotaExceededFault extends __SmithyException, $MetadataBearer {
+    name: "InProgressTableRestoreQuotaExceededFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace InProgressTableRestoreQuotaExceededFault {
+    
+    const filterSensitiveLog: (obj: InProgressTableRestoreQuotaExceededFault) => any;
+}
+
+export interface InvalidRestoreFault extends __SmithyException, $MetadataBearer {
+    name: "InvalidRestoreFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace InvalidRestoreFault {
+    
+    const filterSensitiveLog: (obj: InvalidRestoreFault) => any;
+}
+
+export interface InvalidTableRestoreArgumentFault extends __SmithyException, $MetadataBearer {
+    name: "InvalidTableRestoreArgumentFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace InvalidTableRestoreArgumentFault {
+    
+    const filterSensitiveLog: (obj: InvalidTableRestoreArgumentFault) => any;
+}
+export interface ModifyAquaInputMessage {
+    
+    ClusterIdentifier: string | undefined;
+    
+    AquaConfigurationStatus?: AquaConfigurationStatus | string;
+}
+export declare namespace ModifyAquaInputMessage {
+    
+    const filterSensitiveLog: (obj: ModifyAquaInputMessage) => any;
+}
+export interface ModifyAquaOutputMessage {
+    
+    AquaConfiguration?: AquaConfiguration;
+}
+export declare namespace ModifyAquaOutputMessage {
+    
+    const filterSensitiveLog: (obj: ModifyAquaOutputMessage) => any;
+}
+export interface ModifyAuthenticationProfileMessage {
+    
+    AuthenticationProfileName: string | undefined;
+    
+    AuthenticationProfileContent: string | undefined;
+}
+export declare namespace ModifyAuthenticationProfileMessage {
+    
+    const filterSensitiveLog: (obj: ModifyAuthenticationProfileMessage) => any;
+}
+export interface ModifyAuthenticationProfileResult {
+    
+    AuthenticationProfileName?: string;
+    
+    AuthenticationProfileContent?: string;
+}
+export declare namespace ModifyAuthenticationProfileResult {
+    
+    const filterSensitiveLog: (obj: ModifyAuthenticationProfileResult) => any;
+}
+
+export interface ModifyClusterMessage {
+    
+    ClusterIdentifier: string | undefined;
+    
+    ClusterType?: string;
+    
+    NodeType?: string;
+    
+    NumberOfNodes?: number;
+    
+    ClusterSecurityGroups?: string[];
+    
+    VpcSecurityGroupIds?: string[];
+    
+    MasterUserPassword?: string;
+    
+    ClusterParameterGroupName?: string;
+    
+    AutomatedSnapshotRetentionPeriod?: number;
+    
+    ManualSnapshotRetentionPeriod?: number;
+    
+    PreferredMaintenanceWindow?: string;
+    
+    ClusterVersion?: string;
+    
+    AllowVersionUpgrade?: boolean;
+    
+    HsmClientCertificateIdentifier?: string;
+    
+    HsmConfigurationIdentifier?: string;
+    
+    NewClusterIdentifier?: string;
+    
+    PubliclyAccessible?: boolean;
+    
+    ElasticIp?: string;
+    
+    EnhancedVpcRouting?: boolean;
+    
+    MaintenanceTrackName?: string;
+    
+    Encrypted?: boolean;
+    
+    KmsKeyId?: string;
+    
+    AvailabilityZoneRelocation?: boolean;
+    
+    AvailabilityZone?: string;
+    
+    Port?: number;
+}
+export declare namespace ModifyClusterMessage {
+    
+    const filterSensitiveLog: (obj: ModifyClusterMessage) => any;
+}
+export interface ModifyClusterResult {
+    
+    Cluster?: Cluster;
+}
+export declare namespace ModifyClusterResult {
+    
+    const filterSensitiveLog: (obj: ModifyClusterResult) => any;
+}
+
+export interface TableLimitExceededFault extends __SmithyException, $MetadataBearer {
+    name: "TableLimitExceededFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace TableLimitExceededFault {
+    
+    const filterSensitiveLog: (obj: TableLimitExceededFault) => any;
+}
+
+export interface UnsupportedOptionFault extends __SmithyException, $MetadataBearer {
+    name: "UnsupportedOptionFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace UnsupportedOptionFault {
+    
+    const filterSensitiveLog: (obj: UnsupportedOptionFault) => any;
+}
+export interface ModifyClusterDbRevisionMessage {
+    
+    ClusterIdentifier: string | undefined;
+    
+    RevisionTarget: string | undefined;
+}
+export declare namespace ModifyClusterDbRevisionMessage {
+    
+    const filterSensitiveLog: (obj: ModifyClusterDbRevisionMessage) => any;
+}
+export interface ModifyClusterDbRevisionResult {
+    
+    Cluster?: Cluster;
+}
+export declare namespace ModifyClusterDbRevisionResult {
+    
+    const filterSensitiveLog: (obj: ModifyClusterDbRevisionResult) => any;
+}
+
+export interface ModifyClusterIamRolesMessage {
+    
+    ClusterIdentifier: string | undefined;
+    
+    AddIamRoles?: string[];
+    
+    RemoveIamRoles?: string[];
+}
+export declare namespace ModifyClusterIamRolesMessage {
+    
+    const filterSensitiveLog: (obj: ModifyClusterIamRolesMessage) => any;
+}
+export interface ModifyClusterIamRolesResult {
+    
+    Cluster?: Cluster;
+}
+export declare namespace ModifyClusterIamRolesResult {
+    
+    const filterSensitiveLog: (obj: ModifyClusterIamRolesResult) => any;
+}
+export interface ModifyClusterMaintenanceMessage {
+    
+    ClusterIdentifier: string | undefined;
+    
+    DeferMaintenance?: boolean;
+    
+    DeferMaintenanceIdentifier?: string;
+    
+    DeferMaintenanceStartTime?: Date;
+    
+    DeferMaintenanceEndTime?: Date;
+    
+    DeferMaintenanceDuration?: number;
+}
+export declare namespace ModifyClusterMaintenanceMessage {
+    
+    const filterSensitiveLog: (obj: ModifyClusterMaintenanceMessage) => any;
+}
+export interface ModifyClusterMaintenanceResult {
+    
+    Cluster?: Cluster;
+}
+export declare namespace ModifyClusterMaintenanceResult {
+    
+    const filterSensitiveLog: (obj: ModifyClusterMaintenanceResult) => any;
+}
+
+export interface ModifyClusterParameterGroupMessage {
+    
+    ParameterGroupName: string | undefined;
+    
+    Parameters: Parameter[] | undefined;
+}
+export declare namespace ModifyClusterParameterGroupMessage {
+    
+    const filterSensitiveLog: (obj: ModifyClusterParameterGroupMessage) => any;
+}
+export interface ModifyClusterSnapshotMessage {
+    
+    SnapshotIdentifier: string | undefined;
+    
+    ManualSnapshotRetentionPeriod?: number;
+    
+    Force?: boolean;
+}
+export declare namespace ModifyClusterSnapshotMessage {
+    
+    const filterSensitiveLog: (obj: ModifyClusterSnapshotMessage) => any;
+}
+export interface ModifyClusterSnapshotResult {
+    
+    Snapshot?: Snapshot;
+}
+export declare namespace ModifyClusterSnapshotResult {
+    
+    const filterSensitiveLog: (obj: ModifyClusterSnapshotResult) => any;
+}
+export interface ModifyClusterSnapshotScheduleMessage {
+    
+    ClusterIdentifier: string | undefined;
+    
+    ScheduleIdentifier?: string;
+    
+    DisassociateSchedule?: boolean;
+}
+export declare namespace ModifyClusterSnapshotScheduleMessage {
+    
+    const filterSensitiveLog: (obj: ModifyClusterSnapshotScheduleMessage) => any;
+}
+
+export interface ModifyClusterSubnetGroupMessage {
+    
+    ClusterSubnetGroupName: string | undefined;
+    
+    Description?: string;
+    
+    SubnetIds: string[] | undefined;
+}
+export declare namespace ModifyClusterSubnetGroupMessage {
+    
+    const filterSensitiveLog: (obj: ModifyClusterSubnetGroupMessage) => any;
+}
+export interface ModifyClusterSubnetGroupResult {
+    
+    ClusterSubnetGroup?: ClusterSubnetGroup;
+}
+export declare namespace ModifyClusterSubnetGroupResult {
+    
+    const filterSensitiveLog: (obj: ModifyClusterSubnetGroupResult) => any;
+}
+
+export interface SubnetAlreadyInUse extends __SmithyException, $MetadataBearer {
+    name: "SubnetAlreadyInUse";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace SubnetAlreadyInUse {
+    
+    const filterSensitiveLog: (obj: SubnetAlreadyInUse) => any;
+}
+export interface ModifyEndpointAccessMessage {
+    
+    EndpointName: string | undefined;
+    
+    VpcSecurityGroupIds?: string[];
+}
+export declare namespace ModifyEndpointAccessMessage {
+    
+    const filterSensitiveLog: (obj: ModifyEndpointAccessMessage) => any;
+}
+
+export interface ModifyEventSubscriptionMessage {
+    
+    SubscriptionName: string | undefined;
+    
+    SnsTopicArn?: string;
+    
+    SourceType?: string;
+    
+    SourceIds?: string[];
+    
+    EventCategories?: string[];
+    
+    Severity?: string;
+    
+    Enabled?: boolean;
+}
+export declare namespace ModifyEventSubscriptionMessage {
+    
+    const filterSensitiveLog: (obj: ModifyEventSubscriptionMessage) => any;
+}
+export interface ModifyEventSubscriptionResult {
+    
+    EventSubscription?: EventSubscription;
+}
+export declare namespace ModifyEventSubscriptionResult {
+    
+    const filterSensitiveLog: (obj: ModifyEventSubscriptionResult) => any;
+}
+export interface ModifyScheduledActionMessage {
+    
+    ScheduledActionName: string | undefined;
+    
+    TargetAction?: ScheduledActionType;
+    
+    Schedule?: string;
+    
+    IamRole?: string;
+    
+    ScheduledActionDescription?: string;
+    
+    StartTime?: Date;
+    
+    EndTime?: Date;
+    
+    Enable?: boolean;
+}
+export declare namespace ModifyScheduledActionMessage {
+    
+    const filterSensitiveLog: (obj: ModifyScheduledActionMessage) => any;
+}
+
+export interface ModifySnapshotCopyRetentionPeriodMessage {
+    
+    ClusterIdentifier: string | undefined;
+    
+    RetentionPeriod: number | undefined;
+    
+    Manual?: boolean;
+}
+export declare namespace ModifySnapshotCopyRetentionPeriodMessage {
+    
+    const filterSensitiveLog: (obj: ModifySnapshotCopyRetentionPeriodMessage) => any;
+}
+export interface ModifySnapshotCopyRetentionPeriodResult {
+    
+    Cluster?: Cluster;
+}
+export declare namespace ModifySnapshotCopyRetentionPeriodResult {
+    
+    const filterSensitiveLog: (obj: ModifySnapshotCopyRetentionPeriodResult) => any;
+}
+
+export interface SnapshotCopyDisabledFault extends __SmithyException, $MetadataBearer {
+    name: "SnapshotCopyDisabledFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace SnapshotCopyDisabledFault {
+    
+    const filterSensitiveLog: (obj: SnapshotCopyDisabledFault) => any;
+}
+export interface ModifySnapshotScheduleMessage {
+    
+    ScheduleIdentifier: string | undefined;
+    
+    ScheduleDefinitions: string[] | undefined;
+}
+export declare namespace ModifySnapshotScheduleMessage {
+    
+    const filterSensitiveLog: (obj: ModifySnapshotScheduleMessage) => any;
+}
+
+export interface SnapshotScheduleUpdateInProgressFault extends __SmithyException, $MetadataBearer {
+    name: "SnapshotScheduleUpdateInProgressFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace SnapshotScheduleUpdateInProgressFault {
+    
+    const filterSensitiveLog: (obj: SnapshotScheduleUpdateInProgressFault) => any;
+}
+export interface ModifyUsageLimitMessage {
+    
+    UsageLimitId: string | undefined;
+    
+    Amount?: number;
+    
+    BreachAction?: UsageLimitBreachAction | string;
+}
+export declare namespace ModifyUsageLimitMessage {
+    
+    const filterSensitiveLog: (obj: ModifyUsageLimitMessage) => any;
+}
+export interface PauseClusterResult {
+    
+    Cluster?: Cluster;
+}
+export declare namespace PauseClusterResult {
+    
+    const filterSensitiveLog: (obj: PauseClusterResult) => any;
+}
+
+export interface PurchaseReservedNodeOfferingMessage {
+    
+    ReservedNodeOfferingId: string | undefined;
+    
+    NodeCount?: number;
+}
+export declare namespace PurchaseReservedNodeOfferingMessage {
+    
+    const filterSensitiveLog: (obj: PurchaseReservedNodeOfferingMessage) => any;
+}
+export interface PurchaseReservedNodeOfferingResult {
+    
+    ReservedNode?: ReservedNode;
+}
+export declare namespace PurchaseReservedNodeOfferingResult {
+    
+    const filterSensitiveLog: (obj: PurchaseReservedNodeOfferingResult) => any;
+}
+
+export interface ReservedNodeQuotaExceededFault extends __SmithyException, $MetadataBearer {
+    name: "ReservedNodeQuotaExceededFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace ReservedNodeQuotaExceededFault {
+    
+    const filterSensitiveLog: (obj: ReservedNodeQuotaExceededFault) => any;
+}
+
+export interface RebootClusterMessage {
+    
+    ClusterIdentifier: string | undefined;
+}
+export declare namespace RebootClusterMessage {
+    
+    const filterSensitiveLog: (obj: RebootClusterMessage) => any;
+}
+export interface RebootClusterResult {
+    
+    Cluster?: Cluster;
+}
+export declare namespace RebootClusterResult {
+    
+    const filterSensitiveLog: (obj: RebootClusterResult) => any;
+}
+export interface RejectDataShareMessage {
+    
+    DataShareArn: string | undefined;
+}
+export declare namespace RejectDataShareMessage {
+    
+    const filterSensitiveLog: (obj: RejectDataShareMessage) => any;
+}
+
+export interface ResetClusterParameterGroupMessage {
+    
+    ParameterGroupName: string | undefined;
+    
+    ResetAllParameters?: boolean;
+    
+    Parameters?: Parameter[];
+}
+export declare namespace ResetClusterParameterGroupMessage {
+    
+    const filterSensitiveLog: (obj: ResetClusterParameterGroupMessage) => any;
+}
+export interface ResizeClusterResult {
+    
+    Cluster?: Cluster;
+}
+export declare namespace ResizeClusterResult {
+    
+    const filterSensitiveLog: (obj: ResizeClusterResult) => any;
+}
+
+export interface RestoreFromClusterSnapshotMessage {
+    
+    ClusterIdentifier: string | undefined;
+    
+    SnapshotIdentifier: string | undefined;
+    
+    SnapshotClusterIdentifier?: string;
+    
+    Port?: number;
+    
+    AvailabilityZone?: string;
+    
+    AllowVersionUpgrade?: boolean;
+    
+    ClusterSubnetGroupName?: string;
+    
+    PubliclyAccessible?: boolean;
+    
+    OwnerAccount?: string;
+    
+    HsmClientCertificateIdentifier?: string;
+    
+    HsmConfigurationIdentifier?: string;
+    
+    ElasticIp?: string;
+    
+    ClusterParameterGroupName?: string;
+    
+    ClusterSecurityGroups?: string[];
+    
+    VpcSecurityGroupIds?: string[];
+    
+    PreferredMaintenanceWindow?: string;
+    
+    AutomatedSnapshotRetentionPeriod?: number;
+    
+    ManualSnapshotRetentionPeriod?: number;
+    
+    KmsKeyId?: string;
+    
+    NodeType?: string;
+    
+    EnhancedVpcRouting?: boolean;
+    
+    AdditionalInfo?: string;
+    
+    IamRoles?: string[];
+    
+    MaintenanceTrackName?: string;
+    
+    SnapshotScheduleIdentifier?: string;
+    
+    NumberOfNodes?: number;
+    
+    AvailabilityZoneRelocation?: boolean;
+    
+    AquaConfigurationStatus?: AquaConfigurationStatus | string;
+}
+export declare namespace RestoreFromClusterSnapshotMessage {
+    
+    const filterSensitiveLog: (obj: RestoreFromClusterSnapshotMessage) => any;
+}
+export interface RestoreFromClusterSnapshotResult {
+    
+    Cluster?: Cluster;
+}
+export declare namespace RestoreFromClusterSnapshotResult {
+    
+    const filterSensitiveLog: (obj: RestoreFromClusterSnapshotResult) => any;
+}
+
+export interface RestoreTableFromClusterSnapshotMessage {
+    
+    ClusterIdentifier: string | undefined;
+    
+    SnapshotIdentifier: string | undefined;
+    
+    SourceDatabaseName: string | undefined;
+    
+    SourceSchemaName?: string;
+    
+    SourceTableName: string | undefined;
+    
+    TargetDatabaseName?: string;
+    
+    TargetSchemaName?: string;
+    
+    NewTableName: string | undefined;
+    
+    EnableCaseSensitiveIdentifier?: boolean;
+}
+export declare namespace RestoreTableFromClusterSnapshotMessage {
+    
+    const filterSensitiveLog: (obj: RestoreTableFromClusterSnapshotMessage) => any;
+}
+export interface RestoreTableFromClusterSnapshotResult {
+    
+    TableRestoreStatus?: TableRestoreStatus;
+}
+export declare namespace RestoreTableFromClusterSnapshotResult {
+    
+    const filterSensitiveLog: (obj: RestoreTableFromClusterSnapshotResult) => any;
+}
+export interface ResumeClusterResult {
+    
+    Cluster?: Cluster;
+}
+export declare namespace ResumeClusterResult {
+    
+    const filterSensitiveLog: (obj: ResumeClusterResult) => any;
+}
+
+export interface RevokeClusterSecurityGroupIngressMessage {
+    
+    ClusterSecurityGroupName: string | undefined;
+    
+    CIDRIP?: string;
+    
+    EC2SecurityGroupName?: string;
+    
+    EC2SecurityGroupOwnerId?: string;
+}
+export declare namespace RevokeClusterSecurityGroupIngressMessage {
+    
+    const filterSensitiveLog: (obj: RevokeClusterSecurityGroupIngressMessage) => any;
+}
+export interface RevokeClusterSecurityGroupIngressResult {
+    
+    ClusterSecurityGroup?: ClusterSecurityGroup;
+}
+export declare namespace RevokeClusterSecurityGroupIngressResult {
+    
+    const filterSensitiveLog: (obj: RevokeClusterSecurityGroupIngressResult) => any;
+}
+export interface RevokeEndpointAccessMessage {
+    
+    ClusterIdentifier?: string;
+    
+    Account?: string;
+    
+    VpcIds?: string[];
+    
+    Force?: boolean;
+}
+export declare namespace RevokeEndpointAccessMessage {
+    
+    const filterSensitiveLog: (obj: RevokeEndpointAccessMessage) => any;
+}
+
+export interface RevokeSnapshotAccessMessage {
+    
+    SnapshotIdentifier: string | undefined;
+    
+    SnapshotClusterIdentifier?: string;
+    
+    AccountWithRestoreAccess: string | undefined;
+}
+export declare namespace RevokeSnapshotAccessMessage {
+    
+    const filterSensitiveLog: (obj: RevokeSnapshotAccessMessage) => any;
+}
+export interface RevokeSnapshotAccessResult {
+    
+    Snapshot?: Snapshot;
+}
+export declare namespace RevokeSnapshotAccessResult {
+    
+    const filterSensitiveLog: (obj: RevokeSnapshotAccessResult) => any;
+}
+
+export interface RotateEncryptionKeyMessage {
+    
+    ClusterIdentifier: string | undefined;
+}
+export declare namespace RotateEncryptionKeyMessage {
+    
+    const filterSensitiveLog: (obj: RotateEncryptionKeyMessage) => any;
+}
+export interface RotateEncryptionKeyResult {
+    
+    Cluster?: Cluster;
+}
+export declare namespace RotateEncryptionKeyResult {
+    
+    const filterSensitiveLog: (obj: RotateEncryptionKeyResult) => any;
+}
+export interface UpdatePartnerStatusInputMessage {
+    
+    AccountId: string | undefined;
+    
+    ClusterIdentifier: string | undefined;
+    
+    DatabaseName: string | undefined;
+    
+    PartnerName: string | undefined;
+    
+    Status: PartnerIntegrationStatus | string | undefined;
+    
+    StatusMessage?: string;
+}
+export declare namespace UpdatePartnerStatusInputMessage {
+    
+    const filterSensitiveLog: (obj: UpdatePartnerStatusInputMessage) => any;
+}