@aws-sdk/client-redshift-data 3.50.0 → 3.53.0

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

@@ -0,0 +1,610 @@
+import { ExceptionOptionType as __ExceptionOptionType } from "@aws-sdk/smithy-client";
+import { RedshiftDataServiceException as __BaseException } from "./RedshiftDataServiceException";
+
+export declare class ActiveStatementsExceededException extends __BaseException {
+    readonly name: "ActiveStatementsExceededException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<ActiveStatementsExceededException, __BaseException>);
+}
+
+export declare class BatchExecuteStatementException extends __BaseException {
+    readonly name: "BatchExecuteStatementException";
+    readonly $fault: "server";
+    Message: string | undefined;
+    
+    StatementId: string | undefined;
+    
+    constructor(opts: __ExceptionOptionType<BatchExecuteStatementException, __BaseException>);
+}
+export interface BatchExecuteStatementInput {
+    
+    Sqls: string[] | undefined;
+    
+    ClusterIdentifier?: string;
+    
+    SecretArn?: string;
+    
+    DbUser?: string;
+    
+    Database: string | undefined;
+    
+    WithEvent?: boolean;
+    
+    StatementName?: string;
+}
+export declare namespace BatchExecuteStatementInput {
+    
+    const filterSensitiveLog: (obj: BatchExecuteStatementInput) => any;
+}
+export interface BatchExecuteStatementOutput {
+    
+    Id?: string;
+    
+    CreatedAt?: Date;
+    
+    ClusterIdentifier?: string;
+    
+    DbUser?: string;
+    
+    Database?: string;
+    
+    SecretArn?: string;
+}
+export declare namespace BatchExecuteStatementOutput {
+    
+    const filterSensitiveLog: (obj: BatchExecuteStatementOutput) => any;
+}
+
+export declare class ValidationException extends __BaseException {
+    readonly name: "ValidationException";
+    readonly $fault: "client";
+    
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<ValidationException, __BaseException>);
+}
+export interface CancelStatementRequest {
+    
+    Id: string | undefined;
+}
+export declare namespace CancelStatementRequest {
+    
+    const filterSensitiveLog: (obj: CancelStatementRequest) => any;
+}
+export interface CancelStatementResponse {
+    
+    Status?: boolean;
+}
+export declare namespace CancelStatementResponse {
+    
+    const filterSensitiveLog: (obj: CancelStatementResponse) => any;
+}
+
+export declare class DatabaseConnectionException extends __BaseException {
+    readonly name: "DatabaseConnectionException";
+    readonly $fault: "server";
+    Message: string | undefined;
+    
+    constructor(opts: __ExceptionOptionType<DatabaseConnectionException, __BaseException>);
+}
+
+export declare class InternalServerException extends __BaseException {
+    readonly name: "InternalServerException";
+    readonly $fault: "server";
+    
+    Message: string | undefined;
+    
+    constructor(opts: __ExceptionOptionType<InternalServerException, __BaseException>);
+}
+
+export declare class ResourceNotFoundException extends __BaseException {
+    readonly name: "ResourceNotFoundException";
+    readonly $fault: "client";
+    
+    Message: string | undefined;
+    
+    ResourceId: string | undefined;
+    
+    constructor(opts: __ExceptionOptionType<ResourceNotFoundException, __BaseException>);
+}
+
+export interface ColumnMetadata {
+    
+    isCaseSensitive?: boolean;
+    
+    isCurrency?: boolean;
+    
+    isSigned?: boolean;
+    
+    label?: string;
+    
+    name?: string;
+    
+    nullable?: number;
+    
+    precision?: number;
+    
+    scale?: number;
+    
+    schemaName?: string;
+    
+    tableName?: string;
+    
+    typeName?: string;
+    
+    length?: number;
+    
+    columnDefault?: string;
+}
+export declare namespace ColumnMetadata {
+    
+    const filterSensitiveLog: (obj: ColumnMetadata) => any;
+}
+export interface DescribeStatementRequest {
+    
+    Id: string | undefined;
+}
+export declare namespace DescribeStatementRequest {
+    
+    const filterSensitiveLog: (obj: DescribeStatementRequest) => any;
+}
+
+export interface SqlParameter {
+    
+    name: string | undefined;
+    
+    value: string | undefined;
+}
+export declare namespace SqlParameter {
+    
+    const filterSensitiveLog: (obj: SqlParameter) => any;
+}
+export declare enum StatusString {
+    ABORTED = "ABORTED",
+    ALL = "ALL",
+    FAILED = "FAILED",
+    FINISHED = "FINISHED",
+    PICKED = "PICKED",
+    STARTED = "STARTED",
+    SUBMITTED = "SUBMITTED"
+}
+export declare enum StatementStatusString {
+    ABORTED = "ABORTED",
+    FAILED = "FAILED",
+    FINISHED = "FINISHED",
+    PICKED = "PICKED",
+    STARTED = "STARTED",
+    SUBMITTED = "SUBMITTED"
+}
+
+export interface SubStatementData {
+    
+    Id: string | undefined;
+    
+    Duration?: number;
+    
+    Error?: string;
+    
+    Status?: StatementStatusString | string;
+    
+    CreatedAt?: Date;
+    
+    UpdatedAt?: Date;
+    
+    QueryString?: string;
+    
+    ResultRows?: number;
+    
+    ResultSize?: number;
+    
+    RedshiftQueryId?: number;
+    
+    HasResultSet?: boolean;
+}
+export declare namespace SubStatementData {
+    
+    const filterSensitiveLog: (obj: SubStatementData) => any;
+}
+export interface DescribeStatementResponse {
+    
+    Id: string | undefined;
+    
+    SecretArn?: string;
+    
+    DbUser?: string;
+    
+    Database?: string;
+    
+    ClusterIdentifier?: string;
+    
+    Duration?: number;
+    
+    Error?: string;
+    
+    Status?: StatusString | string;
+    
+    CreatedAt?: Date;
+    
+    UpdatedAt?: Date;
+    
+    RedshiftPid?: number;
+    
+    HasResultSet?: boolean;
+    
+    QueryString?: string;
+    
+    ResultRows?: number;
+    
+    ResultSize?: number;
+    
+    RedshiftQueryId?: number;
+    
+    QueryParameters?: SqlParameter[];
+    
+    SubStatements?: SubStatementData[];
+}
+export declare namespace DescribeStatementResponse {
+    
+    const filterSensitiveLog: (obj: DescribeStatementResponse) => any;
+}
+export interface DescribeTableRequest {
+    
+    ClusterIdentifier?: string;
+    
+    SecretArn?: string;
+    
+    DbUser?: string;
+    
+    Database: string | undefined;
+    
+    ConnectedDatabase?: string;
+    
+    Schema?: string;
+    
+    Table?: string;
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+}
+export declare namespace DescribeTableRequest {
+    
+    const filterSensitiveLog: (obj: DescribeTableRequest) => any;
+}
+export interface DescribeTableResponse {
+    
+    TableName?: string;
+    
+    ColumnList?: ColumnMetadata[];
+    
+    NextToken?: string;
+}
+export declare namespace DescribeTableResponse {
+    
+    const filterSensitiveLog: (obj: DescribeTableResponse) => any;
+}
+
+export declare class ExecuteStatementException extends __BaseException {
+    readonly name: "ExecuteStatementException";
+    readonly $fault: "server";
+    
+    Message: string | undefined;
+    
+    StatementId: string | undefined;
+    
+    constructor(opts: __ExceptionOptionType<ExecuteStatementException, __BaseException>);
+}
+export interface ExecuteStatementInput {
+    
+    Sql: string | undefined;
+    
+    ClusterIdentifier?: string;
+    
+    SecretArn?: string;
+    
+    DbUser?: string;
+    
+    Database: string | undefined;
+    
+    WithEvent?: boolean;
+    
+    StatementName?: string;
+    
+    Parameters?: SqlParameter[];
+}
+export declare namespace ExecuteStatementInput {
+    
+    const filterSensitiveLog: (obj: ExecuteStatementInput) => any;
+}
+export interface ExecuteStatementOutput {
+    
+    Id?: string;
+    
+    CreatedAt?: Date;
+    
+    ClusterIdentifier?: string;
+    
+    DbUser?: string;
+    
+    Database?: string;
+    
+    SecretArn?: string;
+}
+export declare namespace ExecuteStatementOutput {
+    
+    const filterSensitiveLog: (obj: ExecuteStatementOutput) => any;
+}
+
+export declare type Field = Field.BlobValueMember | Field.BooleanValueMember | Field.DoubleValueMember | Field.IsNullMember | Field.LongValueMember | Field.StringValueMember | Field.$UnknownMember;
+export declare namespace Field {
+    
+    interface IsNullMember {
+        isNull: boolean;
+        booleanValue?: never;
+        longValue?: never;
+        doubleValue?: never;
+        stringValue?: never;
+        blobValue?: never;
+        $unknown?: never;
+    }
+    
+    interface BooleanValueMember {
+        isNull?: never;
+        booleanValue: boolean;
+        longValue?: never;
+        doubleValue?: never;
+        stringValue?: never;
+        blobValue?: never;
+        $unknown?: never;
+    }
+    
+    interface LongValueMember {
+        isNull?: never;
+        booleanValue?: never;
+        longValue: number;
+        doubleValue?: never;
+        stringValue?: never;
+        blobValue?: never;
+        $unknown?: never;
+    }
+    
+    interface DoubleValueMember {
+        isNull?: never;
+        booleanValue?: never;
+        longValue?: never;
+        doubleValue: number;
+        stringValue?: never;
+        blobValue?: never;
+        $unknown?: never;
+    }
+    
+    interface StringValueMember {
+        isNull?: never;
+        booleanValue?: never;
+        longValue?: never;
+        doubleValue?: never;
+        stringValue: string;
+        blobValue?: never;
+        $unknown?: never;
+    }
+    
+    interface BlobValueMember {
+        isNull?: never;
+        booleanValue?: never;
+        longValue?: never;
+        doubleValue?: never;
+        stringValue?: never;
+        blobValue: Uint8Array;
+        $unknown?: never;
+    }
+    interface $UnknownMember {
+        isNull?: never;
+        booleanValue?: never;
+        longValue?: never;
+        doubleValue?: never;
+        stringValue?: never;
+        blobValue?: never;
+        $unknown: [
+            string,
+            any
+        ];
+    }
+    interface Visitor<T> {
+        isNull: (value: boolean) => T;
+        booleanValue: (value: boolean) => T;
+        longValue: (value: number) => T;
+        doubleValue: (value: number) => T;
+        stringValue: (value: string) => T;
+        blobValue: (value: Uint8Array) => T;
+        _: (name: string, value: any) => T;
+    }
+    const visit: <T>(value: Field, visitor: Visitor<T>) => T;
+    
+    const filterSensitiveLog: (obj: Field) => any;
+}
+export interface GetStatementResultRequest {
+    
+    Id: string | undefined;
+    
+    NextToken?: string;
+}
+export declare namespace GetStatementResultRequest {
+    
+    const filterSensitiveLog: (obj: GetStatementResultRequest) => any;
+}
+export interface GetStatementResultResponse {
+    
+    Records: Field[][] | undefined;
+    
+    ColumnMetadata?: ColumnMetadata[];
+    
+    TotalNumRows?: number;
+    
+    NextToken?: string;
+}
+export declare namespace GetStatementResultResponse {
+    
+    const filterSensitiveLog: (obj: GetStatementResultResponse) => any;
+}
+export interface ListDatabasesRequest {
+    
+    ClusterIdentifier?: string;
+    
+    Database: string | undefined;
+    
+    SecretArn?: string;
+    
+    DbUser?: string;
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+}
+export declare namespace ListDatabasesRequest {
+    
+    const filterSensitiveLog: (obj: ListDatabasesRequest) => any;
+}
+export interface ListDatabasesResponse {
+    
+    Databases?: string[];
+    
+    NextToken?: string;
+}
+export declare namespace ListDatabasesResponse {
+    
+    const filterSensitiveLog: (obj: ListDatabasesResponse) => any;
+}
+export interface ListSchemasRequest {
+    
+    ClusterIdentifier?: string;
+    
+    SecretArn?: string;
+    
+    DbUser?: string;
+    
+    Database: string | undefined;
+    
+    ConnectedDatabase?: string;
+    
+    SchemaPattern?: string;
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+}
+export declare namespace ListSchemasRequest {
+    
+    const filterSensitiveLog: (obj: ListSchemasRequest) => any;
+}
+export interface ListSchemasResponse {
+    
+    Schemas?: string[];
+    
+    NextToken?: string;
+}
+export declare namespace ListSchemasResponse {
+    
+    const filterSensitiveLog: (obj: ListSchemasResponse) => any;
+}
+export interface ListStatementsRequest {
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+    
+    StatementName?: string;
+    
+    Status?: StatusString | string;
+    
+    RoleLevel?: boolean;
+}
+export declare namespace ListStatementsRequest {
+    
+    const filterSensitiveLog: (obj: ListStatementsRequest) => any;
+}
+
+export interface StatementData {
+    
+    Id: string | undefined;
+    
+    QueryString?: string;
+    
+    QueryStrings?: string[];
+    
+    SecretArn?: string;
+    
+    Status?: StatusString | string;
+    
+    StatementName?: string;
+    
+    CreatedAt?: Date;
+    
+    UpdatedAt?: Date;
+    
+    QueryParameters?: SqlParameter[];
+    
+    IsBatchStatement?: boolean;
+}
+export declare namespace StatementData {
+    
+    const filterSensitiveLog: (obj: StatementData) => any;
+}
+export interface ListStatementsResponse {
+    
+    Statements: StatementData[] | undefined;
+    
+    NextToken?: string;
+}
+export declare namespace ListStatementsResponse {
+    
+    const filterSensitiveLog: (obj: ListStatementsResponse) => any;
+}
+export interface ListTablesRequest {
+    
+    ClusterIdentifier?: string;
+    
+    SecretArn?: string;
+    
+    DbUser?: string;
+    
+    Database: string | undefined;
+    
+    ConnectedDatabase?: string;
+    
+    SchemaPattern?: string;
+    
+    TablePattern?: string;
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+}
+export declare namespace ListTablesRequest {
+    
+    const filterSensitiveLog: (obj: ListTablesRequest) => any;
+}
+
+export interface TableMember {
+    
+    name?: string;
+    
+    type?: string;
+    
+    schema?: string;
+}
+export declare namespace TableMember {
+    
+    const filterSensitiveLog: (obj: TableMember) => any;
+}
+export interface ListTablesResponse {
+    
+    Tables?: TableMember[];
+    
+    NextToken?: string;
+}
+export declare namespace ListTablesResponse {
+    
+    const filterSensitiveLog: (obj: ListTablesResponse) => any;
+}

package/dist-types/ts3.4/pagination/DescribeTablePaginator.d.ts

@@ -0,0 +1,4 @@
+import { Paginator } from "@aws-sdk/types";
+import { DescribeTableCommandInput, DescribeTableCommandOutput } from "../commands/DescribeTableCommand";
+import { RedshiftDataPaginationConfiguration } from "./Interfaces";
+export declare function paginateDescribeTable(config: RedshiftDataPaginationConfiguration, input: DescribeTableCommandInput, ...additionalArguments: any): Paginator<DescribeTableCommandOutput>;

package/dist-types/ts3.4/pagination/GetStatementResultPaginator.d.ts

@@ -0,0 +1,4 @@
+import { Paginator } from "@aws-sdk/types";
+import { GetStatementResultCommandInput, GetStatementResultCommandOutput } from "../commands/GetStatementResultCommand";
+import { RedshiftDataPaginationConfiguration } from "./Interfaces";
+export declare function paginateGetStatementResult(config: RedshiftDataPaginationConfiguration, input: GetStatementResultCommandInput, ...additionalArguments: any): Paginator<GetStatementResultCommandOutput>;

package/dist-types/ts3.4/pagination/Interfaces.d.ts

@@ -0,0 +1,6 @@
+import { PaginationConfiguration } from "@aws-sdk/types";
+import { RedshiftData } from "../RedshiftData";
+import { RedshiftDataClient } from "../RedshiftDataClient";
+export interface RedshiftDataPaginationConfiguration extends PaginationConfiguration {
+    client: RedshiftData | RedshiftDataClient;
+}

package/dist-types/ts3.4/pagination/ListDatabasesPaginator.d.ts

@@ -0,0 +1,4 @@
+import { Paginator } from "@aws-sdk/types";
+import { ListDatabasesCommandInput, ListDatabasesCommandOutput } from "../commands/ListDatabasesCommand";
+import { RedshiftDataPaginationConfiguration } from "./Interfaces";
+export declare function paginateListDatabases(config: RedshiftDataPaginationConfiguration, input: ListDatabasesCommandInput, ...additionalArguments: any): Paginator<ListDatabasesCommandOutput>;

package/dist-types/ts3.4/pagination/ListSchemasPaginator.d.ts

@@ -0,0 +1,4 @@
+import { Paginator } from "@aws-sdk/types";
+import { ListSchemasCommandInput, ListSchemasCommandOutput } from "../commands/ListSchemasCommand";
+import { RedshiftDataPaginationConfiguration } from "./Interfaces";
+export declare function paginateListSchemas(config: RedshiftDataPaginationConfiguration, input: ListSchemasCommandInput, ...additionalArguments: any): Paginator<ListSchemasCommandOutput>;

package/dist-types/ts3.4/pagination/ListStatementsPaginator.d.ts

@@ -0,0 +1,4 @@
+import { Paginator } from "@aws-sdk/types";
+import { ListStatementsCommandInput, ListStatementsCommandOutput } from "../commands/ListStatementsCommand";
+import { RedshiftDataPaginationConfiguration } from "./Interfaces";
+export declare function paginateListStatements(config: RedshiftDataPaginationConfiguration, input: ListStatementsCommandInput, ...additionalArguments: any): Paginator<ListStatementsCommandOutput>;

package/dist-types/ts3.4/pagination/ListTablesPaginator.d.ts

@@ -0,0 +1,4 @@
+import { Paginator } from "@aws-sdk/types";
+import { ListTablesCommandInput, ListTablesCommandOutput } from "../commands/ListTablesCommand";
+import { RedshiftDataPaginationConfiguration } from "./Interfaces";
+export declare function paginateListTables(config: RedshiftDataPaginationConfiguration, input: ListTablesCommandInput, ...additionalArguments: any): Paginator<ListTablesCommandOutput>;

package/dist-types/ts3.4/pagination/index.d.ts

@@ -0,0 +1,7 @@
+export * from "./DescribeTablePaginator";
+export * from "./GetStatementResultPaginator";
+export * from "./Interfaces";
+export * from "./ListDatabasesPaginator";
+export * from "./ListSchemasPaginator";
+export * from "./ListStatementsPaginator";
+export * from "./ListTablesPaginator";

package/dist-types/ts3.4/protocols/Aws_json1_1.d.ts

@@ -0,0 +1,32 @@
+import { HttpRequest as __HttpRequest, HttpResponse as __HttpResponse } from "@aws-sdk/protocol-http";
+import { SerdeContext as __SerdeContext } from "@aws-sdk/types";
+import { BatchExecuteStatementCommandInput, BatchExecuteStatementCommandOutput } from "../commands/BatchExecuteStatementCommand";
+import { CancelStatementCommandInput, CancelStatementCommandOutput } from "../commands/CancelStatementCommand";
+import { DescribeStatementCommandInput, DescribeStatementCommandOutput } from "../commands/DescribeStatementCommand";
+import { DescribeTableCommandInput, DescribeTableCommandOutput } from "../commands/DescribeTableCommand";
+import { ExecuteStatementCommandInput, ExecuteStatementCommandOutput } from "../commands/ExecuteStatementCommand";
+import { GetStatementResultCommandInput, GetStatementResultCommandOutput } from "../commands/GetStatementResultCommand";
+import { ListDatabasesCommandInput, ListDatabasesCommandOutput } from "../commands/ListDatabasesCommand";
+import { ListSchemasCommandInput, ListSchemasCommandOutput } from "../commands/ListSchemasCommand";
+import { ListStatementsCommandInput, ListStatementsCommandOutput } from "../commands/ListStatementsCommand";
+import { ListTablesCommandInput, ListTablesCommandOutput } from "../commands/ListTablesCommand";
+export declare const serializeAws_json1_1BatchExecuteStatementCommand: (input: BatchExecuteStatementCommandInput, context: __SerdeContext) => Promise<__HttpRequest>;
+export declare const serializeAws_json1_1CancelStatementCommand: (input: CancelStatementCommandInput, context: __SerdeContext) => Promise<__HttpRequest>;
+export declare const serializeAws_json1_1DescribeStatementCommand: (input: DescribeStatementCommandInput, context: __SerdeContext) => Promise<__HttpRequest>;
+export declare const serializeAws_json1_1DescribeTableCommand: (input: DescribeTableCommandInput, context: __SerdeContext) => Promise<__HttpRequest>;
+export declare const serializeAws_json1_1ExecuteStatementCommand: (input: ExecuteStatementCommandInput, context: __SerdeContext) => Promise<__HttpRequest>;
+export declare const serializeAws_json1_1GetStatementResultCommand: (input: GetStatementResultCommandInput, context: __SerdeContext) => Promise<__HttpRequest>;
+export declare const serializeAws_json1_1ListDatabasesCommand: (input: ListDatabasesCommandInput, context: __SerdeContext) => Promise<__HttpRequest>;
+export declare const serializeAws_json1_1ListSchemasCommand: (input: ListSchemasCommandInput, context: __SerdeContext) => Promise<__HttpRequest>;
+export declare const serializeAws_json1_1ListStatementsCommand: (input: ListStatementsCommandInput, context: __SerdeContext) => Promise<__HttpRequest>;
+export declare const serializeAws_json1_1ListTablesCommand: (input: ListTablesCommandInput, context: __SerdeContext) => Promise<__HttpRequest>;
+export declare const deserializeAws_json1_1BatchExecuteStatementCommand: (output: __HttpResponse, context: __SerdeContext) => Promise<BatchExecuteStatementCommandOutput>;
+export declare const deserializeAws_json1_1CancelStatementCommand: (output: __HttpResponse, context: __SerdeContext) => Promise<CancelStatementCommandOutput>;
+export declare const deserializeAws_json1_1DescribeStatementCommand: (output: __HttpResponse, context: __SerdeContext) => Promise<DescribeStatementCommandOutput>;
+export declare const deserializeAws_json1_1DescribeTableCommand: (output: __HttpResponse, context: __SerdeContext) => Promise<DescribeTableCommandOutput>;
+export declare const deserializeAws_json1_1ExecuteStatementCommand: (output: __HttpResponse, context: __SerdeContext) => Promise<ExecuteStatementCommandOutput>;
+export declare const deserializeAws_json1_1GetStatementResultCommand: (output: __HttpResponse, context: __SerdeContext) => Promise<GetStatementResultCommandOutput>;
+export declare const deserializeAws_json1_1ListDatabasesCommand: (output: __HttpResponse, context: __SerdeContext) => Promise<ListDatabasesCommandOutput>;
+export declare const deserializeAws_json1_1ListSchemasCommand: (output: __HttpResponse, context: __SerdeContext) => Promise<ListSchemasCommandOutput>;
+export declare const deserializeAws_json1_1ListStatementsCommand: (output: __HttpResponse, context: __SerdeContext) => Promise<ListStatementsCommandOutput>;
+export declare const deserializeAws_json1_1ListTablesCommand: (output: __HttpResponse, context: __SerdeContext) => Promise<ListTablesCommandOutput>;