@aws-sdk/client-lambda 3.186.0 → 3.188.0

package/dist-es/commands/GetCodeSigningConfigCommand.js

@@ -1,39 +1,32 @@
-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";
-var GetCodeSigningConfigCommand = (function (_super) {
-    __extends(GetCodeSigningConfigCommand, _super);
-    function GetCodeSigningConfigCommand(input) {
-        var _this = _super.call(this) || this;
-        _this.input = input;
-        return _this;
+export class GetCodeSigningConfigCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
     }
-    GetCodeSigningConfigCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+    resolveMiddleware(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,
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "LambdaClient";
+        const commandName = "GetCodeSigningConfigCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
             inputFilterSensitiveLog: GetCodeSigningConfigRequestFilterSensitiveLog,
             outputFilterSensitiveLog: GetCodeSigningConfigResponseFilterSensitiveLog,
         };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    GetCodeSigningConfigCommand.prototype.serialize = function (input, context) {
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
         return serializeAws_restJson1GetCodeSigningConfigCommand(input, context);
-    };
-    GetCodeSigningConfigCommand.prototype.deserialize = function (output, context) {
+    }
+    deserialize(output, context) {
         return deserializeAws_restJson1GetCodeSigningConfigCommand(output, context);
-    };
-    return GetCodeSigningConfigCommand;
-}($Command));
-export { GetCodeSigningConfigCommand };
+    }
+}

package/dist-es/commands/GetEventSourceMappingCommand.js

@@ -1,39 +1,32 @@
-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";
-var GetEventSourceMappingCommand = (function (_super) {
-    __extends(GetEventSourceMappingCommand, _super);
-    function GetEventSourceMappingCommand(input) {
-        var _this = _super.call(this) || this;
-        _this.input = input;
-        return _this;
+export class GetEventSourceMappingCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
     }
-    GetEventSourceMappingCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+    resolveMiddleware(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,
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "LambdaClient";
+        const commandName = "GetEventSourceMappingCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
             inputFilterSensitiveLog: GetEventSourceMappingRequestFilterSensitiveLog,
             outputFilterSensitiveLog: EventSourceMappingConfigurationFilterSensitiveLog,
         };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    GetEventSourceMappingCommand.prototype.serialize = function (input, context) {
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
         return serializeAws_restJson1GetEventSourceMappingCommand(input, context);
-    };
-    GetEventSourceMappingCommand.prototype.deserialize = function (output, context) {
+    }
+    deserialize(output, context) {
         return deserializeAws_restJson1GetEventSourceMappingCommand(output, context);
-    };
-    return GetEventSourceMappingCommand;
-}($Command));
-export { GetEventSourceMappingCommand };
+    }
+}

package/dist-es/commands/GetFunctionCodeSigningConfigCommand.js

@@ -1,39 +1,32 @@
-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";
-var GetFunctionCodeSigningConfigCommand = (function (_super) {
-    __extends(GetFunctionCodeSigningConfigCommand, _super);
-    function GetFunctionCodeSigningConfigCommand(input) {
-        var _this = _super.call(this) || this;
-        _this.input = input;
-        return _this;
+export class GetFunctionCodeSigningConfigCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
     }
-    GetFunctionCodeSigningConfigCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+    resolveMiddleware(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,
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "LambdaClient";
+        const commandName = "GetFunctionCodeSigningConfigCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
             inputFilterSensitiveLog: GetFunctionCodeSigningConfigRequestFilterSensitiveLog,
             outputFilterSensitiveLog: GetFunctionCodeSigningConfigResponseFilterSensitiveLog,
         };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    GetFunctionCodeSigningConfigCommand.prototype.serialize = function (input, context) {
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
         return serializeAws_restJson1GetFunctionCodeSigningConfigCommand(input, context);
-    };
-    GetFunctionCodeSigningConfigCommand.prototype.deserialize = function (output, context) {
+    }
+    deserialize(output, context) {
         return deserializeAws_restJson1GetFunctionCodeSigningConfigCommand(output, context);
-    };
-    return GetFunctionCodeSigningConfigCommand;
-}($Command));
-export { GetFunctionCodeSigningConfigCommand };
+    }
+}

package/dist-es/commands/GetFunctionCommand.js

@@ -1,39 +1,32 @@
-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";
-var GetFunctionCommand = (function (_super) {
-    __extends(GetFunctionCommand, _super);
-    function GetFunctionCommand(input) {
-        var _this = _super.call(this) || this;
-        _this.input = input;
-        return _this;
+export class GetFunctionCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
     }
-    GetFunctionCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+    resolveMiddleware(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,
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "LambdaClient";
+        const commandName = "GetFunctionCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
             inputFilterSensitiveLog: GetFunctionRequestFilterSensitiveLog,
             outputFilterSensitiveLog: GetFunctionResponseFilterSensitiveLog,
         };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    GetFunctionCommand.prototype.serialize = function (input, context) {
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
         return serializeAws_restJson1GetFunctionCommand(input, context);
-    };
-    GetFunctionCommand.prototype.deserialize = function (output, context) {
+    }
+    deserialize(output, context) {
         return deserializeAws_restJson1GetFunctionCommand(output, context);
-    };
-    return GetFunctionCommand;
-}($Command));
-export { GetFunctionCommand };
+    }
+}

package/dist-es/commands/GetFunctionConcurrencyCommand.js

@@ -1,39 +1,32 @@
-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";
-var GetFunctionConcurrencyCommand = (function (_super) {
-    __extends(GetFunctionConcurrencyCommand, _super);
-    function GetFunctionConcurrencyCommand(input) {
-        var _this = _super.call(this) || this;
-        _this.input = input;
-        return _this;
+export class GetFunctionConcurrencyCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
     }
-    GetFunctionConcurrencyCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+    resolveMiddleware(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,
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "LambdaClient";
+        const commandName = "GetFunctionConcurrencyCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
             inputFilterSensitiveLog: GetFunctionConcurrencyRequestFilterSensitiveLog,
             outputFilterSensitiveLog: GetFunctionConcurrencyResponseFilterSensitiveLog,
         };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    GetFunctionConcurrencyCommand.prototype.serialize = function (input, context) {
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
         return serializeAws_restJson1GetFunctionConcurrencyCommand(input, context);
-    };
-    GetFunctionConcurrencyCommand.prototype.deserialize = function (output, context) {
+    }
+    deserialize(output, context) {
         return deserializeAws_restJson1GetFunctionConcurrencyCommand(output, context);
-    };
-    return GetFunctionConcurrencyCommand;
-}($Command));
-export { GetFunctionConcurrencyCommand };
+    }
+}

package/dist-es/commands/GetFunctionConfigurationCommand.js

@@ -1,39 +1,32 @@
-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";
-var GetFunctionConfigurationCommand = (function (_super) {
-    __extends(GetFunctionConfigurationCommand, _super);
-    function GetFunctionConfigurationCommand(input) {
-        var _this = _super.call(this) || this;
-        _this.input = input;
-        return _this;
+export class GetFunctionConfigurationCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
     }
-    GetFunctionConfigurationCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+    resolveMiddleware(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,
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "LambdaClient";
+        const commandName = "GetFunctionConfigurationCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
             inputFilterSensitiveLog: GetFunctionConfigurationRequestFilterSensitiveLog,
             outputFilterSensitiveLog: FunctionConfigurationFilterSensitiveLog,
         };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    GetFunctionConfigurationCommand.prototype.serialize = function (input, context) {
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
         return serializeAws_restJson1GetFunctionConfigurationCommand(input, context);
-    };
-    GetFunctionConfigurationCommand.prototype.deserialize = function (output, context) {
+    }
+    deserialize(output, context) {
         return deserializeAws_restJson1GetFunctionConfigurationCommand(output, context);
-    };
-    return GetFunctionConfigurationCommand;
-}($Command));
-export { GetFunctionConfigurationCommand };
+    }
+}

package/dist-es/commands/GetFunctionEventInvokeConfigCommand.js

@@ -1,39 +1,32 @@
-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";
-var GetFunctionEventInvokeConfigCommand = (function (_super) {
-    __extends(GetFunctionEventInvokeConfigCommand, _super);
-    function GetFunctionEventInvokeConfigCommand(input) {
-        var _this = _super.call(this) || this;
-        _this.input = input;
-        return _this;
+export class GetFunctionEventInvokeConfigCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
     }
-    GetFunctionEventInvokeConfigCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+    resolveMiddleware(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,
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "LambdaClient";
+        const commandName = "GetFunctionEventInvokeConfigCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
             inputFilterSensitiveLog: GetFunctionEventInvokeConfigRequestFilterSensitiveLog,
             outputFilterSensitiveLog: FunctionEventInvokeConfigFilterSensitiveLog,
         };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    GetFunctionEventInvokeConfigCommand.prototype.serialize = function (input, context) {
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
         return serializeAws_restJson1GetFunctionEventInvokeConfigCommand(input, context);
-    };
-    GetFunctionEventInvokeConfigCommand.prototype.deserialize = function (output, context) {
+    }
+    deserialize(output, context) {
         return deserializeAws_restJson1GetFunctionEventInvokeConfigCommand(output, context);
-    };
-    return GetFunctionEventInvokeConfigCommand;
-}($Command));
-export { GetFunctionEventInvokeConfigCommand };
+    }
+}

package/dist-es/commands/GetFunctionUrlConfigCommand.js

@@ -1,39 +1,32 @@
-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";
-var GetFunctionUrlConfigCommand = (function (_super) {
-    __extends(GetFunctionUrlConfigCommand, _super);
-    function GetFunctionUrlConfigCommand(input) {
-        var _this = _super.call(this) || this;
-        _this.input = input;
-        return _this;
+export class GetFunctionUrlConfigCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
     }
-    GetFunctionUrlConfigCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+    resolveMiddleware(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 = "GetFunctionUrlConfigCommand";
-        var handlerExecutionContext = {
-            logger: logger,
-            clientName: clientName,
-            commandName: commandName,
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "LambdaClient";
+        const commandName = "GetFunctionUrlConfigCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
             inputFilterSensitiveLog: GetFunctionUrlConfigRequestFilterSensitiveLog,
             outputFilterSensitiveLog: GetFunctionUrlConfigResponseFilterSensitiveLog,
         };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    GetFunctionUrlConfigCommand.prototype.serialize = function (input, context) {
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
         return serializeAws_restJson1GetFunctionUrlConfigCommand(input, context);
-    };
-    GetFunctionUrlConfigCommand.prototype.deserialize = function (output, context) {
+    }
+    deserialize(output, context) {
         return deserializeAws_restJson1GetFunctionUrlConfigCommand(output, context);
-    };
-    return GetFunctionUrlConfigCommand;
-}($Command));
-export { GetFunctionUrlConfigCommand };
+    }
+}

package/dist-es/commands/GetLayerVersionByArnCommand.js

@@ -1,39 +1,32 @@
-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";
-var GetLayerVersionByArnCommand = (function (_super) {
-    __extends(GetLayerVersionByArnCommand, _super);
-    function GetLayerVersionByArnCommand(input) {
-        var _this = _super.call(this) || this;
-        _this.input = input;
-        return _this;
+export class GetLayerVersionByArnCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
     }
-    GetLayerVersionByArnCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+    resolveMiddleware(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,
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "LambdaClient";
+        const commandName = "GetLayerVersionByArnCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
             inputFilterSensitiveLog: GetLayerVersionByArnRequestFilterSensitiveLog,
             outputFilterSensitiveLog: GetLayerVersionResponseFilterSensitiveLog,
         };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    GetLayerVersionByArnCommand.prototype.serialize = function (input, context) {
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
         return serializeAws_restJson1GetLayerVersionByArnCommand(input, context);
-    };
-    GetLayerVersionByArnCommand.prototype.deserialize = function (output, context) {
+    }
+    deserialize(output, context) {
         return deserializeAws_restJson1GetLayerVersionByArnCommand(output, context);
-    };
-    return GetLayerVersionByArnCommand;
-}($Command));
-export { GetLayerVersionByArnCommand };
+    }
+}

package/dist-es/commands/GetLayerVersionCommand.js

@@ -1,39 +1,32 @@
-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";
-var GetLayerVersionCommand = (function (_super) {
-    __extends(GetLayerVersionCommand, _super);
-    function GetLayerVersionCommand(input) {
-        var _this = _super.call(this) || this;
-        _this.input = input;
-        return _this;
+export class GetLayerVersionCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
     }
-    GetLayerVersionCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+    resolveMiddleware(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,
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "LambdaClient";
+        const commandName = "GetLayerVersionCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
             inputFilterSensitiveLog: GetLayerVersionRequestFilterSensitiveLog,
             outputFilterSensitiveLog: GetLayerVersionResponseFilterSensitiveLog,
         };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    GetLayerVersionCommand.prototype.serialize = function (input, context) {
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
         return serializeAws_restJson1GetLayerVersionCommand(input, context);
-    };
-    GetLayerVersionCommand.prototype.deserialize = function (output, context) {
+    }
+    deserialize(output, context) {
         return deserializeAws_restJson1GetLayerVersionCommand(output, context);
-    };
-    return GetLayerVersionCommand;
-}($Command));
-export { GetLayerVersionCommand };
+    }
+}