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

package/{dist/es → dist-es}/RedshiftDataClient.js

@@ -1,5 +1,4 @@
 import { __extends } from "tslib";
-import { getRuntimeConfig as __getRuntimeConfig } from "./runtimeConfig";
 import { resolveEndpointsConfig, resolveRegionConfig, } from "@aws-sdk/config-resolver";
 import { getContentLengthPlugin } from "@aws-sdk/middleware-content-length";
 import { getHostHeaderPlugin, resolveHostHeaderConfig, } from "@aws-sdk/middleware-host-header";
@@ -8,14 +7,8 @@ import { getRetryPlugin, resolveRetryConfig } from "@aws-sdk/middleware-retry";
 import { getAwsAuthPlugin, resolveAwsAuthConfig, } from "@aws-sdk/middleware-signing";
 import { getUserAgentPlugin, resolveUserAgentConfig, } from "@aws-sdk/middleware-user-agent";
 import { Client as __Client, } from "@aws-sdk/smithy-client";
-/**
- * <p>You can use the Amazon Redshift Data API to run queries on Amazon Redshift tables. You
- *       can run SQL statements, which are committed if the statement succeeds. </p>
- *          <p>For more information about the Amazon Redshift Data API, see
- *        <a href="https://docs.aws.amazon.com/redshift/latest/mgmt/data-api.html">Using the Amazon Redshift Data API</a> in the
- *        <i>Amazon Redshift Cluster Management Guide</i>. </p>
- */
-var RedshiftDataClient = /** @class */ (function (_super) {
+import { getRuntimeConfig as __getRuntimeConfig } from "./runtimeConfig";
+var RedshiftDataClient = (function (_super) {
     __extends(RedshiftDataClient, _super);
     function RedshiftDataClient(configuration) {
         var _this = this;
@@ -36,15 +29,9 @@ var RedshiftDataClient = /** @class */ (function (_super) {
         _this.middlewareStack.use(getUserAgentPlugin(_this.config));
         return _this;
     }
-    /**
-     * Destroy underlying resources, like sockets. It's usually not necessary to do this.
-     * However in Node.js, it's best to explicitly shut down the client's agent when it is no longer needed.
-     * Otherwise, sockets might stay open for quite a long time before the server terminates them.
-     */
     RedshiftDataClient.prototype.destroy = function () {
         _super.prototype.destroy.call(this);
     };
     return RedshiftDataClient;
 }(__Client));
 export { RedshiftDataClient };
-//# sourceMappingURL=RedshiftDataClient.js.map

package/dist-es/commands/BatchExecuteStatementCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { BatchExecuteStatementInput, BatchExecuteStatementOutput } from "../models/models_0";
+import { deserializeAws_json1_1BatchExecuteStatementCommand, serializeAws_json1_1BatchExecuteStatementCommand, } from "../protocols/Aws_json1_1";
+var BatchExecuteStatementCommand = (function (_super) {
+    __extends(BatchExecuteStatementCommand, _super);
+    function BatchExecuteStatementCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    BatchExecuteStatementCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "RedshiftDataClient";
+        var commandName = "BatchExecuteStatementCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: BatchExecuteStatementInput.filterSensitiveLog,
+            outputFilterSensitiveLog: BatchExecuteStatementOutput.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    BatchExecuteStatementCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1BatchExecuteStatementCommand(input, context);
+    };
+    BatchExecuteStatementCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1BatchExecuteStatementCommand(output, context);
+    };
+    return BatchExecuteStatementCommand;
+}($Command));
+export { BatchExecuteStatementCommand };

package/{dist/es → dist-es}/commands/CancelStatementCommand.js

@@ -1,40 +1,15 @@
 import { __extends } from "tslib";
-import { CancelStatementRequest, CancelStatementResponse } from "../models/models_0";
-import { deserializeAws_json1_1CancelStatementCommand, serializeAws_json1_1CancelStatementCommand, } from "../protocols/Aws_json1_1";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
-/**
- * <p>Cancels a running query. To be canceled, a query must be running. </p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { RedshiftDataClient, CancelStatementCommand } from "@aws-sdk/client-redshift-data"; // ES Modules import
- * // const { RedshiftDataClient, CancelStatementCommand } = require("@aws-sdk/client-redshift-data"); // CommonJS import
- * const client = new RedshiftDataClient(config);
- * const command = new CancelStatementCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CancelStatementCommandInput} for command's `input` shape.
- * @see {@link CancelStatementCommandOutput} for command's `response` shape.
- * @see {@link RedshiftDataClientResolvedConfig | config} for command's `input` shape.
- *
- */
-var CancelStatementCommand = /** @class */ (function (_super) {
+import { CancelStatementRequest, CancelStatementResponse } from "../models/models_0";
+import { deserializeAws_json1_1CancelStatementCommand, serializeAws_json1_1CancelStatementCommand, } from "../protocols/Aws_json1_1";
+var CancelStatementCommand = (function (_super) {
     __extends(CancelStatementCommand, _super);
-    // Start section: command_properties
-    // End section: command_properties
     function CancelStatementCommand(input) {
-        var _this = 
-        // Start section: command_constructor
-        _super.call(this) || this;
+        var _this = _super.call(this) || this;
         _this.input = input;
         return _this;
-        // End section: command_constructor
     }
-    /**
-     * @internal
-     */
     CancelStatementCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
         var stack = clientStack.concat(this.middlewareStack);
@@ -62,4 +37,3 @@ var CancelStatementCommand = /** @class */ (function (_super) {
     return CancelStatementCommand;
 }($Command));
 export { CancelStatementCommand };
-//# sourceMappingURL=CancelStatementCommand.js.map

package/{dist/es → dist-es}/commands/DescribeStatementCommand.js

@@ -1,42 +1,15 @@
 import { __extends } from "tslib";
-import { DescribeStatementRequest, DescribeStatementResponse } from "../models/models_0";
-import { deserializeAws_json1_1DescribeStatementCommand, serializeAws_json1_1DescribeStatementCommand, } from "../protocols/Aws_json1_1";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
-/**
- * <p>Describes the details about a specific instance when a query was run by the Amazon Redshift Data API. The information
- *       includes when the query started, when it finished, the query status, the number of rows returned, and the SQL
- *       statement. </p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { RedshiftDataClient, DescribeStatementCommand } from "@aws-sdk/client-redshift-data"; // ES Modules import
- * // const { RedshiftDataClient, DescribeStatementCommand } = require("@aws-sdk/client-redshift-data"); // CommonJS import
- * const client = new RedshiftDataClient(config);
- * const command = new DescribeStatementCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeStatementCommandInput} for command's `input` shape.
- * @see {@link DescribeStatementCommandOutput} for command's `response` shape.
- * @see {@link RedshiftDataClientResolvedConfig | config} for command's `input` shape.
- *
- */
-var DescribeStatementCommand = /** @class */ (function (_super) {
+import { DescribeStatementRequest, DescribeStatementResponse } from "../models/models_0";
+import { deserializeAws_json1_1DescribeStatementCommand, serializeAws_json1_1DescribeStatementCommand, } from "../protocols/Aws_json1_1";
+var DescribeStatementCommand = (function (_super) {
     __extends(DescribeStatementCommand, _super);
-    // Start section: command_properties
-    // End section: command_properties
     function DescribeStatementCommand(input) {
-        var _this = 
-        // Start section: command_constructor
-        _super.call(this) || this;
+        var _this = _super.call(this) || this;
         _this.input = input;
         return _this;
-        // End section: command_constructor
     }
-    /**
-     * @internal
-     */
     DescribeStatementCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
         var stack = clientStack.concat(this.middlewareStack);
@@ -64,4 +37,3 @@ var DescribeStatementCommand = /** @class */ (function (_super) {
     return DescribeStatementCommand;
 }($Command));
 export { DescribeStatementCommand };
-//# sourceMappingURL=DescribeStatementCommand.js.map

package/dist-es/commands/DescribeTableCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { DescribeTableRequest, DescribeTableResponse } from "../models/models_0";
+import { deserializeAws_json1_1DescribeTableCommand, serializeAws_json1_1DescribeTableCommand, } from "../protocols/Aws_json1_1";
+var DescribeTableCommand = (function (_super) {
+    __extends(DescribeTableCommand, _super);
+    function DescribeTableCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    DescribeTableCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "RedshiftDataClient";
+        var commandName = "DescribeTableCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: DescribeTableRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: DescribeTableResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    DescribeTableCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1DescribeTableCommand(input, context);
+    };
+    DescribeTableCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1DescribeTableCommand(output, context);
+    };
+    return DescribeTableCommand;
+}($Command));
+export { DescribeTableCommand };

package/dist-es/commands/ExecuteStatementCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { ExecuteStatementInput, ExecuteStatementOutput } from "../models/models_0";
+import { deserializeAws_json1_1ExecuteStatementCommand, serializeAws_json1_1ExecuteStatementCommand, } from "../protocols/Aws_json1_1";
+var ExecuteStatementCommand = (function (_super) {
+    __extends(ExecuteStatementCommand, _super);
+    function ExecuteStatementCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    ExecuteStatementCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "RedshiftDataClient";
+        var commandName = "ExecuteStatementCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: ExecuteStatementInput.filterSensitiveLog,
+            outputFilterSensitiveLog: ExecuteStatementOutput.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    ExecuteStatementCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1ExecuteStatementCommand(input, context);
+    };
+    ExecuteStatementCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1ExecuteStatementCommand(output, context);
+    };
+    return ExecuteStatementCommand;
+}($Command));
+export { ExecuteStatementCommand };

package/{dist/es → dist-es}/commands/GetStatementResultCommand.js

@@ -1,41 +1,15 @@
 import { __extends } from "tslib";
-import { GetStatementResultRequest, GetStatementResultResponse } from "../models/models_0";
-import { deserializeAws_json1_1GetStatementResultCommand, serializeAws_json1_1GetStatementResultCommand, } from "../protocols/Aws_json1_1";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
-/**
- * <p>Fetches the temporarily cached result of an SQL statement.
- *        A token is returned to page through the statement results. </p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { RedshiftDataClient, GetStatementResultCommand } from "@aws-sdk/client-redshift-data"; // ES Modules import
- * // const { RedshiftDataClient, GetStatementResultCommand } = require("@aws-sdk/client-redshift-data"); // CommonJS import
- * const client = new RedshiftDataClient(config);
- * const command = new GetStatementResultCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetStatementResultCommandInput} for command's `input` shape.
- * @see {@link GetStatementResultCommandOutput} for command's `response` shape.
- * @see {@link RedshiftDataClientResolvedConfig | config} for command's `input` shape.
- *
- */
-var GetStatementResultCommand = /** @class */ (function (_super) {
+import { GetStatementResultRequest, GetStatementResultResponse } from "../models/models_0";
+import { deserializeAws_json1_1GetStatementResultCommand, serializeAws_json1_1GetStatementResultCommand, } from "../protocols/Aws_json1_1";
+var GetStatementResultCommand = (function (_super) {
     __extends(GetStatementResultCommand, _super);
-    // Start section: command_properties
-    // End section: command_properties
     function GetStatementResultCommand(input) {
-        var _this = 
-        // Start section: command_constructor
-        _super.call(this) || this;
+        var _this = _super.call(this) || this;
         _this.input = input;
         return _this;
-        // End section: command_constructor
     }
-    /**
-     * @internal
-     */
     GetStatementResultCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
         var stack = clientStack.concat(this.middlewareStack);
@@ -63,4 +37,3 @@ var GetStatementResultCommand = /** @class */ (function (_super) {
     return GetStatementResultCommand;
 }($Command));
 export { GetStatementResultCommand };
-//# sourceMappingURL=GetStatementResultCommand.js.map

package/dist-es/commands/ListDatabasesCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { ListDatabasesRequest, ListDatabasesResponse } from "../models/models_0";
+import { deserializeAws_json1_1ListDatabasesCommand, serializeAws_json1_1ListDatabasesCommand, } from "../protocols/Aws_json1_1";
+var ListDatabasesCommand = (function (_super) {
+    __extends(ListDatabasesCommand, _super);
+    function ListDatabasesCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    ListDatabasesCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "RedshiftDataClient";
+        var commandName = "ListDatabasesCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: ListDatabasesRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: ListDatabasesResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    ListDatabasesCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1ListDatabasesCommand(input, context);
+    };
+    ListDatabasesCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1ListDatabasesCommand(output, context);
+    };
+    return ListDatabasesCommand;
+}($Command));
+export { ListDatabasesCommand };

package/dist-es/commands/ListSchemasCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { ListSchemasRequest, ListSchemasResponse } from "../models/models_0";
+import { deserializeAws_json1_1ListSchemasCommand, serializeAws_json1_1ListSchemasCommand, } from "../protocols/Aws_json1_1";
+var ListSchemasCommand = (function (_super) {
+    __extends(ListSchemasCommand, _super);
+    function ListSchemasCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    ListSchemasCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "RedshiftDataClient";
+        var commandName = "ListSchemasCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: ListSchemasRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: ListSchemasResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    ListSchemasCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1ListSchemasCommand(input, context);
+    };
+    ListSchemasCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1ListSchemasCommand(output, context);
+    };
+    return ListSchemasCommand;
+}($Command));
+export { ListSchemasCommand };

package/{dist/es → dist-es}/commands/ListStatementsCommand.js

@@ -1,41 +1,15 @@
 import { __extends } from "tslib";
-import { ListStatementsRequest, ListStatementsResponse } from "../models/models_0";
-import { deserializeAws_json1_1ListStatementsCommand, serializeAws_json1_1ListStatementsCommand, } from "../protocols/Aws_json1_1";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
-/**
- * <p>List of SQL statements. By default, only finished statements are shown.
- *         A token is returned to page through the statement list. </p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { RedshiftDataClient, ListStatementsCommand } from "@aws-sdk/client-redshift-data"; // ES Modules import
- * // const { RedshiftDataClient, ListStatementsCommand } = require("@aws-sdk/client-redshift-data"); // CommonJS import
- * const client = new RedshiftDataClient(config);
- * const command = new ListStatementsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListStatementsCommandInput} for command's `input` shape.
- * @see {@link ListStatementsCommandOutput} for command's `response` shape.
- * @see {@link RedshiftDataClientResolvedConfig | config} for command's `input` shape.
- *
- */
-var ListStatementsCommand = /** @class */ (function (_super) {
+import { ListStatementsRequest, ListStatementsResponse } from "../models/models_0";
+import { deserializeAws_json1_1ListStatementsCommand, serializeAws_json1_1ListStatementsCommand, } from "../protocols/Aws_json1_1";
+var ListStatementsCommand = (function (_super) {
     __extends(ListStatementsCommand, _super);
-    // Start section: command_properties
-    // End section: command_properties
     function ListStatementsCommand(input) {
-        var _this = 
-        // Start section: command_constructor
-        _super.call(this) || this;
+        var _this = _super.call(this) || this;
         _this.input = input;
         return _this;
-        // End section: command_constructor
     }
-    /**
-     * @internal
-     */
     ListStatementsCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
         var stack = clientStack.concat(this.middlewareStack);
@@ -63,4 +37,3 @@ var ListStatementsCommand = /** @class */ (function (_super) {
     return ListStatementsCommand;
 }($Command));
 export { ListStatementsCommand };
-//# sourceMappingURL=ListStatementsCommand.js.map

package/dist-es/commands/ListTablesCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { ListTablesRequest, ListTablesResponse } from "../models/models_0";
+import { deserializeAws_json1_1ListTablesCommand, serializeAws_json1_1ListTablesCommand, } from "../protocols/Aws_json1_1";
+var ListTablesCommand = (function (_super) {
+    __extends(ListTablesCommand, _super);
+    function ListTablesCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    ListTablesCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "RedshiftDataClient";
+        var commandName = "ListTablesCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: ListTablesRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: ListTablesResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    ListTablesCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1ListTablesCommand(input, context);
+    };
+    ListTablesCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1ListTablesCommand(output, context);
+    };
+    return ListTablesCommand;
+}($Command));
+export { ListTablesCommand };

package/{dist/es → dist-es}/endpoints.js

@@ -47,7 +47,6 @@ var partitionHash = {
 };
 export var defaultRegionInfoProvider = function (region, options) { return __awaiter(void 0, void 0, void 0, function () {
     return __generator(this, function (_a) {
-        return [2 /*return*/, getRegionInfo(region, __assign(__assign({}, options), { signingService: "redshift-data", regionHash: regionHash, partitionHash: partitionHash }))];
+        return [2, getRegionInfo(region, __assign(__assign({}, options), { signingService: "redshift-data", regionHash: regionHash, partitionHash: partitionHash }))];
     });
 }); };
-//# sourceMappingURL=endpoints.js.map