@aws-sdk/client-redshift-serverless 3.107.0

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

@@ -0,0 +1,1140 @@
+import { ExceptionOptionType as __ExceptionOptionType } from "@aws-sdk/smithy-client";
+import { RedshiftServerlessServiceException as __BaseException } from "./RedshiftServerlessServiceException";
+
+export declare class AccessDeniedException extends __BaseException {
+    readonly name: "AccessDeniedException";
+    readonly $fault: "client";
+    code?: string;
+    
+    constructor(opts: __ExceptionOptionType<AccessDeniedException, __BaseException>);
+}
+
+export interface ConfigParameter {
+    
+    parameterKey?: string;
+    
+    parameterValue?: string;
+}
+export declare namespace ConfigParameter {
+    
+    const filterSensitiveLog: (obj: ConfigParameter) => any;
+}
+
+export declare class ConflictException extends __BaseException {
+    readonly name: "ConflictException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<ConflictException, __BaseException>);
+}
+export interface ConvertRecoveryPointToSnapshotRequest {
+    
+    recoveryPointId: string | undefined;
+    
+    snapshotName: string | undefined;
+    
+    retentionPeriod?: number;
+}
+export declare namespace ConvertRecoveryPointToSnapshotRequest {
+    
+    const filterSensitiveLog: (obj: ConvertRecoveryPointToSnapshotRequest) => any;
+}
+export declare enum SnapshotStatus {
+    AVAILABLE = "AVAILABLE",
+    CANCELLED = "CANCELLED",
+    COPYING = "COPYING",
+    CREATING = "CREATING",
+    DELETED = "DELETED",
+    FAILED = "FAILED"
+}
+
+export interface Snapshot {
+    
+    namespaceName?: string;
+    
+    namespaceArn?: string;
+    
+    snapshotName?: string;
+    
+    snapshotCreateTime?: Date;
+    
+    adminUsername?: string;
+    
+    status?: SnapshotStatus | string;
+    
+    kmsKeyId?: string;
+    
+    ownerAccount?: string;
+    
+    totalBackupSizeInMegaBytes?: number;
+    
+    actualIncrementalBackupSizeInMegaBytes?: number;
+    
+    backupProgressInMegaBytes?: number;
+    
+    currentBackupRateInMegaBytesPerSecond?: number;
+    
+    estimatedSecondsToCompletion?: number;
+    
+    elapsedTimeInSeconds?: number;
+    
+    snapshotRetentionPeriod?: number;
+    
+    snapshotRemainingDays?: number;
+    
+    snapshotRetentionStartTime?: Date;
+    
+    snapshotArn?: string;
+    
+    accountsWithRestoreAccess?: string[];
+    
+    accountsWithProvisionedRestoreAccess?: string[];
+}
+export declare namespace Snapshot {
+    
+    const filterSensitiveLog: (obj: Snapshot) => any;
+}
+export interface ConvertRecoveryPointToSnapshotResponse {
+    
+    snapshot?: Snapshot;
+}
+export declare namespace ConvertRecoveryPointToSnapshotResponse {
+    
+    const filterSensitiveLog: (obj: ConvertRecoveryPointToSnapshotResponse) => any;
+}
+
+export declare class InternalServerException extends __BaseException {
+    readonly name: "InternalServerException";
+    readonly $fault: "server";
+    $retryable: {};
+    
+    constructor(opts: __ExceptionOptionType<InternalServerException, __BaseException>);
+}
+
+export declare class ResourceNotFoundException extends __BaseException {
+    readonly name: "ResourceNotFoundException";
+    readonly $fault: "client";
+    
+    resourceName?: string;
+    
+    constructor(opts: __ExceptionOptionType<ResourceNotFoundException, __BaseException>);
+}
+
+export declare class ServiceQuotaExceededException extends __BaseException {
+    readonly name: "ServiceQuotaExceededException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<ServiceQuotaExceededException, __BaseException>);
+}
+
+export declare class ValidationException extends __BaseException {
+    readonly name: "ValidationException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<ValidationException, __BaseException>);
+}
+export interface CreateEndpointAccessRequest {
+    
+    endpointName: string | undefined;
+    
+    subnetIds: string[] | undefined;
+    
+    workgroupName: string | undefined;
+    
+    vpcSecurityGroupIds?: string[];
+}
+export declare namespace CreateEndpointAccessRequest {
+    
+    const filterSensitiveLog: (obj: CreateEndpointAccessRequest) => 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 VpcSecurityGroupMembership {
+    
+    vpcSecurityGroupId?: string;
+    
+    status?: string;
+}
+export declare namespace VpcSecurityGroupMembership {
+    
+    const filterSensitiveLog: (obj: VpcSecurityGroupMembership) => any;
+}
+
+export interface EndpointAccess {
+    
+    endpointName?: string;
+    
+    endpointStatus?: string;
+    
+    workgroupName?: string;
+    
+    endpointCreateTime?: Date;
+    
+    port?: number;
+    
+    address?: string;
+    
+    subnetIds?: string[];
+    
+    vpcSecurityGroups?: VpcSecurityGroupMembership[];
+    
+    vpcEndpoint?: VpcEndpoint;
+    
+    endpointArn?: string;
+}
+export declare namespace EndpointAccess {
+    
+    const filterSensitiveLog: (obj: EndpointAccess) => any;
+}
+export interface CreateEndpointAccessResponse {
+    
+    endpoint?: EndpointAccess;
+}
+export declare namespace CreateEndpointAccessResponse {
+    
+    const filterSensitiveLog: (obj: CreateEndpointAccessResponse) => any;
+}
+export declare enum LogExport {
+    CONNECTION_LOG = "connectionlog",
+    USER_ACTIVITY_LOG = "useractivitylog",
+    USER_LOG = "userlog"
+}
+
+export interface Tag {
+    
+    key: string | undefined;
+    
+    value: string | undefined;
+}
+export declare namespace Tag {
+    
+    const filterSensitiveLog: (obj: Tag) => any;
+}
+export interface CreateNamespaceRequest {
+    
+    namespaceName: string | undefined;
+    
+    adminUsername?: string;
+    
+    adminUserPassword?: string;
+    
+    dbName?: string;
+    
+    kmsKeyId?: string;
+    
+    defaultIamRoleArn?: string;
+    
+    iamRoles?: string[];
+    
+    logExports?: (LogExport | string)[];
+    
+    tags?: Tag[];
+}
+export declare namespace CreateNamespaceRequest {
+    
+    const filterSensitiveLog: (obj: CreateNamespaceRequest) => any;
+}
+export declare enum NamespaceStatus {
+    AVAILABLE = "AVAILABLE",
+    DELETING = "DELETING",
+    MODIFYING = "MODIFYING"
+}
+
+export interface Namespace {
+    
+    namespaceArn?: string;
+    
+    namespaceId?: string;
+    
+    namespaceName?: string;
+    
+    adminUsername?: string;
+    
+    dbName?: string;
+    
+    kmsKeyId?: string;
+    
+    defaultIamRoleArn?: string;
+    
+    iamRoles?: string[];
+    
+    logExports?: (LogExport | string)[];
+    
+    status?: NamespaceStatus | string;
+    
+    creationDate?: Date;
+}
+export declare namespace Namespace {
+    
+    const filterSensitiveLog: (obj: Namespace) => any;
+}
+export interface CreateNamespaceResponse {
+    
+    namespace?: Namespace;
+}
+export declare namespace CreateNamespaceResponse {
+    
+    const filterSensitiveLog: (obj: CreateNamespaceResponse) => any;
+}
+
+export declare class TooManyTagsException extends __BaseException {
+    readonly name: "TooManyTagsException";
+    readonly $fault: "client";
+    
+    resourceName?: string;
+    
+    constructor(opts: __ExceptionOptionType<TooManyTagsException, __BaseException>);
+}
+export interface CreateSnapshotRequest {
+    
+    namespaceName: string | undefined;
+    
+    snapshotName: string | undefined;
+    
+    retentionPeriod?: number;
+}
+export declare namespace CreateSnapshotRequest {
+    
+    const filterSensitiveLog: (obj: CreateSnapshotRequest) => any;
+}
+export interface CreateSnapshotResponse {
+    
+    snapshot?: Snapshot;
+}
+export declare namespace CreateSnapshotResponse {
+    
+    const filterSensitiveLog: (obj: CreateSnapshotResponse) => any;
+}
+export declare enum UsageLimitBreachAction {
+    DEACTIVATE = "deactivate",
+    EMIT_METRIC = "emit-metric",
+    LOG = "log"
+}
+export declare enum UsageLimitPeriod {
+    DAILY = "daily",
+    MONTHLY = "monthly",
+    WEEKLY = "weekly"
+}
+export declare enum UsageLimitUsageType {
+    CROSS_REGION_DATASHARING = "cross-region-datasharing",
+    SERVERLESS_COMPUTE = "serverless-compute"
+}
+export interface CreateUsageLimitRequest {
+    
+    resourceArn: string | undefined;
+    
+    usageType: UsageLimitUsageType | string | undefined;
+    
+    amount: number | undefined;
+    
+    period?: UsageLimitPeriod | string;
+    
+    breachAction?: UsageLimitBreachAction | string;
+}
+export declare namespace CreateUsageLimitRequest {
+    
+    const filterSensitiveLog: (obj: CreateUsageLimitRequest) => any;
+}
+
+export interface UsageLimit {
+    
+    usageLimitId?: string;
+    
+    usageLimitArn?: string;
+    
+    resourceArn?: string;
+    
+    usageType?: UsageLimitUsageType | string;
+    
+    amount?: number;
+    
+    period?: UsageLimitPeriod | string;
+    
+    breachAction?: UsageLimitBreachAction | string;
+}
+export declare namespace UsageLimit {
+    
+    const filterSensitiveLog: (obj: UsageLimit) => any;
+}
+export interface CreateUsageLimitResponse {
+    
+    usageLimit?: UsageLimit;
+}
+export declare namespace CreateUsageLimitResponse {
+    
+    const filterSensitiveLog: (obj: CreateUsageLimitResponse) => any;
+}
+export interface CreateWorkgroupRequest {
+    
+    workgroupName: string | undefined;
+    
+    namespaceName: string | undefined;
+    
+    baseCapacity?: number;
+    
+    enhancedVpcRouting?: boolean;
+    
+    configParameters?: ConfigParameter[];
+    
+    securityGroupIds?: string[];
+    
+    subnetIds?: string[];
+    
+    publiclyAccessible?: boolean;
+    
+    tags?: Tag[];
+}
+export declare namespace CreateWorkgroupRequest {
+    
+    const filterSensitiveLog: (obj: CreateWorkgroupRequest) => any;
+}
+
+export interface Endpoint {
+    
+    address?: string;
+    
+    port?: number;
+    
+    vpcEndpoints?: VpcEndpoint[];
+}
+export declare namespace Endpoint {
+    
+    const filterSensitiveLog: (obj: Endpoint) => any;
+}
+export declare enum WorkgroupStatus {
+    AVAILABLE = "AVAILABLE",
+    CREATING = "CREATING",
+    DELETING = "DELETING",
+    MODIFYING = "MODIFYING"
+}
+
+export interface Workgroup {
+    
+    workgroupId?: string;
+    
+    workgroupArn?: string;
+    
+    workgroupName?: string;
+    
+    namespaceName?: string;
+    
+    baseCapacity?: number;
+    
+    enhancedVpcRouting?: boolean;
+    
+    configParameters?: ConfigParameter[];
+    
+    securityGroupIds?: string[];
+    
+    subnetIds?: string[];
+    
+    status?: WorkgroupStatus | string;
+    
+    endpoint?: Endpoint;
+    
+    publiclyAccessible?: boolean;
+    
+    creationDate?: Date;
+}
+export declare namespace Workgroup {
+    
+    const filterSensitiveLog: (obj: Workgroup) => any;
+}
+export interface CreateWorkgroupResponse {
+    
+    workgroup?: Workgroup;
+}
+export declare namespace CreateWorkgroupResponse {
+    
+    const filterSensitiveLog: (obj: CreateWorkgroupResponse) => any;
+}
+
+export declare class InsufficientCapacityException extends __BaseException {
+    readonly name: "InsufficientCapacityException";
+    readonly $fault: "client";
+    $retryable: {};
+    
+    constructor(opts: __ExceptionOptionType<InsufficientCapacityException, __BaseException>);
+}
+export interface DeleteEndpointAccessRequest {
+    
+    endpointName: string | undefined;
+}
+export declare namespace DeleteEndpointAccessRequest {
+    
+    const filterSensitiveLog: (obj: DeleteEndpointAccessRequest) => any;
+}
+export interface DeleteEndpointAccessResponse {
+    
+    endpoint?: EndpointAccess;
+}
+export declare namespace DeleteEndpointAccessResponse {
+    
+    const filterSensitiveLog: (obj: DeleteEndpointAccessResponse) => any;
+}
+export interface GetEndpointAccessRequest {
+    
+    endpointName: string | undefined;
+}
+export declare namespace GetEndpointAccessRequest {
+    
+    const filterSensitiveLog: (obj: GetEndpointAccessRequest) => any;
+}
+export interface GetEndpointAccessResponse {
+    
+    endpoint?: EndpointAccess;
+}
+export declare namespace GetEndpointAccessResponse {
+    
+    const filterSensitiveLog: (obj: GetEndpointAccessResponse) => any;
+}
+export interface ListEndpointAccessRequest {
+    
+    nextToken?: string;
+    
+    maxResults?: number;
+    
+    workgroupName?: string;
+    
+    vpcId?: string;
+}
+export declare namespace ListEndpointAccessRequest {
+    
+    const filterSensitiveLog: (obj: ListEndpointAccessRequest) => any;
+}
+export interface ListEndpointAccessResponse {
+    
+    nextToken?: string;
+    
+    endpoints: EndpointAccess[] | undefined;
+}
+export declare namespace ListEndpointAccessResponse {
+    
+    const filterSensitiveLog: (obj: ListEndpointAccessResponse) => any;
+}
+export interface UpdateEndpointAccessRequest {
+    
+    endpointName: string | undefined;
+    
+    vpcSecurityGroupIds?: string[];
+}
+export declare namespace UpdateEndpointAccessRequest {
+    
+    const filterSensitiveLog: (obj: UpdateEndpointAccessRequest) => any;
+}
+export interface UpdateEndpointAccessResponse {
+    
+    endpoint?: EndpointAccess;
+}
+export declare namespace UpdateEndpointAccessResponse {
+    
+    const filterSensitiveLog: (obj: UpdateEndpointAccessResponse) => any;
+}
+export interface DeleteNamespaceRequest {
+    
+    namespaceName: string | undefined;
+    
+    finalSnapshotName?: string;
+    
+    finalSnapshotRetentionPeriod?: number;
+}
+export declare namespace DeleteNamespaceRequest {
+    
+    const filterSensitiveLog: (obj: DeleteNamespaceRequest) => any;
+}
+export interface DeleteNamespaceResponse {
+    
+    namespace: Namespace | undefined;
+}
+export declare namespace DeleteNamespaceResponse {
+    
+    const filterSensitiveLog: (obj: DeleteNamespaceResponse) => any;
+}
+export interface DeleteResourcePolicyRequest {
+    
+    resourceArn: string | undefined;
+}
+export declare namespace DeleteResourcePolicyRequest {
+    
+    const filterSensitiveLog: (obj: DeleteResourcePolicyRequest) => any;
+}
+export interface DeleteResourcePolicyResponse {
+}
+export declare namespace DeleteResourcePolicyResponse {
+    
+    const filterSensitiveLog: (obj: DeleteResourcePolicyResponse) => any;
+}
+export interface DeleteSnapshotRequest {
+    
+    snapshotName: string | undefined;
+}
+export declare namespace DeleteSnapshotRequest {
+    
+    const filterSensitiveLog: (obj: DeleteSnapshotRequest) => any;
+}
+export interface DeleteSnapshotResponse {
+    
+    snapshot?: Snapshot;
+}
+export declare namespace DeleteSnapshotResponse {
+    
+    const filterSensitiveLog: (obj: DeleteSnapshotResponse) => any;
+}
+export interface DeleteUsageLimitRequest {
+    
+    usageLimitId: string | undefined;
+}
+export declare namespace DeleteUsageLimitRequest {
+    
+    const filterSensitiveLog: (obj: DeleteUsageLimitRequest) => any;
+}
+export interface DeleteUsageLimitResponse {
+    
+    usageLimit?: UsageLimit;
+}
+export declare namespace DeleteUsageLimitResponse {
+    
+    const filterSensitiveLog: (obj: DeleteUsageLimitResponse) => any;
+}
+export interface DeleteWorkgroupRequest {
+    
+    workgroupName: string | undefined;
+}
+export declare namespace DeleteWorkgroupRequest {
+    
+    const filterSensitiveLog: (obj: DeleteWorkgroupRequest) => any;
+}
+export interface DeleteWorkgroupResponse {
+    
+    workgroup: Workgroup | undefined;
+}
+export declare namespace DeleteWorkgroupResponse {
+    
+    const filterSensitiveLog: (obj: DeleteWorkgroupResponse) => any;
+}
+export interface GetCredentialsRequest {
+    
+    workgroupName: string | undefined;
+    
+    dbName?: string;
+    
+    durationSeconds?: number;
+}
+export declare namespace GetCredentialsRequest {
+    
+    const filterSensitiveLog: (obj: GetCredentialsRequest) => any;
+}
+export interface GetCredentialsResponse {
+    
+    dbUser?: string;
+    
+    dbPassword?: string;
+    
+    expiration?: Date;
+    
+    nextRefreshTime?: Date;
+}
+export declare namespace GetCredentialsResponse {
+    
+    const filterSensitiveLog: (obj: GetCredentialsResponse) => any;
+}
+export interface GetNamespaceRequest {
+    
+    namespaceName: string | undefined;
+}
+export declare namespace GetNamespaceRequest {
+    
+    const filterSensitiveLog: (obj: GetNamespaceRequest) => any;
+}
+export interface GetNamespaceResponse {
+    
+    namespace: Namespace | undefined;
+}
+export declare namespace GetNamespaceResponse {
+    
+    const filterSensitiveLog: (obj: GetNamespaceResponse) => any;
+}
+export interface GetRecoveryPointRequest {
+    
+    recoveryPointId: string | undefined;
+}
+export declare namespace GetRecoveryPointRequest {
+    
+    const filterSensitiveLog: (obj: GetRecoveryPointRequest) => any;
+}
+
+export interface RecoveryPoint {
+    
+    recoveryPointId?: string;
+    
+    recoveryPointCreateTime?: Date;
+    
+    totalSizeInMegaBytes?: number;
+    
+    namespaceName?: string;
+    
+    workgroupName?: string;
+}
+export declare namespace RecoveryPoint {
+    
+    const filterSensitiveLog: (obj: RecoveryPoint) => any;
+}
+export interface GetRecoveryPointResponse {
+    
+    recoveryPoint?: RecoveryPoint;
+}
+export declare namespace GetRecoveryPointResponse {
+    
+    const filterSensitiveLog: (obj: GetRecoveryPointResponse) => any;
+}
+export interface GetResourcePolicyRequest {
+    
+    resourceArn: string | undefined;
+}
+export declare namespace GetResourcePolicyRequest {
+    
+    const filterSensitiveLog: (obj: GetResourcePolicyRequest) => any;
+}
+
+export interface ResourcePolicy {
+    
+    resourceArn?: string;
+    
+    policy?: string;
+}
+export declare namespace ResourcePolicy {
+    
+    const filterSensitiveLog: (obj: ResourcePolicy) => any;
+}
+export interface GetResourcePolicyResponse {
+    
+    resourcePolicy?: ResourcePolicy;
+}
+export declare namespace GetResourcePolicyResponse {
+    
+    const filterSensitiveLog: (obj: GetResourcePolicyResponse) => any;
+}
+export interface GetSnapshotRequest {
+    
+    snapshotName?: string;
+    
+    ownerAccount?: string;
+    
+    snapshotArn?: string;
+}
+export declare namespace GetSnapshotRequest {
+    
+    const filterSensitiveLog: (obj: GetSnapshotRequest) => any;
+}
+export interface GetSnapshotResponse {
+    
+    snapshot?: Snapshot;
+}
+export declare namespace GetSnapshotResponse {
+    
+    const filterSensitiveLog: (obj: GetSnapshotResponse) => any;
+}
+export interface GetUsageLimitRequest {
+    
+    usageLimitId: string | undefined;
+}
+export declare namespace GetUsageLimitRequest {
+    
+    const filterSensitiveLog: (obj: GetUsageLimitRequest) => any;
+}
+export interface GetUsageLimitResponse {
+    
+    usageLimit?: UsageLimit;
+}
+export declare namespace GetUsageLimitResponse {
+    
+    const filterSensitiveLog: (obj: GetUsageLimitResponse) => any;
+}
+export interface GetWorkgroupRequest {
+    
+    workgroupName: string | undefined;
+}
+export declare namespace GetWorkgroupRequest {
+    
+    const filterSensitiveLog: (obj: GetWorkgroupRequest) => any;
+}
+export interface GetWorkgroupResponse {
+    
+    workgroup: Workgroup | undefined;
+}
+export declare namespace GetWorkgroupResponse {
+    
+    const filterSensitiveLog: (obj: GetWorkgroupResponse) => any;
+}
+
+export declare class InvalidPaginationException extends __BaseException {
+    readonly name: "InvalidPaginationException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<InvalidPaginationException, __BaseException>);
+}
+export interface ListNamespacesRequest {
+    
+    nextToken?: string;
+    
+    maxResults?: number;
+}
+export declare namespace ListNamespacesRequest {
+    
+    const filterSensitiveLog: (obj: ListNamespacesRequest) => any;
+}
+export interface ListNamespacesResponse {
+    
+    nextToken?: string;
+    
+    namespaces: Namespace[] | undefined;
+}
+export declare namespace ListNamespacesResponse {
+    
+    const filterSensitiveLog: (obj: ListNamespacesResponse) => any;
+}
+export interface ListRecoveryPointsRequest {
+    
+    nextToken?: string;
+    
+    maxResults?: number;
+    
+    startTime?: Date;
+    
+    endTime?: Date;
+    
+    namespaceName?: string;
+}
+export declare namespace ListRecoveryPointsRequest {
+    
+    const filterSensitiveLog: (obj: ListRecoveryPointsRequest) => any;
+}
+export interface ListRecoveryPointsResponse {
+    
+    recoveryPoints?: RecoveryPoint[];
+    
+    nextToken?: string;
+}
+export declare namespace ListRecoveryPointsResponse {
+    
+    const filterSensitiveLog: (obj: ListRecoveryPointsResponse) => any;
+}
+export interface ListSnapshotsRequest {
+    
+    nextToken?: string;
+    
+    maxResults?: number;
+    
+    namespaceName?: string;
+    
+    namespaceArn?: string;
+    
+    ownerAccount?: string;
+    
+    startTime?: Date;
+    
+    endTime?: Date;
+}
+export declare namespace ListSnapshotsRequest {
+    
+    const filterSensitiveLog: (obj: ListSnapshotsRequest) => any;
+}
+export interface ListSnapshotsResponse {
+    
+    nextToken?: string;
+    
+    snapshots?: Snapshot[];
+}
+export declare namespace ListSnapshotsResponse {
+    
+    const filterSensitiveLog: (obj: ListSnapshotsResponse) => any;
+}
+export interface ListTagsForResourceRequest {
+    
+    resourceArn: string | undefined;
+}
+export declare namespace ListTagsForResourceRequest {
+    
+    const filterSensitiveLog: (obj: ListTagsForResourceRequest) => any;
+}
+export interface ListTagsForResourceResponse {
+    
+    tags?: Tag[];
+}
+export declare namespace ListTagsForResourceResponse {
+    
+    const filterSensitiveLog: (obj: ListTagsForResourceResponse) => any;
+}
+
+export declare class ThrottlingException extends __BaseException {
+    readonly name: "ThrottlingException";
+    readonly $fault: "client";
+    $retryable: {};
+    code?: string;
+    
+    constructor(opts: __ExceptionOptionType<ThrottlingException, __BaseException>);
+}
+export interface ListUsageLimitsRequest {
+    
+    resourceArn?: string;
+    
+    usageType?: UsageLimitUsageType | string;
+    
+    nextToken?: string;
+    
+    maxResults?: number;
+}
+export declare namespace ListUsageLimitsRequest {
+    
+    const filterSensitiveLog: (obj: ListUsageLimitsRequest) => any;
+}
+export interface ListUsageLimitsResponse {
+    
+    usageLimits?: UsageLimit[];
+    
+    nextToken?: string;
+}
+export declare namespace ListUsageLimitsResponse {
+    
+    const filterSensitiveLog: (obj: ListUsageLimitsResponse) => any;
+}
+export interface ListWorkgroupsRequest {
+    
+    nextToken?: string;
+    
+    maxResults?: number;
+}
+export declare namespace ListWorkgroupsRequest {
+    
+    const filterSensitiveLog: (obj: ListWorkgroupsRequest) => any;
+}
+export interface ListWorkgroupsResponse {
+    
+    nextToken?: string;
+    
+    workgroups: Workgroup[] | undefined;
+}
+export declare namespace ListWorkgroupsResponse {
+    
+    const filterSensitiveLog: (obj: ListWorkgroupsResponse) => any;
+}
+export interface UpdateNamespaceRequest {
+    
+    namespaceName: string | undefined;
+    
+    adminUserPassword?: string;
+    
+    adminUsername?: string;
+    
+    kmsKeyId?: string;
+    
+    defaultIamRoleArn?: string;
+    
+    iamRoles?: string[];
+    
+    logExports?: (LogExport | string)[];
+}
+export declare namespace UpdateNamespaceRequest {
+    
+    const filterSensitiveLog: (obj: UpdateNamespaceRequest) => any;
+}
+export interface UpdateNamespaceResponse {
+    
+    namespace: Namespace | undefined;
+}
+export declare namespace UpdateNamespaceResponse {
+    
+    const filterSensitiveLog: (obj: UpdateNamespaceResponse) => any;
+}
+export interface PutResourcePolicyRequest {
+    
+    resourceArn: string | undefined;
+    
+    policy: string | undefined;
+}
+export declare namespace PutResourcePolicyRequest {
+    
+    const filterSensitiveLog: (obj: PutResourcePolicyRequest) => any;
+}
+export interface PutResourcePolicyResponse {
+    
+    resourcePolicy?: ResourcePolicy;
+}
+export declare namespace PutResourcePolicyResponse {
+    
+    const filterSensitiveLog: (obj: PutResourcePolicyResponse) => any;
+}
+export interface RestoreFromRecoveryPointRequest {
+    
+    recoveryPointId: string | undefined;
+    
+    namespaceName: string | undefined;
+    
+    workgroupName: string | undefined;
+}
+export declare namespace RestoreFromRecoveryPointRequest {
+    
+    const filterSensitiveLog: (obj: RestoreFromRecoveryPointRequest) => any;
+}
+export interface RestoreFromRecoveryPointResponse {
+    
+    recoveryPointId?: string;
+    
+    namespace?: Namespace;
+}
+export declare namespace RestoreFromRecoveryPointResponse {
+    
+    const filterSensitiveLog: (obj: RestoreFromRecoveryPointResponse) => any;
+}
+export interface RestoreFromSnapshotRequest {
+    
+    namespaceName: string | undefined;
+    
+    workgroupName: string | undefined;
+    
+    snapshotName?: string;
+    
+    snapshotArn?: string;
+    
+    ownerAccount?: string;
+}
+export declare namespace RestoreFromSnapshotRequest {
+    
+    const filterSensitiveLog: (obj: RestoreFromSnapshotRequest) => any;
+}
+export interface RestoreFromSnapshotResponse {
+    
+    snapshotName?: string;
+    
+    ownerAccount?: string;
+    
+    namespace?: Namespace;
+}
+export declare namespace RestoreFromSnapshotResponse {
+    
+    const filterSensitiveLog: (obj: RestoreFromSnapshotResponse) => any;
+}
+export interface UpdateSnapshotRequest {
+    
+    snapshotName: string | undefined;
+    
+    retentionPeriod?: number;
+}
+export declare namespace UpdateSnapshotRequest {
+    
+    const filterSensitiveLog: (obj: UpdateSnapshotRequest) => any;
+}
+export interface UpdateSnapshotResponse {
+    
+    snapshot?: Snapshot;
+}
+export declare namespace UpdateSnapshotResponse {
+    
+    const filterSensitiveLog: (obj: UpdateSnapshotResponse) => any;
+}
+export interface TagResourceRequest {
+    
+    resourceArn: string | undefined;
+    
+    tags: Tag[] | undefined;
+}
+export declare namespace TagResourceRequest {
+    
+    const filterSensitiveLog: (obj: TagResourceRequest) => any;
+}
+export interface TagResourceResponse {
+}
+export declare namespace TagResourceResponse {
+    
+    const filterSensitiveLog: (obj: TagResourceResponse) => any;
+}
+export interface UntagResourceRequest {
+    
+    resourceArn: string | undefined;
+    
+    tagKeys: string[] | undefined;
+}
+export declare namespace UntagResourceRequest {
+    
+    const filterSensitiveLog: (obj: UntagResourceRequest) => any;
+}
+export interface UntagResourceResponse {
+}
+export declare namespace UntagResourceResponse {
+    
+    const filterSensitiveLog: (obj: UntagResourceResponse) => any;
+}
+export interface UpdateUsageLimitRequest {
+    
+    usageLimitId: string | undefined;
+    
+    amount?: number;
+    
+    breachAction?: UsageLimitBreachAction | string;
+}
+export declare namespace UpdateUsageLimitRequest {
+    
+    const filterSensitiveLog: (obj: UpdateUsageLimitRequest) => any;
+}
+export interface UpdateUsageLimitResponse {
+    
+    usageLimit?: UsageLimit;
+}
+export declare namespace UpdateUsageLimitResponse {
+    
+    const filterSensitiveLog: (obj: UpdateUsageLimitResponse) => any;
+}
+export interface UpdateWorkgroupRequest {
+    
+    workgroupName: string | undefined;
+    
+    baseCapacity?: number;
+    
+    enhancedVpcRouting?: boolean;
+    
+    configParameters?: ConfigParameter[];
+    
+    publiclyAccessible?: boolean;
+    
+    subnetIds?: string[];
+    
+    securityGroupIds?: string[];
+}
+export declare namespace UpdateWorkgroupRequest {
+    
+    const filterSensitiveLog: (obj: UpdateWorkgroupRequest) => any;
+}
+export interface UpdateWorkgroupResponse {
+    
+    workgroup: Workgroup | undefined;
+}
+export declare namespace UpdateWorkgroupResponse {
+    
+    const filterSensitiveLog: (obj: UpdateWorkgroupResponse) => any;
+}