import * as HttpClient from "effect/unstable/http/HttpClient";
import * as redacted from "effect/Redacted";
import * as S from "effect/Schema";
import * as stream from "effect/Stream";
import * as API from "../client/api.ts";
import type { Credentials } from "../credentials.ts";
import type { CommonErrors } from "../errors.ts";
import type { Region } from "../region.ts";
export type WorkgroupName = string;
export type CustomDomainName = string;
export type CustomDomainCertificateArnString = string;
export type AmazonResourceName = string;
export type DbName = string;
export type DbUser = string | redacted.Redacted<string>;
export type DbPassword = string | redacted.Redacted<string>;
export type TrackName = string;
export type PaginationToken = string;
export type TagKey = string;
export type TagValue = string;
export type SubnetId = string;
export type VpcSecurityGroupId = string;
export type OwnerAccount = string;
export type SourceArn = string;
export type ManagedWorkgroupName = string;
export type NamespaceName = string;
export type IamRoleArn = string;
export type LogExport = string;
export type KmsKeyId = string;
export type RedshiftIdcApplicationArn = string;
export type NamespaceStatus = string;
export type LakehouseRegistration = string;
export type CatalogNameString = string;
export type LakehouseIdcRegistration = string;
export type SnapshotStatus = string;
export type Capacity = number;
export type OfferingId = string;
export type ReservationId = string;
export type ReservationArn = string;
export type Duration = number;
export type Charge = number;
export type CurrencyCode = string;
export type OfferingType = string;
export type Status = string;
export type ScheduledActionName = string;
export type SnapshotNamePrefix = string;
export type State = string;
export type UsageLimitUsageType = string;
export type UsageLimitPeriod = string;
export type UsageLimitBreachAction = string;
export type ParameterKey = string;
export type ParameterValue = string;
export type SecurityGroupId = string;
export type PerformanceTargetStatus = string;
export type IpAddressType = string;
export type WorkgroupStatus = string;
export interface CreateCustomDomainAssociationRequest {
    workgroupName: string;
    customDomainName: string;
    customDomainCertificateArn: string;
}
export declare const CreateCustomDomainAssociationRequest: S.Schema<CreateCustomDomainAssociationRequest>;
export interface CreateCustomDomainAssociationResponse {
    customDomainName?: string;
    workgroupName?: string;
    customDomainCertificateArn?: string;
    customDomainCertificateExpiryTime?: Date;
}
export declare const CreateCustomDomainAssociationResponse: S.Schema<CreateCustomDomainAssociationResponse>;
export interface DeleteCustomDomainAssociationRequest {
    workgroupName: string;
    customDomainName: string;
}
export declare const DeleteCustomDomainAssociationRequest: S.Schema<DeleteCustomDomainAssociationRequest>;
export interface DeleteCustomDomainAssociationResponse {
}
export declare const DeleteCustomDomainAssociationResponse: S.Schema<DeleteCustomDomainAssociationResponse>;
export interface DeleteResourcePolicyRequest {
    resourceArn: string;
}
export declare const DeleteResourcePolicyRequest: S.Schema<DeleteResourcePolicyRequest>;
export interface DeleteResourcePolicyResponse {
}
export declare const DeleteResourcePolicyResponse: S.Schema<DeleteResourcePolicyResponse>;
export interface GetCredentialsRequest {
    dbName?: string;
    durationSeconds?: number;
    workgroupName?: string;
    customDomainName?: string;
}
export declare const GetCredentialsRequest: S.Schema<GetCredentialsRequest>;
export interface GetCredentialsResponse {
    dbUser?: string | redacted.Redacted<string>;
    dbPassword?: string | redacted.Redacted<string>;
    expiration?: Date;
    nextRefreshTime?: Date;
}
export declare const GetCredentialsResponse: S.Schema<GetCredentialsResponse>;
export interface GetCustomDomainAssociationRequest {
    customDomainName: string;
    workgroupName: string;
}
export declare const GetCustomDomainAssociationRequest: S.Schema<GetCustomDomainAssociationRequest>;
export interface GetCustomDomainAssociationResponse {
    customDomainName?: string;
    workgroupName?: string;
    customDomainCertificateArn?: string;
    customDomainCertificateExpiryTime?: Date;
}
export declare const GetCustomDomainAssociationResponse: S.Schema<GetCustomDomainAssociationResponse>;
export type WorkgroupNameList = string[];
export declare const WorkgroupNameList: S.$Array<S.String>;
export interface GetIdentityCenterAuthTokenRequest {
    workgroupNames: string[];
}
export declare const GetIdentityCenterAuthTokenRequest: S.Schema<GetIdentityCenterAuthTokenRequest>;
export interface GetIdentityCenterAuthTokenResponse {
    token?: string;
    expirationTime?: Date;
}
export declare const GetIdentityCenterAuthTokenResponse: S.Schema<GetIdentityCenterAuthTokenResponse>;
export interface GetResourcePolicyRequest {
    resourceArn: string;
}
export declare const GetResourcePolicyRequest: S.Schema<GetResourcePolicyRequest>;
export interface ResourcePolicy {
    resourceArn?: string;
    policy?: string;
}
export declare const ResourcePolicy: S.Schema<ResourcePolicy>;
export interface GetResourcePolicyResponse {
    resourcePolicy?: ResourcePolicy;
}
export declare const GetResourcePolicyResponse: S.Schema<GetResourcePolicyResponse>;
export interface GetTrackRequest {
    trackName: string;
}
export declare const GetTrackRequest: S.Schema<GetTrackRequest>;
export interface UpdateTarget {
    trackName?: string;
    workgroupVersion?: string;
}
export declare const UpdateTarget: S.Schema<UpdateTarget>;
export type UpdateTargetsList = UpdateTarget[];
export declare const UpdateTargetsList: S.$Array<S.Schema<UpdateTarget>>;
export interface ServerlessTrack {
    trackName?: string;
    workgroupVersion?: string;
    updateTargets?: UpdateTarget[];
}
export declare const ServerlessTrack: S.Schema<ServerlessTrack>;
export interface GetTrackResponse {
    track?: ServerlessTrack;
}
export declare const GetTrackResponse: S.Schema<GetTrackResponse>;
export interface ListCustomDomainAssociationsRequest {
    nextToken?: string;
    maxResults?: number;
    customDomainName?: string;
    customDomainCertificateArn?: string;
}
export declare const ListCustomDomainAssociationsRequest: S.Schema<ListCustomDomainAssociationsRequest>;
export interface Association {
    customDomainCertificateArn?: string;
    customDomainCertificateExpiryTime?: Date;
    customDomainName?: string;
    workgroupName?: string;
}
export declare const Association: S.Schema<Association>;
export type AssociationList = Association[];
export declare const AssociationList: S.$Array<S.Schema<Association>>;
export interface ListCustomDomainAssociationsResponse {
    nextToken?: string;
    associations?: Association[];
}
export declare const ListCustomDomainAssociationsResponse: S.Schema<ListCustomDomainAssociationsResponse>;
export interface ListTagsForResourceRequest {
    resourceArn: string;
}
export declare const ListTagsForResourceRequest: S.Schema<ListTagsForResourceRequest>;
export interface Tag {
    key: string;
    value: string;
}
export declare const Tag: S.Schema<Tag>;
export type TagList = Tag[];
export declare const TagList: S.$Array<S.Schema<Tag>>;
export interface ListTagsForResourceResponse {
    tags?: Tag[];
}
export declare const ListTagsForResourceResponse: S.Schema<ListTagsForResourceResponse>;
export interface ListTracksRequest {
    nextToken?: string;
    maxResults?: number;
}
export declare const ListTracksRequest: S.Schema<ListTracksRequest>;
export type TrackList = ServerlessTrack[];
export declare const TrackList: S.$Array<S.Schema<ServerlessTrack>>;
export interface ListTracksResponse {
    tracks?: ServerlessTrack[];
    nextToken?: string;
}
export declare const ListTracksResponse: S.Schema<ListTracksResponse>;
export interface PutResourcePolicyRequest {
    resourceArn: string;
    policy: string;
}
export declare const PutResourcePolicyRequest: S.Schema<PutResourcePolicyRequest>;
export interface PutResourcePolicyResponse {
    resourcePolicy?: ResourcePolicy;
}
export declare const PutResourcePolicyResponse: S.Schema<PutResourcePolicyResponse>;
export interface TagResourceRequest {
    resourceArn: string;
    tags: Tag[];
}
export declare const TagResourceRequest: S.Schema<TagResourceRequest>;
export interface TagResourceResponse {
}
export declare const TagResourceResponse: S.Schema<TagResourceResponse>;
export type TagKeyList = string[];
export declare const TagKeyList: S.$Array<S.String>;
export interface UntagResourceRequest {
    resourceArn: string;
    tagKeys: string[];
}
export declare const UntagResourceRequest: S.Schema<UntagResourceRequest>;
export interface UntagResourceResponse {
}
export declare const UntagResourceResponse: S.Schema<UntagResourceResponse>;
export interface UpdateCustomDomainAssociationRequest {
    workgroupName: string;
    customDomainName: string;
    customDomainCertificateArn: string;
}
export declare const UpdateCustomDomainAssociationRequest: S.Schema<UpdateCustomDomainAssociationRequest>;
export interface UpdateCustomDomainAssociationResponse {
    customDomainName?: string;
    workgroupName?: string;
    customDomainCertificateArn?: string;
    customDomainCertificateExpiryTime?: Date;
}
export declare const UpdateCustomDomainAssociationResponse: S.Schema<UpdateCustomDomainAssociationResponse>;
export type SubnetIdList = string[];
export declare const SubnetIdList: S.$Array<S.String>;
export type VpcSecurityGroupIdList = string[];
export declare const VpcSecurityGroupIdList: S.$Array<S.String>;
export interface CreateEndpointAccessRequest {
    endpointName: string;
    subnetIds: string[];
    workgroupName: string;
    vpcSecurityGroupIds?: string[];
    ownerAccount?: string;
}
export declare const CreateEndpointAccessRequest: S.Schema<CreateEndpointAccessRequest>;
export interface VpcSecurityGroupMembership {
    vpcSecurityGroupId?: string;
    status?: string;
}
export declare const VpcSecurityGroupMembership: S.Schema<VpcSecurityGroupMembership>;
export type VpcSecurityGroupMembershipList = VpcSecurityGroupMembership[];
export declare const VpcSecurityGroupMembershipList: S.$Array<S.Schema<VpcSecurityGroupMembership>>;
export interface NetworkInterface {
    networkInterfaceId?: string;
    subnetId?: string;
    privateIpAddress?: string;
    availabilityZone?: string;
    ipv6Address?: string;
}
export declare const NetworkInterface: S.Schema<NetworkInterface>;
export type NetworkInterfaceList = NetworkInterface[];
export declare const NetworkInterfaceList: S.$Array<S.Schema<NetworkInterface>>;
export interface VpcEndpoint {
    vpcEndpointId?: string;
    vpcId?: string;
    networkInterfaces?: NetworkInterface[];
}
export declare const VpcEndpoint: S.Schema<VpcEndpoint>;
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 const EndpointAccess: S.Schema<EndpointAccess>;
export interface CreateEndpointAccessResponse {
    endpoint?: EndpointAccess;
}
export declare const CreateEndpointAccessResponse: S.Schema<CreateEndpointAccessResponse>;
export interface DeleteEndpointAccessRequest {
    endpointName: string;
}
export declare const DeleteEndpointAccessRequest: S.Schema<DeleteEndpointAccessRequest>;
export interface DeleteEndpointAccessResponse {
    endpoint?: EndpointAccess;
}
export declare const DeleteEndpointAccessResponse: S.Schema<DeleteEndpointAccessResponse>;
export interface GetEndpointAccessRequest {
    endpointName: string;
}
export declare const GetEndpointAccessRequest: S.Schema<GetEndpointAccessRequest>;
export interface GetEndpointAccessResponse {
    endpoint?: EndpointAccess;
}
export declare const GetEndpointAccessResponse: S.Schema<GetEndpointAccessResponse>;
export interface ListEndpointAccessRequest {
    nextToken?: string;
    maxResults?: number;
    workgroupName?: string;
    vpcId?: string;
    ownerAccount?: string;
}
export declare const ListEndpointAccessRequest: S.Schema<ListEndpointAccessRequest>;
export type EndpointAccessList = EndpointAccess[];
export declare const EndpointAccessList: S.$Array<S.Schema<EndpointAccess>>;
export interface ListEndpointAccessResponse {
    nextToken?: string;
    endpoints: EndpointAccess[];
}
export declare const ListEndpointAccessResponse: S.Schema<ListEndpointAccessResponse>;
export interface UpdateEndpointAccessRequest {
    endpointName: string;
    vpcSecurityGroupIds?: string[];
}
export declare const UpdateEndpointAccessRequest: S.Schema<UpdateEndpointAccessRequest>;
export interface UpdateEndpointAccessResponse {
    endpoint?: EndpointAccess;
}
export declare const UpdateEndpointAccessResponse: S.Schema<UpdateEndpointAccessResponse>;
export interface ListManagedWorkgroupsRequest {
    sourceArn?: string;
    nextToken?: string;
    maxResults?: number;
}
export declare const ListManagedWorkgroupsRequest: S.Schema<ListManagedWorkgroupsRequest>;
export type ManagedWorkgroupStatus = "CREATING" | "DELETING" | "MODIFYING" | "AVAILABLE" | "NOT_AVAILABLE" | (string & {});
export declare const ManagedWorkgroupStatus: S.String;
export interface ManagedWorkgroupListItem {
    managedWorkgroupName?: string;
    managedWorkgroupId?: string;
    sourceArn?: string;
    status?: ManagedWorkgroupStatus;
    creationDate?: Date;
}
export declare const ManagedWorkgroupListItem: S.Schema<ManagedWorkgroupListItem>;
export type ManagedWorkgroups = ManagedWorkgroupListItem[];
export declare const ManagedWorkgroups: S.$Array<S.Schema<ManagedWorkgroupListItem>>;
export interface ListManagedWorkgroupsResponse {
    nextToken?: string;
    managedWorkgroups?: ManagedWorkgroupListItem[];
}
export declare const ListManagedWorkgroupsResponse: S.Schema<ListManagedWorkgroupsResponse>;
export type IamRoleArnList = string[];
export declare const IamRoleArnList: S.$Array<S.String>;
export type LogExportList = string[];
export declare const LogExportList: S.$Array<S.String>;
export interface CreateNamespaceRequest {
    namespaceName: string;
    adminUsername?: string | redacted.Redacted<string>;
    adminUserPassword?: string | redacted.Redacted<string>;
    dbName?: string;
    kmsKeyId?: string;
    defaultIamRoleArn?: string;
    iamRoles?: string[];
    logExports?: string[];
    tags?: Tag[];
    manageAdminPassword?: boolean;
    adminPasswordSecretKmsKeyId?: string;
    redshiftIdcApplicationArn?: string;
}
export declare const CreateNamespaceRequest: S.Schema<CreateNamespaceRequest>;
export interface Namespace {
    namespaceArn?: string;
    namespaceId?: string;
    namespaceName?: string;
    adminUsername?: string | redacted.Redacted<string>;
    dbName?: string;
    kmsKeyId?: string;
    defaultIamRoleArn?: string;
    iamRoles?: string[];
    logExports?: string[];
    status?: string;
    creationDate?: Date;
    adminPasswordSecretArn?: string;
    adminPasswordSecretKmsKeyId?: string;
    lakehouseRegistrationStatus?: string;
    catalogArn?: string;
}
export declare const Namespace: S.Schema<Namespace>;
export interface CreateNamespaceResponse {
    namespace?: Namespace;
}
export declare const CreateNamespaceResponse: S.Schema<CreateNamespaceResponse>;
export interface GetNamespaceRequest {
    namespaceName: string;
}
export declare const GetNamespaceRequest: S.Schema<GetNamespaceRequest>;
export interface GetNamespaceResponse {
    namespace: Namespace;
}
export declare const GetNamespaceResponse: S.Schema<GetNamespaceResponse>;
export interface UpdateNamespaceRequest {
    namespaceName: string;
    adminUserPassword?: string | redacted.Redacted<string>;
    adminUsername?: string | redacted.Redacted<string>;
    kmsKeyId?: string;
    defaultIamRoleArn?: string;
    iamRoles?: string[];
    logExports?: string[];
    manageAdminPassword?: boolean;
    adminPasswordSecretKmsKeyId?: string;
}
export declare const UpdateNamespaceRequest: S.Schema<UpdateNamespaceRequest>;
export interface UpdateNamespaceResponse {
    namespace: Namespace;
}
export declare const UpdateNamespaceResponse: S.Schema<UpdateNamespaceResponse>;
export interface DeleteNamespaceRequest {
    namespaceName: string;
    finalSnapshotName?: string;
    finalSnapshotRetentionPeriod?: number;
}
export declare const DeleteNamespaceRequest: S.Schema<DeleteNamespaceRequest>;
export interface DeleteNamespaceResponse {
    namespace: Namespace;
}
export declare const DeleteNamespaceResponse: S.Schema<DeleteNamespaceResponse>;
export interface ListNamespacesRequest {
    nextToken?: string;
    maxResults?: number;
}
export declare const ListNamespacesRequest: S.Schema<ListNamespacesRequest>;
export type NamespaceList = Namespace[];
export declare const NamespaceList: S.$Array<S.Schema<Namespace>>;
export interface ListNamespacesResponse {
    nextToken?: string;
    namespaces: Namespace[];
}
export declare const ListNamespacesResponse: S.Schema<ListNamespacesResponse>;
export interface UpdateLakehouseConfigurationRequest {
    namespaceName: string;
    lakehouseRegistration?: string;
    catalogName?: string;
    lakehouseIdcRegistration?: string;
    lakehouseIdcApplicationArn?: string;
    dryRun?: boolean;
}
export declare const UpdateLakehouseConfigurationRequest: S.Schema<UpdateLakehouseConfigurationRequest>;
export interface UpdateLakehouseConfigurationResponse {
    namespaceName?: string;
    lakehouseIdcApplicationArn?: string;
    lakehouseRegistrationStatus?: string;
    catalogArn?: string;
}
export declare const UpdateLakehouseConfigurationResponse: S.Schema<UpdateLakehouseConfigurationResponse>;
export interface ConvertRecoveryPointToSnapshotRequest {
    recoveryPointId: string;
    snapshotName: string;
    retentionPeriod?: number;
    tags?: Tag[];
}
export declare const ConvertRecoveryPointToSnapshotRequest: S.Schema<ConvertRecoveryPointToSnapshotRequest>;
export type AccountIdList = string[];
export declare const AccountIdList: S.$Array<S.String>;
export interface Snapshot {
    namespaceName?: string;
    namespaceArn?: string;
    snapshotName?: string;
    snapshotCreateTime?: Date;
    adminUsername?: string;
    status?: 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[];
    adminPasswordSecretArn?: string;
    adminPasswordSecretKmsKeyId?: string;
}
export declare const Snapshot: S.Schema<Snapshot>;
export interface ConvertRecoveryPointToSnapshotResponse {
    snapshot?: Snapshot;
}
export declare const ConvertRecoveryPointToSnapshotResponse: S.Schema<ConvertRecoveryPointToSnapshotResponse>;
export interface GetRecoveryPointRequest {
    recoveryPointId: string;
}
export declare const GetRecoveryPointRequest: S.Schema<GetRecoveryPointRequest>;
export interface RecoveryPoint {
    recoveryPointId?: string;
    recoveryPointCreateTime?: Date;
    totalSizeInMegaBytes?: number;
    namespaceName?: string;
    workgroupName?: string;
    namespaceArn?: string;
}
export declare const RecoveryPoint: S.Schema<RecoveryPoint>;
export interface GetRecoveryPointResponse {
    recoveryPoint?: RecoveryPoint;
}
export declare const GetRecoveryPointResponse: S.Schema<GetRecoveryPointResponse>;
export interface ListRecoveryPointsRequest {
    nextToken?: string;
    maxResults?: number;
    startTime?: Date;
    endTime?: Date;
    namespaceName?: string;
    namespaceArn?: string;
}
export declare const ListRecoveryPointsRequest: S.Schema<ListRecoveryPointsRequest>;
export type RecoveryPointList = RecoveryPoint[];
export declare const RecoveryPointList: S.$Array<S.Schema<RecoveryPoint>>;
export interface ListRecoveryPointsResponse {
    recoveryPoints?: RecoveryPoint[];
    nextToken?: string;
}
export declare const ListRecoveryPointsResponse: S.Schema<ListRecoveryPointsResponse>;
export interface RestoreFromRecoveryPointRequest {
    recoveryPointId: string;
    namespaceName: string;
    workgroupName: string;
}
export declare const RestoreFromRecoveryPointRequest: S.Schema<RestoreFromRecoveryPointRequest>;
export interface RestoreFromRecoveryPointResponse {
    recoveryPointId?: string;
    namespace?: Namespace;
}
export declare const RestoreFromRecoveryPointResponse: S.Schema<RestoreFromRecoveryPointResponse>;
export interface RestoreTableFromRecoveryPointRequest {
    namespaceName: string;
    workgroupName: string;
    recoveryPointId: string;
    sourceDatabaseName: string;
    sourceSchemaName?: string;
    sourceTableName: string;
    targetDatabaseName?: string;
    targetSchemaName?: string;
    newTableName: string;
    activateCaseSensitiveIdentifier?: boolean;
}
export declare const RestoreTableFromRecoveryPointRequest: S.Schema<RestoreTableFromRecoveryPointRequest>;
export interface TableRestoreStatus {
    tableRestoreRequestId?: string;
    status?: string;
    message?: string;
    requestTime?: Date;
    namespaceName?: string;
    workgroupName?: string;
    snapshotName?: string;
    progressInMegaBytes?: number;
    totalDataInMegaBytes?: number;
    sourceDatabaseName?: string;
    sourceSchemaName?: string;
    sourceTableName?: string;
    targetDatabaseName?: string;
    targetSchemaName?: string;
    newTableName?: string;
    recoveryPointId?: string;
}
export declare const TableRestoreStatus: S.Schema<TableRestoreStatus>;
export interface RestoreTableFromRecoveryPointResponse {
    tableRestoreStatus?: TableRestoreStatus;
}
export declare const RestoreTableFromRecoveryPointResponse: S.Schema<RestoreTableFromRecoveryPointResponse>;
export interface CreateReservationRequest {
    capacity: number;
    offeringId: string;
    clientToken?: string;
}
export declare const CreateReservationRequest: S.Schema<CreateReservationRequest>;
export interface ReservationOffering {
    offeringId?: string;
    duration?: number;
    upfrontCharge?: number;
    hourlyCharge?: number;
    currencyCode?: string;
    offeringType?: string;
}
export declare const ReservationOffering: S.Schema<ReservationOffering>;
export interface Reservation {
    reservationId?: string;
    reservationArn?: string;
    startDate?: Date;
    endDate?: Date;
    capacity?: number;
    offering?: ReservationOffering;
    status?: string;
}
export declare const Reservation: S.Schema<Reservation>;
export interface CreateReservationResponse {
    reservation?: Reservation;
}
export declare const CreateReservationResponse: S.Schema<CreateReservationResponse>;
export interface GetReservationRequest {
    reservationId: string;
}
export declare const GetReservationRequest: S.Schema<GetReservationRequest>;
export interface GetReservationResponse {
    reservation: Reservation;
}
export declare const GetReservationResponse: S.Schema<GetReservationResponse>;
export interface GetReservationOfferingRequest {
    offeringId: string;
}
export declare const GetReservationOfferingRequest: S.Schema<GetReservationOfferingRequest>;
export interface GetReservationOfferingResponse {
    reservationOffering: ReservationOffering;
}
export declare const GetReservationOfferingResponse: S.Schema<GetReservationOfferingResponse>;
export interface ListReservationOfferingsRequest {
    nextToken?: string;
    maxResults?: number;
}
export declare const ListReservationOfferingsRequest: S.Schema<ListReservationOfferingsRequest>;
export type ReservationOfferingsList = ReservationOffering[];
export declare const ReservationOfferingsList: S.$Array<S.Schema<ReservationOffering>>;
export interface ListReservationOfferingsResponse {
    reservationOfferingsList: ReservationOffering[];
    nextToken?: string;
}
export declare const ListReservationOfferingsResponse: S.Schema<ListReservationOfferingsResponse>;
export interface ListReservationsRequest {
    nextToken?: string;
    maxResults?: number;
}
export declare const ListReservationsRequest: S.Schema<ListReservationsRequest>;
export type ReservationsList = Reservation[];
export declare const ReservationsList: S.$Array<S.Schema<Reservation>>;
export interface ListReservationsResponse {
    reservationsList: Reservation[];
    nextToken?: string;
}
export declare const ListReservationsResponse: S.Schema<ListReservationsResponse>;
export interface CreateSnapshotScheduleActionParameters {
    namespaceName: string;
    snapshotNamePrefix: string;
    retentionPeriod?: number;
    tags?: Tag[];
}
export declare const CreateSnapshotScheduleActionParameters: S.Schema<CreateSnapshotScheduleActionParameters>;
export type TargetAction = {
    createSnapshot: CreateSnapshotScheduleActionParameters;
};
export declare const TargetAction: S.Union<readonly [S.Struct<{
    readonly createSnapshot: S.Schema<CreateSnapshotScheduleActionParameters>;
}>]>;
export type Schedule = {
    at: Date;
    cron?: never;
} | {
    at?: never;
    cron: string;
};
export declare const Schedule: S.Union<readonly [S.Struct<{
    readonly at: S.Date;
}>, S.Struct<{
    readonly cron: S.String;
}>]>;
export interface CreateScheduledActionRequest {
    scheduledActionName: string;
    targetAction: TargetAction;
    schedule: Schedule;
    roleArn: string;
    namespaceName: string;
    enabled?: boolean;
    scheduledActionDescription?: string;
    startTime?: Date;
    endTime?: Date;
}
export declare const CreateScheduledActionRequest: S.Schema<CreateScheduledActionRequest>;
export type NextInvocationsList = Date[];
export declare const NextInvocationsList: S.$Array<S.Date>;
export interface ScheduledActionResponse {
    scheduledActionName?: string;
    schedule?: Schedule;
    scheduledActionDescription?: string;
    nextInvocations?: Date[];
    roleArn?: string;
    state?: string;
    startTime?: Date;
    endTime?: Date;
    targetAction?: TargetAction;
    namespaceName?: string;
    scheduledActionUuid?: string;
}
export declare const ScheduledActionResponse: S.Schema<ScheduledActionResponse>;
export interface CreateScheduledActionResponse {
    scheduledAction?: ScheduledActionResponse;
}
export declare const CreateScheduledActionResponse: S.Schema<CreateScheduledActionResponse>;
export interface DeleteScheduledActionRequest {
    scheduledActionName: string;
}
export declare const DeleteScheduledActionRequest: S.Schema<DeleteScheduledActionRequest>;
export interface DeleteScheduledActionResponse {
    scheduledAction?: ScheduledActionResponse;
}
export declare const DeleteScheduledActionResponse: S.Schema<DeleteScheduledActionResponse>;
export interface GetScheduledActionRequest {
    scheduledActionName: string;
}
export declare const GetScheduledActionRequest: S.Schema<GetScheduledActionRequest>;
export interface GetScheduledActionResponse {
    scheduledAction?: ScheduledActionResponse;
}
export declare const GetScheduledActionResponse: S.Schema<GetScheduledActionResponse>;
export interface ListScheduledActionsRequest {
    nextToken?: string;
    maxResults?: number;
    namespaceName?: string;
}
export declare const ListScheduledActionsRequest: S.Schema<ListScheduledActionsRequest>;
export interface ScheduledActionAssociation {
    namespaceName?: string;
    scheduledActionName?: string;
}
export declare const ScheduledActionAssociation: S.Schema<ScheduledActionAssociation>;
export type ScheduledActionsList = ScheduledActionAssociation[];
export declare const ScheduledActionsList: S.$Array<S.Schema<ScheduledActionAssociation>>;
export interface ListScheduledActionsResponse {
    nextToken?: string;
    scheduledActions?: ScheduledActionAssociation[];
}
export declare const ListScheduledActionsResponse: S.Schema<ListScheduledActionsResponse>;
export interface UpdateScheduledActionRequest {
    scheduledActionName: string;
    targetAction?: TargetAction;
    schedule?: Schedule;
    roleArn?: string;
    enabled?: boolean;
    scheduledActionDescription?: string;
    startTime?: Date;
    endTime?: Date;
}
export declare const UpdateScheduledActionRequest: S.Schema<UpdateScheduledActionRequest>;
export interface UpdateScheduledActionResponse {
    scheduledAction?: ScheduledActionResponse;
}
export declare const UpdateScheduledActionResponse: S.Schema<UpdateScheduledActionResponse>;
export interface CreateSnapshotRequest {
    namespaceName: string;
    snapshotName: string;
    retentionPeriod?: number;
    tags?: Tag[];
}
export declare const CreateSnapshotRequest: S.Schema<CreateSnapshotRequest>;
export interface CreateSnapshotResponse {
    snapshot?: Snapshot;
}
export declare const CreateSnapshotResponse: S.Schema<CreateSnapshotResponse>;
export interface CreateSnapshotCopyConfigurationRequest {
    namespaceName: string;
    destinationRegion: string;
    snapshotRetentionPeriod?: number;
    destinationKmsKeyId?: string;
}
export declare const CreateSnapshotCopyConfigurationRequest: S.Schema<CreateSnapshotCopyConfigurationRequest>;
export interface SnapshotCopyConfiguration {
    snapshotCopyConfigurationId?: string;
    snapshotCopyConfigurationArn?: string;
    namespaceName?: string;
    destinationRegion?: string;
    snapshotRetentionPeriod?: number;
    destinationKmsKeyId?: string;
}
export declare const SnapshotCopyConfiguration: S.Schema<SnapshotCopyConfiguration>;
export interface CreateSnapshotCopyConfigurationResponse {
    snapshotCopyConfiguration: SnapshotCopyConfiguration;
}
export declare const CreateSnapshotCopyConfigurationResponse: S.Schema<CreateSnapshotCopyConfigurationResponse>;
export interface DeleteSnapshotRequest {
    snapshotName: string;
}
export declare const DeleteSnapshotRequest: S.Schema<DeleteSnapshotRequest>;
export interface DeleteSnapshotResponse {
    snapshot?: Snapshot;
}
export declare const DeleteSnapshotResponse: S.Schema<DeleteSnapshotResponse>;
export interface DeleteSnapshotCopyConfigurationRequest {
    snapshotCopyConfigurationId: string;
}
export declare const DeleteSnapshotCopyConfigurationRequest: S.Schema<DeleteSnapshotCopyConfigurationRequest>;
export interface DeleteSnapshotCopyConfigurationResponse {
    snapshotCopyConfiguration: SnapshotCopyConfiguration;
}
export declare const DeleteSnapshotCopyConfigurationResponse: S.Schema<DeleteSnapshotCopyConfigurationResponse>;
export interface GetSnapshotRequest {
    snapshotName?: string;
    ownerAccount?: string;
    snapshotArn?: string;
}
export declare const GetSnapshotRequest: S.Schema<GetSnapshotRequest>;
export interface GetSnapshotResponse {
    snapshot?: Snapshot;
}
export declare const GetSnapshotResponse: S.Schema<GetSnapshotResponse>;
export interface GetTableRestoreStatusRequest {
    tableRestoreRequestId: string;
}
export declare const GetTableRestoreStatusRequest: S.Schema<GetTableRestoreStatusRequest>;
export interface GetTableRestoreStatusResponse {
    tableRestoreStatus?: TableRestoreStatus;
}
export declare const GetTableRestoreStatusResponse: S.Schema<GetTableRestoreStatusResponse>;
export interface ListSnapshotCopyConfigurationsRequest {
    namespaceName?: string;
    nextToken?: string;
    maxResults?: number;
}
export declare const ListSnapshotCopyConfigurationsRequest: S.Schema<ListSnapshotCopyConfigurationsRequest>;
export type SnapshotCopyConfigurations = SnapshotCopyConfiguration[];
export declare const SnapshotCopyConfigurations: S.$Array<S.Schema<SnapshotCopyConfiguration>>;
export interface ListSnapshotCopyConfigurationsResponse {
    nextToken?: string;
    snapshotCopyConfigurations: SnapshotCopyConfiguration[];
}
export declare const ListSnapshotCopyConfigurationsResponse: S.Schema<ListSnapshotCopyConfigurationsResponse>;
export interface ListSnapshotsRequest {
    nextToken?: string;
    maxResults?: number;
    namespaceName?: string;
    namespaceArn?: string;
    ownerAccount?: string;
    startTime?: Date;
    endTime?: Date;
}
export declare const ListSnapshotsRequest: S.Schema<ListSnapshotsRequest>;
export type SnapshotList = Snapshot[];
export declare const SnapshotList: S.$Array<S.Schema<Snapshot>>;
export interface ListSnapshotsResponse {
    nextToken?: string;
    snapshots?: Snapshot[];
}
export declare const ListSnapshotsResponse: S.Schema<ListSnapshotsResponse>;
export interface ListTableRestoreStatusRequest {
    nextToken?: string;
    maxResults?: number;
    namespaceName?: string;
    workgroupName?: string;
}
export declare const ListTableRestoreStatusRequest: S.Schema<ListTableRestoreStatusRequest>;
export type TableRestoreStatusList = TableRestoreStatus[];
export declare const TableRestoreStatusList: S.$Array<S.Schema<TableRestoreStatus>>;
export interface ListTableRestoreStatusResponse {
    nextToken?: string;
    tableRestoreStatuses?: TableRestoreStatus[];
}
export declare const ListTableRestoreStatusResponse: S.Schema<ListTableRestoreStatusResponse>;
export interface RestoreFromSnapshotRequest {
    namespaceName: string;
    workgroupName: string;
    snapshotName?: string;
    snapshotArn?: string;
    ownerAccount?: string;
    manageAdminPassword?: boolean;
    adminPasswordSecretKmsKeyId?: string;
}
export declare const RestoreFromSnapshotRequest: S.Schema<RestoreFromSnapshotRequest>;
export interface RestoreFromSnapshotResponse {
    snapshotName?: string;
    ownerAccount?: string;
    namespace?: Namespace;
}
export declare const RestoreFromSnapshotResponse: S.Schema<RestoreFromSnapshotResponse>;
export interface RestoreTableFromSnapshotRequest {
    namespaceName: string;
    workgroupName: string;
    snapshotName: string;
    sourceDatabaseName: string;
    sourceSchemaName?: string;
    sourceTableName: string;
    targetDatabaseName?: string;
    targetSchemaName?: string;
    newTableName: string;
    activateCaseSensitiveIdentifier?: boolean;
}
export declare const RestoreTableFromSnapshotRequest: S.Schema<RestoreTableFromSnapshotRequest>;
export interface RestoreTableFromSnapshotResponse {
    tableRestoreStatus?: TableRestoreStatus;
}
export declare const RestoreTableFromSnapshotResponse: S.Schema<RestoreTableFromSnapshotResponse>;
export interface UpdateSnapshotRequest {
    snapshotName: string;
    retentionPeriod?: number;
}
export declare const UpdateSnapshotRequest: S.Schema<UpdateSnapshotRequest>;
export interface UpdateSnapshotResponse {
    snapshot?: Snapshot;
}
export declare const UpdateSnapshotResponse: S.Schema<UpdateSnapshotResponse>;
export interface UpdateSnapshotCopyConfigurationRequest {
    snapshotCopyConfigurationId: string;
    snapshotRetentionPeriod?: number;
}
export declare const UpdateSnapshotCopyConfigurationRequest: S.Schema<UpdateSnapshotCopyConfigurationRequest>;
export interface UpdateSnapshotCopyConfigurationResponse {
    snapshotCopyConfiguration: SnapshotCopyConfiguration;
}
export declare const UpdateSnapshotCopyConfigurationResponse: S.Schema<UpdateSnapshotCopyConfigurationResponse>;
export interface CreateUsageLimitRequest {
    resourceArn: string;
    usageType: string;
    amount: number;
    period?: string;
    breachAction?: string;
}
export declare const CreateUsageLimitRequest: S.Schema<CreateUsageLimitRequest>;
export interface UsageLimit {
    usageLimitId?: string;
    usageLimitArn?: string;
    resourceArn?: string;
    usageType?: string;
    amount?: number;
    period?: string;
    breachAction?: string;
}
export declare const UsageLimit: S.Schema<UsageLimit>;
export interface CreateUsageLimitResponse {
    usageLimit?: UsageLimit;
}
export declare const CreateUsageLimitResponse: S.Schema<CreateUsageLimitResponse>;
export interface DeleteUsageLimitRequest {
    usageLimitId: string;
}
export declare const DeleteUsageLimitRequest: S.Schema<DeleteUsageLimitRequest>;
export interface DeleteUsageLimitResponse {
    usageLimit?: UsageLimit;
}
export declare const DeleteUsageLimitResponse: S.Schema<DeleteUsageLimitResponse>;
export interface GetUsageLimitRequest {
    usageLimitId: string;
}
export declare const GetUsageLimitRequest: S.Schema<GetUsageLimitRequest>;
export interface GetUsageLimitResponse {
    usageLimit?: UsageLimit;
}
export declare const GetUsageLimitResponse: S.Schema<GetUsageLimitResponse>;
export interface ListUsageLimitsRequest {
    resourceArn?: string;
    usageType?: string;
    nextToken?: string;
    maxResults?: number;
}
export declare const ListUsageLimitsRequest: S.Schema<ListUsageLimitsRequest>;
export type UsageLimits = UsageLimit[];
export declare const UsageLimits: S.$Array<S.Schema<UsageLimit>>;
export interface ListUsageLimitsResponse {
    usageLimits?: UsageLimit[];
    nextToken?: string;
}
export declare const ListUsageLimitsResponse: S.Schema<ListUsageLimitsResponse>;
export interface UpdateUsageLimitRequest {
    usageLimitId: string;
    amount?: number;
    breachAction?: string;
}
export declare const UpdateUsageLimitRequest: S.Schema<UpdateUsageLimitRequest>;
export interface UpdateUsageLimitResponse {
    usageLimit?: UsageLimit;
}
export declare const UpdateUsageLimitResponse: S.Schema<UpdateUsageLimitResponse>;
export interface ConfigParameter {
    parameterKey?: string;
    parameterValue?: string;
}
export declare const ConfigParameter: S.Schema<ConfigParameter>;
export type ConfigParameterList = ConfigParameter[];
export declare const ConfigParameterList: S.$Array<S.Schema<ConfigParameter>>;
export type SecurityGroupIdList = string[];
export declare const SecurityGroupIdList: S.$Array<S.String>;
export interface PerformanceTarget {
    status?: string;
    level?: number;
}
export declare const PerformanceTarget: S.Schema<PerformanceTarget>;
export interface CreateWorkgroupRequest {
    workgroupName: string;
    namespaceName: string;
    baseCapacity?: number;
    enhancedVpcRouting?: boolean;
    configParameters?: ConfigParameter[];
    securityGroupIds?: string[];
    subnetIds?: string[];
    publiclyAccessible?: boolean;
    tags?: Tag[];
    port?: number;
    maxCapacity?: number;
    pricePerformanceTarget?: PerformanceTarget;
    ipAddressType?: string;
    trackName?: string;
    extraComputeForAutomaticOptimization?: boolean;
}
export declare const CreateWorkgroupRequest: S.Schema<CreateWorkgroupRequest>;
export type VpcEndpointList = VpcEndpoint[];
export declare const VpcEndpointList: S.$Array<S.Schema<VpcEndpoint>>;
export interface Endpoint {
    address?: string;
    port?: number;
    vpcEndpoints?: VpcEndpoint[];
}
export declare const Endpoint: S.Schema<Endpoint>;
export type VpcIds = string[];
export declare const VpcIds: S.$Array<S.String>;
export interface Workgroup {
    workgroupId?: string;
    workgroupArn?: string;
    workgroupName?: string;
    namespaceName?: string;
    baseCapacity?: number;
    enhancedVpcRouting?: boolean;
    configParameters?: ConfigParameter[];
    securityGroupIds?: string[];
    subnetIds?: string[];
    status?: string;
    endpoint?: Endpoint;
    publiclyAccessible?: boolean;
    creationDate?: Date;
    port?: number;
    customDomainName?: string;
    customDomainCertificateArn?: string;
    customDomainCertificateExpiryTime?: Date;
    workgroupVersion?: string;
    patchVersion?: string;
    maxCapacity?: number;
    crossAccountVpcs?: string[];
    ipAddressType?: string;
    pricePerformanceTarget?: PerformanceTarget;
    trackName?: string;
    pendingTrackName?: string;
    extraComputeForAutomaticOptimization?: boolean;
}
export declare const Workgroup: S.Schema<Workgroup>;
export interface CreateWorkgroupResponse {
    workgroup?: Workgroup;
}
export declare const CreateWorkgroupResponse: S.Schema<CreateWorkgroupResponse>;
export interface GetWorkgroupRequest {
    workgroupName: string;
}
export declare const GetWorkgroupRequest: S.Schema<GetWorkgroupRequest>;
export interface GetWorkgroupResponse {
    workgroup: Workgroup;
}
export declare const GetWorkgroupResponse: S.Schema<GetWorkgroupResponse>;
export interface UpdateWorkgroupRequest {
    workgroupName: string;
    baseCapacity?: number;
    enhancedVpcRouting?: boolean;
    configParameters?: ConfigParameter[];
    publiclyAccessible?: boolean;
    subnetIds?: string[];
    securityGroupIds?: string[];
    port?: number;
    maxCapacity?: number;
    ipAddressType?: string;
    pricePerformanceTarget?: PerformanceTarget;
    trackName?: string;
    extraComputeForAutomaticOptimization?: boolean;
}
export declare const UpdateWorkgroupRequest: S.Schema<UpdateWorkgroupRequest>;
export interface UpdateWorkgroupResponse {
    workgroup: Workgroup;
}
export declare const UpdateWorkgroupResponse: S.Schema<UpdateWorkgroupResponse>;
export interface DeleteWorkgroupRequest {
    workgroupName: string;
}
export declare const DeleteWorkgroupRequest: S.Schema<DeleteWorkgroupRequest>;
export interface DeleteWorkgroupResponse {
    workgroup: Workgroup;
}
export declare const DeleteWorkgroupResponse: S.Schema<DeleteWorkgroupResponse>;
export interface ListWorkgroupsRequest {
    nextToken?: string;
    maxResults?: number;
    ownerAccount?: string;
}
export declare const ListWorkgroupsRequest: S.Schema<ListWorkgroupsRequest>;
export type WorkgroupList = Workgroup[];
export declare const WorkgroupList: S.$Array<S.Schema<Workgroup>>;
export interface ListWorkgroupsResponse {
    nextToken?: string;
    workgroups: Workgroup[];
}
export declare const ListWorkgroupsResponse: S.Schema<ListWorkgroupsResponse>;
declare const AccessDeniedException_base: S.Class<AccessDeniedException, S.TaggedStruct<"AccessDeniedException", {
    readonly code: S.optional<S.String>;
    readonly message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        AuthError: true;
    };
});
export declare class AccessDeniedException extends AccessDeniedException_base {
}
declare const ConflictException_base: S.Class<ConflictException, S.TaggedStruct<"ConflictException", {
    readonly message: S.String;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        ConflictError: true;
    };
});
export declare class ConflictException extends ConflictException_base {
}
declare const InternalServerException_base: S.Class<InternalServerException, S.TaggedStruct<"InternalServerException", {
    readonly message: S.String;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        ServerError: true;
    };
}) & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        RetryableError: true;
    };
});
export declare class InternalServerException extends InternalServerException_base {
}
declare const ResourceNotFoundException_base: S.Class<ResourceNotFoundException, S.TaggedStruct<"ResourceNotFoundException", {
    readonly message: S.String;
    readonly resourceName: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        BadRequestError: true;
    };
});
export declare class ResourceNotFoundException extends ResourceNotFoundException_base {
}
declare const ThrottlingException_base: S.Class<ThrottlingException, S.TaggedStruct<"ThrottlingException", {
    readonly code: S.optional<S.String>;
    readonly message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        ThrottlingError: true;
    };
}) & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        RetryableError: true;
    };
});
export declare class ThrottlingException extends ThrottlingException_base {
}
declare const ValidationException_base: S.Class<ValidationException, S.TaggedStruct<"ValidationException", {
    readonly message: S.String;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        BadRequestError: true;
    };
});
export declare class ValidationException extends ValidationException_base {
}
declare const DryRunException_base: S.Class<DryRunException, S.TaggedStruct<"DryRunException", {
    readonly message: S.String;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        BadRequestError: true;
    };
});
export declare class DryRunException extends DryRunException_base {
}
declare const InvalidPaginationException_base: S.Class<InvalidPaginationException, S.TaggedStruct<"InvalidPaginationException", {
    readonly message: S.String;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        BadRequestError: true;
    };
});
export declare class InvalidPaginationException extends InvalidPaginationException_base {
}
declare const ServiceQuotaExceededException_base: S.Class<ServiceQuotaExceededException, S.TaggedStruct<"ServiceQuotaExceededException", {
    readonly message: S.String;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        QuotaError: true;
    };
});
export declare class ServiceQuotaExceededException extends ServiceQuotaExceededException_base {
}
declare const TooManyTagsException_base: S.Class<TooManyTagsException, S.TaggedStruct<"TooManyTagsException", {
    readonly message: S.optional<S.String>;
    readonly resourceName: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        BadRequestError: true;
    };
});
export declare class TooManyTagsException extends TooManyTagsException_base {
}
declare const InsufficientCapacityException_base: S.Class<InsufficientCapacityException, S.TaggedStruct<"InsufficientCapacityException", {
    readonly message: S.String;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        BadRequestError: true;
    };
}) & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        RetryableError: true;
    };
});
export declare class InsufficientCapacityException extends InsufficientCapacityException_base {
}
declare const Ipv6CidrBlockNotFoundException_base: S.Class<Ipv6CidrBlockNotFoundException, S.TaggedStruct<"Ipv6CidrBlockNotFoundException", {
    readonly message: S.String;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        BadRequestError: true;
    };
});
export declare class Ipv6CidrBlockNotFoundException extends Ipv6CidrBlockNotFoundException_base {
}
export type CreateCustomDomainAssociationError = AccessDeniedException | ConflictException | InternalServerException | ResourceNotFoundException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Creates a custom domain association for Amazon Redshift Serverless.
 */
export declare const createCustomDomainAssociation: API.OperationMethod<CreateCustomDomainAssociationRequest, CreateCustomDomainAssociationResponse, CreateCustomDomainAssociationError, Credentials | Region | HttpClient.HttpClient>;
export type DeleteCustomDomainAssociationError = AccessDeniedException | ConflictException | InternalServerException | ResourceNotFoundException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Deletes a custom domain association for Amazon Redshift Serverless.
 */
export declare const deleteCustomDomainAssociation: API.OperationMethod<DeleteCustomDomainAssociationRequest, DeleteCustomDomainAssociationResponse, DeleteCustomDomainAssociationError, Credentials | Region | HttpClient.HttpClient>;
export type DeleteResourcePolicyError = InternalServerException | ResourceNotFoundException | ValidationException | CommonErrors;
/**
 * Deletes the specified resource policy.
 */
export declare const deleteResourcePolicy: API.OperationMethod<DeleteResourcePolicyRequest, DeleteResourcePolicyResponse, DeleteResourcePolicyError, Credentials | Region | HttpClient.HttpClient>;
export type GetCredentialsError = InternalServerException | ResourceNotFoundException | ValidationException | CommonErrors;
/**
 * Returns a database user name and temporary password with temporary authorization to log in to Amazon Redshift Serverless.
 *
 * By default, the temporary credentials expire in 900 seconds. You can optionally specify a duration between 900 seconds (15 minutes) and 3600 seconds (60 minutes).
 *
 * The Identity and Access Management (IAM) user or role that runs GetCredentials must have an IAM policy attached that allows access to all necessary actions and resources.
 *
 * If the `DbName` parameter is specified, the IAM policy must allow access to the resource dbname for the specified database name.
 */
export declare const getCredentials: API.OperationMethod<GetCredentialsRequest, GetCredentialsResponse, GetCredentialsError, Credentials | Region | HttpClient.HttpClient>;
export type GetCustomDomainAssociationError = AccessDeniedException | ConflictException | InternalServerException | ResourceNotFoundException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Gets information about a specific custom domain association.
 */
export declare const getCustomDomainAssociation: API.OperationMethod<GetCustomDomainAssociationRequest, GetCustomDomainAssociationResponse, GetCustomDomainAssociationError, Credentials | Region | HttpClient.HttpClient>;
export type GetIdentityCenterAuthTokenError = AccessDeniedException | ConflictException | DryRunException | InternalServerException | ResourceNotFoundException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Returns an Identity Center authentication token for accessing Amazon Redshift Serverless workgroups.
 *
 * The token provides secure access to data within the specified workgroups using Identity Center identity propagation. The token expires after a specified duration and must be refreshed for continued access.
 *
 * The Identity and Access Management (IAM) user or role that runs GetIdentityCenterAuthToken must have appropriate permissions to access the specified workgroups and Identity Center integration must be configured for the workgroups.
 */
export declare const getIdentityCenterAuthToken: API.OperationMethod<GetIdentityCenterAuthTokenRequest, GetIdentityCenterAuthTokenResponse, GetIdentityCenterAuthTokenError, Credentials | Region | HttpClient.HttpClient>;
export type GetResourcePolicyError = InternalServerException | ResourceNotFoundException | ValidationException | CommonErrors;
/**
 * Returns a resource policy.
 */
export declare const getResourcePolicy: API.OperationMethod<GetResourcePolicyRequest, GetResourcePolicyResponse, GetResourcePolicyError, Credentials | Region | HttpClient.HttpClient>;
export type GetTrackError = AccessDeniedException | ConflictException | DryRunException | InternalServerException | ResourceNotFoundException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Get the Redshift Serverless version for a specified track.
 */
export declare const getTrack: API.OperationMethod<GetTrackRequest, GetTrackResponse, GetTrackError, Credentials | Region | HttpClient.HttpClient>;
export type ListCustomDomainAssociationsError = AccessDeniedException | InternalServerException | InvalidPaginationException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Lists custom domain associations for Amazon Redshift Serverless.
 */
export declare const listCustomDomainAssociations: API.OperationMethod<ListCustomDomainAssociationsRequest, ListCustomDomainAssociationsResponse, ListCustomDomainAssociationsError, Credentials | Region | HttpClient.HttpClient> & {
    pages: (input: ListCustomDomainAssociationsRequest) => stream.Stream<ListCustomDomainAssociationsResponse, ListCustomDomainAssociationsError, Credentials | Region | HttpClient.HttpClient>;
    items: (input: ListCustomDomainAssociationsRequest) => stream.Stream<Association, ListCustomDomainAssociationsError, Credentials | Region | HttpClient.HttpClient>;
};
export type ListTagsForResourceError = InternalServerException | ResourceNotFoundException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Lists the tags assigned to a resource.
 */
export declare const listTagsForResource: API.OperationMethod<ListTagsForResourceRequest, ListTagsForResourceResponse, ListTagsForResourceError, Credentials | Region | HttpClient.HttpClient>;
export type ListTracksError = AccessDeniedException | InternalServerException | InvalidPaginationException | ThrottlingException | ValidationException | CommonErrors;
/**
 * List the Amazon Redshift Serverless versions.
 */
export declare const listTracks: API.OperationMethod<ListTracksRequest, ListTracksResponse, ListTracksError, Credentials | Region | HttpClient.HttpClient> & {
    pages: (input: ListTracksRequest) => stream.Stream<ListTracksResponse, ListTracksError, Credentials | Region | HttpClient.HttpClient>;
    items: (input: ListTracksRequest) => stream.Stream<ServerlessTrack, ListTracksError, Credentials | Region | HttpClient.HttpClient>;
};
export type PutResourcePolicyError = ConflictException | InternalServerException | ResourceNotFoundException | ServiceQuotaExceededException | ValidationException | CommonErrors;
/**
 * Creates or updates a resource policy. Currently, you can use policies to share snapshots across Amazon Web Services accounts.
 */
export declare const putResourcePolicy: API.OperationMethod<PutResourcePolicyRequest, PutResourcePolicyResponse, PutResourcePolicyError, Credentials | Region | HttpClient.HttpClient>;
export type TagResourceError = InternalServerException | ResourceNotFoundException | ThrottlingException | TooManyTagsException | ValidationException | CommonErrors;
/**
 * Assigns one or more tags to a resource.
 */
export declare const tagResource: API.OperationMethod<TagResourceRequest, TagResourceResponse, TagResourceError, Credentials | Region | HttpClient.HttpClient>;
export type UntagResourceError = InternalServerException | ResourceNotFoundException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Removes a tag or set of tags from a resource.
 */
export declare const untagResource: API.OperationMethod<UntagResourceRequest, UntagResourceResponse, UntagResourceError, Credentials | Region | HttpClient.HttpClient>;
export type UpdateCustomDomainAssociationError = AccessDeniedException | ConflictException | InternalServerException | ResourceNotFoundException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Updates an Amazon Redshift Serverless certificate associated with a custom domain.
 */
export declare const updateCustomDomainAssociation: API.OperationMethod<UpdateCustomDomainAssociationRequest, UpdateCustomDomainAssociationResponse, UpdateCustomDomainAssociationError, Credentials | Region | HttpClient.HttpClient>;
export type CreateEndpointAccessError = AccessDeniedException | ConflictException | InternalServerException | ResourceNotFoundException | ServiceQuotaExceededException | ValidationException | CommonErrors;
/**
 * Creates an Amazon Redshift Serverless managed VPC endpoint.
 */
export declare const createEndpointAccess: API.OperationMethod<CreateEndpointAccessRequest, CreateEndpointAccessResponse, CreateEndpointAccessError, Credentials | Region | HttpClient.HttpClient>;
export type DeleteEndpointAccessError = ConflictException | InternalServerException | ResourceNotFoundException | ValidationException | CommonErrors;
/**
 * Deletes an Amazon Redshift Serverless managed VPC endpoint.
 */
export declare const deleteEndpointAccess: API.OperationMethod<DeleteEndpointAccessRequest, DeleteEndpointAccessResponse, DeleteEndpointAccessError, Credentials | Region | HttpClient.HttpClient>;
export type GetEndpointAccessError = ConflictException | InternalServerException | ResourceNotFoundException | ValidationException | CommonErrors;
/**
 * Returns information, such as the name, about a VPC endpoint.
 */
export declare const getEndpointAccess: API.OperationMethod<GetEndpointAccessRequest, GetEndpointAccessResponse, GetEndpointAccessError, Credentials | Region | HttpClient.HttpClient>;
export type ListEndpointAccessError = ConflictException | InternalServerException | ResourceNotFoundException | ValidationException | CommonErrors;
/**
 * Returns an array of `EndpointAccess` objects and relevant information.
 */
export declare const listEndpointAccess: API.OperationMethod<ListEndpointAccessRequest, ListEndpointAccessResponse, ListEndpointAccessError, Credentials | Region | HttpClient.HttpClient> & {
    pages: (input: ListEndpointAccessRequest) => stream.Stream<ListEndpointAccessResponse, ListEndpointAccessError, Credentials | Region | HttpClient.HttpClient>;
    items: (input: ListEndpointAccessRequest) => stream.Stream<EndpointAccess, ListEndpointAccessError, Credentials | Region | HttpClient.HttpClient>;
};
export type UpdateEndpointAccessError = AccessDeniedException | ConflictException | InternalServerException | ResourceNotFoundException | ValidationException | CommonErrors;
/**
 * Updates an Amazon Redshift Serverless managed endpoint.
 */
export declare const updateEndpointAccess: API.OperationMethod<UpdateEndpointAccessRequest, UpdateEndpointAccessResponse, UpdateEndpointAccessError, Credentials | Region | HttpClient.HttpClient>;
export type ListManagedWorkgroupsError = AccessDeniedException | InternalServerException | CommonErrors;
/**
 * Returns information about a list of specified managed workgroups in your account.
 */
export declare const listManagedWorkgroups: API.OperationMethod<ListManagedWorkgroupsRequest, ListManagedWorkgroupsResponse, ListManagedWorkgroupsError, Credentials | Region | HttpClient.HttpClient> & {
    pages: (input: ListManagedWorkgroupsRequest) => stream.Stream<ListManagedWorkgroupsResponse, ListManagedWorkgroupsError, Credentials | Region | HttpClient.HttpClient>;
    items: (input: ListManagedWorkgroupsRequest) => stream.Stream<ManagedWorkgroupListItem, ListManagedWorkgroupsError, Credentials | Region | HttpClient.HttpClient>;
};
export type CreateNamespaceError = ConflictException | InternalServerException | TooManyTagsException | ValidationException | CommonErrors;
/**
 * Creates a namespace in Amazon Redshift Serverless.
 */
export declare const createNamespace: API.OperationMethod<CreateNamespaceRequest, CreateNamespaceResponse, CreateNamespaceError, Credentials | Region | HttpClient.HttpClient>;
export type GetNamespaceError = InternalServerException | ResourceNotFoundException | ValidationException | CommonErrors;
/**
 * Returns information about a namespace in Amazon Redshift Serverless.
 */
export declare const getNamespace: API.OperationMethod<GetNamespaceRequest, GetNamespaceResponse, GetNamespaceError, Credentials | Region | HttpClient.HttpClient>;
export type UpdateNamespaceError = ConflictException | InternalServerException | ResourceNotFoundException | ValidationException | CommonErrors;
/**
 * Updates a namespace with the specified settings. Unless required, you can't update multiple parameters in one request. For example, you must specify both `adminUsername` and `adminUserPassword` to update either field, but you can't update both `kmsKeyId` and `logExports` in a single request.
 */
export declare const updateNamespace: API.OperationMethod<UpdateNamespaceRequest, UpdateNamespaceResponse, UpdateNamespaceError, Credentials | Region | HttpClient.HttpClient>;
export type DeleteNamespaceError = ConflictException | InternalServerException | ResourceNotFoundException | ValidationException | CommonErrors;
/**
 * Deletes a namespace from Amazon Redshift Serverless. Before you delete the namespace, you can create a final snapshot that has all of the data within the namespace.
 */
export declare const deleteNamespace: API.OperationMethod<DeleteNamespaceRequest, DeleteNamespaceResponse, DeleteNamespaceError, Credentials | Region | HttpClient.HttpClient>;
export type ListNamespacesError = InternalServerException | ValidationException | CommonErrors;
/**
 * Returns information about a list of specified namespaces.
 */
export declare const listNamespaces: API.OperationMethod<ListNamespacesRequest, ListNamespacesResponse, ListNamespacesError, Credentials | Region | HttpClient.HttpClient> & {
    pages: (input: ListNamespacesRequest) => stream.Stream<ListNamespacesResponse, ListNamespacesError, Credentials | Region | HttpClient.HttpClient>;
    items: (input: ListNamespacesRequest) => stream.Stream<Namespace, ListNamespacesError, Credentials | Region | HttpClient.HttpClient>;
};
export type UpdateLakehouseConfigurationError = ConflictException | DryRunException | InternalServerException | ResourceNotFoundException | ValidationException | CommonErrors;
/**
 * Modifies the lakehouse configuration for a namespace. This operation allows you to manage Amazon Redshift federated permissions and Amazon Web Services IAM Identity Center trusted identity propagation.
 */
export declare const updateLakehouseConfiguration: API.OperationMethod<UpdateLakehouseConfigurationRequest, UpdateLakehouseConfigurationResponse, UpdateLakehouseConfigurationError, Credentials | Region | HttpClient.HttpClient>;
export type ConvertRecoveryPointToSnapshotError = ConflictException | InternalServerException | ResourceNotFoundException | ServiceQuotaExceededException | TooManyTagsException | ValidationException | CommonErrors;
/**
 * Converts a recovery point to a snapshot. For more information about recovery points and snapshots, see Working with snapshots and recovery points.
 */
export declare const convertRecoveryPointToSnapshot: API.OperationMethod<ConvertRecoveryPointToSnapshotRequest, ConvertRecoveryPointToSnapshotResponse, ConvertRecoveryPointToSnapshotError, Credentials | Region | HttpClient.HttpClient>;
export type GetRecoveryPointError = ConflictException | InternalServerException | ResourceNotFoundException | ValidationException | CommonErrors;
/**
 * Returns information about a recovery point.
 */
export declare const getRecoveryPoint: API.OperationMethod<GetRecoveryPointRequest, GetRecoveryPointResponse, GetRecoveryPointError, Credentials | Region | HttpClient.HttpClient>;
export type ListRecoveryPointsError = InternalServerException | ValidationException | CommonErrors;
/**
 * Returns an array of recovery points.
 */
export declare const listRecoveryPoints: API.OperationMethod<ListRecoveryPointsRequest, ListRecoveryPointsResponse, ListRecoveryPointsError, Credentials | Region | HttpClient.HttpClient> & {
    pages: (input: ListRecoveryPointsRequest) => stream.Stream<ListRecoveryPointsResponse, ListRecoveryPointsError, Credentials | Region | HttpClient.HttpClient>;
    items: (input: ListRecoveryPointsRequest) => stream.Stream<RecoveryPoint, ListRecoveryPointsError, Credentials | Region | HttpClient.HttpClient>;
};
export type RestoreFromRecoveryPointError = ConflictException | InternalServerException | ResourceNotFoundException | ValidationException | CommonErrors;
/**
 * Restore the data from a recovery point.
 */
export declare const restoreFromRecoveryPoint: API.OperationMethod<RestoreFromRecoveryPointRequest, RestoreFromRecoveryPointResponse, RestoreFromRecoveryPointError, Credentials | Region | HttpClient.HttpClient>;
export type RestoreTableFromRecoveryPointError = ConflictException | InternalServerException | ResourceNotFoundException | ValidationException | CommonErrors;
/**
 * Restores a table from a recovery point to your Amazon Redshift Serverless instance. You can't use this operation to restore tables with interleaved sort keys.
 */
export declare const restoreTableFromRecoveryPoint: API.OperationMethod<RestoreTableFromRecoveryPointRequest, RestoreTableFromRecoveryPointResponse, RestoreTableFromRecoveryPointError, Credentials | Region | HttpClient.HttpClient>;
export type CreateReservationError = ConflictException | InternalServerException | ResourceNotFoundException | ServiceQuotaExceededException | ThrottlingException | TooManyTagsException | ValidationException | CommonErrors;
/**
 * Creates an Amazon Redshift Serverless reservation, which gives you the option to commit to a specified number of Redshift Processing Units (RPUs) for a year at a discount from Serverless on-demand (OD) rates.
 */
export declare const createReservation: API.OperationMethod<CreateReservationRequest, CreateReservationResponse, CreateReservationError, Credentials | Region | HttpClient.HttpClient>;
export type GetReservationError = InternalServerException | ResourceNotFoundException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Gets an Amazon Redshift Serverless reservation. A reservation gives you the option to commit to a specified number of Redshift Processing Units (RPUs) for a year at a discount from Serverless on-demand (OD) rates.
 */
export declare const getReservation: API.OperationMethod<GetReservationRequest, GetReservationResponse, GetReservationError, Credentials | Region | HttpClient.HttpClient>;
export type GetReservationOfferingError = InternalServerException | ResourceNotFoundException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Returns the reservation offering. The offering determines the payment schedule for the reservation.
 */
export declare const getReservationOffering: API.OperationMethod<GetReservationOfferingRequest, GetReservationOfferingResponse, GetReservationOfferingError, Credentials | Region | HttpClient.HttpClient>;
export type ListReservationOfferingsError = InternalServerException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Returns the current reservation offerings in your account.
 */
export declare const listReservationOfferings: API.OperationMethod<ListReservationOfferingsRequest, ListReservationOfferingsResponse, ListReservationOfferingsError, Credentials | Region | HttpClient.HttpClient> & {
    pages: (input: ListReservationOfferingsRequest) => stream.Stream<ListReservationOfferingsResponse, ListReservationOfferingsError, Credentials | Region | HttpClient.HttpClient>;
    items: (input: ListReservationOfferingsRequest) => stream.Stream<ReservationOffering, ListReservationOfferingsError, Credentials | Region | HttpClient.HttpClient>;
};
export type ListReservationsError = InternalServerException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Returns a list of Reservation objects.
 */
export declare const listReservations: API.OperationMethod<ListReservationsRequest, ListReservationsResponse, ListReservationsError, Credentials | Region | HttpClient.HttpClient> & {
    pages: (input: ListReservationsRequest) => stream.Stream<ListReservationsResponse, ListReservationsError, Credentials | Region | HttpClient.HttpClient>;
    items: (input: ListReservationsRequest) => stream.Stream<Reservation, ListReservationsError, Credentials | Region | HttpClient.HttpClient>;
};
export type CreateScheduledActionError = ConflictException | InternalServerException | ResourceNotFoundException | ValidationException | CommonErrors;
/**
 * Creates a scheduled action. A scheduled action contains a schedule and an Amazon Redshift API action. For example, you can create a schedule of when to run the `CreateSnapshot` API operation.
 */
export declare const createScheduledAction: API.OperationMethod<CreateScheduledActionRequest, CreateScheduledActionResponse, CreateScheduledActionError, Credentials | Region | HttpClient.HttpClient>;
export type DeleteScheduledActionError = InternalServerException | ResourceNotFoundException | ValidationException | CommonErrors;
/**
 * Deletes a scheduled action.
 */
export declare const deleteScheduledAction: API.OperationMethod<DeleteScheduledActionRequest, DeleteScheduledActionResponse, DeleteScheduledActionError, Credentials | Region | HttpClient.HttpClient>;
export type GetScheduledActionError = InternalServerException | ResourceNotFoundException | ValidationException | CommonErrors;
/**
 * Returns information about a scheduled action.
 */
export declare const getScheduledAction: API.OperationMethod<GetScheduledActionRequest, GetScheduledActionResponse, GetScheduledActionError, Credentials | Region | HttpClient.HttpClient>;
export type ListScheduledActionsError = InternalServerException | InvalidPaginationException | ResourceNotFoundException | ValidationException | CommonErrors;
/**
 * Returns a list of scheduled actions. You can use the flags to filter the list of returned scheduled actions.
 */
export declare const listScheduledActions: API.OperationMethod<ListScheduledActionsRequest, ListScheduledActionsResponse, ListScheduledActionsError, Credentials | Region | HttpClient.HttpClient> & {
    pages: (input: ListScheduledActionsRequest) => stream.Stream<ListScheduledActionsResponse, ListScheduledActionsError, Credentials | Region | HttpClient.HttpClient>;
    items: (input: ListScheduledActionsRequest) => stream.Stream<ScheduledActionAssociation, ListScheduledActionsError, Credentials | Region | HttpClient.HttpClient>;
};
export type UpdateScheduledActionError = ConflictException | InternalServerException | ResourceNotFoundException | ValidationException | CommonErrors;
/**
 * Updates a scheduled action.
 */
export declare const updateScheduledAction: API.OperationMethod<UpdateScheduledActionRequest, UpdateScheduledActionResponse, UpdateScheduledActionError, Credentials | Region | HttpClient.HttpClient>;
export type CreateSnapshotError = ConflictException | InternalServerException | ResourceNotFoundException | ServiceQuotaExceededException | TooManyTagsException | ValidationException | CommonErrors;
/**
 * Creates a snapshot of all databases in a namespace. For more information about snapshots, see Working with snapshots and recovery points.
 */
export declare const createSnapshot: API.OperationMethod<CreateSnapshotRequest, CreateSnapshotResponse, CreateSnapshotError, Credentials | Region | HttpClient.HttpClient>;
export type CreateSnapshotCopyConfigurationError = AccessDeniedException | ConflictException | InternalServerException | ResourceNotFoundException | ServiceQuotaExceededException | ValidationException | CommonErrors;
/**
 * Creates a snapshot copy configuration that lets you copy snapshots to another Amazon Web Services Region.
 */
export declare const createSnapshotCopyConfiguration: API.OperationMethod<CreateSnapshotCopyConfigurationRequest, CreateSnapshotCopyConfigurationResponse, CreateSnapshotCopyConfigurationError, Credentials | Region | HttpClient.HttpClient>;
export type DeleteSnapshotError = ConflictException | InternalServerException | ResourceNotFoundException | ValidationException | CommonErrors;
/**
 * Deletes a snapshot from Amazon Redshift Serverless.
 */
export declare const deleteSnapshot: API.OperationMethod<DeleteSnapshotRequest, DeleteSnapshotResponse, DeleteSnapshotError, Credentials | Region | HttpClient.HttpClient>;
export type DeleteSnapshotCopyConfigurationError = AccessDeniedException | ConflictException | InternalServerException | ResourceNotFoundException | ValidationException | CommonErrors;
/**
 * Deletes a snapshot copy configuration
 */
export declare const deleteSnapshotCopyConfiguration: API.OperationMethod<DeleteSnapshotCopyConfigurationRequest, DeleteSnapshotCopyConfigurationResponse, DeleteSnapshotCopyConfigurationError, Credentials | Region | HttpClient.HttpClient>;
export type GetSnapshotError = InternalServerException | ResourceNotFoundException | ValidationException | CommonErrors;
/**
 * Returns information about a specific snapshot.
 */
export declare const getSnapshot: API.OperationMethod<GetSnapshotRequest, GetSnapshotResponse, GetSnapshotError, Credentials | Region | HttpClient.HttpClient>;
export type GetTableRestoreStatusError = ResourceNotFoundException | ValidationException | CommonErrors;
/**
 * Returns information about a `TableRestoreStatus` object.
 */
export declare const getTableRestoreStatus: API.OperationMethod<GetTableRestoreStatusRequest, GetTableRestoreStatusResponse, GetTableRestoreStatusError, Credentials | Region | HttpClient.HttpClient>;
export type ListSnapshotCopyConfigurationsError = ConflictException | InternalServerException | InvalidPaginationException | ResourceNotFoundException | ValidationException | CommonErrors;
/**
 * Returns a list of snapshot copy configurations.
 */
export declare const listSnapshotCopyConfigurations: API.OperationMethod<ListSnapshotCopyConfigurationsRequest, ListSnapshotCopyConfigurationsResponse, ListSnapshotCopyConfigurationsError, Credentials | Region | HttpClient.HttpClient> & {
    pages: (input: ListSnapshotCopyConfigurationsRequest) => stream.Stream<ListSnapshotCopyConfigurationsResponse, ListSnapshotCopyConfigurationsError, Credentials | Region | HttpClient.HttpClient>;
    items: (input: ListSnapshotCopyConfigurationsRequest) => stream.Stream<SnapshotCopyConfiguration, ListSnapshotCopyConfigurationsError, Credentials | Region | HttpClient.HttpClient>;
};
export type ListSnapshotsError = InternalServerException | ResourceNotFoundException | ValidationException | CommonErrors;
/**
 * Returns a list of snapshots.
 */
export declare const listSnapshots: API.OperationMethod<ListSnapshotsRequest, ListSnapshotsResponse, ListSnapshotsError, Credentials | Region | HttpClient.HttpClient> & {
    pages: (input: ListSnapshotsRequest) => stream.Stream<ListSnapshotsResponse, ListSnapshotsError, Credentials | Region | HttpClient.HttpClient>;
    items: (input: ListSnapshotsRequest) => stream.Stream<Snapshot, ListSnapshotsError, Credentials | Region | HttpClient.HttpClient>;
};
export type ListTableRestoreStatusError = InvalidPaginationException | ResourceNotFoundException | ValidationException | CommonErrors;
/**
 * Returns information about an array of `TableRestoreStatus` objects.
 */
export declare const listTableRestoreStatus: API.OperationMethod<ListTableRestoreStatusRequest, ListTableRestoreStatusResponse, ListTableRestoreStatusError, Credentials | Region | HttpClient.HttpClient> & {
    pages: (input: ListTableRestoreStatusRequest) => stream.Stream<ListTableRestoreStatusResponse, ListTableRestoreStatusError, Credentials | Region | HttpClient.HttpClient>;
    items: (input: ListTableRestoreStatusRequest) => stream.Stream<TableRestoreStatus, ListTableRestoreStatusError, Credentials | Region | HttpClient.HttpClient>;
};
export type RestoreFromSnapshotError = ConflictException | InternalServerException | ResourceNotFoundException | ServiceQuotaExceededException | ValidationException | CommonErrors;
/**
 * Restores a namespace from a snapshot.
 */
export declare const restoreFromSnapshot: API.OperationMethod<RestoreFromSnapshotRequest, RestoreFromSnapshotResponse, RestoreFromSnapshotError, Credentials | Region | HttpClient.HttpClient>;
export type RestoreTableFromSnapshotError = ConflictException | InternalServerException | ResourceNotFoundException | ValidationException | CommonErrors;
/**
 * Restores a table from a snapshot to your Amazon Redshift Serverless instance. You can't use this operation to restore tables with interleaved sort keys.
 */
export declare const restoreTableFromSnapshot: API.OperationMethod<RestoreTableFromSnapshotRequest, RestoreTableFromSnapshotResponse, RestoreTableFromSnapshotError, Credentials | Region | HttpClient.HttpClient>;
export type UpdateSnapshotError = ConflictException | InternalServerException | ResourceNotFoundException | ValidationException | CommonErrors;
/**
 * Updates a snapshot.
 */
export declare const updateSnapshot: API.OperationMethod<UpdateSnapshotRequest, UpdateSnapshotResponse, UpdateSnapshotError, Credentials | Region | HttpClient.HttpClient>;
export type UpdateSnapshotCopyConfigurationError = AccessDeniedException | ConflictException | InternalServerException | ResourceNotFoundException | ValidationException | CommonErrors;
/**
 * Updates a snapshot copy configuration.
 */
export declare const updateSnapshotCopyConfiguration: API.OperationMethod<UpdateSnapshotCopyConfigurationRequest, UpdateSnapshotCopyConfigurationResponse, UpdateSnapshotCopyConfigurationError, Credentials | Region | HttpClient.HttpClient>;
export type CreateUsageLimitError = ConflictException | InternalServerException | ResourceNotFoundException | ServiceQuotaExceededException | ValidationException | CommonErrors;
/**
 * Creates a usage limit for a specified Amazon Redshift Serverless usage type. The usage limit is identified by the returned usage limit identifier.
 */
export declare const createUsageLimit: API.OperationMethod<CreateUsageLimitRequest, CreateUsageLimitResponse, CreateUsageLimitError, Credentials | Region | HttpClient.HttpClient>;
export type DeleteUsageLimitError = ConflictException | InternalServerException | ResourceNotFoundException | ValidationException | CommonErrors;
/**
 * Deletes a usage limit from Amazon Redshift Serverless.
 */
export declare const deleteUsageLimit: API.OperationMethod<DeleteUsageLimitRequest, DeleteUsageLimitResponse, DeleteUsageLimitError, Credentials | Region | HttpClient.HttpClient>;
export type GetUsageLimitError = ConflictException | InternalServerException | ResourceNotFoundException | ValidationException | CommonErrors;
/**
 * Returns information about a usage limit.
 */
export declare const getUsageLimit: API.OperationMethod<GetUsageLimitRequest, GetUsageLimitResponse, GetUsageLimitError, Credentials | Region | HttpClient.HttpClient>;
export type ListUsageLimitsError = ConflictException | InternalServerException | InvalidPaginationException | ResourceNotFoundException | ValidationException | CommonErrors;
/**
 * Lists all usage limits within Amazon Redshift Serverless.
 */
export declare const listUsageLimits: API.OperationMethod<ListUsageLimitsRequest, ListUsageLimitsResponse, ListUsageLimitsError, Credentials | Region | HttpClient.HttpClient> & {
    pages: (input: ListUsageLimitsRequest) => stream.Stream<ListUsageLimitsResponse, ListUsageLimitsError, Credentials | Region | HttpClient.HttpClient>;
    items: (input: ListUsageLimitsRequest) => stream.Stream<UsageLimit, ListUsageLimitsError, Credentials | Region | HttpClient.HttpClient>;
};
export type UpdateUsageLimitError = ConflictException | InternalServerException | ResourceNotFoundException | ValidationException | CommonErrors;
/**
 * Update a usage limit in Amazon Redshift Serverless. You can't update the usage type or period of a usage limit.
 */
export declare const updateUsageLimit: API.OperationMethod<UpdateUsageLimitRequest, UpdateUsageLimitResponse, UpdateUsageLimitError, Credentials | Region | HttpClient.HttpClient>;
export type CreateWorkgroupError = ConflictException | InsufficientCapacityException | InternalServerException | Ipv6CidrBlockNotFoundException | ResourceNotFoundException | TooManyTagsException | ValidationException | CommonErrors;
/**
 * Creates an workgroup in Amazon Redshift Serverless.
 *
 * VPC Block Public Access (BPA) enables you to block resources in VPCs and subnets that you own in a Region from reaching or being reached from the internet through internet gateways and egress-only internet gateways. If a workgroup is in an account with VPC BPA turned on, the following capabilities are blocked:
 *
 * - Creating a public access workgroup
 *
 * - Modifying a private workgroup to public
 *
 * - Adding a subnet with VPC BPA turned on to the workgroup when the workgroup is public
 *
 * For more information about VPC BPA, see Block public access to VPCs and subnets in the *Amazon VPC User Guide*.
 */
export declare const createWorkgroup: API.OperationMethod<CreateWorkgroupRequest, CreateWorkgroupResponse, CreateWorkgroupError, Credentials | Region | HttpClient.HttpClient>;
export type GetWorkgroupError = InternalServerException | ResourceNotFoundException | ValidationException | CommonErrors;
/**
 * Returns information about a specific workgroup.
 */
export declare const getWorkgroup: API.OperationMethod<GetWorkgroupRequest, GetWorkgroupResponse, GetWorkgroupError, Credentials | Region | HttpClient.HttpClient>;
export type UpdateWorkgroupError = ConflictException | InsufficientCapacityException | InternalServerException | Ipv6CidrBlockNotFoundException | ResourceNotFoundException | ValidationException | CommonErrors;
/**
 * Updates a workgroup with the specified configuration settings. You can't update multiple parameters in one request. For example, you can update `baseCapacity` or `port` in a single request, but you can't update both in the same request.
 *
 * VPC Block Public Access (BPA) enables you to block resources in VPCs and subnets that you own in a Region from reaching or being reached from the internet through internet gateways and egress-only internet gateways. If a workgroup is in an account with VPC BPA turned on, the following capabilities are blocked:
 *
 * - Creating a public access workgroup
 *
 * - Modifying a private workgroup to public
 *
 * - Adding a subnet with VPC BPA turned on to the workgroup when the workgroup is public
 *
 * For more information about VPC BPA, see Block public access to VPCs and subnets in the *Amazon VPC User Guide*.
 */
export declare const updateWorkgroup: API.OperationMethod<UpdateWorkgroupRequest, UpdateWorkgroupResponse, UpdateWorkgroupError, Credentials | Region | HttpClient.HttpClient>;
export type DeleteWorkgroupError = ConflictException | InternalServerException | ResourceNotFoundException | ValidationException | CommonErrors;
/**
 * Deletes a workgroup.
 */
export declare const deleteWorkgroup: API.OperationMethod<DeleteWorkgroupRequest, DeleteWorkgroupResponse, DeleteWorkgroupError, Credentials | Region | HttpClient.HttpClient>;
export type ListWorkgroupsError = InternalServerException | ValidationException | CommonErrors;
/**
 * Returns information about a list of specified workgroups.
 */
export declare const listWorkgroups: API.OperationMethod<ListWorkgroupsRequest, ListWorkgroupsResponse, ListWorkgroupsError, Credentials | Region | HttpClient.HttpClient> & {
    pages: (input: ListWorkgroupsRequest) => stream.Stream<ListWorkgroupsResponse, ListWorkgroupsError, Credentials | Region | HttpClient.HttpClient>;
    items: (input: ListWorkgroupsRequest) => stream.Stream<Workgroup, ListWorkgroupsError, Credentials | Region | HttpClient.HttpClient>;
};
export {};
//# sourceMappingURL=redshift-serverless.d.ts.map