@aws-sdk/client-lambda 3.183.0 → 3.185.0

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

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

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

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

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

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

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

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

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

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