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

package/dist-types/index.d.ts

@@ -3,3 +3,4 @@ export * from "./RedshiftDataClient";
 export * from "./commands";
 export * from "./models";
 export * from "./pagination";
+export { RedshiftDataServiceException } from "./models/RedshiftDataServiceException";

package/dist-types/models/RedshiftDataServiceException.d.ts

@@ -0,0 +1,10 @@
+import { ServiceException as __ServiceException, ServiceExceptionOptions as __ServiceExceptionOptions } from "@aws-sdk/smithy-client";
+/**
+ * Base exception class for all service exceptions from RedshiftData service.
+ */
+export declare class RedshiftDataServiceException extends __ServiceException {
+    /**
+     * @internal
+     */
+    constructor(options: __ServiceExceptionOptions);
+}

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

@@ -1,23 +1,32 @@
-import { MetadataBearer as $MetadataBearer, SmithyException as __SmithyException } from "@aws-sdk/types";
+import { ExceptionOptionType as __ExceptionOptionType } from "@aws-sdk/smithy-client";
+import { RedshiftDataServiceException as __BaseException } from "./RedshiftDataServiceException";
 /**
  * <p>The number of active statements exceeds the limit.</p>
  */
-export interface ActiveStatementsExceededException extends __SmithyException, $MetadataBearer {
-    name: "ActiveStatementsExceededException";
-    $fault: "client";
+export declare class ActiveStatementsExceededException extends __BaseException {
+    readonly name: "ActiveStatementsExceededException";
+    readonly $fault: "client";
     Message?: string;
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<ActiveStatementsExceededException, __BaseException>);
 }
 /**
  * <p>An SQL statement encountered an environmental error while running.</p>
  */
-export interface BatchExecuteStatementException extends __SmithyException, $MetadataBearer {
-    name: "BatchExecuteStatementException";
-    $fault: "server";
+export declare class BatchExecuteStatementException extends __BaseException {
+    readonly name: "BatchExecuteStatementException";
+    readonly $fault: "server";
     Message: string | undefined;
     /**
      * <p>Statement identifier of the exception.</p>
      */
     StatementId: string | undefined;
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<BatchExecuteStatementException, __BaseException>);
 }
 export interface BatchExecuteStatementInput {
     /**
@@ -91,13 +100,17 @@ export declare namespace BatchExecuteStatementOutput {
 /**
  * <p>The Amazon Redshift Data API operation failed due to invalid input. </p>
  */
-export interface ValidationException extends __SmithyException, $MetadataBearer {
-    name: "ValidationException";
-    $fault: "client";
+export declare class ValidationException extends __BaseException {
+    readonly name: "ValidationException";
+    readonly $fault: "client";
     /**
      * <p>The exception message.</p>
      */
     Message?: string;
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<ValidationException, __BaseException>);
 }
 export interface CancelStatementRequest {
     /**
@@ -127,28 +140,36 @@ export declare namespace CancelStatementResponse {
 /**
  * <p>Connection to a database failed.</p>
  */
-export interface DatabaseConnectionException extends __SmithyException, $MetadataBearer {
-    name: "DatabaseConnectionException";
-    $fault: "server";
+export declare class DatabaseConnectionException extends __BaseException {
+    readonly name: "DatabaseConnectionException";
+    readonly $fault: "server";
     Message: string | undefined;
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<DatabaseConnectionException, __BaseException>);
 }
 /**
  * <p>The Amazon Redshift Data API operation failed due to invalid input. </p>
  */
-export interface InternalServerException extends __SmithyException, $MetadataBearer {
-    name: "InternalServerException";
-    $fault: "server";
+export declare class InternalServerException extends __BaseException {
+    readonly name: "InternalServerException";
+    readonly $fault: "server";
     /**
      * <p>The exception message.</p>
      */
     Message: string | undefined;
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<InternalServerException, __BaseException>);
 }
 /**
  * <p>The Amazon Redshift Data API operation failed due to a missing resource. </p>
  */
-export interface ResourceNotFoundException extends __SmithyException, $MetadataBearer {
-    name: "ResourceNotFoundException";
-    $fault: "client";
+export declare class ResourceNotFoundException extends __BaseException {
+    readonly name: "ResourceNotFoundException";
+    readonly $fault: "client";
     /**
      * <p>The exception message.</p>
      */
@@ -157,6 +178,10 @@ export interface ResourceNotFoundException extends __SmithyException, $MetadataB
      * <p>Resource identifier associated with the exception.</p>
      */
     ResourceId: string | undefined;
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<ResourceNotFoundException, __BaseException>);
 }
 /**
  * <p>The properties (metadata) of a column. </p>
@@ -514,9 +539,9 @@ export declare namespace DescribeTableResponse {
 /**
  * <p>The SQL statement encountered an environmental error while running.</p>
  */
-export interface ExecuteStatementException extends __SmithyException, $MetadataBearer {
-    name: "ExecuteStatementException";
-    $fault: "server";
+export declare class ExecuteStatementException extends __BaseException {
+    readonly name: "ExecuteStatementException";
+    readonly $fault: "server";
     /**
      * <p>The exception message.</p>
      */
@@ -525,6 +550,10 @@ export interface ExecuteStatementException extends __SmithyException, $MetadataB
      * <p>Statement identifier of the exception.</p>
      */
     StatementId: string | undefined;
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<ExecuteStatementException, __BaseException>);
 }
 export interface ExecuteStatementInput {
     /**

package/dist-types/ts3.4/RedshiftData.d.ts

@@ -0,0 +1,55 @@
+import { HttpHandlerOptions as __HttpHandlerOptions } 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";
+import { RedshiftDataClient } from "./RedshiftDataClient";
+
+export declare class RedshiftData extends RedshiftDataClient {
+    
+    batchExecuteStatement(args: BatchExecuteStatementCommandInput, options?: __HttpHandlerOptions): Promise<BatchExecuteStatementCommandOutput>;
+    batchExecuteStatement(args: BatchExecuteStatementCommandInput, cb: (err: any, data?: BatchExecuteStatementCommandOutput) => void): void;
+    batchExecuteStatement(args: BatchExecuteStatementCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: BatchExecuteStatementCommandOutput) => void): void;
+    
+    cancelStatement(args: CancelStatementCommandInput, options?: __HttpHandlerOptions): Promise<CancelStatementCommandOutput>;
+    cancelStatement(args: CancelStatementCommandInput, cb: (err: any, data?: CancelStatementCommandOutput) => void): void;
+    cancelStatement(args: CancelStatementCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: CancelStatementCommandOutput) => void): void;
+    
+    describeStatement(args: DescribeStatementCommandInput, options?: __HttpHandlerOptions): Promise<DescribeStatementCommandOutput>;
+    describeStatement(args: DescribeStatementCommandInput, cb: (err: any, data?: DescribeStatementCommandOutput) => void): void;
+    describeStatement(args: DescribeStatementCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DescribeStatementCommandOutput) => void): void;
+    
+    describeTable(args: DescribeTableCommandInput, options?: __HttpHandlerOptions): Promise<DescribeTableCommandOutput>;
+    describeTable(args: DescribeTableCommandInput, cb: (err: any, data?: DescribeTableCommandOutput) => void): void;
+    describeTable(args: DescribeTableCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DescribeTableCommandOutput) => void): void;
+    
+    executeStatement(args: ExecuteStatementCommandInput, options?: __HttpHandlerOptions): Promise<ExecuteStatementCommandOutput>;
+    executeStatement(args: ExecuteStatementCommandInput, cb: (err: any, data?: ExecuteStatementCommandOutput) => void): void;
+    executeStatement(args: ExecuteStatementCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: ExecuteStatementCommandOutput) => void): void;
+    
+    getStatementResult(args: GetStatementResultCommandInput, options?: __HttpHandlerOptions): Promise<GetStatementResultCommandOutput>;
+    getStatementResult(args: GetStatementResultCommandInput, cb: (err: any, data?: GetStatementResultCommandOutput) => void): void;
+    getStatementResult(args: GetStatementResultCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: GetStatementResultCommandOutput) => void): void;
+    
+    listDatabases(args: ListDatabasesCommandInput, options?: __HttpHandlerOptions): Promise<ListDatabasesCommandOutput>;
+    listDatabases(args: ListDatabasesCommandInput, cb: (err: any, data?: ListDatabasesCommandOutput) => void): void;
+    listDatabases(args: ListDatabasesCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: ListDatabasesCommandOutput) => void): void;
+    
+    listSchemas(args: ListSchemasCommandInput, options?: __HttpHandlerOptions): Promise<ListSchemasCommandOutput>;
+    listSchemas(args: ListSchemasCommandInput, cb: (err: any, data?: ListSchemasCommandOutput) => void): void;
+    listSchemas(args: ListSchemasCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: ListSchemasCommandOutput) => void): void;
+    
+    listStatements(args: ListStatementsCommandInput, options?: __HttpHandlerOptions): Promise<ListStatementsCommandOutput>;
+    listStatements(args: ListStatementsCommandInput, cb: (err: any, data?: ListStatementsCommandOutput) => void): void;
+    listStatements(args: ListStatementsCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: ListStatementsCommandOutput) => void): void;
+    
+    listTables(args: ListTablesCommandInput, options?: __HttpHandlerOptions): Promise<ListTablesCommandOutput>;
+    listTables(args: ListTablesCommandInput, cb: (err: any, data?: ListTablesCommandOutput) => void): void;
+    listTables(args: ListTablesCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: ListTablesCommandOutput) => void): void;
+}

package/dist-types/ts3.4/RedshiftDataClient.d.ts

@@ -0,0 +1,83 @@
+import { EndpointsInputConfig, EndpointsResolvedConfig, RegionInputConfig, RegionResolvedConfig } from "@aws-sdk/config-resolver";
+import { HostHeaderInputConfig, HostHeaderResolvedConfig } from "@aws-sdk/middleware-host-header";
+import { RetryInputConfig, RetryResolvedConfig } from "@aws-sdk/middleware-retry";
+import { AwsAuthInputConfig, AwsAuthResolvedConfig } from "@aws-sdk/middleware-signing";
+import { UserAgentInputConfig, UserAgentResolvedConfig } from "@aws-sdk/middleware-user-agent";
+import { HttpHandler as __HttpHandler } from "@aws-sdk/protocol-http";
+import { Client as __Client, DefaultsMode, SmithyConfiguration as __SmithyConfiguration, SmithyResolvedConfiguration as __SmithyResolvedConfiguration } from "@aws-sdk/smithy-client";
+import { Credentials as __Credentials, Decoder as __Decoder, Encoder as __Encoder, HashConstructor as __HashConstructor, HttpHandlerOptions as __HttpHandlerOptions, Logger as __Logger, Provider as __Provider, Provider, RegionInfoProvider, StreamCollector as __StreamCollector, UrlParser as __UrlParser, UserAgent as __UserAgent } 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 type ServiceInputTypes = BatchExecuteStatementCommandInput | CancelStatementCommandInput | DescribeStatementCommandInput | DescribeTableCommandInput | ExecuteStatementCommandInput | GetStatementResultCommandInput | ListDatabasesCommandInput | ListSchemasCommandInput | ListStatementsCommandInput | ListTablesCommandInput;
+export declare type ServiceOutputTypes = BatchExecuteStatementCommandOutput | CancelStatementCommandOutput | DescribeStatementCommandOutput | DescribeTableCommandOutput | ExecuteStatementCommandOutput | GetStatementResultCommandOutput | ListDatabasesCommandOutput | ListSchemasCommandOutput | ListStatementsCommandOutput | ListTablesCommandOutput;
+export interface ClientDefaults extends Partial<__SmithyResolvedConfiguration<__HttpHandlerOptions>> {
+    
+    requestHandler?: __HttpHandler;
+    
+    sha256?: __HashConstructor;
+    
+    urlParser?: __UrlParser;
+    
+    bodyLengthChecker?: (body: any) => number | undefined;
+    
+    streamCollector?: __StreamCollector;
+    
+    base64Decoder?: __Decoder;
+    
+    base64Encoder?: __Encoder;
+    
+    utf8Decoder?: __Decoder;
+    
+    utf8Encoder?: __Encoder;
+    
+    runtime?: string;
+    
+    disableHostPrefix?: boolean;
+    
+    maxAttempts?: number | __Provider<number>;
+    
+    retryMode?: string | __Provider<string>;
+    
+    logger?: __Logger;
+    
+    useDualstackEndpoint?: boolean | __Provider<boolean>;
+    
+    useFipsEndpoint?: boolean | __Provider<boolean>;
+    
+    serviceId?: string;
+    
+    region?: string | __Provider<string>;
+    
+    credentialDefaultProvider?: (input: any) => __Provider<__Credentials>;
+    
+    regionInfoProvider?: RegionInfoProvider;
+    
+    defaultUserAgentProvider?: Provider<__UserAgent>;
+    
+    defaultsMode?: DefaultsMode | Provider<DefaultsMode>;
+}
+declare type RedshiftDataClientConfigType = Partial<__SmithyConfiguration<__HttpHandlerOptions>> & ClientDefaults & RegionInputConfig & EndpointsInputConfig & RetryInputConfig & HostHeaderInputConfig & AwsAuthInputConfig & UserAgentInputConfig;
+
+export interface RedshiftDataClientConfig extends RedshiftDataClientConfigType {
+}
+declare type RedshiftDataClientResolvedConfigType = __SmithyResolvedConfiguration<__HttpHandlerOptions> & Required<ClientDefaults> & RegionResolvedConfig & EndpointsResolvedConfig & RetryResolvedConfig & HostHeaderResolvedConfig & AwsAuthResolvedConfig & UserAgentResolvedConfig;
+
+export interface RedshiftDataClientResolvedConfig extends RedshiftDataClientResolvedConfigType {
+}
+
+export declare class RedshiftDataClient extends __Client<__HttpHandlerOptions, ServiceInputTypes, ServiceOutputTypes, RedshiftDataClientResolvedConfig> {
+    
+    readonly config: RedshiftDataClientResolvedConfig;
+    constructor(configuration: RedshiftDataClientConfig);
+    
+    destroy(): void;
+}
+export {};

package/dist-types/ts3.4/commands/BatchExecuteStatementCommand.d.ts

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { BatchExecuteStatementInput, BatchExecuteStatementOutput } from "../models/models_0";
+import { RedshiftDataClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RedshiftDataClient";
+export interface BatchExecuteStatementCommandInput extends BatchExecuteStatementInput {
+}
+export interface BatchExecuteStatementCommandOutput extends BatchExecuteStatementOutput, __MetadataBearer {
+}
+
+export declare class BatchExecuteStatementCommand extends $Command<BatchExecuteStatementCommandInput, BatchExecuteStatementCommandOutput, RedshiftDataClientResolvedConfig> {
+    readonly input: BatchExecuteStatementCommandInput;
+    constructor(input: BatchExecuteStatementCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RedshiftDataClientResolvedConfig, options?: __HttpHandlerOptions): Handler<BatchExecuteStatementCommandInput, BatchExecuteStatementCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/CancelStatementCommand.d.ts

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { CancelStatementRequest, CancelStatementResponse } from "../models/models_0";
+import { RedshiftDataClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RedshiftDataClient";
+export interface CancelStatementCommandInput extends CancelStatementRequest {
+}
+export interface CancelStatementCommandOutput extends CancelStatementResponse, __MetadataBearer {
+}
+
+export declare class CancelStatementCommand extends $Command<CancelStatementCommandInput, CancelStatementCommandOutput, RedshiftDataClientResolvedConfig> {
+    readonly input: CancelStatementCommandInput;
+    constructor(input: CancelStatementCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RedshiftDataClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CancelStatementCommandInput, CancelStatementCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/DescribeStatementCommand.d.ts

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { DescribeStatementRequest, DescribeStatementResponse } from "../models/models_0";
+import { RedshiftDataClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RedshiftDataClient";
+export interface DescribeStatementCommandInput extends DescribeStatementRequest {
+}
+export interface DescribeStatementCommandOutput extends DescribeStatementResponse, __MetadataBearer {
+}
+
+export declare class DescribeStatementCommand extends $Command<DescribeStatementCommandInput, DescribeStatementCommandOutput, RedshiftDataClientResolvedConfig> {
+    readonly input: DescribeStatementCommandInput;
+    constructor(input: DescribeStatementCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RedshiftDataClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeStatementCommandInput, DescribeStatementCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/DescribeTableCommand.d.ts

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { DescribeTableRequest, DescribeTableResponse } from "../models/models_0";
+import { RedshiftDataClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RedshiftDataClient";
+export interface DescribeTableCommandInput extends DescribeTableRequest {
+}
+export interface DescribeTableCommandOutput extends DescribeTableResponse, __MetadataBearer {
+}
+
+export declare class DescribeTableCommand extends $Command<DescribeTableCommandInput, DescribeTableCommandOutput, RedshiftDataClientResolvedConfig> {
+    readonly input: DescribeTableCommandInput;
+    constructor(input: DescribeTableCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RedshiftDataClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeTableCommandInput, DescribeTableCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/ExecuteStatementCommand.d.ts

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ExecuteStatementInput, ExecuteStatementOutput } from "../models/models_0";
+import { RedshiftDataClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RedshiftDataClient";
+export interface ExecuteStatementCommandInput extends ExecuteStatementInput {
+}
+export interface ExecuteStatementCommandOutput extends ExecuteStatementOutput, __MetadataBearer {
+}
+
+export declare class ExecuteStatementCommand extends $Command<ExecuteStatementCommandInput, ExecuteStatementCommandOutput, RedshiftDataClientResolvedConfig> {
+    readonly input: ExecuteStatementCommandInput;
+    constructor(input: ExecuteStatementCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RedshiftDataClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ExecuteStatementCommandInput, ExecuteStatementCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/GetStatementResultCommand.d.ts

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { GetStatementResultRequest, GetStatementResultResponse } from "../models/models_0";
+import { RedshiftDataClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RedshiftDataClient";
+export interface GetStatementResultCommandInput extends GetStatementResultRequest {
+}
+export interface GetStatementResultCommandOutput extends GetStatementResultResponse, __MetadataBearer {
+}
+
+export declare class GetStatementResultCommand extends $Command<GetStatementResultCommandInput, GetStatementResultCommandOutput, RedshiftDataClientResolvedConfig> {
+    readonly input: GetStatementResultCommandInput;
+    constructor(input: GetStatementResultCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RedshiftDataClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetStatementResultCommandInput, GetStatementResultCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/ListDatabasesCommand.d.ts

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ListDatabasesRequest, ListDatabasesResponse } from "../models/models_0";
+import { RedshiftDataClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RedshiftDataClient";
+export interface ListDatabasesCommandInput extends ListDatabasesRequest {
+}
+export interface ListDatabasesCommandOutput extends ListDatabasesResponse, __MetadataBearer {
+}
+
+export declare class ListDatabasesCommand extends $Command<ListDatabasesCommandInput, ListDatabasesCommandOutput, RedshiftDataClientResolvedConfig> {
+    readonly input: ListDatabasesCommandInput;
+    constructor(input: ListDatabasesCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RedshiftDataClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListDatabasesCommandInput, ListDatabasesCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/ListSchemasCommand.d.ts

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ListSchemasRequest, ListSchemasResponse } from "../models/models_0";
+import { RedshiftDataClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RedshiftDataClient";
+export interface ListSchemasCommandInput extends ListSchemasRequest {
+}
+export interface ListSchemasCommandOutput extends ListSchemasResponse, __MetadataBearer {
+}
+
+export declare class ListSchemasCommand extends $Command<ListSchemasCommandInput, ListSchemasCommandOutput, RedshiftDataClientResolvedConfig> {
+    readonly input: ListSchemasCommandInput;
+    constructor(input: ListSchemasCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RedshiftDataClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListSchemasCommandInput, ListSchemasCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/ListStatementsCommand.d.ts

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ListStatementsRequest, ListStatementsResponse } from "../models/models_0";
+import { RedshiftDataClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RedshiftDataClient";
+export interface ListStatementsCommandInput extends ListStatementsRequest {
+}
+export interface ListStatementsCommandOutput extends ListStatementsResponse, __MetadataBearer {
+}
+
+export declare class ListStatementsCommand extends $Command<ListStatementsCommandInput, ListStatementsCommandOutput, RedshiftDataClientResolvedConfig> {
+    readonly input: ListStatementsCommandInput;
+    constructor(input: ListStatementsCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RedshiftDataClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListStatementsCommandInput, ListStatementsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/ListTablesCommand.d.ts

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ListTablesRequest, ListTablesResponse } from "../models/models_0";
+import { RedshiftDataClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RedshiftDataClient";
+export interface ListTablesCommandInput extends ListTablesRequest {
+}
+export interface ListTablesCommandOutput extends ListTablesResponse, __MetadataBearer {
+}
+
+export declare class ListTablesCommand extends $Command<ListTablesCommandInput, ListTablesCommandOutput, RedshiftDataClientResolvedConfig> {
+    readonly input: ListTablesCommandInput;
+    constructor(input: ListTablesCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RedshiftDataClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListTablesCommandInput, ListTablesCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,10 @@
+export * from "./BatchExecuteStatementCommand";
+export * from "./CancelStatementCommand";
+export * from "./DescribeStatementCommand";
+export * from "./DescribeTableCommand";
+export * from "./ExecuteStatementCommand";
+export * from "./GetStatementResultCommand";
+export * from "./ListDatabasesCommand";
+export * from "./ListSchemasCommand";
+export * from "./ListStatementsCommand";
+export * from "./ListTablesCommand";

package/dist-types/ts3.4/endpoints.d.ts

@@ -0,0 +1,2 @@
+import { RegionInfoProvider } from "@aws-sdk/types";
+export declare const defaultRegionInfoProvider: RegionInfoProvider;

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

@@ -0,0 +1,6 @@
+export * from "./RedshiftData";
+export * from "./RedshiftDataClient";
+export * from "./commands";
+export * from "./models";
+export * from "./pagination";
+export { RedshiftDataServiceException } from "./models/RedshiftDataServiceException";

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

@@ -0,0 +1,6 @@
+import { ServiceException as __ServiceException, ServiceExceptionOptions as __ServiceExceptionOptions } from "@aws-sdk/smithy-client";
+
+export declare class RedshiftDataServiceException extends __ServiceException {
+    
+    constructor(options: __ServiceExceptionOptions);
+}

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

@@ -0,0 +1 @@
+export * from "./models_0";