@aws-sdk/client-lambda 3.32.0 → 3.36.0

package/dist-es/commands/GetAccountSettingsCommand.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 { GetAccountSettingsRequest, GetAccountSettingsResponse } from "../models/models_0";
+import { deserializeAws_restJson1GetAccountSettingsCommand, serializeAws_restJson1GetAccountSettingsCommand, } from "../protocols/Aws_restJson1";
+var GetAccountSettingsCommand = (function (_super) {
+    __extends(GetAccountSettingsCommand, _super);
+    function GetAccountSettingsCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    GetAccountSettingsCommand.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 = "GetAccountSettingsCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: GetAccountSettingsRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: GetAccountSettingsResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    GetAccountSettingsCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1GetAccountSettingsCommand(input, context);
+    };
+    GetAccountSettingsCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1GetAccountSettingsCommand(output, context);
+    };
+    return GetAccountSettingsCommand;
+}($Command));
+export { GetAccountSettingsCommand };

package/dist-es/commands/GetAliasCommand.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 { AliasConfiguration, GetAliasRequest } from "../models/models_0";
+import { deserializeAws_restJson1GetAliasCommand, serializeAws_restJson1GetAliasCommand, } from "../protocols/Aws_restJson1";
+var GetAliasCommand = (function (_super) {
+    __extends(GetAliasCommand, _super);
+    function GetAliasCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    GetAliasCommand.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 = "GetAliasCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: GetAliasRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: AliasConfiguration.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    GetAliasCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1GetAliasCommand(input, context);
+    };
+    GetAliasCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1GetAliasCommand(output, context);
+    };
+    return GetAliasCommand;
+}($Command));
+export { GetAliasCommand };

package/dist-es/commands/GetCodeSigningConfigCommand.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 { GetCodeSigningConfigRequest, GetCodeSigningConfigResponse } from "../models/models_0";
+import { deserializeAws_restJson1GetCodeSigningConfigCommand, serializeAws_restJson1GetCodeSigningConfigCommand, } from "../protocols/Aws_restJson1";
+var GetCodeSigningConfigCommand = (function (_super) {
+    __extends(GetCodeSigningConfigCommand, _super);
+    function GetCodeSigningConfigCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    GetCodeSigningConfigCommand.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 = "GetCodeSigningConfigCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: GetCodeSigningConfigRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: GetCodeSigningConfigResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    GetCodeSigningConfigCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1GetCodeSigningConfigCommand(input, context);
+    };
+    GetCodeSigningConfigCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1GetCodeSigningConfigCommand(output, context);
+    };
+    return GetCodeSigningConfigCommand;
+}($Command));
+export { GetCodeSigningConfigCommand };

package/dist-es/commands/GetEventSourceMappingCommand.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 { EventSourceMappingConfiguration, GetEventSourceMappingRequest } from "../models/models_0";
+import { deserializeAws_restJson1GetEventSourceMappingCommand, serializeAws_restJson1GetEventSourceMappingCommand, } from "../protocols/Aws_restJson1";
+var GetEventSourceMappingCommand = (function (_super) {
+    __extends(GetEventSourceMappingCommand, _super);
+    function GetEventSourceMappingCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    GetEventSourceMappingCommand.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 = "GetEventSourceMappingCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: GetEventSourceMappingRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: EventSourceMappingConfiguration.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    GetEventSourceMappingCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1GetEventSourceMappingCommand(input, context);
+    };
+    GetEventSourceMappingCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1GetEventSourceMappingCommand(output, context);
+    };
+    return GetEventSourceMappingCommand;
+}($Command));
+export { GetEventSourceMappingCommand };

package/dist-es/commands/GetFunctionCodeSigningConfigCommand.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 { GetFunctionCodeSigningConfigRequest, GetFunctionCodeSigningConfigResponse } from "../models/models_0";
+import { deserializeAws_restJson1GetFunctionCodeSigningConfigCommand, serializeAws_restJson1GetFunctionCodeSigningConfigCommand, } from "../protocols/Aws_restJson1";
+var GetFunctionCodeSigningConfigCommand = (function (_super) {
+    __extends(GetFunctionCodeSigningConfigCommand, _super);
+    function GetFunctionCodeSigningConfigCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    GetFunctionCodeSigningConfigCommand.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 = "GetFunctionCodeSigningConfigCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: GetFunctionCodeSigningConfigRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: GetFunctionCodeSigningConfigResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    GetFunctionCodeSigningConfigCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1GetFunctionCodeSigningConfigCommand(input, context);
+    };
+    GetFunctionCodeSigningConfigCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1GetFunctionCodeSigningConfigCommand(output, context);
+    };
+    return GetFunctionCodeSigningConfigCommand;
+}($Command));
+export { GetFunctionCodeSigningConfigCommand };

package/dist-es/commands/GetFunctionCommand.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 { GetFunctionRequest, GetFunctionResponse } from "../models/models_0";
+import { deserializeAws_restJson1GetFunctionCommand, serializeAws_restJson1GetFunctionCommand, } from "../protocols/Aws_restJson1";
+var GetFunctionCommand = (function (_super) {
+    __extends(GetFunctionCommand, _super);
+    function GetFunctionCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    GetFunctionCommand.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 = "GetFunctionCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: GetFunctionRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: GetFunctionResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    GetFunctionCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1GetFunctionCommand(input, context);
+    };
+    GetFunctionCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1GetFunctionCommand(output, context);
+    };
+    return GetFunctionCommand;
+}($Command));
+export { GetFunctionCommand };

package/dist-es/commands/GetFunctionConcurrencyCommand.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 { GetFunctionConcurrencyRequest, GetFunctionConcurrencyResponse } from "../models/models_0";
+import { deserializeAws_restJson1GetFunctionConcurrencyCommand, serializeAws_restJson1GetFunctionConcurrencyCommand, } from "../protocols/Aws_restJson1";
+var GetFunctionConcurrencyCommand = (function (_super) {
+    __extends(GetFunctionConcurrencyCommand, _super);
+    function GetFunctionConcurrencyCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    GetFunctionConcurrencyCommand.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 = "GetFunctionConcurrencyCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: GetFunctionConcurrencyRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: GetFunctionConcurrencyResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    GetFunctionConcurrencyCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1GetFunctionConcurrencyCommand(input, context);
+    };
+    GetFunctionConcurrencyCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1GetFunctionConcurrencyCommand(output, context);
+    };
+    return GetFunctionConcurrencyCommand;
+}($Command));
+export { GetFunctionConcurrencyCommand };

package/dist-es/commands/GetFunctionConfigurationCommand.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, GetFunctionConfigurationRequest } from "../models/models_0";
+import { deserializeAws_restJson1GetFunctionConfigurationCommand, serializeAws_restJson1GetFunctionConfigurationCommand, } from "../protocols/Aws_restJson1";
+var GetFunctionConfigurationCommand = (function (_super) {
+    __extends(GetFunctionConfigurationCommand, _super);
+    function GetFunctionConfigurationCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    GetFunctionConfigurationCommand.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 = "GetFunctionConfigurationCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: GetFunctionConfigurationRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: FunctionConfiguration.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    GetFunctionConfigurationCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1GetFunctionConfigurationCommand(input, context);
+    };
+    GetFunctionConfigurationCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1GetFunctionConfigurationCommand(output, context);
+    };
+    return GetFunctionConfigurationCommand;
+}($Command));
+export { GetFunctionConfigurationCommand };

package/dist-es/commands/GetFunctionEventInvokeConfigCommand.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, GetFunctionEventInvokeConfigRequest } from "../models/models_0";
+import { deserializeAws_restJson1GetFunctionEventInvokeConfigCommand, serializeAws_restJson1GetFunctionEventInvokeConfigCommand, } from "../protocols/Aws_restJson1";
+var GetFunctionEventInvokeConfigCommand = (function (_super) {
+    __extends(GetFunctionEventInvokeConfigCommand, _super);
+    function GetFunctionEventInvokeConfigCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    GetFunctionEventInvokeConfigCommand.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 = "GetFunctionEventInvokeConfigCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: GetFunctionEventInvokeConfigRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: FunctionEventInvokeConfig.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    GetFunctionEventInvokeConfigCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1GetFunctionEventInvokeConfigCommand(input, context);
+    };
+    GetFunctionEventInvokeConfigCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1GetFunctionEventInvokeConfigCommand(output, context);
+    };
+    return GetFunctionEventInvokeConfigCommand;
+}($Command));
+export { GetFunctionEventInvokeConfigCommand };

package/dist-es/commands/GetLayerVersionByArnCommand.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 { GetLayerVersionByArnRequest, GetLayerVersionResponse } from "../models/models_0";
+import { deserializeAws_restJson1GetLayerVersionByArnCommand, serializeAws_restJson1GetLayerVersionByArnCommand, } from "../protocols/Aws_restJson1";
+var GetLayerVersionByArnCommand = (function (_super) {
+    __extends(GetLayerVersionByArnCommand, _super);
+    function GetLayerVersionByArnCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    GetLayerVersionByArnCommand.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 = "GetLayerVersionByArnCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: GetLayerVersionByArnRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: GetLayerVersionResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    GetLayerVersionByArnCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1GetLayerVersionByArnCommand(input, context);
+    };
+    GetLayerVersionByArnCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1GetLayerVersionByArnCommand(output, context);
+    };
+    return GetLayerVersionByArnCommand;
+}($Command));
+export { GetLayerVersionByArnCommand };

package/dist-es/commands/GetLayerVersionCommand.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 { GetLayerVersionRequest, GetLayerVersionResponse } from "../models/models_0";
+import { deserializeAws_restJson1GetLayerVersionCommand, serializeAws_restJson1GetLayerVersionCommand, } from "../protocols/Aws_restJson1";
+var GetLayerVersionCommand = (function (_super) {
+    __extends(GetLayerVersionCommand, _super);
+    function GetLayerVersionCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    GetLayerVersionCommand.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 = "GetLayerVersionCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: GetLayerVersionRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: GetLayerVersionResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    GetLayerVersionCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1GetLayerVersionCommand(input, context);
+    };
+    GetLayerVersionCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1GetLayerVersionCommand(output, context);
+    };
+    return GetLayerVersionCommand;
+}($Command));
+export { GetLayerVersionCommand };

package/dist-es/commands/GetLayerVersionPolicyCommand.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 { GetLayerVersionPolicyRequest, GetLayerVersionPolicyResponse } from "../models/models_0";
+import { deserializeAws_restJson1GetLayerVersionPolicyCommand, serializeAws_restJson1GetLayerVersionPolicyCommand, } from "../protocols/Aws_restJson1";
+var GetLayerVersionPolicyCommand = (function (_super) {
+    __extends(GetLayerVersionPolicyCommand, _super);
+    function GetLayerVersionPolicyCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    GetLayerVersionPolicyCommand.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 = "GetLayerVersionPolicyCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: GetLayerVersionPolicyRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: GetLayerVersionPolicyResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    GetLayerVersionPolicyCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1GetLayerVersionPolicyCommand(input, context);
+    };
+    GetLayerVersionPolicyCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1GetLayerVersionPolicyCommand(output, context);
+    };
+    return GetLayerVersionPolicyCommand;
+}($Command));
+export { GetLayerVersionPolicyCommand };

package/dist-es/commands/GetPolicyCommand.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 { GetPolicyRequest, GetPolicyResponse } from "../models/models_0";
+import { deserializeAws_restJson1GetPolicyCommand, serializeAws_restJson1GetPolicyCommand, } from "../protocols/Aws_restJson1";
+var GetPolicyCommand = (function (_super) {
+    __extends(GetPolicyCommand, _super);
+    function GetPolicyCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    GetPolicyCommand.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 = "GetPolicyCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: GetPolicyRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: GetPolicyResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    GetPolicyCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1GetPolicyCommand(input, context);
+    };
+    GetPolicyCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1GetPolicyCommand(output, context);
+    };
+    return GetPolicyCommand;
+}($Command));
+export { GetPolicyCommand };

package/dist-es/commands/GetProvisionedConcurrencyConfigCommand.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 { GetProvisionedConcurrencyConfigRequest, GetProvisionedConcurrencyConfigResponse } from "../models/models_0";
+import { deserializeAws_restJson1GetProvisionedConcurrencyConfigCommand, serializeAws_restJson1GetProvisionedConcurrencyConfigCommand, } from "../protocols/Aws_restJson1";
+var GetProvisionedConcurrencyConfigCommand = (function (_super) {
+    __extends(GetProvisionedConcurrencyConfigCommand, _super);
+    function GetProvisionedConcurrencyConfigCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    GetProvisionedConcurrencyConfigCommand.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 = "GetProvisionedConcurrencyConfigCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: GetProvisionedConcurrencyConfigRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: GetProvisionedConcurrencyConfigResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    GetProvisionedConcurrencyConfigCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1GetProvisionedConcurrencyConfigCommand(input, context);
+    };
+    GetProvisionedConcurrencyConfigCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1GetProvisionedConcurrencyConfigCommand(output, context);
+    };
+    return GetProvisionedConcurrencyConfigCommand;
+}($Command));
+export { GetProvisionedConcurrencyConfigCommand };

package/dist-es/commands/InvokeAsyncCommand.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 { InvokeAsyncRequest, InvokeAsyncResponse } from "../models/models_0";
+import { deserializeAws_restJson1InvokeAsyncCommand, serializeAws_restJson1InvokeAsyncCommand, } from "../protocols/Aws_restJson1";
+var InvokeAsyncCommand = (function (_super) {
+    __extends(InvokeAsyncCommand, _super);
+    function InvokeAsyncCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    InvokeAsyncCommand.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 = "InvokeAsyncCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: InvokeAsyncRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: InvokeAsyncResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    InvokeAsyncCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1InvokeAsyncCommand(input, context);
+    };
+    InvokeAsyncCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1InvokeAsyncCommand(output, context);
+    };
+    return InvokeAsyncCommand;
+}($Command));
+export { InvokeAsyncCommand };

package/dist-es/commands/InvokeCommand.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 { InvocationRequest, InvocationResponse } from "../models/models_0";
+import { deserializeAws_restJson1InvokeCommand, serializeAws_restJson1InvokeCommand } from "../protocols/Aws_restJson1";
+var InvokeCommand = (function (_super) {
+    __extends(InvokeCommand, _super);
+    function InvokeCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    InvokeCommand.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 = "InvokeCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: InvocationRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: InvocationResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    InvokeCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1InvokeCommand(input, context);
+    };
+    InvokeCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1InvokeCommand(output, context);
+    };
+    return InvokeCommand;
+}($Command));
+export { InvokeCommand };