@aws-sdk/lib-dynamodb 3.185.0 → 3.186.0

package/CHANGELOG.md

@@ -3,6 +3,14 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# [3.186.0](https://github.com/aws/aws-sdk-js-v3/compare/v3.185.0...v3.186.0) (2022-10-06)
+
+**Note:** Version bump only for package @aws-sdk/lib-dynamodb
+
+
+
+
+
 # [3.185.0](https://github.com/aws/aws-sdk-js-v3/compare/v3.184.0...v3.185.0) (2022-10-05)
 
 **Note:** Version bump only for package @aws-sdk/lib-dynamodb

package/dist-es/DynamoDBDocument.js

@@ -1,3 +1,4 @@
+import { __extends } from "tslib";
 import { BatchExecuteStatementCommand, } from "./commands/BatchExecuteStatementCommand";
 import { BatchGetCommand } from "./commands/BatchGetCommand";
 import { BatchWriteCommand } from "./commands/BatchWriteCommand";
@@ -12,190 +13,196 @@ import { TransactGetCommand } from "./commands/TransactGetCommand";
 import { TransactWriteCommand, } from "./commands/TransactWriteCommand";
 import { UpdateCommand } from "./commands/UpdateCommand";
 import { DynamoDBDocumentClient } from "./DynamoDBDocumentClient";
-export class DynamoDBDocument extends DynamoDBDocumentClient {
-    static from(client, translateConfig) {
-        return new DynamoDBDocument(client, translateConfig);
+var DynamoDBDocument = (function (_super) {
+    __extends(DynamoDBDocument, _super);
+    function DynamoDBDocument() {
+        return _super !== null && _super.apply(this, arguments) || this;
     }
-    batchExecuteStatement(args, optionsOrCb, cb) {
-        const command = new BatchExecuteStatementCommand(args);
+    DynamoDBDocument.from = function (client, translateConfig) {
+        return new DynamoDBDocument(client, translateConfig);
+    };
+    DynamoDBDocument.prototype.batchExecuteStatement = function (args, optionsOrCb, cb) {
+        var command = new BatchExecuteStatementCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    batchGet(args, optionsOrCb, cb) {
-        const command = new BatchGetCommand(args);
+    };
+    DynamoDBDocument.prototype.batchGet = function (args, optionsOrCb, cb) {
+        var command = new BatchGetCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    batchWrite(args, optionsOrCb, cb) {
-        const command = new BatchWriteCommand(args);
+    };
+    DynamoDBDocument.prototype.batchWrite = function (args, optionsOrCb, cb) {
+        var command = new BatchWriteCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    delete(args, optionsOrCb, cb) {
-        const command = new DeleteCommand(args);
+    };
+    DynamoDBDocument.prototype.delete = function (args, optionsOrCb, cb) {
+        var command = new DeleteCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    executeStatement(args, optionsOrCb, cb) {
-        const command = new ExecuteStatementCommand(args);
+    };
+    DynamoDBDocument.prototype.executeStatement = function (args, optionsOrCb, cb) {
+        var command = new ExecuteStatementCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    executeTransaction(args, optionsOrCb, cb) {
-        const command = new ExecuteTransactionCommand(args);
+    };
+    DynamoDBDocument.prototype.executeTransaction = function (args, optionsOrCb, cb) {
+        var command = new ExecuteTransactionCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    get(args, optionsOrCb, cb) {
-        const command = new GetCommand(args);
+    };
+    DynamoDBDocument.prototype.get = function (args, optionsOrCb, cb) {
+        var command = new GetCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    put(args, optionsOrCb, cb) {
-        const command = new PutCommand(args);
+    };
+    DynamoDBDocument.prototype.put = function (args, optionsOrCb, cb) {
+        var command = new PutCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    query(args, optionsOrCb, cb) {
-        const command = new QueryCommand(args);
+    };
+    DynamoDBDocument.prototype.query = function (args, optionsOrCb, cb) {
+        var command = new QueryCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    scan(args, optionsOrCb, cb) {
-        const command = new ScanCommand(args);
+    };
+    DynamoDBDocument.prototype.scan = function (args, optionsOrCb, cb) {
+        var command = new ScanCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    transactGet(args, optionsOrCb, cb) {
-        const command = new TransactGetCommand(args);
+    };
+    DynamoDBDocument.prototype.transactGet = function (args, optionsOrCb, cb) {
+        var command = new TransactGetCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    transactWrite(args, optionsOrCb, cb) {
-        const command = new TransactWriteCommand(args);
+    };
+    DynamoDBDocument.prototype.transactWrite = function (args, optionsOrCb, cb) {
+        var command = new TransactWriteCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    update(args, optionsOrCb, cb) {
-        const command = new UpdateCommand(args);
+    };
+    DynamoDBDocument.prototype.update = function (args, optionsOrCb, cb) {
+        var command = new UpdateCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-}
+    };
+    return DynamoDBDocument;
+}(DynamoDBDocumentClient));
+export { DynamoDBDocument };

package/dist-es/DynamoDBDocumentClient.js

@@ -1,14 +1,19 @@
+import { __extends } from "tslib";
 import { Client as __Client } from "@aws-sdk/smithy-client";
-export class DynamoDBDocumentClient extends __Client {
-    constructor(client, translateConfig) {
-        super(client.config);
-        this.config = client.config;
-        this.config.translateConfig = translateConfig;
-        this.middlewareStack = client.middlewareStack;
+var DynamoDBDocumentClient = (function (_super) {
+    __extends(DynamoDBDocumentClient, _super);
+    function DynamoDBDocumentClient(client, translateConfig) {
+        var _this = _super.call(this, client.config) || this;
+        _this.config = client.config;
+        _this.config.translateConfig = translateConfig;
+        _this.middlewareStack = client.middlewareStack;
+        return _this;
     }
-    static from(client, translateConfig) {
+    DynamoDBDocumentClient.from = function (client, translateConfig) {
         return new DynamoDBDocumentClient(client, translateConfig);
-    }
-    destroy() {
-    }
-}
+    };
+    DynamoDBDocumentClient.prototype.destroy = function () {
+    };
+    return DynamoDBDocumentClient;
+}(__Client));
+export { DynamoDBDocumentClient };

package/dist-es/baseCommand/DynamoDBDocumentClientCommand.js

@@ -1,24 +1,45 @@
+import { __awaiter, __extends, __generator } from "tslib";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { marshallInput, unmarshallOutput } from "../commands/utils";
-export class DynamoDBDocumentClientCommand extends $Command {
-    addMarshallingMiddleware(configuration) {
-        const { marshallOptions, unmarshallOptions } = configuration.translateConfig || {};
-        this.clientCommand.middlewareStack.add((next) => async (args) => {
-            args.input = marshallInput(this.input, this.inputKeyNodes, marshallOptions);
-            return next(args);
+var DynamoDBDocumentClientCommand = (function (_super) {
+    __extends(DynamoDBDocumentClientCommand, _super);
+    function DynamoDBDocumentClientCommand() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    DynamoDBDocumentClientCommand.prototype.addMarshallingMiddleware = function (configuration) {
+        var _this = this;
+        var _a = configuration.translateConfig || {}, marshallOptions = _a.marshallOptions, unmarshallOptions = _a.unmarshallOptions;
+        this.clientCommand.middlewareStack.add(function (next) {
+            return function (args) { return __awaiter(_this, void 0, void 0, function () {
+                return __generator(this, function (_a) {
+                    args.input = marshallInput(this.input, this.inputKeyNodes, marshallOptions);
+                    return [2, next(args)];
+                });
+            }); };
         }, {
             name: "DocumentMarshall",
             step: "initialize",
             override: true,
         });
-        this.clientCommand.middlewareStack.add((next) => async (args) => {
-            const deserialized = await next(args);
-            deserialized.output = unmarshallOutput(deserialized.output, this.outputKeyNodes, unmarshallOptions);
-            return deserialized;
+        this.clientCommand.middlewareStack.add(function (next) {
+            return function (args) { return __awaiter(_this, void 0, void 0, function () {
+                var deserialized;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0: return [4, next(args)];
+                        case 1:
+                            deserialized = _a.sent();
+                            deserialized.output = unmarshallOutput(deserialized.output, this.outputKeyNodes, unmarshallOptions);
+                            return [2, deserialized];
+                    }
+                });
+            }); };
         }, {
             name: "DocumentUnmarshall",
             step: "deserialize",
             override: true,
         });
-    }
-}
+    };
+    return DynamoDBDocumentClientCommand;
+}($Command));
+export { DynamoDBDocumentClientCommand };

package/dist-es/commands/BatchExecuteStatementCommand.js

@@ -1,18 +1,26 @@
+import { __awaiter, __extends, __generator } from "tslib";
 import { BatchExecuteStatementCommand as __BatchExecuteStatementCommand, } from "@aws-sdk/client-dynamodb";
 import { DynamoDBDocumentClientCommand } from "../baseCommand/DynamoDBDocumentClientCommand";
-export class BatchExecuteStatementCommand extends DynamoDBDocumentClientCommand {
-    constructor(input) {
-        super();
-        this.input = input;
-        this.inputKeyNodes = [{ key: "Statements", children: [{ key: "Parameters" }] }];
-        this.outputKeyNodes = [{ key: "Responses", children: [{ key: "Item" }] }];
-        this.clientCommand = new __BatchExecuteStatementCommand(this.input);
-        this.middlewareStack = this.clientCommand.middlewareStack;
+var BatchExecuteStatementCommand = (function (_super) {
+    __extends(BatchExecuteStatementCommand, _super);
+    function BatchExecuteStatementCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        _this.inputKeyNodes = [{ key: "Statements", children: [{ key: "Parameters" }] }];
+        _this.outputKeyNodes = [{ key: "Responses", children: [{ key: "Item" }] }];
+        _this.clientCommand = new __BatchExecuteStatementCommand(_this.input);
+        _this.middlewareStack = _this.clientCommand.middlewareStack;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    BatchExecuteStatementCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        var _this = this;
         this.addMarshallingMiddleware(configuration);
-        const stack = clientStack.concat(this.middlewareStack);
-        const handler = this.clientCommand.resolveMiddleware(stack, configuration, options);
-        return async () => handler(this.clientCommand);
-    }
-}
+        var stack = clientStack.concat(this.middlewareStack);
+        var handler = this.clientCommand.resolveMiddleware(stack, configuration, options);
+        return function () { return __awaiter(_this, void 0, void 0, function () { return __generator(this, function (_a) {
+            return [2, handler(this.clientCommand)];
+        }); }); };
+    };
+    return BatchExecuteStatementCommand;
+}(DynamoDBDocumentClientCommand));
+export { BatchExecuteStatementCommand };

package/dist-es/commands/BatchGetCommand.js

@@ -1,10 +1,12 @@
+import { __awaiter, __extends, __generator } from "tslib";
 import { BatchGetItemCommand as __BatchGetItemCommand, } from "@aws-sdk/client-dynamodb";
 import { DynamoDBDocumentClientCommand } from "../baseCommand/DynamoDBDocumentClientCommand";
-export class BatchGetCommand extends DynamoDBDocumentClientCommand {
-    constructor(input) {
-        super();
-        this.input = input;
-        this.inputKeyNodes = [
+var BatchGetCommand = (function (_super) {
+    __extends(BatchGetCommand, _super);
+    function BatchGetCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        _this.inputKeyNodes = [
             {
                 key: "RequestItems",
                 children: {
@@ -12,7 +14,7 @@ export class BatchGetCommand extends DynamoDBDocumentClientCommand {
                 },
             },
         ];
-        this.outputKeyNodes = [
+        _this.outputKeyNodes = [
             { key: "Responses", children: {} },
             {
                 key: "UnprocessedKeys",
@@ -21,13 +23,19 @@ export class BatchGetCommand extends DynamoDBDocumentClientCommand {
                 },
             },
         ];
-        this.clientCommand = new __BatchGetItemCommand(this.input);
-        this.middlewareStack = this.clientCommand.middlewareStack;
+        _this.clientCommand = new __BatchGetItemCommand(_this.input);
+        _this.middlewareStack = _this.clientCommand.middlewareStack;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    BatchGetCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        var _this = this;
         this.addMarshallingMiddleware(configuration);
-        const stack = clientStack.concat(this.middlewareStack);
-        const handler = this.clientCommand.resolveMiddleware(stack, configuration, options);
-        return async () => handler(this.clientCommand);
-    }
-}
+        var stack = clientStack.concat(this.middlewareStack);
+        var handler = this.clientCommand.resolveMiddleware(stack, configuration, options);
+        return function () { return __awaiter(_this, void 0, void 0, function () { return __generator(this, function (_a) {
+            return [2, handler(this.clientCommand)];
+        }); }); };
+    };
+    return BatchGetCommand;
+}(DynamoDBDocumentClientCommand));
+export { BatchGetCommand };

package/dist-es/commands/BatchWriteCommand.js

@@ -1,10 +1,12 @@
+import { __awaiter, __extends, __generator } from "tslib";
 import { BatchWriteItemCommand as __BatchWriteItemCommand, } from "@aws-sdk/client-dynamodb";
 import { DynamoDBDocumentClientCommand } from "../baseCommand/DynamoDBDocumentClientCommand";
-export class BatchWriteCommand extends DynamoDBDocumentClientCommand {
-    constructor(input) {
-        super();
-        this.input = input;
-        this.inputKeyNodes = [
+var BatchWriteCommand = (function (_super) {
+    __extends(BatchWriteCommand, _super);
+    function BatchWriteCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        _this.inputKeyNodes = [
             {
                 key: "RequestItems",
                 children: {
@@ -15,7 +17,7 @@ export class BatchWriteCommand extends DynamoDBDocumentClientCommand {
                 },
             },
         ];
-        this.outputKeyNodes = [
+        _this.outputKeyNodes = [
             {
                 key: "UnprocessedItems",
                 children: {
@@ -32,13 +34,19 @@ export class BatchWriteCommand extends DynamoDBDocumentClientCommand {
                 },
             },
         ];
-        this.clientCommand = new __BatchWriteItemCommand(this.input);
-        this.middlewareStack = this.clientCommand.middlewareStack;
+        _this.clientCommand = new __BatchWriteItemCommand(_this.input);
+        _this.middlewareStack = _this.clientCommand.middlewareStack;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    BatchWriteCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        var _this = this;
         this.addMarshallingMiddleware(configuration);
-        const stack = clientStack.concat(this.middlewareStack);
-        const handler = this.clientCommand.resolveMiddleware(stack, configuration, options);
-        return async () => handler(this.clientCommand);
-    }
-}
+        var stack = clientStack.concat(this.middlewareStack);
+        var handler = this.clientCommand.resolveMiddleware(stack, configuration, options);
+        return function () { return __awaiter(_this, void 0, void 0, function () { return __generator(this, function (_a) {
+            return [2, handler(this.clientCommand)];
+        }); }); };
+    };
+    return BatchWriteCommand;
+}(DynamoDBDocumentClientCommand));
+export { BatchWriteCommand };

package/dist-es/commands/DeleteCommand.js

@@ -1,10 +1,12 @@
+import { __awaiter, __extends, __generator } from "tslib";
 import { DeleteItemCommand as __DeleteItemCommand, } from "@aws-sdk/client-dynamodb";
 import { DynamoDBDocumentClientCommand } from "../baseCommand/DynamoDBDocumentClientCommand";
-export class DeleteCommand extends DynamoDBDocumentClientCommand {
-    constructor(input) {
-        super();
-        this.input = input;
-        this.inputKeyNodes = [
+var DeleteCommand = (function (_super) {
+    __extends(DeleteCommand, _super);
+    function DeleteCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        _this.inputKeyNodes = [
             { key: "Key" },
             {
                 key: "Expected",
@@ -14,17 +16,23 @@ export class DeleteCommand extends DynamoDBDocumentClientCommand {
             },
             { key: "ExpressionAttributeValues" },
         ];
-        this.outputKeyNodes = [
+        _this.outputKeyNodes = [
             { key: "Attributes" },
             { key: "ItemCollectionMetrics", children: [{ key: "ItemCollectionKey" }] },
         ];
-        this.clientCommand = new __DeleteItemCommand(this.input);
-        this.middlewareStack = this.clientCommand.middlewareStack;
+        _this.clientCommand = new __DeleteItemCommand(_this.input);
+        _this.middlewareStack = _this.clientCommand.middlewareStack;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    DeleteCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        var _this = this;
         this.addMarshallingMiddleware(configuration);
-        const stack = clientStack.concat(this.middlewareStack);
-        const handler = this.clientCommand.resolveMiddleware(stack, configuration, options);
-        return async () => handler(this.clientCommand);
-    }
-}
+        var stack = clientStack.concat(this.middlewareStack);
+        var handler = this.clientCommand.resolveMiddleware(stack, configuration, options);
+        return function () { return __awaiter(_this, void 0, void 0, function () { return __generator(this, function (_a) {
+            return [2, handler(this.clientCommand)];
+        }); }); };
+    };
+    return DeleteCommand;
+}(DynamoDBDocumentClientCommand));
+export { DeleteCommand };

package/dist-es/commands/ExecuteStatementCommand.js

@@ -1,18 +1,26 @@
+import { __awaiter, __extends, __generator } from "tslib";
 import { ExecuteStatementCommand as __ExecuteStatementCommand, } from "@aws-sdk/client-dynamodb";
 import { DynamoDBDocumentClientCommand } from "../baseCommand/DynamoDBDocumentClientCommand";
-export class ExecuteStatementCommand extends DynamoDBDocumentClientCommand {
-    constructor(input) {
-        super();
-        this.input = input;
-        this.inputKeyNodes = [{ key: "Parameters" }];
-        this.outputKeyNodes = [{ key: "Items" }, { key: "LastEvaluatedKey" }];
-        this.clientCommand = new __ExecuteStatementCommand(this.input);
-        this.middlewareStack = this.clientCommand.middlewareStack;
+var ExecuteStatementCommand = (function (_super) {
+    __extends(ExecuteStatementCommand, _super);
+    function ExecuteStatementCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        _this.inputKeyNodes = [{ key: "Parameters" }];
+        _this.outputKeyNodes = [{ key: "Items" }, { key: "LastEvaluatedKey" }];
+        _this.clientCommand = new __ExecuteStatementCommand(_this.input);
+        _this.middlewareStack = _this.clientCommand.middlewareStack;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    ExecuteStatementCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        var _this = this;
         this.addMarshallingMiddleware(configuration);
-        const stack = clientStack.concat(this.middlewareStack);
-        const handler = this.clientCommand.resolveMiddleware(stack, configuration, options);
-        return async () => handler(this.clientCommand);
-    }
-}
+        var stack = clientStack.concat(this.middlewareStack);
+        var handler = this.clientCommand.resolveMiddleware(stack, configuration, options);
+        return function () { return __awaiter(_this, void 0, void 0, function () { return __generator(this, function (_a) {
+            return [2, handler(this.clientCommand)];
+        }); }); };
+    };
+    return ExecuteStatementCommand;
+}(DynamoDBDocumentClientCommand));
+export { ExecuteStatementCommand };