@aws-sdk/client-dynamodb 3.183.0 → 3.186.0

package/dist-es/DynamoDBClient.js

@@ -1,3 +1,4 @@
+import { __extends } from "tslib";
 import { resolveEndpointsConfig, resolveRegionConfig, } from "@aws-sdk/config-resolver";
 import { getContentLengthPlugin } from "@aws-sdk/middleware-content-length";
 import { resolveEndpointDiscoveryConfig, } from "@aws-sdk/middleware-endpoint-discovery";
@@ -10,29 +11,34 @@ import { getUserAgentPlugin, resolveUserAgentConfig, } from "@aws-sdk/middleware
 import { Client as __Client, } from "@aws-sdk/smithy-client";
 import { DescribeEndpointsCommand, } from "./commands/DescribeEndpointsCommand";
 import { getRuntimeConfig as __getRuntimeConfig } from "./runtimeConfig";
-export class DynamoDBClient extends __Client {
-    constructor(configuration) {
-        const _config_0 = __getRuntimeConfig(configuration);
-        const _config_1 = resolveRegionConfig(_config_0);
-        const _config_2 = resolveEndpointsConfig(_config_1);
-        const _config_3 = resolveRetryConfig(_config_2);
-        const _config_4 = resolveHostHeaderConfig(_config_3);
-        const _config_5 = resolveAwsAuthConfig(_config_4);
-        const _config_6 = resolveUserAgentConfig(_config_5);
-        const _config_7 = resolveEndpointDiscoveryConfig(_config_6, {
+var DynamoDBClient = (function (_super) {
+    __extends(DynamoDBClient, _super);
+    function DynamoDBClient(configuration) {
+        var _this = this;
+        var _config_0 = __getRuntimeConfig(configuration);
+        var _config_1 = resolveRegionConfig(_config_0);
+        var _config_2 = resolveEndpointsConfig(_config_1);
+        var _config_3 = resolveRetryConfig(_config_2);
+        var _config_4 = resolveHostHeaderConfig(_config_3);
+        var _config_5 = resolveAwsAuthConfig(_config_4);
+        var _config_6 = resolveUserAgentConfig(_config_5);
+        var _config_7 = resolveEndpointDiscoveryConfig(_config_6, {
             endpointDiscoveryCommandCtor: DescribeEndpointsCommand,
         });
-        super(_config_7);
-        this.config = _config_7;
-        this.middlewareStack.use(getRetryPlugin(this.config));
-        this.middlewareStack.use(getContentLengthPlugin(this.config));
-        this.middlewareStack.use(getHostHeaderPlugin(this.config));
-        this.middlewareStack.use(getLoggerPlugin(this.config));
-        this.middlewareStack.use(getRecursionDetectionPlugin(this.config));
-        this.middlewareStack.use(getAwsAuthPlugin(this.config));
-        this.middlewareStack.use(getUserAgentPlugin(this.config));
+        _this = _super.call(this, _config_7) || this;
+        _this.config = _config_7;
+        _this.middlewareStack.use(getRetryPlugin(_this.config));
+        _this.middlewareStack.use(getContentLengthPlugin(_this.config));
+        _this.middlewareStack.use(getHostHeaderPlugin(_this.config));
+        _this.middlewareStack.use(getLoggerPlugin(_this.config));
+        _this.middlewareStack.use(getRecursionDetectionPlugin(_this.config));
+        _this.middlewareStack.use(getAwsAuthPlugin(_this.config));
+        _this.middlewareStack.use(getUserAgentPlugin(_this.config));
+        return _this;
     }
-    destroy() {
-        super.destroy();
-    }
-}
+    DynamoDBClient.prototype.destroy = function () {
+        _super.prototype.destroy.call(this);
+    };
+    return DynamoDBClient;
+}(__Client));
+export { DynamoDBClient };

package/dist-es/commands/BatchExecuteStatementCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { BatchExecuteStatementInputFilterSensitiveLog, BatchExecuteStatementOutputFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_0BatchExecuteStatementCommand, serializeAws_json1_0BatchExecuteStatementCommand, } from "../protocols/Aws_json1_0";
-export class BatchExecuteStatementCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var BatchExecuteStatementCommand = (function (_super) {
+    __extends(BatchExecuteStatementCommand, _super);
+    function BatchExecuteStatementCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    BatchExecuteStatementCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "DynamoDBClient";
-        const commandName = "BatchExecuteStatementCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "DynamoDBClient";
+        var commandName = "BatchExecuteStatementCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: BatchExecuteStatementInputFilterSensitiveLog,
             outputFilterSensitiveLog: BatchExecuteStatementOutputFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        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_0BatchExecuteStatementCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    BatchExecuteStatementCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_0BatchExecuteStatementCommand(output, context);
-    }
-}
+    };
+    return BatchExecuteStatementCommand;
+}($Command));
+export { BatchExecuteStatementCommand };

package/dist-es/commands/BatchGetItemCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { BatchGetItemInputFilterSensitiveLog, BatchGetItemOutputFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_0BatchGetItemCommand, serializeAws_json1_0BatchGetItemCommand, } from "../protocols/Aws_json1_0";
-export class BatchGetItemCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var BatchGetItemCommand = (function (_super) {
+    __extends(BatchGetItemCommand, _super);
+    function BatchGetItemCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    BatchGetItemCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "DynamoDBClient";
-        const commandName = "BatchGetItemCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "DynamoDBClient";
+        var commandName = "BatchGetItemCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: BatchGetItemInputFilterSensitiveLog,
             outputFilterSensitiveLog: BatchGetItemOutputFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    BatchGetItemCommand.prototype.serialize = function (input, context) {
         return serializeAws_json1_0BatchGetItemCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    BatchGetItemCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_0BatchGetItemCommand(output, context);
-    }
-}
+    };
+    return BatchGetItemCommand;
+}($Command));
+export { BatchGetItemCommand };

package/dist-es/commands/BatchWriteItemCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { BatchWriteItemInputFilterSensitiveLog, BatchWriteItemOutputFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_0BatchWriteItemCommand, serializeAws_json1_0BatchWriteItemCommand, } from "../protocols/Aws_json1_0";
-export class BatchWriteItemCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var BatchWriteItemCommand = (function (_super) {
+    __extends(BatchWriteItemCommand, _super);
+    function BatchWriteItemCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    BatchWriteItemCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "DynamoDBClient";
-        const commandName = "BatchWriteItemCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "DynamoDBClient";
+        var commandName = "BatchWriteItemCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: BatchWriteItemInputFilterSensitiveLog,
             outputFilterSensitiveLog: BatchWriteItemOutputFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    BatchWriteItemCommand.prototype.serialize = function (input, context) {
         return serializeAws_json1_0BatchWriteItemCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    BatchWriteItemCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_0BatchWriteItemCommand(output, context);
-    }
-}
+    };
+    return BatchWriteItemCommand;
+}($Command));
+export { BatchWriteItemCommand };

package/dist-es/commands/CreateBackupCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { CreateBackupInputFilterSensitiveLog, CreateBackupOutputFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_0CreateBackupCommand, serializeAws_json1_0CreateBackupCommand, } from "../protocols/Aws_json1_0";
-export class CreateBackupCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var CreateBackupCommand = (function (_super) {
+    __extends(CreateBackupCommand, _super);
+    function CreateBackupCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    CreateBackupCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "DynamoDBClient";
-        const commandName = "CreateBackupCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "DynamoDBClient";
+        var commandName = "CreateBackupCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: CreateBackupInputFilterSensitiveLog,
             outputFilterSensitiveLog: CreateBackupOutputFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    CreateBackupCommand.prototype.serialize = function (input, context) {
         return serializeAws_json1_0CreateBackupCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    CreateBackupCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_0CreateBackupCommand(output, context);
-    }
-}
+    };
+    return CreateBackupCommand;
+}($Command));
+export { CreateBackupCommand };

package/dist-es/commands/CreateGlobalTableCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { CreateGlobalTableInputFilterSensitiveLog, CreateGlobalTableOutputFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_0CreateGlobalTableCommand, serializeAws_json1_0CreateGlobalTableCommand, } from "../protocols/Aws_json1_0";
-export class CreateGlobalTableCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var CreateGlobalTableCommand = (function (_super) {
+    __extends(CreateGlobalTableCommand, _super);
+    function CreateGlobalTableCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    CreateGlobalTableCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "DynamoDBClient";
-        const commandName = "CreateGlobalTableCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "DynamoDBClient";
+        var commandName = "CreateGlobalTableCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: CreateGlobalTableInputFilterSensitiveLog,
             outputFilterSensitiveLog: CreateGlobalTableOutputFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    CreateGlobalTableCommand.prototype.serialize = function (input, context) {
         return serializeAws_json1_0CreateGlobalTableCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    CreateGlobalTableCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_0CreateGlobalTableCommand(output, context);
-    }
-}
+    };
+    return CreateGlobalTableCommand;
+}($Command));
+export { CreateGlobalTableCommand };

package/dist-es/commands/CreateTableCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { CreateTableInputFilterSensitiveLog, CreateTableOutputFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_0CreateTableCommand, serializeAws_json1_0CreateTableCommand, } from "../protocols/Aws_json1_0";
-export class CreateTableCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var CreateTableCommand = (function (_super) {
+    __extends(CreateTableCommand, _super);
+    function CreateTableCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    CreateTableCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "DynamoDBClient";
-        const commandName = "CreateTableCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "DynamoDBClient";
+        var commandName = "CreateTableCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: CreateTableInputFilterSensitiveLog,
             outputFilterSensitiveLog: CreateTableOutputFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    CreateTableCommand.prototype.serialize = function (input, context) {
         return serializeAws_json1_0CreateTableCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    CreateTableCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_0CreateTableCommand(output, context);
-    }
-}
+    };
+    return CreateTableCommand;
+}($Command));
+export { CreateTableCommand };

package/dist-es/commands/DeleteBackupCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { DeleteBackupInputFilterSensitiveLog, DeleteBackupOutputFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_0DeleteBackupCommand, serializeAws_json1_0DeleteBackupCommand, } from "../protocols/Aws_json1_0";
-export class DeleteBackupCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var DeleteBackupCommand = (function (_super) {
+    __extends(DeleteBackupCommand, _super);
+    function DeleteBackupCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    DeleteBackupCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "DynamoDBClient";
-        const commandName = "DeleteBackupCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "DynamoDBClient";
+        var commandName = "DeleteBackupCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: DeleteBackupInputFilterSensitiveLog,
             outputFilterSensitiveLog: DeleteBackupOutputFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    DeleteBackupCommand.prototype.serialize = function (input, context) {
         return serializeAws_json1_0DeleteBackupCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    DeleteBackupCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_0DeleteBackupCommand(output, context);
-    }
-}
+    };
+    return DeleteBackupCommand;
+}($Command));
+export { DeleteBackupCommand };

package/dist-es/commands/DeleteItemCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { DeleteItemInputFilterSensitiveLog, DeleteItemOutputFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_0DeleteItemCommand, serializeAws_json1_0DeleteItemCommand, } from "../protocols/Aws_json1_0";
-export class DeleteItemCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var DeleteItemCommand = (function (_super) {
+    __extends(DeleteItemCommand, _super);
+    function DeleteItemCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    DeleteItemCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "DynamoDBClient";
-        const commandName = "DeleteItemCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "DynamoDBClient";
+        var commandName = "DeleteItemCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: DeleteItemInputFilterSensitiveLog,
             outputFilterSensitiveLog: DeleteItemOutputFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    DeleteItemCommand.prototype.serialize = function (input, context) {
         return serializeAws_json1_0DeleteItemCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    DeleteItemCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_0DeleteItemCommand(output, context);
-    }
-}
+    };
+    return DeleteItemCommand;
+}($Command));
+export { DeleteItemCommand };

package/dist-es/commands/DeleteTableCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { DeleteTableInputFilterSensitiveLog, DeleteTableOutputFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_0DeleteTableCommand, serializeAws_json1_0DeleteTableCommand, } from "../protocols/Aws_json1_0";
-export class DeleteTableCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var DeleteTableCommand = (function (_super) {
+    __extends(DeleteTableCommand, _super);
+    function DeleteTableCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    DeleteTableCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "DynamoDBClient";
-        const commandName = "DeleteTableCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "DynamoDBClient";
+        var commandName = "DeleteTableCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: DeleteTableInputFilterSensitiveLog,
             outputFilterSensitiveLog: DeleteTableOutputFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    DeleteTableCommand.prototype.serialize = function (input, context) {
         return serializeAws_json1_0DeleteTableCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    DeleteTableCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_0DeleteTableCommand(output, context);
-    }
-}
+    };
+    return DeleteTableCommand;
+}($Command));
+export { DeleteTableCommand };