@aws-sdk/client-athena 3.50.0 → 3.53.0

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

@@ -0,0 +1,1180 @@
+import { ExceptionOptionType as __ExceptionOptionType } from "@aws-sdk/smithy-client";
+import { AthenaServiceException as __BaseException } from "./AthenaServiceException";
+export interface BatchGetNamedQueryInput {
+    
+    NamedQueryIds: string[] | undefined;
+}
+export declare namespace BatchGetNamedQueryInput {
+    
+    const filterSensitiveLog: (obj: BatchGetNamedQueryInput) => any;
+}
+
+export interface NamedQuery {
+    
+    Name: string | undefined;
+    
+    Description?: string;
+    
+    Database: string | undefined;
+    
+    QueryString: string | undefined;
+    
+    NamedQueryId?: string;
+    
+    WorkGroup?: string;
+}
+export declare namespace NamedQuery {
+    
+    const filterSensitiveLog: (obj: NamedQuery) => any;
+}
+
+export interface UnprocessedNamedQueryId {
+    
+    NamedQueryId?: string;
+    
+    ErrorCode?: string;
+    
+    ErrorMessage?: string;
+}
+export declare namespace UnprocessedNamedQueryId {
+    
+    const filterSensitiveLog: (obj: UnprocessedNamedQueryId) => any;
+}
+export interface BatchGetNamedQueryOutput {
+    
+    NamedQueries?: NamedQuery[];
+    
+    UnprocessedNamedQueryIds?: UnprocessedNamedQueryId[];
+}
+export declare namespace BatchGetNamedQueryOutput {
+    
+    const filterSensitiveLog: (obj: BatchGetNamedQueryOutput) => any;
+}
+
+export declare class InternalServerException extends __BaseException {
+    readonly name: "InternalServerException";
+    readonly $fault: "server";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<InternalServerException, __BaseException>);
+}
+
+export declare class InvalidRequestException extends __BaseException {
+    readonly name: "InvalidRequestException";
+    readonly $fault: "client";
+    
+    AthenaErrorCode?: string;
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<InvalidRequestException, __BaseException>);
+}
+export interface BatchGetQueryExecutionInput {
+    
+    QueryExecutionIds: string[] | undefined;
+}
+export declare namespace BatchGetQueryExecutionInput {
+    
+    const filterSensitiveLog: (obj: BatchGetQueryExecutionInput) => any;
+}
+
+export interface EngineVersion {
+    
+    SelectedEngineVersion?: string;
+    
+    EffectiveEngineVersion?: string;
+}
+export declare namespace EngineVersion {
+    
+    const filterSensitiveLog: (obj: EngineVersion) => any;
+}
+
+export interface QueryExecutionContext {
+    
+    Database?: string;
+    
+    Catalog?: string;
+}
+export declare namespace QueryExecutionContext {
+    
+    const filterSensitiveLog: (obj: QueryExecutionContext) => any;
+}
+export declare enum EncryptionOption {
+    CSE_KMS = "CSE_KMS",
+    SSE_KMS = "SSE_KMS",
+    SSE_S3 = "SSE_S3"
+}
+
+export interface EncryptionConfiguration {
+    
+    EncryptionOption: EncryptionOption | string | undefined;
+    
+    KmsKey?: string;
+}
+export declare namespace EncryptionConfiguration {
+    
+    const filterSensitiveLog: (obj: EncryptionConfiguration) => any;
+}
+
+export interface ResultConfiguration {
+    
+    OutputLocation?: string;
+    
+    EncryptionConfiguration?: EncryptionConfiguration;
+    
+    ExpectedBucketOwner?: string;
+}
+export declare namespace ResultConfiguration {
+    
+    const filterSensitiveLog: (obj: ResultConfiguration) => any;
+}
+export declare enum StatementType {
+    DDL = "DDL",
+    DML = "DML",
+    UTILITY = "UTILITY"
+}
+
+export interface QueryExecutionStatistics {
+    
+    EngineExecutionTimeInMillis?: number;
+    
+    DataScannedInBytes?: number;
+    
+    DataManifestLocation?: string;
+    
+    TotalExecutionTimeInMillis?: number;
+    
+    QueryQueueTimeInMillis?: number;
+    
+    QueryPlanningTimeInMillis?: number;
+    
+    ServiceProcessingTimeInMillis?: number;
+}
+export declare namespace QueryExecutionStatistics {
+    
+    const filterSensitiveLog: (obj: QueryExecutionStatistics) => any;
+}
+
+export interface AthenaError {
+    
+    ErrorCategory?: number;
+    
+    ErrorType?: number;
+}
+export declare namespace AthenaError {
+    
+    const filterSensitiveLog: (obj: AthenaError) => any;
+}
+export declare enum QueryExecutionState {
+    CANCELLED = "CANCELLED",
+    FAILED = "FAILED",
+    QUEUED = "QUEUED",
+    RUNNING = "RUNNING",
+    SUCCEEDED = "SUCCEEDED"
+}
+
+export interface QueryExecutionStatus {
+    
+    State?: QueryExecutionState | string;
+    
+    StateChangeReason?: string;
+    
+    SubmissionDateTime?: Date;
+    
+    CompletionDateTime?: Date;
+    
+    AthenaError?: AthenaError;
+}
+export declare namespace QueryExecutionStatus {
+    
+    const filterSensitiveLog: (obj: QueryExecutionStatus) => any;
+}
+
+export interface QueryExecution {
+    
+    QueryExecutionId?: string;
+    
+    Query?: string;
+    
+    StatementType?: StatementType | string;
+    
+    ResultConfiguration?: ResultConfiguration;
+    
+    QueryExecutionContext?: QueryExecutionContext;
+    
+    Status?: QueryExecutionStatus;
+    
+    Statistics?: QueryExecutionStatistics;
+    
+    WorkGroup?: string;
+    
+    EngineVersion?: EngineVersion;
+}
+export declare namespace QueryExecution {
+    
+    const filterSensitiveLog: (obj: QueryExecution) => any;
+}
+
+export interface UnprocessedQueryExecutionId {
+    
+    QueryExecutionId?: string;
+    
+    ErrorCode?: string;
+    
+    ErrorMessage?: string;
+}
+export declare namespace UnprocessedQueryExecutionId {
+    
+    const filterSensitiveLog: (obj: UnprocessedQueryExecutionId) => any;
+}
+export interface BatchGetQueryExecutionOutput {
+    
+    QueryExecutions?: QueryExecution[];
+    
+    UnprocessedQueryExecutionIds?: UnprocessedQueryExecutionId[];
+}
+export declare namespace BatchGetQueryExecutionOutput {
+    
+    const filterSensitiveLog: (obj: BatchGetQueryExecutionOutput) => any;
+}
+
+export interface Tag {
+    
+    Key?: string;
+    
+    Value?: string;
+}
+export declare namespace Tag {
+    
+    const filterSensitiveLog: (obj: Tag) => any;
+}
+export declare enum DataCatalogType {
+    GLUE = "GLUE",
+    HIVE = "HIVE",
+    LAMBDA = "LAMBDA"
+}
+export interface CreateDataCatalogInput {
+    
+    Name: string | undefined;
+    
+    Type: DataCatalogType | string | undefined;
+    
+    Description?: string;
+    
+    Parameters?: {
+        [key: string]: string;
+    };
+    
+    Tags?: Tag[];
+}
+export declare namespace CreateDataCatalogInput {
+    
+    const filterSensitiveLog: (obj: CreateDataCatalogInput) => any;
+}
+export interface CreateDataCatalogOutput {
+}
+export declare namespace CreateDataCatalogOutput {
+    
+    const filterSensitiveLog: (obj: CreateDataCatalogOutput) => any;
+}
+export interface CreateNamedQueryInput {
+    
+    Name: string | undefined;
+    
+    Description?: string;
+    
+    Database: string | undefined;
+    
+    QueryString: string | undefined;
+    
+    ClientRequestToken?: string;
+    
+    WorkGroup?: string;
+}
+export declare namespace CreateNamedQueryInput {
+    
+    const filterSensitiveLog: (obj: CreateNamedQueryInput) => any;
+}
+export interface CreateNamedQueryOutput {
+    
+    NamedQueryId?: string;
+}
+export declare namespace CreateNamedQueryOutput {
+    
+    const filterSensitiveLog: (obj: CreateNamedQueryOutput) => any;
+}
+export interface CreatePreparedStatementInput {
+    
+    StatementName: string | undefined;
+    
+    WorkGroup: string | undefined;
+    
+    QueryStatement: string | undefined;
+    
+    Description?: string;
+}
+export declare namespace CreatePreparedStatementInput {
+    
+    const filterSensitiveLog: (obj: CreatePreparedStatementInput) => any;
+}
+export interface CreatePreparedStatementOutput {
+}
+export declare namespace CreatePreparedStatementOutput {
+    
+    const filterSensitiveLog: (obj: CreatePreparedStatementOutput) => any;
+}
+
+export interface WorkGroupConfiguration {
+    
+    ResultConfiguration?: ResultConfiguration;
+    
+    EnforceWorkGroupConfiguration?: boolean;
+    
+    PublishCloudWatchMetricsEnabled?: boolean;
+    
+    BytesScannedCutoffPerQuery?: number;
+    
+    RequesterPaysEnabled?: boolean;
+    
+    EngineVersion?: EngineVersion;
+}
+export declare namespace WorkGroupConfiguration {
+    
+    const filterSensitiveLog: (obj: WorkGroupConfiguration) => any;
+}
+export interface CreateWorkGroupInput {
+    
+    Name: string | undefined;
+    
+    Configuration?: WorkGroupConfiguration;
+    
+    Description?: string;
+    
+    Tags?: Tag[];
+}
+export declare namespace CreateWorkGroupInput {
+    
+    const filterSensitiveLog: (obj: CreateWorkGroupInput) => any;
+}
+export interface CreateWorkGroupOutput {
+}
+export declare namespace CreateWorkGroupOutput {
+    
+    const filterSensitiveLog: (obj: CreateWorkGroupOutput) => any;
+}
+export interface DeleteDataCatalogInput {
+    
+    Name: string | undefined;
+}
+export declare namespace DeleteDataCatalogInput {
+    
+    const filterSensitiveLog: (obj: DeleteDataCatalogInput) => any;
+}
+export interface DeleteDataCatalogOutput {
+}
+export declare namespace DeleteDataCatalogOutput {
+    
+    const filterSensitiveLog: (obj: DeleteDataCatalogOutput) => any;
+}
+export interface DeleteNamedQueryInput {
+    
+    NamedQueryId?: string;
+}
+export declare namespace DeleteNamedQueryInput {
+    
+    const filterSensitiveLog: (obj: DeleteNamedQueryInput) => any;
+}
+export interface DeleteNamedQueryOutput {
+}
+export declare namespace DeleteNamedQueryOutput {
+    
+    const filterSensitiveLog: (obj: DeleteNamedQueryOutput) => any;
+}
+export interface DeletePreparedStatementInput {
+    
+    StatementName: string | undefined;
+    
+    WorkGroup: string | undefined;
+}
+export declare namespace DeletePreparedStatementInput {
+    
+    const filterSensitiveLog: (obj: DeletePreparedStatementInput) => any;
+}
+export interface DeletePreparedStatementOutput {
+}
+export declare namespace DeletePreparedStatementOutput {
+    
+    const filterSensitiveLog: (obj: DeletePreparedStatementOutput) => any;
+}
+
+export declare class ResourceNotFoundException extends __BaseException {
+    readonly name: "ResourceNotFoundException";
+    readonly $fault: "client";
+    Message?: string;
+    ResourceName?: string;
+    
+    constructor(opts: __ExceptionOptionType<ResourceNotFoundException, __BaseException>);
+}
+export interface DeleteWorkGroupInput {
+    
+    WorkGroup: string | undefined;
+    
+    RecursiveDeleteOption?: boolean;
+}
+export declare namespace DeleteWorkGroupInput {
+    
+    const filterSensitiveLog: (obj: DeleteWorkGroupInput) => any;
+}
+export interface DeleteWorkGroupOutput {
+}
+export declare namespace DeleteWorkGroupOutput {
+    
+    const filterSensitiveLog: (obj: DeleteWorkGroupOutput) => any;
+}
+export interface GetDatabaseInput {
+    
+    CatalogName: string | undefined;
+    
+    DatabaseName: string | undefined;
+}
+export declare namespace GetDatabaseInput {
+    
+    const filterSensitiveLog: (obj: GetDatabaseInput) => any;
+}
+
+export interface Database {
+    
+    Name: string | undefined;
+    
+    Description?: string;
+    
+    Parameters?: {
+        [key: string]: string;
+    };
+}
+export declare namespace Database {
+    
+    const filterSensitiveLog: (obj: Database) => any;
+}
+export interface GetDatabaseOutput {
+    
+    Database?: Database;
+}
+export declare namespace GetDatabaseOutput {
+    
+    const filterSensitiveLog: (obj: GetDatabaseOutput) => any;
+}
+
+export declare class MetadataException extends __BaseException {
+    readonly name: "MetadataException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<MetadataException, __BaseException>);
+}
+export interface GetDataCatalogInput {
+    
+    Name: string | undefined;
+}
+export declare namespace GetDataCatalogInput {
+    
+    const filterSensitiveLog: (obj: GetDataCatalogInput) => any;
+}
+
+export interface DataCatalog {
+    
+    Name: string | undefined;
+    
+    Description?: string;
+    
+    Type: DataCatalogType | string | undefined;
+    
+    Parameters?: {
+        [key: string]: string;
+    };
+}
+export declare namespace DataCatalog {
+    
+    const filterSensitiveLog: (obj: DataCatalog) => any;
+}
+export interface GetDataCatalogOutput {
+    
+    DataCatalog?: DataCatalog;
+}
+export declare namespace GetDataCatalogOutput {
+    
+    const filterSensitiveLog: (obj: GetDataCatalogOutput) => any;
+}
+export interface GetNamedQueryInput {
+    
+    NamedQueryId: string | undefined;
+}
+export declare namespace GetNamedQueryInput {
+    
+    const filterSensitiveLog: (obj: GetNamedQueryInput) => any;
+}
+export interface GetNamedQueryOutput {
+    
+    NamedQuery?: NamedQuery;
+}
+export declare namespace GetNamedQueryOutput {
+    
+    const filterSensitiveLog: (obj: GetNamedQueryOutput) => any;
+}
+export interface GetPreparedStatementInput {
+    
+    StatementName: string | undefined;
+    
+    WorkGroup: string | undefined;
+}
+export declare namespace GetPreparedStatementInput {
+    
+    const filterSensitiveLog: (obj: GetPreparedStatementInput) => any;
+}
+
+export interface PreparedStatement {
+    
+    StatementName?: string;
+    
+    QueryStatement?: string;
+    
+    WorkGroupName?: string;
+    
+    Description?: string;
+    
+    LastModifiedTime?: Date;
+}
+export declare namespace PreparedStatement {
+    
+    const filterSensitiveLog: (obj: PreparedStatement) => any;
+}
+export interface GetPreparedStatementOutput {
+    
+    PreparedStatement?: PreparedStatement;
+}
+export declare namespace GetPreparedStatementOutput {
+    
+    const filterSensitiveLog: (obj: GetPreparedStatementOutput) => any;
+}
+export interface GetQueryExecutionInput {
+    
+    QueryExecutionId: string | undefined;
+}
+export declare namespace GetQueryExecutionInput {
+    
+    const filterSensitiveLog: (obj: GetQueryExecutionInput) => any;
+}
+export interface GetQueryExecutionOutput {
+    
+    QueryExecution?: QueryExecution;
+}
+export declare namespace GetQueryExecutionOutput {
+    
+    const filterSensitiveLog: (obj: GetQueryExecutionOutput) => any;
+}
+export interface GetQueryResultsInput {
+    
+    QueryExecutionId: string | undefined;
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+}
+export declare namespace GetQueryResultsInput {
+    
+    const filterSensitiveLog: (obj: GetQueryResultsInput) => any;
+}
+export declare enum ColumnNullable {
+    NOT_NULL = "NOT_NULL",
+    NULLABLE = "NULLABLE",
+    UNKNOWN = "UNKNOWN"
+}
+
+export interface ColumnInfo {
+    
+    CatalogName?: string;
+    
+    SchemaName?: string;
+    
+    TableName?: string;
+    
+    Name: string | undefined;
+    
+    Label?: string;
+    
+    Type: string | undefined;
+    
+    Precision?: number;
+    
+    Scale?: number;
+    
+    Nullable?: ColumnNullable | string;
+    
+    CaseSensitive?: boolean;
+}
+export declare namespace ColumnInfo {
+    
+    const filterSensitiveLog: (obj: ColumnInfo) => any;
+}
+
+export interface ResultSetMetadata {
+    
+    ColumnInfo?: ColumnInfo[];
+}
+export declare namespace ResultSetMetadata {
+    
+    const filterSensitiveLog: (obj: ResultSetMetadata) => any;
+}
+
+export interface Datum {
+    
+    VarCharValue?: string;
+}
+export declare namespace Datum {
+    
+    const filterSensitiveLog: (obj: Datum) => any;
+}
+
+export interface Row {
+    
+    Data?: Datum[];
+}
+export declare namespace Row {
+    
+    const filterSensitiveLog: (obj: Row) => any;
+}
+
+export interface ResultSet {
+    
+    Rows?: Row[];
+    
+    ResultSetMetadata?: ResultSetMetadata;
+}
+export declare namespace ResultSet {
+    
+    const filterSensitiveLog: (obj: ResultSet) => any;
+}
+export interface GetQueryResultsOutput {
+    
+    UpdateCount?: number;
+    
+    ResultSet?: ResultSet;
+    
+    NextToken?: string;
+}
+export declare namespace GetQueryResultsOutput {
+    
+    const filterSensitiveLog: (obj: GetQueryResultsOutput) => any;
+}
+export interface GetTableMetadataInput {
+    
+    CatalogName: string | undefined;
+    
+    DatabaseName: string | undefined;
+    
+    TableName: string | undefined;
+}
+export declare namespace GetTableMetadataInput {
+    
+    const filterSensitiveLog: (obj: GetTableMetadataInput) => any;
+}
+
+export interface Column {
+    
+    Name: string | undefined;
+    
+    Type?: string;
+    
+    Comment?: string;
+}
+export declare namespace Column {
+    
+    const filterSensitiveLog: (obj: Column) => any;
+}
+
+export interface TableMetadata {
+    
+    Name: string | undefined;
+    
+    CreateTime?: Date;
+    
+    LastAccessTime?: Date;
+    
+    TableType?: string;
+    
+    Columns?: Column[];
+    
+    PartitionKeys?: Column[];
+    
+    Parameters?: {
+        [key: string]: string;
+    };
+}
+export declare namespace TableMetadata {
+    
+    const filterSensitiveLog: (obj: TableMetadata) => any;
+}
+export interface GetTableMetadataOutput {
+    
+    TableMetadata?: TableMetadata;
+}
+export declare namespace GetTableMetadataOutput {
+    
+    const filterSensitiveLog: (obj: GetTableMetadataOutput) => any;
+}
+export interface GetWorkGroupInput {
+    
+    WorkGroup: string | undefined;
+}
+export declare namespace GetWorkGroupInput {
+    
+    const filterSensitiveLog: (obj: GetWorkGroupInput) => any;
+}
+export declare enum WorkGroupState {
+    DISABLED = "DISABLED",
+    ENABLED = "ENABLED"
+}
+
+export interface WorkGroup {
+    
+    Name: string | undefined;
+    
+    State?: WorkGroupState | string;
+    
+    Configuration?: WorkGroupConfiguration;
+    
+    Description?: string;
+    
+    CreationTime?: Date;
+}
+export declare namespace WorkGroup {
+    
+    const filterSensitiveLog: (obj: WorkGroup) => any;
+}
+export interface GetWorkGroupOutput {
+    
+    WorkGroup?: WorkGroup;
+}
+export declare namespace GetWorkGroupOutput {
+    
+    const filterSensitiveLog: (obj: GetWorkGroupOutput) => any;
+}
+export interface ListDatabasesInput {
+    
+    CatalogName: string | undefined;
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+}
+export declare namespace ListDatabasesInput {
+    
+    const filterSensitiveLog: (obj: ListDatabasesInput) => any;
+}
+export interface ListDatabasesOutput {
+    
+    DatabaseList?: Database[];
+    
+    NextToken?: string;
+}
+export declare namespace ListDatabasesOutput {
+    
+    const filterSensitiveLog: (obj: ListDatabasesOutput) => any;
+}
+export interface ListDataCatalogsInput {
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+}
+export declare namespace ListDataCatalogsInput {
+    
+    const filterSensitiveLog: (obj: ListDataCatalogsInput) => any;
+}
+
+export interface DataCatalogSummary {
+    
+    CatalogName?: string;
+    
+    Type?: DataCatalogType | string;
+}
+export declare namespace DataCatalogSummary {
+    
+    const filterSensitiveLog: (obj: DataCatalogSummary) => any;
+}
+export interface ListDataCatalogsOutput {
+    
+    DataCatalogsSummary?: DataCatalogSummary[];
+    
+    NextToken?: string;
+}
+export declare namespace ListDataCatalogsOutput {
+    
+    const filterSensitiveLog: (obj: ListDataCatalogsOutput) => any;
+}
+export interface ListEngineVersionsInput {
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+}
+export declare namespace ListEngineVersionsInput {
+    
+    const filterSensitiveLog: (obj: ListEngineVersionsInput) => any;
+}
+export interface ListEngineVersionsOutput {
+    
+    EngineVersions?: EngineVersion[];
+    
+    NextToken?: string;
+}
+export declare namespace ListEngineVersionsOutput {
+    
+    const filterSensitiveLog: (obj: ListEngineVersionsOutput) => any;
+}
+export interface ListNamedQueriesInput {
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+    
+    WorkGroup?: string;
+}
+export declare namespace ListNamedQueriesInput {
+    
+    const filterSensitiveLog: (obj: ListNamedQueriesInput) => any;
+}
+export interface ListNamedQueriesOutput {
+    
+    NamedQueryIds?: string[];
+    
+    NextToken?: string;
+}
+export declare namespace ListNamedQueriesOutput {
+    
+    const filterSensitiveLog: (obj: ListNamedQueriesOutput) => any;
+}
+export interface ListPreparedStatementsInput {
+    
+    WorkGroup: string | undefined;
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+}
+export declare namespace ListPreparedStatementsInput {
+    
+    const filterSensitiveLog: (obj: ListPreparedStatementsInput) => any;
+}
+
+export interface PreparedStatementSummary {
+    
+    StatementName?: string;
+    
+    LastModifiedTime?: Date;
+}
+export declare namespace PreparedStatementSummary {
+    
+    const filterSensitiveLog: (obj: PreparedStatementSummary) => any;
+}
+export interface ListPreparedStatementsOutput {
+    
+    PreparedStatements?: PreparedStatementSummary[];
+    
+    NextToken?: string;
+}
+export declare namespace ListPreparedStatementsOutput {
+    
+    const filterSensitiveLog: (obj: ListPreparedStatementsOutput) => any;
+}
+export interface ListQueryExecutionsInput {
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+    
+    WorkGroup?: string;
+}
+export declare namespace ListQueryExecutionsInput {
+    
+    const filterSensitiveLog: (obj: ListQueryExecutionsInput) => any;
+}
+export interface ListQueryExecutionsOutput {
+    
+    QueryExecutionIds?: string[];
+    
+    NextToken?: string;
+}
+export declare namespace ListQueryExecutionsOutput {
+    
+    const filterSensitiveLog: (obj: ListQueryExecutionsOutput) => any;
+}
+export interface ListTableMetadataInput {
+    
+    CatalogName: string | undefined;
+    
+    DatabaseName: string | undefined;
+    
+    Expression?: string;
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+}
+export declare namespace ListTableMetadataInput {
+    
+    const filterSensitiveLog: (obj: ListTableMetadataInput) => any;
+}
+export interface ListTableMetadataOutput {
+    
+    TableMetadataList?: TableMetadata[];
+    
+    NextToken?: string;
+}
+export declare namespace ListTableMetadataOutput {
+    
+    const filterSensitiveLog: (obj: ListTableMetadataOutput) => any;
+}
+export interface ListTagsForResourceInput {
+    
+    ResourceARN: string | undefined;
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+}
+export declare namespace ListTagsForResourceInput {
+    
+    const filterSensitiveLog: (obj: ListTagsForResourceInput) => any;
+}
+export interface ListTagsForResourceOutput {
+    
+    Tags?: Tag[];
+    
+    NextToken?: string;
+}
+export declare namespace ListTagsForResourceOutput {
+    
+    const filterSensitiveLog: (obj: ListTagsForResourceOutput) => any;
+}
+export interface ListWorkGroupsInput {
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+}
+export declare namespace ListWorkGroupsInput {
+    
+    const filterSensitiveLog: (obj: ListWorkGroupsInput) => any;
+}
+
+export interface WorkGroupSummary {
+    
+    Name?: string;
+    
+    State?: WorkGroupState | string;
+    
+    Description?: string;
+    
+    CreationTime?: Date;
+    
+    EngineVersion?: EngineVersion;
+}
+export declare namespace WorkGroupSummary {
+    
+    const filterSensitiveLog: (obj: WorkGroupSummary) => any;
+}
+export interface ListWorkGroupsOutput {
+    
+    WorkGroups?: WorkGroupSummary[];
+    
+    NextToken?: string;
+}
+export declare namespace ListWorkGroupsOutput {
+    
+    const filterSensitiveLog: (obj: ListWorkGroupsOutput) => any;
+}
+export interface StartQueryExecutionInput {
+    
+    QueryString: string | undefined;
+    
+    ClientRequestToken?: string;
+    
+    QueryExecutionContext?: QueryExecutionContext;
+    
+    ResultConfiguration?: ResultConfiguration;
+    
+    WorkGroup?: string;
+}
+export declare namespace StartQueryExecutionInput {
+    
+    const filterSensitiveLog: (obj: StartQueryExecutionInput) => any;
+}
+export interface StartQueryExecutionOutput {
+    
+    QueryExecutionId?: string;
+}
+export declare namespace StartQueryExecutionOutput {
+    
+    const filterSensitiveLog: (obj: StartQueryExecutionOutput) => any;
+}
+export declare enum ThrottleReason {
+    CONCURRENT_QUERY_LIMIT_EXCEEDED = "CONCURRENT_QUERY_LIMIT_EXCEEDED"
+}
+
+export declare class TooManyRequestsException extends __BaseException {
+    readonly name: "TooManyRequestsException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    Reason?: ThrottleReason | string;
+    
+    constructor(opts: __ExceptionOptionType<TooManyRequestsException, __BaseException>);
+}
+export interface StopQueryExecutionInput {
+    
+    QueryExecutionId?: string;
+}
+export declare namespace StopQueryExecutionInput {
+    
+    const filterSensitiveLog: (obj: StopQueryExecutionInput) => any;
+}
+export interface StopQueryExecutionOutput {
+}
+export declare namespace StopQueryExecutionOutput {
+    
+    const filterSensitiveLog: (obj: StopQueryExecutionOutput) => any;
+}
+export interface TagResourceInput {
+    
+    ResourceARN: string | undefined;
+    
+    Tags: Tag[] | undefined;
+}
+export declare namespace TagResourceInput {
+    
+    const filterSensitiveLog: (obj: TagResourceInput) => any;
+}
+export interface TagResourceOutput {
+}
+export declare namespace TagResourceOutput {
+    
+    const filterSensitiveLog: (obj: TagResourceOutput) => any;
+}
+export interface UntagResourceInput {
+    
+    ResourceARN: string | undefined;
+    
+    TagKeys: string[] | undefined;
+}
+export declare namespace UntagResourceInput {
+    
+    const filterSensitiveLog: (obj: UntagResourceInput) => any;
+}
+export interface UntagResourceOutput {
+}
+export declare namespace UntagResourceOutput {
+    
+    const filterSensitiveLog: (obj: UntagResourceOutput) => any;
+}
+export interface UpdateDataCatalogInput {
+    
+    Name: string | undefined;
+    
+    Type: DataCatalogType | string | undefined;
+    
+    Description?: string;
+    
+    Parameters?: {
+        [key: string]: string;
+    };
+}
+export declare namespace UpdateDataCatalogInput {
+    
+    const filterSensitiveLog: (obj: UpdateDataCatalogInput) => any;
+}
+export interface UpdateDataCatalogOutput {
+}
+export declare namespace UpdateDataCatalogOutput {
+    
+    const filterSensitiveLog: (obj: UpdateDataCatalogOutput) => any;
+}
+export interface UpdatePreparedStatementInput {
+    
+    StatementName: string | undefined;
+    
+    WorkGroup: string | undefined;
+    
+    QueryStatement: string | undefined;
+    
+    Description?: string;
+}
+export declare namespace UpdatePreparedStatementInput {
+    
+    const filterSensitiveLog: (obj: UpdatePreparedStatementInput) => any;
+}
+export interface UpdatePreparedStatementOutput {
+}
+export declare namespace UpdatePreparedStatementOutput {
+    
+    const filterSensitiveLog: (obj: UpdatePreparedStatementOutput) => any;
+}
+
+export interface ResultConfigurationUpdates {
+    
+    OutputLocation?: string;
+    
+    RemoveOutputLocation?: boolean;
+    
+    EncryptionConfiguration?: EncryptionConfiguration;
+    
+    RemoveEncryptionConfiguration?: boolean;
+    
+    ExpectedBucketOwner?: string;
+    
+    RemoveExpectedBucketOwner?: boolean;
+}
+export declare namespace ResultConfigurationUpdates {
+    
+    const filterSensitiveLog: (obj: ResultConfigurationUpdates) => any;
+}
+
+export interface WorkGroupConfigurationUpdates {
+    
+    EnforceWorkGroupConfiguration?: boolean;
+    
+    ResultConfigurationUpdates?: ResultConfigurationUpdates;
+    
+    PublishCloudWatchMetricsEnabled?: boolean;
+    
+    BytesScannedCutoffPerQuery?: number;
+    
+    RemoveBytesScannedCutoffPerQuery?: boolean;
+    
+    RequesterPaysEnabled?: boolean;
+    
+    EngineVersion?: EngineVersion;
+}
+export declare namespace WorkGroupConfigurationUpdates {
+    
+    const filterSensitiveLog: (obj: WorkGroupConfigurationUpdates) => any;
+}
+export interface UpdateWorkGroupInput {
+    
+    WorkGroup: string | undefined;
+    
+    Description?: string;
+    
+    ConfigurationUpdates?: WorkGroupConfigurationUpdates;
+    
+    State?: WorkGroupState | string;
+}
+export declare namespace UpdateWorkGroupInput {
+    
+    const filterSensitiveLog: (obj: UpdateWorkGroupInput) => any;
+}
+export interface UpdateWorkGroupOutput {
+}
+export declare namespace UpdateWorkGroupOutput {
+    
+    const filterSensitiveLog: (obj: UpdateWorkGroupOutput) => any;
+}