@aws-sdk/client-lambda 3.32.0 → 3.36.0

package/dist-es/commands/ListAliasesCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { ListAliasesRequest, ListAliasesResponse } from "../models/models_0";
+import { deserializeAws_restJson1ListAliasesCommand, serializeAws_restJson1ListAliasesCommand, } from "../protocols/Aws_restJson1";
+var ListAliasesCommand = (function (_super) {
+    __extends(ListAliasesCommand, _super);
+    function ListAliasesCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    ListAliasesCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "LambdaClient";
+        var commandName = "ListAliasesCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: ListAliasesRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: ListAliasesResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    ListAliasesCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1ListAliasesCommand(input, context);
+    };
+    ListAliasesCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1ListAliasesCommand(output, context);
+    };
+    return ListAliasesCommand;
+}($Command));
+export { ListAliasesCommand };

package/dist-es/commands/ListCodeSigningConfigsCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { ListCodeSigningConfigsRequest, ListCodeSigningConfigsResponse } from "../models/models_0";
+import { deserializeAws_restJson1ListCodeSigningConfigsCommand, serializeAws_restJson1ListCodeSigningConfigsCommand, } from "../protocols/Aws_restJson1";
+var ListCodeSigningConfigsCommand = (function (_super) {
+    __extends(ListCodeSigningConfigsCommand, _super);
+    function ListCodeSigningConfigsCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    ListCodeSigningConfigsCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "LambdaClient";
+        var commandName = "ListCodeSigningConfigsCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: ListCodeSigningConfigsRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: ListCodeSigningConfigsResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    ListCodeSigningConfigsCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1ListCodeSigningConfigsCommand(input, context);
+    };
+    ListCodeSigningConfigsCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1ListCodeSigningConfigsCommand(output, context);
+    };
+    return ListCodeSigningConfigsCommand;
+}($Command));
+export { ListCodeSigningConfigsCommand };

package/dist-es/commands/ListEventSourceMappingsCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { ListEventSourceMappingsRequest, ListEventSourceMappingsResponse } from "../models/models_0";
+import { deserializeAws_restJson1ListEventSourceMappingsCommand, serializeAws_restJson1ListEventSourceMappingsCommand, } from "../protocols/Aws_restJson1";
+var ListEventSourceMappingsCommand = (function (_super) {
+    __extends(ListEventSourceMappingsCommand, _super);
+    function ListEventSourceMappingsCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    ListEventSourceMappingsCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "LambdaClient";
+        var commandName = "ListEventSourceMappingsCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: ListEventSourceMappingsRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: ListEventSourceMappingsResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    ListEventSourceMappingsCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1ListEventSourceMappingsCommand(input, context);
+    };
+    ListEventSourceMappingsCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1ListEventSourceMappingsCommand(output, context);
+    };
+    return ListEventSourceMappingsCommand;
+}($Command));
+export { ListEventSourceMappingsCommand };

package/dist-es/commands/ListFunctionEventInvokeConfigsCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { ListFunctionEventInvokeConfigsRequest, ListFunctionEventInvokeConfigsResponse } from "../models/models_0";
+import { deserializeAws_restJson1ListFunctionEventInvokeConfigsCommand, serializeAws_restJson1ListFunctionEventInvokeConfigsCommand, } from "../protocols/Aws_restJson1";
+var ListFunctionEventInvokeConfigsCommand = (function (_super) {
+    __extends(ListFunctionEventInvokeConfigsCommand, _super);
+    function ListFunctionEventInvokeConfigsCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    ListFunctionEventInvokeConfigsCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "LambdaClient";
+        var commandName = "ListFunctionEventInvokeConfigsCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: ListFunctionEventInvokeConfigsRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: ListFunctionEventInvokeConfigsResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    ListFunctionEventInvokeConfigsCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1ListFunctionEventInvokeConfigsCommand(input, context);
+    };
+    ListFunctionEventInvokeConfigsCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1ListFunctionEventInvokeConfigsCommand(output, context);
+    };
+    return ListFunctionEventInvokeConfigsCommand;
+}($Command));
+export { ListFunctionEventInvokeConfigsCommand };

package/dist-es/commands/ListFunctionsByCodeSigningConfigCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { ListFunctionsByCodeSigningConfigRequest, ListFunctionsByCodeSigningConfigResponse } from "../models/models_0";
+import { deserializeAws_restJson1ListFunctionsByCodeSigningConfigCommand, serializeAws_restJson1ListFunctionsByCodeSigningConfigCommand, } from "../protocols/Aws_restJson1";
+var ListFunctionsByCodeSigningConfigCommand = (function (_super) {
+    __extends(ListFunctionsByCodeSigningConfigCommand, _super);
+    function ListFunctionsByCodeSigningConfigCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    ListFunctionsByCodeSigningConfigCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        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: ListFunctionsByCodeSigningConfigRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: ListFunctionsByCodeSigningConfigResponse.filterSensitiveLog,
+        };
+        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);
+    };
+    ListFunctionsByCodeSigningConfigCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1ListFunctionsByCodeSigningConfigCommand(output, context);
+    };
+    return ListFunctionsByCodeSigningConfigCommand;
+}($Command));
+export { ListFunctionsByCodeSigningConfigCommand };

package/dist-es/commands/ListFunctionsCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { ListFunctionsRequest, ListFunctionsResponse } from "../models/models_0";
+import { deserializeAws_restJson1ListFunctionsCommand, serializeAws_restJson1ListFunctionsCommand, } from "../protocols/Aws_restJson1";
+var ListFunctionsCommand = (function (_super) {
+    __extends(ListFunctionsCommand, _super);
+    function ListFunctionsCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    ListFunctionsCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        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: ListFunctionsRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: ListFunctionsResponse.filterSensitiveLog,
+        };
+        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);
+    };
+    ListFunctionsCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1ListFunctionsCommand(output, context);
+    };
+    return ListFunctionsCommand;
+}($Command));
+export { ListFunctionsCommand };

package/dist-es/commands/ListLayerVersionsCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { ListLayerVersionsRequest, ListLayerVersionsResponse } from "../models/models_0";
+import { deserializeAws_restJson1ListLayerVersionsCommand, serializeAws_restJson1ListLayerVersionsCommand, } from "../protocols/Aws_restJson1";
+var ListLayerVersionsCommand = (function (_super) {
+    __extends(ListLayerVersionsCommand, _super);
+    function ListLayerVersionsCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    ListLayerVersionsCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        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: ListLayerVersionsRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: ListLayerVersionsResponse.filterSensitiveLog,
+        };
+        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);
+    };
+    ListLayerVersionsCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1ListLayerVersionsCommand(output, context);
+    };
+    return ListLayerVersionsCommand;
+}($Command));
+export { ListLayerVersionsCommand };

package/dist-es/commands/ListLayersCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { ListLayersRequest, ListLayersResponse } from "../models/models_0";
+import { deserializeAws_restJson1ListLayersCommand, serializeAws_restJson1ListLayersCommand, } from "../protocols/Aws_restJson1";
+var ListLayersCommand = (function (_super) {
+    __extends(ListLayersCommand, _super);
+    function ListLayersCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    ListLayersCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        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: ListLayersRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: ListLayersResponse.filterSensitiveLog,
+        };
+        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);
+    };
+    ListLayersCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1ListLayersCommand(output, context);
+    };
+    return ListLayersCommand;
+}($Command));
+export { ListLayersCommand };

package/dist-es/commands/ListProvisionedConcurrencyConfigsCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { ListProvisionedConcurrencyConfigsRequest, ListProvisionedConcurrencyConfigsResponse, } from "../models/models_0";
+import { deserializeAws_restJson1ListProvisionedConcurrencyConfigsCommand, serializeAws_restJson1ListProvisionedConcurrencyConfigsCommand, } from "../protocols/Aws_restJson1";
+var ListProvisionedConcurrencyConfigsCommand = (function (_super) {
+    __extends(ListProvisionedConcurrencyConfigsCommand, _super);
+    function ListProvisionedConcurrencyConfigsCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    ListProvisionedConcurrencyConfigsCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        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: ListProvisionedConcurrencyConfigsRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: ListProvisionedConcurrencyConfigsResponse.filterSensitiveLog,
+        };
+        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);
+    };
+    ListProvisionedConcurrencyConfigsCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1ListProvisionedConcurrencyConfigsCommand(output, context);
+    };
+    return ListProvisionedConcurrencyConfigsCommand;
+}($Command));
+export { ListProvisionedConcurrencyConfigsCommand };

package/dist-es/commands/ListTagsCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { ListTagsRequest, ListTagsResponse } from "../models/models_0";
+import { deserializeAws_restJson1ListTagsCommand, serializeAws_restJson1ListTagsCommand, } from "../protocols/Aws_restJson1";
+var ListTagsCommand = (function (_super) {
+    __extends(ListTagsCommand, _super);
+    function ListTagsCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    ListTagsCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        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: ListTagsRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: ListTagsResponse.filterSensitiveLog,
+        };
+        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);
+    };
+    ListTagsCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1ListTagsCommand(output, context);
+    };
+    return ListTagsCommand;
+}($Command));
+export { ListTagsCommand };

package/dist-es/commands/ListVersionsByFunctionCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { ListVersionsByFunctionRequest, ListVersionsByFunctionResponse } from "../models/models_0";
+import { deserializeAws_restJson1ListVersionsByFunctionCommand, serializeAws_restJson1ListVersionsByFunctionCommand, } from "../protocols/Aws_restJson1";
+var ListVersionsByFunctionCommand = (function (_super) {
+    __extends(ListVersionsByFunctionCommand, _super);
+    function ListVersionsByFunctionCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    ListVersionsByFunctionCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        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: ListVersionsByFunctionRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: ListVersionsByFunctionResponse.filterSensitiveLog,
+        };
+        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);
+    };
+    ListVersionsByFunctionCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1ListVersionsByFunctionCommand(output, context);
+    };
+    return ListVersionsByFunctionCommand;
+}($Command));
+export { ListVersionsByFunctionCommand };

package/dist-es/commands/PublishLayerVersionCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { PublishLayerVersionRequest, PublishLayerVersionResponse } from "../models/models_0";
+import { deserializeAws_restJson1PublishLayerVersionCommand, serializeAws_restJson1PublishLayerVersionCommand, } from "../protocols/Aws_restJson1";
+var PublishLayerVersionCommand = (function (_super) {
+    __extends(PublishLayerVersionCommand, _super);
+    function PublishLayerVersionCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    PublishLayerVersionCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        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: PublishLayerVersionRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: PublishLayerVersionResponse.filterSensitiveLog,
+        };
+        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);
+    };
+    PublishLayerVersionCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1PublishLayerVersionCommand(output, context);
+    };
+    return PublishLayerVersionCommand;
+}($Command));
+export { PublishLayerVersionCommand };

package/dist-es/commands/PublishVersionCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { FunctionConfiguration, PublishVersionRequest } from "../models/models_0";
+import { deserializeAws_restJson1PublishVersionCommand, serializeAws_restJson1PublishVersionCommand, } from "../protocols/Aws_restJson1";
+var PublishVersionCommand = (function (_super) {
+    __extends(PublishVersionCommand, _super);
+    function PublishVersionCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    PublishVersionCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        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: PublishVersionRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: FunctionConfiguration.filterSensitiveLog,
+        };
+        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);
+    };
+    PublishVersionCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1PublishVersionCommand(output, context);
+    };
+    return PublishVersionCommand;
+}($Command));
+export { PublishVersionCommand };

package/dist-es/commands/PutFunctionCodeSigningConfigCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { PutFunctionCodeSigningConfigRequest, PutFunctionCodeSigningConfigResponse } from "../models/models_0";
+import { deserializeAws_restJson1PutFunctionCodeSigningConfigCommand, serializeAws_restJson1PutFunctionCodeSigningConfigCommand, } from "../protocols/Aws_restJson1";
+var PutFunctionCodeSigningConfigCommand = (function (_super) {
+    __extends(PutFunctionCodeSigningConfigCommand, _super);
+    function PutFunctionCodeSigningConfigCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    PutFunctionCodeSigningConfigCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        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: PutFunctionCodeSigningConfigRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: PutFunctionCodeSigningConfigResponse.filterSensitiveLog,
+        };
+        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);
+    };
+    PutFunctionCodeSigningConfigCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1PutFunctionCodeSigningConfigCommand(output, context);
+    };
+    return PutFunctionCodeSigningConfigCommand;
+}($Command));
+export { PutFunctionCodeSigningConfigCommand };

package/dist-es/commands/PutFunctionConcurrencyCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Concurrency, PutFunctionConcurrencyRequest } from "../models/models_0";
+import { deserializeAws_restJson1PutFunctionConcurrencyCommand, serializeAws_restJson1PutFunctionConcurrencyCommand, } from "../protocols/Aws_restJson1";
+var PutFunctionConcurrencyCommand = (function (_super) {
+    __extends(PutFunctionConcurrencyCommand, _super);
+    function PutFunctionConcurrencyCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    PutFunctionConcurrencyCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "LambdaClient";
+        var commandName = "PutFunctionConcurrencyCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: PutFunctionConcurrencyRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: Concurrency.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    PutFunctionConcurrencyCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1PutFunctionConcurrencyCommand(input, context);
+    };
+    PutFunctionConcurrencyCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1PutFunctionConcurrencyCommand(output, context);
+    };
+    return PutFunctionConcurrencyCommand;
+}($Command));
+export { PutFunctionConcurrencyCommand };

package/dist-es/commands/PutFunctionEventInvokeConfigCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { FunctionEventInvokeConfig, PutFunctionEventInvokeConfigRequest } from "../models/models_0";
+import { deserializeAws_restJson1PutFunctionEventInvokeConfigCommand, serializeAws_restJson1PutFunctionEventInvokeConfigCommand, } from "../protocols/Aws_restJson1";
+var PutFunctionEventInvokeConfigCommand = (function (_super) {
+    __extends(PutFunctionEventInvokeConfigCommand, _super);
+    function PutFunctionEventInvokeConfigCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    PutFunctionEventInvokeConfigCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "LambdaClient";
+        var commandName = "PutFunctionEventInvokeConfigCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: PutFunctionEventInvokeConfigRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: FunctionEventInvokeConfig.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    PutFunctionEventInvokeConfigCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1PutFunctionEventInvokeConfigCommand(input, context);
+    };
+    PutFunctionEventInvokeConfigCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1PutFunctionEventInvokeConfigCommand(output, context);
+    };
+    return PutFunctionEventInvokeConfigCommand;
+}($Command));
+export { PutFunctionEventInvokeConfigCommand };