@aws-sdk/client-redshift-data 3.33.0 → 3.36.1

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

@@ -0,0 +1,613 @@
+import { MetadataBearer as $MetadataBearer, SmithyException as __SmithyException } from "@aws-sdk/types";
+
+export interface ActiveStatementsExceededException extends __SmithyException, $MetadataBearer {
+    name: "ActiveStatementsExceededException";
+    $fault: "client";
+    Message?: string;
+}
+export declare namespace ActiveStatementsExceededException {
+    
+    const filterSensitiveLog: (obj: ActiveStatementsExceededException) => any;
+}
+
+export interface BatchExecuteStatementException extends __SmithyException, $MetadataBearer {
+    name: "BatchExecuteStatementException";
+    $fault: "server";
+    Message: string | undefined;
+    
+    StatementId: string | undefined;
+}
+export declare namespace BatchExecuteStatementException {
+    
+    const filterSensitiveLog: (obj: BatchExecuteStatementException) => any;
+}
+export interface BatchExecuteStatementInput {
+    
+    Sqls: string[] | undefined;
+    
+    ClusterIdentifier: string | undefined;
+    
+    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 interface ValidationException extends __SmithyException, $MetadataBearer {
+    name: "ValidationException";
+    $fault: "client";
+    
+    Message?: string;
+}
+export declare namespace ValidationException {
+    
+    const filterSensitiveLog: (obj: ValidationException) => any;
+}
+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 interface InternalServerException extends __SmithyException, $MetadataBearer {
+    name: "InternalServerException";
+    $fault: "server";
+    
+    Message: string | undefined;
+}
+export declare namespace InternalServerException {
+    
+    const filterSensitiveLog: (obj: InternalServerException) => any;
+}
+
+export interface ResourceNotFoundException extends __SmithyException, $MetadataBearer {
+    name: "ResourceNotFoundException";
+    $fault: "client";
+    
+    Message: string | undefined;
+    
+    ResourceId: string | undefined;
+}
+export declare namespace ResourceNotFoundException {
+    
+    const filterSensitiveLog: (obj: ResourceNotFoundException) => any;
+}
+
+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 | undefined;
+    
+    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 interface ExecuteStatementException extends __SmithyException, $MetadataBearer {
+    name: "ExecuteStatementException";
+    $fault: "server";
+    
+    Message: string | undefined;
+    
+    StatementId: string | undefined;
+}
+export declare namespace ExecuteStatementException {
+    
+    const filterSensitiveLog: (obj: ExecuteStatementException) => any;
+}
+export interface ExecuteStatementInput {
+    
+    Sql: string | undefined;
+    
+    ClusterIdentifier: string | undefined;
+    
+    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 | undefined;
+    
+    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 | undefined;
+    
+    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 | undefined;
+    
+    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 → dist-types}/ts3.4/pagination/DescribeTablePaginator.d.ts

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -1,3 +1,5 @@
+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";
@@ -8,8 +10,6 @@ import { ListDatabasesCommandInput, ListDatabasesCommandOutput } from "../comman
 import { ListSchemasCommandInput, ListSchemasCommandOutput } from "../commands/ListSchemasCommand";
 import { ListStatementsCommandInput, ListStatementsCommandOutput } from "../commands/ListStatementsCommand";
 import { ListTablesCommandInput, ListTablesCommandOutput } from "../commands/ListTablesCommand";
-import { HttpRequest as __HttpRequest, HttpResponse as __HttpResponse } from "@aws-sdk/protocol-http";
-import { SerdeContext as __SerdeContext } from "@aws-sdk/types";
 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>;

package/{dist/types → dist-types}/ts3.4/runtimeConfig.browser.d.ts

@@ -1,8 +1,6 @@
 import { FetchHttpHandler } from "@aws-sdk/fetch-http-handler";
 import { RedshiftDataClientConfig } from "./RedshiftDataClient";
-/**
- * @internal
- */
+
 export declare const getRuntimeConfig: (config: RedshiftDataClientConfig) => {
     runtime: string;
     base64Decoder: import("@aws-sdk/types").Decoder;

package/{dist/types → dist-types}/ts3.4/runtimeConfig.d.ts

@@ -1,14 +1,12 @@
 import { NodeHttpHandler } from "@aws-sdk/node-http-handler";
 import { RedshiftDataClientConfig } from "./RedshiftDataClient";
-/**
- * @internal
- */
+
 export declare const getRuntimeConfig: (config: RedshiftDataClientConfig) => {
     runtime: string;
     base64Decoder: import("@aws-sdk/types").Decoder;
     base64Encoder: import("@aws-sdk/types").Encoder;
     bodyLengthChecker: (body: any) => number | undefined;
-    credentialDefaultProvider: import("@aws-sdk/client-sts/dist/types/defaultStsRoleAssumers").DefaultCredentialProvider;
+    credentialDefaultProvider: import("@aws-sdk/client-sts/dist-types/defaultStsRoleAssumers").DefaultCredentialProvider;
     defaultUserAgentProvider: import("@aws-sdk/types").Provider<import("@aws-sdk/types").UserAgent>;
     maxAttempts: number | import("@aws-sdk/types").Provider<number>;
     region: string | import("@aws-sdk/types").Provider<string>;