@aws-sdk/client-lambda 3.186.0 → 3.190.0

package/dist-es/commands/GetLayerVersionPolicyCommand.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 { GetLayerVersionPolicyRequestFilterSensitiveLog, GetLayerVersionPolicyResponseFilterSensitiveLog, } 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;
+export class GetLayerVersionPolicyCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
     }
-    GetLayerVersionPolicyCommand.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 = "GetLayerVersionPolicyCommand";
-        var handlerExecutionContext = {
-            logger: logger,
-            clientName: clientName,
-            commandName: commandName,
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "LambdaClient";
+        const commandName = "GetLayerVersionPolicyCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
             inputFilterSensitiveLog: GetLayerVersionPolicyRequestFilterSensitiveLog,
             outputFilterSensitiveLog: GetLayerVersionPolicyResponseFilterSensitiveLog,
         };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    GetLayerVersionPolicyCommand.prototype.serialize = function (input, context) {
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
         return serializeAws_restJson1GetLayerVersionPolicyCommand(input, context);
-    };
-    GetLayerVersionPolicyCommand.prototype.deserialize = function (output, context) {
+    }
+    deserialize(output, context) {
         return deserializeAws_restJson1GetLayerVersionPolicyCommand(output, context);
-    };
-    return GetLayerVersionPolicyCommand;
-}($Command));
-export { GetLayerVersionPolicyCommand };
+    }
+}

package/dist-es/commands/GetPolicyCommand.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 { GetPolicyRequestFilterSensitiveLog, GetPolicyResponseFilterSensitiveLog, } 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;
+export class GetPolicyCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
     }
-    GetPolicyCommand.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 = "GetPolicyCommand";
-        var handlerExecutionContext = {
-            logger: logger,
-            clientName: clientName,
-            commandName: commandName,
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "LambdaClient";
+        const commandName = "GetPolicyCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
             inputFilterSensitiveLog: GetPolicyRequestFilterSensitiveLog,
             outputFilterSensitiveLog: GetPolicyResponseFilterSensitiveLog,
         };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    GetPolicyCommand.prototype.serialize = function (input, context) {
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
         return serializeAws_restJson1GetPolicyCommand(input, context);
-    };
-    GetPolicyCommand.prototype.deserialize = function (output, context) {
+    }
+    deserialize(output, context) {
         return deserializeAws_restJson1GetPolicyCommand(output, context);
-    };
-    return GetPolicyCommand;
-}($Command));
-export { GetPolicyCommand };
+    }
+}

package/dist-es/commands/GetProvisionedConcurrencyConfigCommand.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 { GetProvisionedConcurrencyConfigRequestFilterSensitiveLog, GetProvisionedConcurrencyConfigResponseFilterSensitiveLog, } 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;
+export class GetProvisionedConcurrencyConfigCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
     }
-    GetProvisionedConcurrencyConfigCommand.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 = "GetProvisionedConcurrencyConfigCommand";
-        var handlerExecutionContext = {
-            logger: logger,
-            clientName: clientName,
-            commandName: commandName,
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "LambdaClient";
+        const commandName = "GetProvisionedConcurrencyConfigCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
             inputFilterSensitiveLog: GetProvisionedConcurrencyConfigRequestFilterSensitiveLog,
             outputFilterSensitiveLog: GetProvisionedConcurrencyConfigResponseFilterSensitiveLog,
         };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    GetProvisionedConcurrencyConfigCommand.prototype.serialize = function (input, context) {
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
         return serializeAws_restJson1GetProvisionedConcurrencyConfigCommand(input, context);
-    };
-    GetProvisionedConcurrencyConfigCommand.prototype.deserialize = function (output, context) {
+    }
+    deserialize(output, context) {
         return deserializeAws_restJson1GetProvisionedConcurrencyConfigCommand(output, context);
-    };
-    return GetProvisionedConcurrencyConfigCommand;
-}($Command));
-export { GetProvisionedConcurrencyConfigCommand };
+    }
+}

package/dist-es/commands/InvokeAsyncCommand.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 { InvokeAsyncRequestFilterSensitiveLog, InvokeAsyncResponseFilterSensitiveLog, } 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;
+export class InvokeAsyncCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
     }
-    InvokeAsyncCommand.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 = "InvokeAsyncCommand";
-        var handlerExecutionContext = {
-            logger: logger,
-            clientName: clientName,
-            commandName: commandName,
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "LambdaClient";
+        const commandName = "InvokeAsyncCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
             inputFilterSensitiveLog: InvokeAsyncRequestFilterSensitiveLog,
             outputFilterSensitiveLog: InvokeAsyncResponseFilterSensitiveLog,
         };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    InvokeAsyncCommand.prototype.serialize = function (input, context) {
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
         return serializeAws_restJson1InvokeAsyncCommand(input, context);
-    };
-    InvokeAsyncCommand.prototype.deserialize = function (output, context) {
+    }
+    deserialize(output, context) {
         return deserializeAws_restJson1InvokeAsyncCommand(output, context);
-    };
-    return InvokeAsyncCommand;
-}($Command));
-export { InvokeAsyncCommand };
+    }
+}

package/dist-es/commands/InvokeCommand.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 { InvocationRequestFilterSensitiveLog, InvocationResponseFilterSensitiveLog, } 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;
+export class InvokeCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
     }
-    InvokeCommand.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 = "InvokeCommand";
-        var handlerExecutionContext = {
-            logger: logger,
-            clientName: clientName,
-            commandName: commandName,
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "LambdaClient";
+        const commandName = "InvokeCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
             inputFilterSensitiveLog: InvocationRequestFilterSensitiveLog,
             outputFilterSensitiveLog: InvocationResponseFilterSensitiveLog,
         };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    InvokeCommand.prototype.serialize = function (input, context) {
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
         return serializeAws_restJson1InvokeCommand(input, context);
-    };
-    InvokeCommand.prototype.deserialize = function (output, context) {
+    }
+    deserialize(output, context) {
         return deserializeAws_restJson1InvokeCommand(output, context);
-    };
-    return InvokeCommand;
-}($Command));
-export { InvokeCommand };
+    }
+}

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

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

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

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

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