@aws-sdk/client-dynamodb 3.183.0 → 3.186.0

package/dist-es/commands/DescribeTableCommand.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 { DescribeTableInputFilterSensitiveLog, DescribeTableOutputFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_0DescribeTableCommand, serializeAws_json1_0DescribeTableCommand, } from "../protocols/Aws_json1_0";
-export class DescribeTableCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var DescribeTableCommand = (function (_super) {
+    __extends(DescribeTableCommand, _super);
+    function DescribeTableCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    DescribeTableCommand.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 = "DescribeTableCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "DynamoDBClient";
+        var commandName = "DescribeTableCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: DescribeTableInputFilterSensitiveLog,
             outputFilterSensitiveLog: DescribeTableOutputFilterSensitiveLog,
         };
-        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);
+    };
+    DescribeTableCommand.prototype.serialize = function (input, context) {
         return serializeAws_json1_0DescribeTableCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    DescribeTableCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_0DescribeTableCommand(output, context);
-    }
-}
+    };
+    return DescribeTableCommand;
+}($Command));
+export { DescribeTableCommand };

package/dist-es/commands/DescribeTableReplicaAutoScalingCommand.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 { DescribeTableReplicaAutoScalingInputFilterSensitiveLog, DescribeTableReplicaAutoScalingOutputFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_0DescribeTableReplicaAutoScalingCommand, serializeAws_json1_0DescribeTableReplicaAutoScalingCommand, } from "../protocols/Aws_json1_0";
-export class DescribeTableReplicaAutoScalingCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var DescribeTableReplicaAutoScalingCommand = (function (_super) {
+    __extends(DescribeTableReplicaAutoScalingCommand, _super);
+    function DescribeTableReplicaAutoScalingCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    DescribeTableReplicaAutoScalingCommand.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 = "DescribeTableReplicaAutoScalingCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "DynamoDBClient";
+        var commandName = "DescribeTableReplicaAutoScalingCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: DescribeTableReplicaAutoScalingInputFilterSensitiveLog,
             outputFilterSensitiveLog: DescribeTableReplicaAutoScalingOutputFilterSensitiveLog,
         };
-        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);
+    };
+    DescribeTableReplicaAutoScalingCommand.prototype.serialize = function (input, context) {
         return serializeAws_json1_0DescribeTableReplicaAutoScalingCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    DescribeTableReplicaAutoScalingCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_0DescribeTableReplicaAutoScalingCommand(output, context);
-    }
-}
+    };
+    return DescribeTableReplicaAutoScalingCommand;
+}($Command));
+export { DescribeTableReplicaAutoScalingCommand };

package/dist-es/commands/DescribeTimeToLiveCommand.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 { DescribeTimeToLiveInputFilterSensitiveLog, DescribeTimeToLiveOutputFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_0DescribeTimeToLiveCommand, serializeAws_json1_0DescribeTimeToLiveCommand, } from "../protocols/Aws_json1_0";
-export class DescribeTimeToLiveCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var DescribeTimeToLiveCommand = (function (_super) {
+    __extends(DescribeTimeToLiveCommand, _super);
+    function DescribeTimeToLiveCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    DescribeTimeToLiveCommand.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 = "DescribeTimeToLiveCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "DynamoDBClient";
+        var commandName = "DescribeTimeToLiveCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: DescribeTimeToLiveInputFilterSensitiveLog,
             outputFilterSensitiveLog: DescribeTimeToLiveOutputFilterSensitiveLog,
         };
-        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);
+    };
+    DescribeTimeToLiveCommand.prototype.serialize = function (input, context) {
         return serializeAws_json1_0DescribeTimeToLiveCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    DescribeTimeToLiveCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_0DescribeTimeToLiveCommand(output, context);
-    }
-}
+    };
+    return DescribeTimeToLiveCommand;
+}($Command));
+export { DescribeTimeToLiveCommand };

package/dist-es/commands/DisableKinesisStreamingDestinationCommand.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 { KinesisStreamingDestinationInputFilterSensitiveLog, KinesisStreamingDestinationOutputFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_0DisableKinesisStreamingDestinationCommand, serializeAws_json1_0DisableKinesisStreamingDestinationCommand, } from "../protocols/Aws_json1_0";
-export class DisableKinesisStreamingDestinationCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var DisableKinesisStreamingDestinationCommand = (function (_super) {
+    __extends(DisableKinesisStreamingDestinationCommand, _super);
+    function DisableKinesisStreamingDestinationCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    DisableKinesisStreamingDestinationCommand.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 = "DisableKinesisStreamingDestinationCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "DynamoDBClient";
+        var commandName = "DisableKinesisStreamingDestinationCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: KinesisStreamingDestinationInputFilterSensitiveLog,
             outputFilterSensitiveLog: KinesisStreamingDestinationOutputFilterSensitiveLog,
         };
-        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);
+    };
+    DisableKinesisStreamingDestinationCommand.prototype.serialize = function (input, context) {
         return serializeAws_json1_0DisableKinesisStreamingDestinationCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    DisableKinesisStreamingDestinationCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_0DisableKinesisStreamingDestinationCommand(output, context);
-    }
-}
+    };
+    return DisableKinesisStreamingDestinationCommand;
+}($Command));
+export { DisableKinesisStreamingDestinationCommand };

package/dist-es/commands/EnableKinesisStreamingDestinationCommand.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 { KinesisStreamingDestinationInputFilterSensitiveLog, KinesisStreamingDestinationOutputFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_0EnableKinesisStreamingDestinationCommand, serializeAws_json1_0EnableKinesisStreamingDestinationCommand, } from "../protocols/Aws_json1_0";
-export class EnableKinesisStreamingDestinationCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var EnableKinesisStreamingDestinationCommand = (function (_super) {
+    __extends(EnableKinesisStreamingDestinationCommand, _super);
+    function EnableKinesisStreamingDestinationCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    EnableKinesisStreamingDestinationCommand.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 = "EnableKinesisStreamingDestinationCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "DynamoDBClient";
+        var commandName = "EnableKinesisStreamingDestinationCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: KinesisStreamingDestinationInputFilterSensitiveLog,
             outputFilterSensitiveLog: KinesisStreamingDestinationOutputFilterSensitiveLog,
         };
-        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);
+    };
+    EnableKinesisStreamingDestinationCommand.prototype.serialize = function (input, context) {
         return serializeAws_json1_0EnableKinesisStreamingDestinationCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    EnableKinesisStreamingDestinationCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_0EnableKinesisStreamingDestinationCommand(output, context);
-    }
-}
+    };
+    return EnableKinesisStreamingDestinationCommand;
+}($Command));
+export { EnableKinesisStreamingDestinationCommand };

package/dist-es/commands/ExecuteStatementCommand.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 { ExecuteStatementInputFilterSensitiveLog, ExecuteStatementOutputFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_0ExecuteStatementCommand, serializeAws_json1_0ExecuteStatementCommand, } from "../protocols/Aws_json1_0";
-export class ExecuteStatementCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var ExecuteStatementCommand = (function (_super) {
+    __extends(ExecuteStatementCommand, _super);
+    function ExecuteStatementCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    ExecuteStatementCommand.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 = "ExecuteStatementCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "DynamoDBClient";
+        var commandName = "ExecuteStatementCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: ExecuteStatementInputFilterSensitiveLog,
             outputFilterSensitiveLog: ExecuteStatementOutputFilterSensitiveLog,
         };
-        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);
+    };
+    ExecuteStatementCommand.prototype.serialize = function (input, context) {
         return serializeAws_json1_0ExecuteStatementCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    ExecuteStatementCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_0ExecuteStatementCommand(output, context);
-    }
-}
+    };
+    return ExecuteStatementCommand;
+}($Command));
+export { ExecuteStatementCommand };

package/dist-es/commands/ExecuteTransactionCommand.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 { ExecuteTransactionInputFilterSensitiveLog, ExecuteTransactionOutputFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_0ExecuteTransactionCommand, serializeAws_json1_0ExecuteTransactionCommand, } from "../protocols/Aws_json1_0";
-export class ExecuteTransactionCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var ExecuteTransactionCommand = (function (_super) {
+    __extends(ExecuteTransactionCommand, _super);
+    function ExecuteTransactionCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    ExecuteTransactionCommand.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 = "ExecuteTransactionCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "DynamoDBClient";
+        var commandName = "ExecuteTransactionCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: ExecuteTransactionInputFilterSensitiveLog,
             outputFilterSensitiveLog: ExecuteTransactionOutputFilterSensitiveLog,
         };
-        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);
+    };
+    ExecuteTransactionCommand.prototype.serialize = function (input, context) {
         return serializeAws_json1_0ExecuteTransactionCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    ExecuteTransactionCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_0ExecuteTransactionCommand(output, context);
-    }
-}
+    };
+    return ExecuteTransactionCommand;
+}($Command));
+export { ExecuteTransactionCommand };

package/dist-es/commands/ExportTableToPointInTimeCommand.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 { ExportTableToPointInTimeInputFilterSensitiveLog, ExportTableToPointInTimeOutputFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_0ExportTableToPointInTimeCommand, serializeAws_json1_0ExportTableToPointInTimeCommand, } from "../protocols/Aws_json1_0";
-export class ExportTableToPointInTimeCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var ExportTableToPointInTimeCommand = (function (_super) {
+    __extends(ExportTableToPointInTimeCommand, _super);
+    function ExportTableToPointInTimeCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    ExportTableToPointInTimeCommand.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 = "ExportTableToPointInTimeCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "DynamoDBClient";
+        var commandName = "ExportTableToPointInTimeCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: ExportTableToPointInTimeInputFilterSensitiveLog,
             outputFilterSensitiveLog: ExportTableToPointInTimeOutputFilterSensitiveLog,
         };
-        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);
+    };
+    ExportTableToPointInTimeCommand.prototype.serialize = function (input, context) {
         return serializeAws_json1_0ExportTableToPointInTimeCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    ExportTableToPointInTimeCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_0ExportTableToPointInTimeCommand(output, context);
-    }
-}
+    };
+    return ExportTableToPointInTimeCommand;
+}($Command));
+export { ExportTableToPointInTimeCommand };

package/dist-es/commands/GetItemCommand.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 { GetItemInputFilterSensitiveLog, GetItemOutputFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_0GetItemCommand, serializeAws_json1_0GetItemCommand } from "../protocols/Aws_json1_0";
-export class GetItemCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var GetItemCommand = (function (_super) {
+    __extends(GetItemCommand, _super);
+    function GetItemCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    GetItemCommand.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 = "GetItemCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "DynamoDBClient";
+        var commandName = "GetItemCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: GetItemInputFilterSensitiveLog,
             outputFilterSensitiveLog: GetItemOutputFilterSensitiveLog,
         };
-        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);
+    };
+    GetItemCommand.prototype.serialize = function (input, context) {
         return serializeAws_json1_0GetItemCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    GetItemCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_0GetItemCommand(output, context);
-    }
-}
+    };
+    return GetItemCommand;
+}($Command));
+export { GetItemCommand };

package/dist-es/commands/ImportTableCommand.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 { ImportTableInputFilterSensitiveLog, ImportTableOutputFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_0ImportTableCommand, serializeAws_json1_0ImportTableCommand, } from "../protocols/Aws_json1_0";
-export class ImportTableCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var ImportTableCommand = (function (_super) {
+    __extends(ImportTableCommand, _super);
+    function ImportTableCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    ImportTableCommand.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 = "ImportTableCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "DynamoDBClient";
+        var commandName = "ImportTableCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: ImportTableInputFilterSensitiveLog,
             outputFilterSensitiveLog: ImportTableOutputFilterSensitiveLog,
         };
-        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);
+    };
+    ImportTableCommand.prototype.serialize = function (input, context) {
         return serializeAws_json1_0ImportTableCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    ImportTableCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_0ImportTableCommand(output, context);
-    }
-}
+    };
+    return ImportTableCommand;
+}($Command));
+export { ImportTableCommand };