@aws-sdk/client-lambda 3.58.0 → 3.72.0

package/dist-es/Lambda.js

@@ -5,6 +5,7 @@ import { CreateAliasCommand } from "./commands/CreateAliasCommand";
 import { CreateCodeSigningConfigCommand, } from "./commands/CreateCodeSigningConfigCommand";
 import { CreateEventSourceMappingCommand, } from "./commands/CreateEventSourceMappingCommand";
 import { CreateFunctionCommand, } from "./commands/CreateFunctionCommand";
+import { CreateFunctionUrlConfigCommand, } from "./commands/CreateFunctionUrlConfigCommand";
 import { DeleteAliasCommand } from "./commands/DeleteAliasCommand";
 import { DeleteCodeSigningConfigCommand, } from "./commands/DeleteCodeSigningConfigCommand";
 import { DeleteEventSourceMappingCommand, } from "./commands/DeleteEventSourceMappingCommand";
@@ -12,6 +13,7 @@ import { DeleteFunctionCodeSigningConfigCommand, } from "./commands/DeleteFuncti
 import { DeleteFunctionCommand, } from "./commands/DeleteFunctionCommand";
 import { DeleteFunctionConcurrencyCommand, } from "./commands/DeleteFunctionConcurrencyCommand";
 import { DeleteFunctionEventInvokeConfigCommand, } from "./commands/DeleteFunctionEventInvokeConfigCommand";
+import { DeleteFunctionUrlConfigCommand, } from "./commands/DeleteFunctionUrlConfigCommand";
 import { DeleteLayerVersionCommand, } from "./commands/DeleteLayerVersionCommand";
 import { DeleteProvisionedConcurrencyConfigCommand, } from "./commands/DeleteProvisionedConcurrencyConfigCommand";
 import { GetAccountSettingsCommand, } from "./commands/GetAccountSettingsCommand";
@@ -23,6 +25,7 @@ import { GetFunctionCommand } from "./commands/GetFunctionCommand";
 import { GetFunctionConcurrencyCommand, } from "./commands/GetFunctionConcurrencyCommand";
 import { GetFunctionConfigurationCommand, } from "./commands/GetFunctionConfigurationCommand";
 import { GetFunctionEventInvokeConfigCommand, } from "./commands/GetFunctionEventInvokeConfigCommand";
+import { GetFunctionUrlConfigCommand, } from "./commands/GetFunctionUrlConfigCommand";
 import { GetLayerVersionByArnCommand, } from "./commands/GetLayerVersionByArnCommand";
 import { GetLayerVersionCommand, } from "./commands/GetLayerVersionCommand";
 import { GetLayerVersionPolicyCommand, } from "./commands/GetLayerVersionPolicyCommand";
@@ -36,6 +39,7 @@ import { ListEventSourceMappingsCommand, } from "./commands/ListEventSourceMappi
 import { ListFunctionEventInvokeConfigsCommand, } from "./commands/ListFunctionEventInvokeConfigsCommand";
 import { ListFunctionsByCodeSigningConfigCommand, } from "./commands/ListFunctionsByCodeSigningConfigCommand";
 import { ListFunctionsCommand, } from "./commands/ListFunctionsCommand";
+import { ListFunctionUrlConfigsCommand, } from "./commands/ListFunctionUrlConfigsCommand";
 import { ListLayersCommand } from "./commands/ListLayersCommand";
 import { ListLayerVersionsCommand, } from "./commands/ListLayerVersionsCommand";
 import { ListProvisionedConcurrencyConfigsCommand, } from "./commands/ListProvisionedConcurrencyConfigsCommand";
@@ -57,6 +61,7 @@ import { UpdateEventSourceMappingCommand, } from "./commands/UpdateEventSourceMa
 import { UpdateFunctionCodeCommand, } from "./commands/UpdateFunctionCodeCommand";
 import { UpdateFunctionConfigurationCommand, } from "./commands/UpdateFunctionConfigurationCommand";
 import { UpdateFunctionEventInvokeConfigCommand, } from "./commands/UpdateFunctionEventInvokeConfigCommand";
+import { UpdateFunctionUrlConfigCommand, } from "./commands/UpdateFunctionUrlConfigCommand";
 import { LambdaClient } from "./LambdaClient";
 var Lambda = (function (_super) {
     __extends(Lambda, _super);
@@ -147,6 +152,20 @@ var Lambda = (function (_super) {
             return this.send(command, optionsOrCb);
         }
     };
+    Lambda.prototype.createFunctionUrlConfig = function (args, optionsOrCb, cb) {
+        var command = new CreateFunctionUrlConfigCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    };
     Lambda.prototype.deleteAlias = function (args, optionsOrCb, cb) {
         var command = new DeleteAliasCommand(args);
         if (typeof optionsOrCb === "function") {
@@ -245,6 +264,20 @@ var Lambda = (function (_super) {
             return this.send(command, optionsOrCb);
         }
     };
+    Lambda.prototype.deleteFunctionUrlConfig = function (args, optionsOrCb, cb) {
+        var command = new DeleteFunctionUrlConfigCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    };
     Lambda.prototype.deleteLayerVersion = function (args, optionsOrCb, cb) {
         var command = new DeleteLayerVersionCommand(args);
         if (typeof optionsOrCb === "function") {
@@ -399,6 +432,20 @@ var Lambda = (function (_super) {
             return this.send(command, optionsOrCb);
         }
     };
+    Lambda.prototype.getFunctionUrlConfig = function (args, optionsOrCb, cb) {
+        var command = new GetFunctionUrlConfigCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    };
     Lambda.prototype.getLayerVersion = function (args, optionsOrCb, cb) {
         var command = new GetLayerVersionCommand(args);
         if (typeof optionsOrCb === "function") {
@@ -581,6 +628,20 @@ var Lambda = (function (_super) {
             return this.send(command, optionsOrCb);
         }
     };
+    Lambda.prototype.listFunctionUrlConfigs = function (args, optionsOrCb, cb) {
+        var command = new ListFunctionUrlConfigsCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    };
     Lambda.prototype.listLayers = function (args, optionsOrCb, cb) {
         var command = new ListLayersCommand(args);
         if (typeof optionsOrCb === "function") {
@@ -875,6 +936,20 @@ var Lambda = (function (_super) {
             return this.send(command, optionsOrCb);
         }
     };
+    Lambda.prototype.updateFunctionUrlConfig = function (args, optionsOrCb, cb) {
+        var command = new UpdateFunctionUrlConfigCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    };
     return Lambda;
 }(LambdaClient));
 export { Lambda };

package/dist-es/commands/CreateFunctionUrlConfigCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { CreateFunctionUrlConfigRequest, CreateFunctionUrlConfigResponse } from "../models/models_0";
+import { deserializeAws_restJson1CreateFunctionUrlConfigCommand, serializeAws_restJson1CreateFunctionUrlConfigCommand, } from "../protocols/Aws_restJson1";
+var CreateFunctionUrlConfigCommand = (function (_super) {
+    __extends(CreateFunctionUrlConfigCommand, _super);
+    function CreateFunctionUrlConfigCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    CreateFunctionUrlConfigCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "LambdaClient";
+        var commandName = "CreateFunctionUrlConfigCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: CreateFunctionUrlConfigRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: CreateFunctionUrlConfigResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    CreateFunctionUrlConfigCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1CreateFunctionUrlConfigCommand(input, context);
+    };
+    CreateFunctionUrlConfigCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1CreateFunctionUrlConfigCommand(output, context);
+    };
+    return CreateFunctionUrlConfigCommand;
+}($Command));
+export { CreateFunctionUrlConfigCommand };

package/dist-es/commands/DeleteFunctionUrlConfigCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { DeleteFunctionUrlConfigRequest } from "../models/models_0";
+import { deserializeAws_restJson1DeleteFunctionUrlConfigCommand, serializeAws_restJson1DeleteFunctionUrlConfigCommand, } from "../protocols/Aws_restJson1";
+var DeleteFunctionUrlConfigCommand = (function (_super) {
+    __extends(DeleteFunctionUrlConfigCommand, _super);
+    function DeleteFunctionUrlConfigCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    DeleteFunctionUrlConfigCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "LambdaClient";
+        var commandName = "DeleteFunctionUrlConfigCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: DeleteFunctionUrlConfigRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: function (output) { return output; },
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    DeleteFunctionUrlConfigCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1DeleteFunctionUrlConfigCommand(input, context);
+    };
+    DeleteFunctionUrlConfigCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1DeleteFunctionUrlConfigCommand(output, context);
+    };
+    return DeleteFunctionUrlConfigCommand;
+}($Command));
+export { DeleteFunctionUrlConfigCommand };

package/dist-es/commands/GetFunctionUrlConfigCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { GetFunctionUrlConfigRequest, GetFunctionUrlConfigResponse } 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;
+    }
+    GetFunctionUrlConfigCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "LambdaClient";
+        var commandName = "GetFunctionUrlConfigCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: GetFunctionUrlConfigRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: GetFunctionUrlConfigResponse.filterSensitiveLog,
+        };
+        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);
+    };
+    GetFunctionUrlConfigCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1GetFunctionUrlConfigCommand(output, context);
+    };
+    return GetFunctionUrlConfigCommand;
+}($Command));
+export { GetFunctionUrlConfigCommand };

package/dist-es/commands/ListFunctionUrlConfigsCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { ListFunctionUrlConfigsRequest, ListFunctionUrlConfigsResponse } 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;
+    }
+    ListFunctionUrlConfigsCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "LambdaClient";
+        var commandName = "ListFunctionUrlConfigsCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: ListFunctionUrlConfigsRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: ListFunctionUrlConfigsResponse.filterSensitiveLog,
+        };
+        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);
+    };
+    ListFunctionUrlConfigsCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1ListFunctionUrlConfigsCommand(output, context);
+    };
+    return ListFunctionUrlConfigsCommand;
+}($Command));
+export { ListFunctionUrlConfigsCommand };

package/dist-es/commands/UpdateFunctionUrlConfigCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { UpdateFunctionUrlConfigRequest, UpdateFunctionUrlConfigResponse } from "../models/models_0";
+import { deserializeAws_restJson1UpdateFunctionUrlConfigCommand, serializeAws_restJson1UpdateFunctionUrlConfigCommand, } from "../protocols/Aws_restJson1";
+var UpdateFunctionUrlConfigCommand = (function (_super) {
+    __extends(UpdateFunctionUrlConfigCommand, _super);
+    function UpdateFunctionUrlConfigCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    UpdateFunctionUrlConfigCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "LambdaClient";
+        var commandName = "UpdateFunctionUrlConfigCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: UpdateFunctionUrlConfigRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: UpdateFunctionUrlConfigResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    UpdateFunctionUrlConfigCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1UpdateFunctionUrlConfigCommand(input, context);
+    };
+    UpdateFunctionUrlConfigCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1UpdateFunctionUrlConfigCommand(output, context);
+    };
+    return UpdateFunctionUrlConfigCommand;
+}($Command));
+export { UpdateFunctionUrlConfigCommand };

package/dist-es/commands/index.js

@@ -4,6 +4,7 @@ export * from "./CreateAliasCommand";
 export * from "./CreateCodeSigningConfigCommand";
 export * from "./CreateEventSourceMappingCommand";
 export * from "./CreateFunctionCommand";
+export * from "./CreateFunctionUrlConfigCommand";
 export * from "./DeleteAliasCommand";
 export * from "./DeleteCodeSigningConfigCommand";
 export * from "./DeleteEventSourceMappingCommand";
@@ -11,6 +12,7 @@ export * from "./DeleteFunctionCodeSigningConfigCommand";
 export * from "./DeleteFunctionCommand";
 export * from "./DeleteFunctionConcurrencyCommand";
 export * from "./DeleteFunctionEventInvokeConfigCommand";
+export * from "./DeleteFunctionUrlConfigCommand";
 export * from "./DeleteLayerVersionCommand";
 export * from "./DeleteProvisionedConcurrencyConfigCommand";
 export * from "./GetAccountSettingsCommand";
@@ -22,6 +24,7 @@ export * from "./GetFunctionCommand";
 export * from "./GetFunctionConcurrencyCommand";
 export * from "./GetFunctionConfigurationCommand";
 export * from "./GetFunctionEventInvokeConfigCommand";
+export * from "./GetFunctionUrlConfigCommand";
 export * from "./GetLayerVersionByArnCommand";
 export * from "./GetLayerVersionCommand";
 export * from "./GetLayerVersionPolicyCommand";
@@ -33,6 +36,7 @@ export * from "./ListAliasesCommand";
 export * from "./ListCodeSigningConfigsCommand";
 export * from "./ListEventSourceMappingsCommand";
 export * from "./ListFunctionEventInvokeConfigsCommand";
+export * from "./ListFunctionUrlConfigsCommand";
 export * from "./ListFunctionsByCodeSigningConfigCommand";
 export * from "./ListFunctionsCommand";
 export * from "./ListLayerVersionsCommand";
@@ -56,3 +60,4 @@ export * from "./UpdateEventSourceMappingCommand";
 export * from "./UpdateFunctionCodeCommand";
 export * from "./UpdateFunctionConfigurationCommand";
 export * from "./UpdateFunctionEventInvokeConfigCommand";
+export * from "./UpdateFunctionUrlConfigCommand";

package/dist-es/models/models_0.js

@@ -120,6 +120,11 @@ var TooManyRequestsException = (function (_super) {
     return TooManyRequestsException;
 }(__BaseException));
 export { TooManyRequestsException };
+export var FunctionUrlAuthType;
+(function (FunctionUrlAuthType) {
+    FunctionUrlAuthType["AWS_IAM"] = "AWS_IAM";
+    FunctionUrlAuthType["NONE"] = "NONE";
+})(FunctionUrlAuthType || (FunctionUrlAuthType = {}));
 export var AddPermissionRequest;
 (function (AddPermissionRequest) {
     AddPermissionRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
@@ -437,6 +442,18 @@ var InvalidCodeSignatureException = (function (_super) {
     return InvalidCodeSignatureException;
 }(__BaseException));
 export { InvalidCodeSignatureException };
+export var Cors;
+(function (Cors) {
+    Cors.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(Cors || (Cors = {}));
+export var CreateFunctionUrlConfigRequest;
+(function (CreateFunctionUrlConfigRequest) {
+    CreateFunctionUrlConfigRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(CreateFunctionUrlConfigRequest || (CreateFunctionUrlConfigRequest = {}));
+export var CreateFunctionUrlConfigResponse;
+(function (CreateFunctionUrlConfigResponse) {
+    CreateFunctionUrlConfigResponse.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(CreateFunctionUrlConfigResponse || (CreateFunctionUrlConfigResponse = {}));
 export var DeleteAliasRequest;
 (function (DeleteAliasRequest) {
     DeleteAliasRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
@@ -483,6 +500,10 @@ export var DeleteFunctionEventInvokeConfigRequest;
 (function (DeleteFunctionEventInvokeConfigRequest) {
     DeleteFunctionEventInvokeConfigRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
 })(DeleteFunctionEventInvokeConfigRequest || (DeleteFunctionEventInvokeConfigRequest = {}));
+export var DeleteFunctionUrlConfigRequest;
+(function (DeleteFunctionUrlConfigRequest) {
+    DeleteFunctionUrlConfigRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(DeleteFunctionUrlConfigRequest || (DeleteFunctionUrlConfigRequest = {}));
 export var DeleteLayerVersionRequest;
 (function (DeleteLayerVersionRequest) {
     DeleteLayerVersionRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
@@ -559,6 +580,14 @@ export var GetFunctionEventInvokeConfigRequest;
 (function (GetFunctionEventInvokeConfigRequest) {
     GetFunctionEventInvokeConfigRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
 })(GetFunctionEventInvokeConfigRequest || (GetFunctionEventInvokeConfigRequest = {}));
+export var GetFunctionUrlConfigRequest;
+(function (GetFunctionUrlConfigRequest) {
+    GetFunctionUrlConfigRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(GetFunctionUrlConfigRequest || (GetFunctionUrlConfigRequest = {}));
+export var GetFunctionUrlConfigResponse;
+(function (GetFunctionUrlConfigResponse) {
+    GetFunctionUrlConfigResponse.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(GetFunctionUrlConfigResponse || (GetFunctionUrlConfigResponse = {}));
 export var GetLayerVersionRequest;
 (function (GetLayerVersionRequest) {
     GetLayerVersionRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
@@ -988,6 +1017,18 @@ export var ListFunctionsByCodeSigningConfigResponse;
 (function (ListFunctionsByCodeSigningConfigResponse) {
     ListFunctionsByCodeSigningConfigResponse.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
 })(ListFunctionsByCodeSigningConfigResponse || (ListFunctionsByCodeSigningConfigResponse = {}));
+export var ListFunctionUrlConfigsRequest;
+(function (ListFunctionUrlConfigsRequest) {
+    ListFunctionUrlConfigsRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(ListFunctionUrlConfigsRequest || (ListFunctionUrlConfigsRequest = {}));
+export var FunctionUrlConfig;
+(function (FunctionUrlConfig) {
+    FunctionUrlConfig.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(FunctionUrlConfig || (FunctionUrlConfig = {}));
+export var ListFunctionUrlConfigsResponse;
+(function (ListFunctionUrlConfigsResponse) {
+    ListFunctionUrlConfigsResponse.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(ListFunctionUrlConfigsResponse || (ListFunctionUrlConfigsResponse = {}));
 export var ListLayersRequest;
 (function (ListLayersRequest) {
     ListLayersRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
@@ -1124,3 +1165,11 @@ export var UpdateFunctionEventInvokeConfigRequest;
 (function (UpdateFunctionEventInvokeConfigRequest) {
     UpdateFunctionEventInvokeConfigRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
 })(UpdateFunctionEventInvokeConfigRequest || (UpdateFunctionEventInvokeConfigRequest = {}));
+export var UpdateFunctionUrlConfigRequest;
+(function (UpdateFunctionUrlConfigRequest) {
+    UpdateFunctionUrlConfigRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(UpdateFunctionUrlConfigRequest || (UpdateFunctionUrlConfigRequest = {}));
+export var UpdateFunctionUrlConfigResponse;
+(function (UpdateFunctionUrlConfigResponse) {
+    UpdateFunctionUrlConfigResponse.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(UpdateFunctionUrlConfigResponse || (UpdateFunctionUrlConfigResponse = {}));

package/dist-es/pagination/ListFunctionUrlConfigsPaginator.js

@@ -0,0 +1,74 @@
+import { __asyncGenerator, __await, __awaiter, __generator, __read, __spreadArray } from "tslib";
+import { ListFunctionUrlConfigsCommand, } from "../commands/ListFunctionUrlConfigsCommand";
+import { Lambda } from "../Lambda";
+import { LambdaClient } from "../LambdaClient";
+var makePagedClientRequest = function (client, input) {
+    var args = [];
+    for (var _i = 2; _i < arguments.length; _i++) {
+        args[_i - 2] = arguments[_i];
+    }
+    return __awaiter(void 0, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4, client.send.apply(client, __spreadArray([new ListFunctionUrlConfigsCommand(input)], __read(args), false))];
+                case 1: return [2, _a.sent()];
+            }
+        });
+    });
+};
+var makePagedRequest = function (client, input) {
+    var args = [];
+    for (var _i = 2; _i < arguments.length; _i++) {
+        args[_i - 2] = arguments[_i];
+    }
+    return __awaiter(void 0, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4, client.listFunctionUrlConfigs.apply(client, __spreadArray([input], __read(args), false))];
+                case 1: return [2, _a.sent()];
+            }
+        });
+    });
+};
+export function paginateListFunctionUrlConfigs(config, input) {
+    var additionalArguments = [];
+    for (var _i = 2; _i < arguments.length; _i++) {
+        additionalArguments[_i - 2] = arguments[_i];
+    }
+    return __asyncGenerator(this, arguments, function paginateListFunctionUrlConfigs_1() {
+        var token, hasNext, page;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    token = config.startingToken || undefined;
+                    hasNext = true;
+                    _a.label = 1;
+                case 1:
+                    if (!hasNext) return [3, 9];
+                    input.Marker = token;
+                    input["MaxItems"] = config.pageSize;
+                    if (!(config.client instanceof Lambda)) return [3, 3];
+                    return [4, __await(makePagedRequest.apply(void 0, __spreadArray([config.client, input], __read(additionalArguments), false)))];
+                case 2:
+                    page = _a.sent();
+                    return [3, 6];
+                case 3:
+                    if (!(config.client instanceof LambdaClient)) return [3, 5];
+                    return [4, __await(makePagedClientRequest.apply(void 0, __spreadArray([config.client, input], __read(additionalArguments), false)))];
+                case 4:
+                    page = _a.sent();
+                    return [3, 6];
+                case 5: throw new Error("Invalid client, expected Lambda | LambdaClient");
+                case 6: return [4, __await(page)];
+                case 7: return [4, _a.sent()];
+                case 8:
+                    _a.sent();
+                    token = page.NextMarker;
+                    hasNext = !!token;
+                    return [3, 1];
+                case 9: return [4, __await(undefined)];
+                case 10: return [2, _a.sent()];
+            }
+        });
+    });
+}

package/dist-es/pagination/index.js

@@ -3,6 +3,7 @@ export * from "./ListAliasesPaginator";
 export * from "./ListCodeSigningConfigsPaginator";
 export * from "./ListEventSourceMappingsPaginator";
 export * from "./ListFunctionEventInvokeConfigsPaginator";
+export * from "./ListFunctionUrlConfigsPaginator";
 export * from "./ListFunctionsByCodeSigningConfigPaginator";
 export * from "./ListFunctionsPaginator";
 export * from "./ListLayerVersionsPaginator";