@aws-sdk/lib-dynamodb 3.186.0 → 3.188.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.188.0](https://github.com/aws/aws-sdk-js-v3/compare/v3.187.0...v3.188.0) (2022-10-13)
+
+**Note:** Version bump only for package @aws-sdk/lib-dynamodb
+
+
+
+
+
 # [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

package/dist-es/DynamoDBDocument.js

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

package/dist-es/DynamoDBDocumentClient.js

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

package/dist-es/baseCommand/DynamoDBDocumentClientCommand.js

@@ -1,45 +1,24 @@
-import { __awaiter, __extends, __generator } from "tslib";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { marshallInput, unmarshallOutput } from "../commands/utils";
-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)];
-                });
-            }); };
+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);
         }, {
             name: "DocumentMarshall",
             step: "initialize",
             override: true,
         });
-        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];
-                    }
-                });
-            }); };
+        this.clientCommand.middlewareStack.add((next) => async (args) => {
+            const deserialized = await next(args);
+            deserialized.output = unmarshallOutput(deserialized.output, this.outputKeyNodes, unmarshallOptions);
+            return deserialized;
         }, {
             name: "DocumentUnmarshall",
             step: "deserialize",
             override: true,
         });
-    };
-    return DynamoDBDocumentClientCommand;
-}($Command));
-export { DynamoDBDocumentClientCommand };
+    }
+}

package/dist-es/commands/BatchExecuteStatementCommand.js

@@ -1,26 +1,18 @@
-import { __awaiter, __extends, __generator } from "tslib";
 import { BatchExecuteStatementCommand as __BatchExecuteStatementCommand, } from "@aws-sdk/client-dynamodb";
 import { DynamoDBDocumentClientCommand } from "../baseCommand/DynamoDBDocumentClientCommand";
-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;
+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;
     }
-    BatchExecuteStatementCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
-        var _this = this;
+    resolveMiddleware(clientStack, configuration, options) {
         this.addMarshallingMiddleware(configuration);
-        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 };
+        const stack = clientStack.concat(this.middlewareStack);
+        const handler = this.clientCommand.resolveMiddleware(stack, configuration, options);
+        return async () => handler(this.clientCommand);
+    }
+}

package/dist-es/commands/BatchGetCommand.js

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

package/dist-es/commands/BatchWriteCommand.js

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

package/dist-es/commands/DeleteCommand.js

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

package/dist-es/commands/ExecuteStatementCommand.js

@@ -1,26 +1,18 @@
-import { __awaiter, __extends, __generator } from "tslib";
 import { ExecuteStatementCommand as __ExecuteStatementCommand, } from "@aws-sdk/client-dynamodb";
 import { DynamoDBDocumentClientCommand } from "../baseCommand/DynamoDBDocumentClientCommand";
-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;
+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;
     }
-    ExecuteStatementCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
-        var _this = this;
+    resolveMiddleware(clientStack, configuration, options) {
         this.addMarshallingMiddleware(configuration);
-        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 };
+        const stack = clientStack.concat(this.middlewareStack);
+        const handler = this.clientCommand.resolveMiddleware(stack, configuration, options);
+        return async () => handler(this.clientCommand);
+    }
+}