@aws-sdk/client-dynamodb 3.183.0 → 3.186.0

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

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

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

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

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

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

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

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

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

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