@aws-sdk/client-lambda 3.183.0 → 3.185.0

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

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

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

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

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

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

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

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

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

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