@aws-sdk/client-dynamodb 3.180.0 → 3.183.0

package/dist-es/DynamoDBClient.js

@@ -1,4 +1,3 @@
-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";
@@ -11,34 +10,29 @@ 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";
-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, {
+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, {
             endpointDiscoveryCommandCtor: DescribeEndpointsCommand,
         });
-        _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;
+        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));
     }
-    DynamoDBClient.prototype.destroy = function () {
-        _super.prototype.destroy.call(this);
-    };
-    return DynamoDBClient;
-}(__Client));
-export { DynamoDBClient };
+    destroy() {
+        super.destroy();
+    }
+}

package/dist-es/commands/BatchExecuteStatementCommand.js

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

package/dist-es/commands/BatchGetItemCommand.js

@@ -1,39 +1,32 @@
-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";
-var BatchGetItemCommand = (function (_super) {
-    __extends(BatchGetItemCommand, _super);
-    function BatchGetItemCommand(input) {
-        var _this = _super.call(this) || this;
-        _this.input = input;
-        return _this;
+export class BatchGetItemCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
     }
-    BatchGetItemCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+    resolveMiddleware(clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        var stack = clientStack.concat(this.middlewareStack);
-        var logger = configuration.logger;
-        var clientName = "DynamoDBClient";
-        var commandName = "BatchGetItemCommand";
-        var handlerExecutionContext = {
-            logger: logger,
-            clientName: clientName,
-            commandName: commandName,
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "DynamoDBClient";
+        const commandName = "BatchGetItemCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
             inputFilterSensitiveLog: BatchGetItemInputFilterSensitiveLog,
             outputFilterSensitiveLog: BatchGetItemOutputFilterSensitiveLog,
         };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    BatchGetItemCommand.prototype.serialize = function (input, context) {
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
         return serializeAws_json1_0BatchGetItemCommand(input, context);
-    };
-    BatchGetItemCommand.prototype.deserialize = function (output, context) {
+    }
+    deserialize(output, context) {
         return deserializeAws_json1_0BatchGetItemCommand(output, context);
-    };
-    return BatchGetItemCommand;
-}($Command));
-export { BatchGetItemCommand };
+    }
+}

package/dist-es/commands/BatchWriteItemCommand.js

@@ -1,39 +1,32 @@
-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";
-var BatchWriteItemCommand = (function (_super) {
-    __extends(BatchWriteItemCommand, _super);
-    function BatchWriteItemCommand(input) {
-        var _this = _super.call(this) || this;
-        _this.input = input;
-        return _this;
+export class BatchWriteItemCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
     }
-    BatchWriteItemCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+    resolveMiddleware(clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        var stack = clientStack.concat(this.middlewareStack);
-        var logger = configuration.logger;
-        var clientName = "DynamoDBClient";
-        var commandName = "BatchWriteItemCommand";
-        var handlerExecutionContext = {
-            logger: logger,
-            clientName: clientName,
-            commandName: commandName,
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "DynamoDBClient";
+        const commandName = "BatchWriteItemCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
             inputFilterSensitiveLog: BatchWriteItemInputFilterSensitiveLog,
             outputFilterSensitiveLog: BatchWriteItemOutputFilterSensitiveLog,
         };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    BatchWriteItemCommand.prototype.serialize = function (input, context) {
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
         return serializeAws_json1_0BatchWriteItemCommand(input, context);
-    };
-    BatchWriteItemCommand.prototype.deserialize = function (output, context) {
+    }
+    deserialize(output, context) {
         return deserializeAws_json1_0BatchWriteItemCommand(output, context);
-    };
-    return BatchWriteItemCommand;
-}($Command));
-export { BatchWriteItemCommand };
+    }
+}

package/dist-es/commands/CreateBackupCommand.js

@@ -1,39 +1,32 @@
-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";
-var CreateBackupCommand = (function (_super) {
-    __extends(CreateBackupCommand, _super);
-    function CreateBackupCommand(input) {
-        var _this = _super.call(this) || this;
-        _this.input = input;
-        return _this;
+export class CreateBackupCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
     }
-    CreateBackupCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+    resolveMiddleware(clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        var stack = clientStack.concat(this.middlewareStack);
-        var logger = configuration.logger;
-        var clientName = "DynamoDBClient";
-        var commandName = "CreateBackupCommand";
-        var handlerExecutionContext = {
-            logger: logger,
-            clientName: clientName,
-            commandName: commandName,
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "DynamoDBClient";
+        const commandName = "CreateBackupCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
             inputFilterSensitiveLog: CreateBackupInputFilterSensitiveLog,
             outputFilterSensitiveLog: CreateBackupOutputFilterSensitiveLog,
         };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    CreateBackupCommand.prototype.serialize = function (input, context) {
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
         return serializeAws_json1_0CreateBackupCommand(input, context);
-    };
-    CreateBackupCommand.prototype.deserialize = function (output, context) {
+    }
+    deserialize(output, context) {
         return deserializeAws_json1_0CreateBackupCommand(output, context);
-    };
-    return CreateBackupCommand;
-}($Command));
-export { CreateBackupCommand };
+    }
+}

package/dist-es/commands/CreateGlobalTableCommand.js

@@ -1,39 +1,32 @@
-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";
-var CreateGlobalTableCommand = (function (_super) {
-    __extends(CreateGlobalTableCommand, _super);
-    function CreateGlobalTableCommand(input) {
-        var _this = _super.call(this) || this;
-        _this.input = input;
-        return _this;
+export class CreateGlobalTableCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
     }
-    CreateGlobalTableCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+    resolveMiddleware(clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        var stack = clientStack.concat(this.middlewareStack);
-        var logger = configuration.logger;
-        var clientName = "DynamoDBClient";
-        var commandName = "CreateGlobalTableCommand";
-        var handlerExecutionContext = {
-            logger: logger,
-            clientName: clientName,
-            commandName: commandName,
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "DynamoDBClient";
+        const commandName = "CreateGlobalTableCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
             inputFilterSensitiveLog: CreateGlobalTableInputFilterSensitiveLog,
             outputFilterSensitiveLog: CreateGlobalTableOutputFilterSensitiveLog,
         };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    CreateGlobalTableCommand.prototype.serialize = function (input, context) {
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
         return serializeAws_json1_0CreateGlobalTableCommand(input, context);
-    };
-    CreateGlobalTableCommand.prototype.deserialize = function (output, context) {
+    }
+    deserialize(output, context) {
         return deserializeAws_json1_0CreateGlobalTableCommand(output, context);
-    };
-    return CreateGlobalTableCommand;
-}($Command));
-export { CreateGlobalTableCommand };
+    }
+}

package/dist-es/commands/CreateTableCommand.js

@@ -1,39 +1,32 @@
-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";
-var CreateTableCommand = (function (_super) {
-    __extends(CreateTableCommand, _super);
-    function CreateTableCommand(input) {
-        var _this = _super.call(this) || this;
-        _this.input = input;
-        return _this;
+export class CreateTableCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
     }
-    CreateTableCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+    resolveMiddleware(clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        var stack = clientStack.concat(this.middlewareStack);
-        var logger = configuration.logger;
-        var clientName = "DynamoDBClient";
-        var commandName = "CreateTableCommand";
-        var handlerExecutionContext = {
-            logger: logger,
-            clientName: clientName,
-            commandName: commandName,
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "DynamoDBClient";
+        const commandName = "CreateTableCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
             inputFilterSensitiveLog: CreateTableInputFilterSensitiveLog,
             outputFilterSensitiveLog: CreateTableOutputFilterSensitiveLog,
         };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    CreateTableCommand.prototype.serialize = function (input, context) {
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
         return serializeAws_json1_0CreateTableCommand(input, context);
-    };
-    CreateTableCommand.prototype.deserialize = function (output, context) {
+    }
+    deserialize(output, context) {
         return deserializeAws_json1_0CreateTableCommand(output, context);
-    };
-    return CreateTableCommand;
-}($Command));
-export { CreateTableCommand };
+    }
+}

package/dist-es/commands/DeleteBackupCommand.js

@@ -1,39 +1,32 @@
-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";
-var DeleteBackupCommand = (function (_super) {
-    __extends(DeleteBackupCommand, _super);
-    function DeleteBackupCommand(input) {
-        var _this = _super.call(this) || this;
-        _this.input = input;
-        return _this;
+export class DeleteBackupCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
     }
-    DeleteBackupCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+    resolveMiddleware(clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        var stack = clientStack.concat(this.middlewareStack);
-        var logger = configuration.logger;
-        var clientName = "DynamoDBClient";
-        var commandName = "DeleteBackupCommand";
-        var handlerExecutionContext = {
-            logger: logger,
-            clientName: clientName,
-            commandName: commandName,
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "DynamoDBClient";
+        const commandName = "DeleteBackupCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
             inputFilterSensitiveLog: DeleteBackupInputFilterSensitiveLog,
             outputFilterSensitiveLog: DeleteBackupOutputFilterSensitiveLog,
         };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    DeleteBackupCommand.prototype.serialize = function (input, context) {
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
         return serializeAws_json1_0DeleteBackupCommand(input, context);
-    };
-    DeleteBackupCommand.prototype.deserialize = function (output, context) {
+    }
+    deserialize(output, context) {
         return deserializeAws_json1_0DeleteBackupCommand(output, context);
-    };
-    return DeleteBackupCommand;
-}($Command));
-export { DeleteBackupCommand };
+    }
+}

package/dist-es/commands/DeleteItemCommand.js

@@ -1,39 +1,32 @@
-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";
-var DeleteItemCommand = (function (_super) {
-    __extends(DeleteItemCommand, _super);
-    function DeleteItemCommand(input) {
-        var _this = _super.call(this) || this;
-        _this.input = input;
-        return _this;
+export class DeleteItemCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
     }
-    DeleteItemCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+    resolveMiddleware(clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        var stack = clientStack.concat(this.middlewareStack);
-        var logger = configuration.logger;
-        var clientName = "DynamoDBClient";
-        var commandName = "DeleteItemCommand";
-        var handlerExecutionContext = {
-            logger: logger,
-            clientName: clientName,
-            commandName: commandName,
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "DynamoDBClient";
+        const commandName = "DeleteItemCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
             inputFilterSensitiveLog: DeleteItemInputFilterSensitiveLog,
             outputFilterSensitiveLog: DeleteItemOutputFilterSensitiveLog,
         };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    DeleteItemCommand.prototype.serialize = function (input, context) {
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
         return serializeAws_json1_0DeleteItemCommand(input, context);
-    };
-    DeleteItemCommand.prototype.deserialize = function (output, context) {
+    }
+    deserialize(output, context) {
         return deserializeAws_json1_0DeleteItemCommand(output, context);
-    };
-    return DeleteItemCommand;
-}($Command));
-export { DeleteItemCommand };
+    }
+}

package/dist-es/commands/DeleteTableCommand.js

@@ -1,39 +1,32 @@
-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";
-var DeleteTableCommand = (function (_super) {
-    __extends(DeleteTableCommand, _super);
-    function DeleteTableCommand(input) {
-        var _this = _super.call(this) || this;
-        _this.input = input;
-        return _this;
+export class DeleteTableCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
     }
-    DeleteTableCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+    resolveMiddleware(clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        var stack = clientStack.concat(this.middlewareStack);
-        var logger = configuration.logger;
-        var clientName = "DynamoDBClient";
-        var commandName = "DeleteTableCommand";
-        var handlerExecutionContext = {
-            logger: logger,
-            clientName: clientName,
-            commandName: commandName,
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "DynamoDBClient";
+        const commandName = "DeleteTableCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
             inputFilterSensitiveLog: DeleteTableInputFilterSensitiveLog,
             outputFilterSensitiveLog: DeleteTableOutputFilterSensitiveLog,
         };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    DeleteTableCommand.prototype.serialize = function (input, context) {
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
         return serializeAws_json1_0DeleteTableCommand(input, context);
-    };
-    DeleteTableCommand.prototype.deserialize = function (output, context) {
+    }
+    deserialize(output, context) {
         return deserializeAws_json1_0DeleteTableCommand(output, context);
-    };
-    return DeleteTableCommand;
-}($Command));
-export { DeleteTableCommand };
+    }
+}