@aws-sdk/client-lambda 3.183.0 → 3.185.0

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

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

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

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

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

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

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

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

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

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