//------------------------------------------------------------------------------
// <auto-generated>
//     This code was generated by a tool.
//
//     Changes to this file may cause incorrect behavior and will be lost if
//     the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------
#nullable enable
 
namespace System.Runtime.CompilerServices
{
    [System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.AspNetCore.Http.RequestDelegateGenerator, Version=42.42.42.42, Culture=neutral, PublicKeyToken=adb9793829ddae60", "42.42.42.42")]
    [AttributeUsage(AttributeTargets.Method, AllowMultiple = true)]
    file sealed class InterceptsLocationAttribute : Attribute
    {
        public InterceptsLocationAttribute(int version, string data)
        {
        }
    }
}
 
namespace Microsoft.AspNetCore.Http.Generated
{
    using System;
    using System.Collections;
    using System.Collections.Generic;
    using System.Collections.ObjectModel;
    using System.Diagnostics;
    using System.Diagnostics.CodeAnalysis;
    using System.Globalization;
    using System.Linq;
    using System.Reflection;
    using System.Runtime.CompilerServices;
    using System.Text.Json;
    using System.Text.Json.Serialization.Metadata;
    using System.Threading.Tasks;
    using System.IO;
    using Microsoft.AspNetCore.Antiforgery;
    using Microsoft.AspNetCore.Routing;
    using Microsoft.AspNetCore.Routing.Patterns;
    using Microsoft.AspNetCore.Builder;
    using Microsoft.AspNetCore.Http;
    using Microsoft.AspNetCore.Http.Json;
    using Microsoft.AspNetCore.Http.Metadata;
    using Microsoft.Extensions.DependencyInjection;
    using Microsoft.Extensions.FileProviders;
    using Microsoft.Extensions.Logging;
    using Microsoft.Extensions.Primitives;
    using Microsoft.Extensions.Options;
 
    using MetadataPopulator = System.Func<System.Reflection.MethodInfo, Microsoft.AspNetCore.Http.RequestDelegateFactoryOptions?, Microsoft.AspNetCore.Http.RequestDelegateMetadataResult>;
    using RequestDelegateFactoryFunc = System.Func<System.Delegate, Microsoft.AspNetCore.Http.RequestDelegateFactoryOptions, Microsoft.AspNetCore.Http.RequestDelegateMetadataResult?, Microsoft.AspNetCore.Http.RequestDelegateResult>;
 
    [System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.AspNetCore.Http.RequestDelegateGenerator, Version=42.42.42.42, Culture=neutral, PublicKeyToken=adb9793829ddae60", "42.42.42.42")]
    file static class GeneratedRouteBuilderExtensionsCore
    {
        private static readonly JsonOptions FallbackJsonOptions = new();
        private static readonly string[] GetVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Get };
        private static readonly string[] PostVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Post };
 
        [global::System.Runtime.CompilerServices.InterceptsLocationAttribute(1, "J4fwklE6dqSkeKxd+PIY01ALAABJZGVudGl0eUFwaUVuZHBvaW50Um91dGVCdWlsZGVyRXh0ZW5zaW9ucy5jcw==")]
        internal static RouteHandlerBuilder MapPost0(
            this IEndpointRouteBuilder endpoints,
            [StringSyntax("Route")] string pattern,
            Delegate handler)
        {
            MetadataPopulator populateMetadata = (methodInfo, options) =>
            {
                Debug.Assert(options != null, "RequestDelegateFactoryOptions not found.");
                Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found.");
                options.EndpointBuilder.Metadata.Add(new System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.AspNetCore.Http.RequestDelegateGenerator, Version=42.42.42.42, Culture=neutral, PublicKeyToken=adb9793829ddae60", "42.42.42.42"));
                options.EndpointBuilder.Metadata.Add(new AcceptsMetadata(type: typeof(global::Microsoft.AspNetCore.Identity.Data.RegisterRequest), isOptional: false, contentTypes: GeneratedMetadataConstants.JsonContentType));
                var parameters = methodInfo.GetParameters();
                options.EndpointBuilder.Metadata.Add(new ParameterBindingMetadata("registration", parameters[0], hasTryParse: false, hasBindAsync: false, isOptional: false));
                options.EndpointBuilder.Metadata.Add(new ParameterBindingMetadata("context", parameters[1], hasTryParse: false, hasBindAsync: false, isOptional: false));
                options.EndpointBuilder.Metadata.Add(new ParameterBindingMetadata("sp", parameters[2], hasTryParse: false, hasBindAsync: false, isOptional: false));
                PopulateMetadataForEndpoint<global::Microsoft.AspNetCore.Http.HttpResults.Results<global::Microsoft.AspNetCore.Http.HttpResults.Ok, global::Microsoft.AspNetCore.Http.HttpResults.ValidationProblem>>(methodInfo, options.EndpointBuilder);
                return new RequestDelegateMetadataResult { EndpointMetadata = options.EndpointBuilder.Metadata.AsReadOnly() };
            };
            RequestDelegateFactoryFunc createRequestDelegate = (del, options, inferredMetadataResult) =>
            {
                Debug.Assert(options != null, "RequestDelegateFactoryOptions not found.");
                Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found.");
                Debug.Assert(options.EndpointBuilder.ApplicationServices != null, "ApplicationServices not found.");
                Debug.Assert(options.EndpointBuilder.FilterFactories != null, "FilterFactories not found.");
                var handler = Cast(del, global::System.Threading.Tasks.Task<global::Microsoft.AspNetCore.Http.HttpResults.Results<global::Microsoft.AspNetCore.Http.HttpResults.Ok, global::Microsoft.AspNetCore.Http.HttpResults.ValidationProblem>> (global::Microsoft.AspNetCore.Identity.Data.RegisterRequest arg0, global::Microsoft.AspNetCore.Http.HttpContext arg1, global::System.IServiceProvider arg2) => throw null!);
                EndpointFilterDelegate? filteredInvocation = null;
                var serviceProvider = options.ServiceProvider ?? options.EndpointBuilder.ApplicationServices;
                var logOrThrowExceptionHelper = new LogOrThrowExceptionHelper(serviceProvider, options);
                var jsonOptions = serviceProvider?.GetService<IOptions<JsonOptions>>()?.Value ?? FallbackJsonOptions;
                var jsonSerializerOptions = jsonOptions.SerializerOptions;
                jsonSerializerOptions.MakeReadOnly();
                var objectJsonTypeInfo = (JsonTypeInfo<object?>)jsonSerializerOptions.GetTypeInfo(typeof(object));
                var registration_JsonTypeInfo = (JsonTypeInfo<global::Microsoft.AspNetCore.Identity.Data.RegisterRequest>)jsonSerializerOptions.GetTypeInfo(typeof(global::Microsoft.AspNetCore.Identity.Data.RegisterRequest));
 
                if (options.EndpointBuilder.FilterFactories.Count > 0)
                {
                    filteredInvocation = GeneratedRouteBuilderExtensionsCore.BuildFilterDelegate(async ic =>
                    {
                        if (ic.HttpContext.Response.StatusCode == 400)
                        {
                            return (object?)Results.Empty;
                        }
                        var task = handler(ic.GetArgument<global::Microsoft.AspNetCore.Identity.Data.RegisterRequest>(0)!, ic.GetArgument<global::Microsoft.AspNetCore.Http.HttpContext>(1)!, ic.GetArgument<global::System.IServiceProvider>(2)!);
                        var result = await task;
                        return (object?)result;
                    },
                    options.EndpointBuilder,
                    handler.Method);
                }
 
                async Task RequestHandler(HttpContext httpContext)
                {
                    var wasParamCheckFailure = false;
                    // Endpoint Parameter: registration (Type = Microsoft.AspNetCore.Identity.Data.RegisterRequest, IsOptional = False, IsParsable = False, IsArray = False, Source = JsonBody)
                    var registration_resolveBodyResult = await GeneratedRouteBuilderExtensionsCore.TryResolveBodyAsync<global::Microsoft.AspNetCore.Identity.Data.RegisterRequest>(httpContext, logOrThrowExceptionHelper, false, "RegisterRequest", "registration", registration_JsonTypeInfo);
                    var registration_local = registration_resolveBodyResult.Item2;
                    if (!registration_resolveBodyResult.Item1)
                    {
                        return;
                    }
                    var context_local = httpContext;
                    // Endpoint Parameter: sp (Type = System.IServiceProvider, IsOptional = False, IsParsable = False, IsArray = False, Source = Service)
                    var sp_local = httpContext.RequestServices.GetRequiredService<global::System.IServiceProvider>();
 
                    if (wasParamCheckFailure)
                    {
                        httpContext.Response.StatusCode = 400;
                        return;
                    }
                    var task = handler(registration_local!, context_local, sp_local);
                    var result = await task;
                    if (result == null)
                    {
                        throw new InvalidOperationException("The IResult returned by the Delegate must not be null.");
                    }
                    await GeneratedRouteBuilderExtensionsCore.ExecuteAsyncExplicit(result, httpContext);
                }
 
                async Task RequestHandlerFiltered(HttpContext httpContext)
                {
                    var wasParamCheckFailure = false;
                    // Endpoint Parameter: registration (Type = Microsoft.AspNetCore.Identity.Data.RegisterRequest, IsOptional = False, IsParsable = False, IsArray = False, Source = JsonBody)
                    var registration_resolveBodyResult = await GeneratedRouteBuilderExtensionsCore.TryResolveBodyAsync<global::Microsoft.AspNetCore.Identity.Data.RegisterRequest>(httpContext, logOrThrowExceptionHelper, false, "RegisterRequest", "registration", registration_JsonTypeInfo);
                    var registration_local = registration_resolveBodyResult.Item2;
                    if (!registration_resolveBodyResult.Item1)
                    {
                        return;
                    }
                    var context_local = httpContext;
                    // Endpoint Parameter: sp (Type = System.IServiceProvider, IsOptional = False, IsParsable = False, IsArray = False, Source = Service)
                    var sp_local = httpContext.RequestServices.GetRequiredService<global::System.IServiceProvider>();
 
                    if (wasParamCheckFailure)
                    {
                        httpContext.Response.StatusCode = 400;
                    }
                    var result = await filteredInvocation(EndpointFilterInvocationContext.Create<global::Microsoft.AspNetCore.Identity.Data.RegisterRequest, global::Microsoft.AspNetCore.Http.HttpContext, global::System.IServiceProvider>(httpContext, registration_local!, context_local, sp_local));
                    if (result is not null)
                    {
                        await GeneratedRouteBuilderExtensionsCore.ExecuteReturnAsync(result, httpContext, objectJsonTypeInfo);
                    }
                }
 
                RequestDelegate targetDelegate = filteredInvocation is null ? RequestHandler : RequestHandlerFiltered;
                var metadata = inferredMetadataResult?.EndpointMetadata ?? ReadOnlyCollection<object>.Empty;
                return new RequestDelegateResult(targetDelegate, metadata);
            };
            var castHandler = Cast(handler, global::System.Threading.Tasks.Task<global::Microsoft.AspNetCore.Http.HttpResults.Results<global::Microsoft.AspNetCore.Http.HttpResults.Ok, global::Microsoft.AspNetCore.Http.HttpResults.ValidationProblem>> (global::Microsoft.AspNetCore.Identity.Data.RegisterRequest arg0, global::Microsoft.AspNetCore.Http.HttpContext arg1, global::System.IServiceProvider arg2) => throw null!);
            return MapCore(
                endpoints,
                pattern,
                handler,
                PostVerb,
                populateMetadata,
                createRequestDelegate,
                castHandler.Method);
        }
 
        [global::System.Runtime.CompilerServices.InterceptsLocationAttribute(1, "J4fwklE6dqSkeKxd+PIY0wsRAABJZGVudGl0eUFwaUVuZHBvaW50Um91dGVCdWlsZGVyRXh0ZW5zaW9ucy5jcw==")]
        internal static RouteHandlerBuilder MapPost1(
            this IEndpointRouteBuilder endpoints,
            [StringSyntax("Route")] string pattern,
            Delegate handler)
        {
            MetadataPopulator populateMetadata = (methodInfo, options) =>
            {
                Debug.Assert(options != null, "RequestDelegateFactoryOptions not found.");
                Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found.");
                options.EndpointBuilder.Metadata.Add(new System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.AspNetCore.Http.RequestDelegateGenerator, Version=42.42.42.42, Culture=neutral, PublicKeyToken=adb9793829ddae60", "42.42.42.42"));
                options.EndpointBuilder.Metadata.Add(new AcceptsMetadata(type: typeof(global::Microsoft.AspNetCore.Identity.Data.LoginRequest), isOptional: false, contentTypes: GeneratedMetadataConstants.JsonContentType));
                var parameters = methodInfo.GetParameters();
                options.EndpointBuilder.Metadata.Add(new ParameterBindingMetadata("login", parameters[0], hasTryParse: false, hasBindAsync: false, isOptional: false));
                options.EndpointBuilder.Metadata.Add(new ParameterBindingMetadata("useCookies", parameters[1], hasTryParse: true, hasBindAsync: false, isOptional: true));
                options.EndpointBuilder.Metadata.Add(new ParameterBindingMetadata("useSessionCookies", parameters[2], hasTryParse: true, hasBindAsync: false, isOptional: true));
                options.EndpointBuilder.Metadata.Add(new ParameterBindingMetadata("sp", parameters[3], hasTryParse: false, hasBindAsync: false, isOptional: false));
                PopulateMetadataForEndpoint<global::Microsoft.AspNetCore.Http.HttpResults.Results<global::Microsoft.AspNetCore.Http.HttpResults.Ok<global::Microsoft.AspNetCore.Authentication.BearerToken.AccessTokenResponse>, global::Microsoft.AspNetCore.Http.HttpResults.EmptyHttpResult, global::Microsoft.AspNetCore.Http.HttpResults.ProblemHttpResult>>(methodInfo, options.EndpointBuilder);
                return new RequestDelegateMetadataResult { EndpointMetadata = options.EndpointBuilder.Metadata.AsReadOnly() };
            };
            RequestDelegateFactoryFunc createRequestDelegate = (del, options, inferredMetadataResult) =>
            {
                Debug.Assert(options != null, "RequestDelegateFactoryOptions not found.");
                Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found.");
                Debug.Assert(options.EndpointBuilder.ApplicationServices != null, "ApplicationServices not found.");
                Debug.Assert(options.EndpointBuilder.FilterFactories != null, "FilterFactories not found.");
                var handler = Cast(del, global::System.Threading.Tasks.Task<global::Microsoft.AspNetCore.Http.HttpResults.Results<global::Microsoft.AspNetCore.Http.HttpResults.Ok<global::Microsoft.AspNetCore.Authentication.BearerToken.AccessTokenResponse>, global::Microsoft.AspNetCore.Http.HttpResults.EmptyHttpResult, global::Microsoft.AspNetCore.Http.HttpResults.ProblemHttpResult>> (global::Microsoft.AspNetCore.Identity.Data.LoginRequest arg0, global::System.Boolean? arg1, global::System.Boolean? arg2, global::System.IServiceProvider arg3) => throw null!);
                EndpointFilterDelegate? filteredInvocation = null;
                var serviceProvider = options.ServiceProvider ?? options.EndpointBuilder.ApplicationServices;
                var logOrThrowExceptionHelper = new LogOrThrowExceptionHelper(serviceProvider, options);
                var jsonOptions = serviceProvider?.GetService<IOptions<JsonOptions>>()?.Value ?? FallbackJsonOptions;
                var jsonSerializerOptions = jsonOptions.SerializerOptions;
                jsonSerializerOptions.MakeReadOnly();
                var objectJsonTypeInfo = (JsonTypeInfo<object?>)jsonSerializerOptions.GetTypeInfo(typeof(object));
                var login_JsonTypeInfo = (JsonTypeInfo<global::Microsoft.AspNetCore.Identity.Data.LoginRequest>)jsonSerializerOptions.GetTypeInfo(typeof(global::Microsoft.AspNetCore.Identity.Data.LoginRequest));
 
                if (options.EndpointBuilder.FilterFactories.Count > 0)
                {
                    filteredInvocation = GeneratedRouteBuilderExtensionsCore.BuildFilterDelegate(async ic =>
                    {
                        if (ic.HttpContext.Response.StatusCode == 400)
                        {
                            return (object?)Results.Empty;
                        }
                        var task = handler(ic.GetArgument<global::Microsoft.AspNetCore.Identity.Data.LoginRequest>(0)!, ic.GetArgument<global::System.Boolean?>(1)!, ic.GetArgument<global::System.Boolean?>(2)!, ic.GetArgument<global::System.IServiceProvider>(3)!);
                        var result = await task;
                        return (object?)result;
                    },
                    options.EndpointBuilder,
                    handler.Method);
                }
 
                async Task RequestHandler(HttpContext httpContext)
                {
                    var wasParamCheckFailure = false;
                    // Endpoint Parameter: login (Type = Microsoft.AspNetCore.Identity.Data.LoginRequest, IsOptional = False, IsParsable = False, IsArray = False, Source = JsonBody)
                    var login_resolveBodyResult = await GeneratedRouteBuilderExtensionsCore.TryResolveBodyAsync<global::Microsoft.AspNetCore.Identity.Data.LoginRequest>(httpContext, logOrThrowExceptionHelper, false, "LoginRequest", "login", login_JsonTypeInfo);
                    var login_local = login_resolveBodyResult.Item2;
                    if (!login_resolveBodyResult.Item1)
                    {
                        return;
                    }
                    // Endpoint Parameter: useCookies (Type = bool?, IsOptional = True, IsParsable = True, IsArray = False, Source = Query)
                    var useCookies_raw = httpContext.Request.Query["useCookies"];
                    var useCookies_temp = useCookies_raw.Count > 0 ? (string?)useCookies_raw : null;
                    global::System.Boolean? useCookies_parsed_temp = default;
                    if (GeneratedRouteBuilderExtensionsCore.TryParseExplicit<bool>(useCookies_temp!, CultureInfo.InvariantCulture, out var useCookies_temp_parsed_non_nullable))
                    {
                        useCookies_parsed_temp = useCookies_temp_parsed_non_nullable;
                    }
                    else if (string.IsNullOrEmpty(useCookies_temp))
                    {
                        useCookies_parsed_temp = null;
                    }
                    else
                    {
                        wasParamCheckFailure = true;
                    }
                    bool? useCookies_local = useCookies_parsed_temp!;
                    // Endpoint Parameter: useSessionCookies (Type = bool?, IsOptional = True, IsParsable = True, IsArray = False, Source = Query)
                    var useSessionCookies_raw = httpContext.Request.Query["useSessionCookies"];
                    var useSessionCookies_temp = useSessionCookies_raw.Count > 0 ? (string?)useSessionCookies_raw : null;
                    global::System.Boolean? useSessionCookies_parsed_temp = default;
                    if (GeneratedRouteBuilderExtensionsCore.TryParseExplicit<bool>(useSessionCookies_temp!, CultureInfo.InvariantCulture, out var useSessionCookies_temp_parsed_non_nullable))
                    {
                        useSessionCookies_parsed_temp = useSessionCookies_temp_parsed_non_nullable;
                    }
                    else if (string.IsNullOrEmpty(useSessionCookies_temp))
                    {
                        useSessionCookies_parsed_temp = null;
                    }
                    else
                    {
                        wasParamCheckFailure = true;
                    }
                    bool? useSessionCookies_local = useSessionCookies_parsed_temp!;
                    // Endpoint Parameter: sp (Type = System.IServiceProvider, IsOptional = False, IsParsable = False, IsArray = False, Source = Service)
                    var sp_local = httpContext.RequestServices.GetRequiredService<global::System.IServiceProvider>();
 
                    if (wasParamCheckFailure)
                    {
                        httpContext.Response.StatusCode = 400;
                        return;
                    }
                    var task = handler(login_local!, useCookies_local, useSessionCookies_local, sp_local);
                    var result = await task;
                    if (result == null)
                    {
                        throw new InvalidOperationException("The IResult returned by the Delegate must not be null.");
                    }
                    await GeneratedRouteBuilderExtensionsCore.ExecuteAsyncExplicit(result, httpContext);
                }
 
                async Task RequestHandlerFiltered(HttpContext httpContext)
                {
                    var wasParamCheckFailure = false;
                    // Endpoint Parameter: login (Type = Microsoft.AspNetCore.Identity.Data.LoginRequest, IsOptional = False, IsParsable = False, IsArray = False, Source = JsonBody)
                    var login_resolveBodyResult = await GeneratedRouteBuilderExtensionsCore.TryResolveBodyAsync<global::Microsoft.AspNetCore.Identity.Data.LoginRequest>(httpContext, logOrThrowExceptionHelper, false, "LoginRequest", "login", login_JsonTypeInfo);
                    var login_local = login_resolveBodyResult.Item2;
                    if (!login_resolveBodyResult.Item1)
                    {
                        return;
                    }
                    // Endpoint Parameter: useCookies (Type = bool?, IsOptional = True, IsParsable = True, IsArray = False, Source = Query)
                    var useCookies_raw = httpContext.Request.Query["useCookies"];
                    var useCookies_temp = useCookies_raw.Count > 0 ? (string?)useCookies_raw : null;
                    global::System.Boolean? useCookies_parsed_temp = default;
                    if (GeneratedRouteBuilderExtensionsCore.TryParseExplicit<bool>(useCookies_temp!, CultureInfo.InvariantCulture, out var useCookies_temp_parsed_non_nullable))
                    {
                        useCookies_parsed_temp = useCookies_temp_parsed_non_nullable;
                    }
                    else if (string.IsNullOrEmpty(useCookies_temp))
                    {
                        useCookies_parsed_temp = null;
                    }
                    else
                    {
                        wasParamCheckFailure = true;
                    }
                    bool? useCookies_local = useCookies_parsed_temp!;
                    // Endpoint Parameter: useSessionCookies (Type = bool?, IsOptional = True, IsParsable = True, IsArray = False, Source = Query)
                    var useSessionCookies_raw = httpContext.Request.Query["useSessionCookies"];
                    var useSessionCookies_temp = useSessionCookies_raw.Count > 0 ? (string?)useSessionCookies_raw : null;
                    global::System.Boolean? useSessionCookies_parsed_temp = default;
                    if (GeneratedRouteBuilderExtensionsCore.TryParseExplicit<bool>(useSessionCookies_temp!, CultureInfo.InvariantCulture, out var useSessionCookies_temp_parsed_non_nullable))
                    {
                        useSessionCookies_parsed_temp = useSessionCookies_temp_parsed_non_nullable;
                    }
                    else if (string.IsNullOrEmpty(useSessionCookies_temp))
                    {
                        useSessionCookies_parsed_temp = null;
                    }
                    else
                    {
                        wasParamCheckFailure = true;
                    }
                    bool? useSessionCookies_local = useSessionCookies_parsed_temp!;
                    // Endpoint Parameter: sp (Type = System.IServiceProvider, IsOptional = False, IsParsable = False, IsArray = False, Source = Service)
                    var sp_local = httpContext.RequestServices.GetRequiredService<global::System.IServiceProvider>();
 
                    if (wasParamCheckFailure)
                    {
                        httpContext.Response.StatusCode = 400;
                    }
                    var result = await filteredInvocation(EndpointFilterInvocationContext.Create<global::Microsoft.AspNetCore.Identity.Data.LoginRequest, global::System.Boolean?, global::System.Boolean?, global::System.IServiceProvider>(httpContext, login_local!, useCookies_local, useSessionCookies_local, sp_local));
                    if (result is not null)
                    {
                        await GeneratedRouteBuilderExtensionsCore.ExecuteReturnAsync(result, httpContext, objectJsonTypeInfo);
                    }
                }
 
                RequestDelegate targetDelegate = filteredInvocation is null ? RequestHandler : RequestHandlerFiltered;
                var metadata = inferredMetadataResult?.EndpointMetadata ?? ReadOnlyCollection<object>.Empty;
                return new RequestDelegateResult(targetDelegate, metadata);
            };
            var castHandler = Cast(handler, global::System.Threading.Tasks.Task<global::Microsoft.AspNetCore.Http.HttpResults.Results<global::Microsoft.AspNetCore.Http.HttpResults.Ok<global::Microsoft.AspNetCore.Authentication.BearerToken.AccessTokenResponse>, global::Microsoft.AspNetCore.Http.HttpResults.EmptyHttpResult, global::Microsoft.AspNetCore.Http.HttpResults.ProblemHttpResult>> (global::Microsoft.AspNetCore.Identity.Data.LoginRequest arg0, global::System.Boolean? arg1, global::System.Boolean? arg2, global::System.IServiceProvider arg3) => throw null!);
            return MapCore(
                endpoints,
                pattern,
                handler,
                PostVerb,
                populateMetadata,
                createRequestDelegate,
                castHandler.Method);
        }
 
        [global::System.Runtime.CompilerServices.InterceptsLocationAttribute(1, "J4fwklE6dqSkeKxd+PIY078XAABJZGVudGl0eUFwaUVuZHBvaW50Um91dGVCdWlsZGVyRXh0ZW5zaW9ucy5jcw==")]
        internal static RouteHandlerBuilder MapPost2(
            this IEndpointRouteBuilder endpoints,
            [StringSyntax("Route")] string pattern,
            Delegate handler)
        {
            MetadataPopulator populateMetadata = (methodInfo, options) =>
            {
                Debug.Assert(options != null, "RequestDelegateFactoryOptions not found.");
                Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found.");
                options.EndpointBuilder.Metadata.Add(new System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.AspNetCore.Http.RequestDelegateGenerator, Version=42.42.42.42, Culture=neutral, PublicKeyToken=adb9793829ddae60", "42.42.42.42"));
                options.EndpointBuilder.Metadata.Add(new AcceptsMetadata(type: typeof(global::Microsoft.AspNetCore.Identity.Data.RefreshRequest), isOptional: false, contentTypes: GeneratedMetadataConstants.JsonContentType));
                var parameters = methodInfo.GetParameters();
                options.EndpointBuilder.Metadata.Add(new ParameterBindingMetadata("refreshRequest", parameters[0], hasTryParse: false, hasBindAsync: false, isOptional: false));
                options.EndpointBuilder.Metadata.Add(new ParameterBindingMetadata("sp", parameters[1], hasTryParse: false, hasBindAsync: false, isOptional: false));
                PopulateMetadataForEndpoint<global::Microsoft.AspNetCore.Http.HttpResults.Results<global::Microsoft.AspNetCore.Http.HttpResults.Ok<global::Microsoft.AspNetCore.Authentication.BearerToken.AccessTokenResponse>, global::Microsoft.AspNetCore.Http.HttpResults.UnauthorizedHttpResult, global::Microsoft.AspNetCore.Http.HttpResults.SignInHttpResult, global::Microsoft.AspNetCore.Http.HttpResults.ChallengeHttpResult>>(methodInfo, options.EndpointBuilder);
                return new RequestDelegateMetadataResult { EndpointMetadata = options.EndpointBuilder.Metadata.AsReadOnly() };
            };
            RequestDelegateFactoryFunc createRequestDelegate = (del, options, inferredMetadataResult) =>
            {
                Debug.Assert(options != null, "RequestDelegateFactoryOptions not found.");
                Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found.");
                Debug.Assert(options.EndpointBuilder.ApplicationServices != null, "ApplicationServices not found.");
                Debug.Assert(options.EndpointBuilder.FilterFactories != null, "FilterFactories not found.");
                var handler = Cast(del, global::System.Threading.Tasks.Task<global::Microsoft.AspNetCore.Http.HttpResults.Results<global::Microsoft.AspNetCore.Http.HttpResults.Ok<global::Microsoft.AspNetCore.Authentication.BearerToken.AccessTokenResponse>, global::Microsoft.AspNetCore.Http.HttpResults.UnauthorizedHttpResult, global::Microsoft.AspNetCore.Http.HttpResults.SignInHttpResult, global::Microsoft.AspNetCore.Http.HttpResults.ChallengeHttpResult>> (global::Microsoft.AspNetCore.Identity.Data.RefreshRequest arg0, global::System.IServiceProvider arg1) => throw null!);
                EndpointFilterDelegate? filteredInvocation = null;
                var serviceProvider = options.ServiceProvider ?? options.EndpointBuilder.ApplicationServices;
                var logOrThrowExceptionHelper = new LogOrThrowExceptionHelper(serviceProvider, options);
                var jsonOptions = serviceProvider?.GetService<IOptions<JsonOptions>>()?.Value ?? FallbackJsonOptions;
                var jsonSerializerOptions = jsonOptions.SerializerOptions;
                jsonSerializerOptions.MakeReadOnly();
                var objectJsonTypeInfo = (JsonTypeInfo<object?>)jsonSerializerOptions.GetTypeInfo(typeof(object));
                var refreshRequest_JsonTypeInfo = (JsonTypeInfo<global::Microsoft.AspNetCore.Identity.Data.RefreshRequest>)jsonSerializerOptions.GetTypeInfo(typeof(global::Microsoft.AspNetCore.Identity.Data.RefreshRequest));
 
                if (options.EndpointBuilder.FilterFactories.Count > 0)
                {
                    filteredInvocation = GeneratedRouteBuilderExtensionsCore.BuildFilterDelegate(async ic =>
                    {
                        if (ic.HttpContext.Response.StatusCode == 400)
                        {
                            return (object?)Results.Empty;
                        }
                        var task = handler(ic.GetArgument<global::Microsoft.AspNetCore.Identity.Data.RefreshRequest>(0)!, ic.GetArgument<global::System.IServiceProvider>(1)!);
                        var result = await task;
                        return (object?)result;
                    },
                    options.EndpointBuilder,
                    handler.Method);
                }
 
                async Task RequestHandler(HttpContext httpContext)
                {
                    var wasParamCheckFailure = false;
                    // Endpoint Parameter: refreshRequest (Type = Microsoft.AspNetCore.Identity.Data.RefreshRequest, IsOptional = False, IsParsable = False, IsArray = False, Source = JsonBody)
                    var refreshRequest_resolveBodyResult = await GeneratedRouteBuilderExtensionsCore.TryResolveBodyAsync<global::Microsoft.AspNetCore.Identity.Data.RefreshRequest>(httpContext, logOrThrowExceptionHelper, false, "RefreshRequest", "refreshRequest", refreshRequest_JsonTypeInfo);
                    var refreshRequest_local = refreshRequest_resolveBodyResult.Item2;
                    if (!refreshRequest_resolveBodyResult.Item1)
                    {
                        return;
                    }
                    // Endpoint Parameter: sp (Type = System.IServiceProvider, IsOptional = False, IsParsable = False, IsArray = False, Source = Service)
                    var sp_local = httpContext.RequestServices.GetRequiredService<global::System.IServiceProvider>();
 
                    if (wasParamCheckFailure)
                    {
                        httpContext.Response.StatusCode = 400;
                        return;
                    }
                    var task = handler(refreshRequest_local!, sp_local);
                    var result = await task;
                    if (result == null)
                    {
                        throw new InvalidOperationException("The IResult returned by the Delegate must not be null.");
                    }
                    await GeneratedRouteBuilderExtensionsCore.ExecuteAsyncExplicit(result, httpContext);
                }
 
                async Task RequestHandlerFiltered(HttpContext httpContext)
                {
                    var wasParamCheckFailure = false;
                    // Endpoint Parameter: refreshRequest (Type = Microsoft.AspNetCore.Identity.Data.RefreshRequest, IsOptional = False, IsParsable = False, IsArray = False, Source = JsonBody)
                    var refreshRequest_resolveBodyResult = await GeneratedRouteBuilderExtensionsCore.TryResolveBodyAsync<global::Microsoft.AspNetCore.Identity.Data.RefreshRequest>(httpContext, logOrThrowExceptionHelper, false, "RefreshRequest", "refreshRequest", refreshRequest_JsonTypeInfo);
                    var refreshRequest_local = refreshRequest_resolveBodyResult.Item2;
                    if (!refreshRequest_resolveBodyResult.Item1)
                    {
                        return;
                    }
                    // Endpoint Parameter: sp (Type = System.IServiceProvider, IsOptional = False, IsParsable = False, IsArray = False, Source = Service)
                    var sp_local = httpContext.RequestServices.GetRequiredService<global::System.IServiceProvider>();
 
                    if (wasParamCheckFailure)
                    {
                        httpContext.Response.StatusCode = 400;
                    }
                    var result = await filteredInvocation(EndpointFilterInvocationContext.Create<global::Microsoft.AspNetCore.Identity.Data.RefreshRequest, global::System.IServiceProvider>(httpContext, refreshRequest_local!, sp_local));
                    if (result is not null)
                    {
                        await GeneratedRouteBuilderExtensionsCore.ExecuteReturnAsync(result, httpContext, objectJsonTypeInfo);
                    }
                }
 
                RequestDelegate targetDelegate = filteredInvocation is null ? RequestHandler : RequestHandlerFiltered;
                var metadata = inferredMetadataResult?.EndpointMetadata ?? ReadOnlyCollection<object>.Empty;
                return new RequestDelegateResult(targetDelegate, metadata);
            };
            var castHandler = Cast(handler, global::System.Threading.Tasks.Task<global::Microsoft.AspNetCore.Http.HttpResults.Results<global::Microsoft.AspNetCore.Http.HttpResults.Ok<global::Microsoft.AspNetCore.Authentication.BearerToken.AccessTokenResponse>, global::Microsoft.AspNetCore.Http.HttpResults.UnauthorizedHttpResult, global::Microsoft.AspNetCore.Http.HttpResults.SignInHttpResult, global::Microsoft.AspNetCore.Http.HttpResults.ChallengeHttpResult>> (global::Microsoft.AspNetCore.Identity.Data.RefreshRequest arg0, global::System.IServiceProvider arg1) => throw null!);
            return MapCore(
                endpoints,
                pattern,
                handler,
                PostVerb,
                populateMetadata,
                createRequestDelegate,
                castHandler.Method);
        }
 
        [global::System.Runtime.CompilerServices.InterceptsLocationAttribute(1, "J4fwklE6dqSkeKxd+PIY03McAABJZGVudGl0eUFwaUVuZHBvaW50Um91dGVCdWlsZGVyRXh0ZW5zaW9ucy5jcw==")]
        internal static RouteHandlerBuilder MapGet3(
            this IEndpointRouteBuilder endpoints,
            [StringSyntax("Route")] string pattern,
            Delegate handler)
        {
            MetadataPopulator populateMetadata = (methodInfo, options) =>
            {
                Debug.Assert(options != null, "RequestDelegateFactoryOptions not found.");
                Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found.");
                options.EndpointBuilder.Metadata.Add(new System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.AspNetCore.Http.RequestDelegateGenerator, Version=42.42.42.42, Culture=neutral, PublicKeyToken=adb9793829ddae60", "42.42.42.42"));
                var parameters = methodInfo.GetParameters();
                options.EndpointBuilder.Metadata.Add(new ParameterBindingMetadata("userId", parameters[0], hasTryParse: false, hasBindAsync: false, isOptional: false));
                options.EndpointBuilder.Metadata.Add(new ParameterBindingMetadata("code", parameters[1], hasTryParse: false, hasBindAsync: false, isOptional: false));
                options.EndpointBuilder.Metadata.Add(new ParameterBindingMetadata("changedEmail", parameters[2], hasTryParse: false, hasBindAsync: false, isOptional: true));
                options.EndpointBuilder.Metadata.Add(new ParameterBindingMetadata("sp", parameters[3], hasTryParse: false, hasBindAsync: false, isOptional: false));
                PopulateMetadataForEndpoint<global::Microsoft.AspNetCore.Http.HttpResults.Results<global::Microsoft.AspNetCore.Http.HttpResults.ContentHttpResult, global::Microsoft.AspNetCore.Http.HttpResults.UnauthorizedHttpResult>>(methodInfo, options.EndpointBuilder);
                return new RequestDelegateMetadataResult { EndpointMetadata = options.EndpointBuilder.Metadata.AsReadOnly() };
            };
            RequestDelegateFactoryFunc createRequestDelegate = (del, options, inferredMetadataResult) =>
            {
                Debug.Assert(options != null, "RequestDelegateFactoryOptions not found.");
                Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found.");
                Debug.Assert(options.EndpointBuilder.ApplicationServices != null, "ApplicationServices not found.");
                Debug.Assert(options.EndpointBuilder.FilterFactories != null, "FilterFactories not found.");
                var handler = Cast(del, global::System.Threading.Tasks.Task<global::Microsoft.AspNetCore.Http.HttpResults.Results<global::Microsoft.AspNetCore.Http.HttpResults.ContentHttpResult, global::Microsoft.AspNetCore.Http.HttpResults.UnauthorizedHttpResult>> (global::System.String arg0, global::System.String arg1, global::System.String? arg2, global::System.IServiceProvider arg3) => throw null!);
                EndpointFilterDelegate? filteredInvocation = null;
                var serviceProvider = options.ServiceProvider ?? options.EndpointBuilder.ApplicationServices;
                var logOrThrowExceptionHelper = new LogOrThrowExceptionHelper(serviceProvider, options);
                var jsonOptions = serviceProvider?.GetService<IOptions<JsonOptions>>()?.Value ?? FallbackJsonOptions;
                var jsonSerializerOptions = jsonOptions.SerializerOptions;
                jsonSerializerOptions.MakeReadOnly();
                var objectJsonTypeInfo = (JsonTypeInfo<object?>)jsonSerializerOptions.GetTypeInfo(typeof(object));
 
                if (options.EndpointBuilder.FilterFactories.Count > 0)
                {
                    filteredInvocation = GeneratedRouteBuilderExtensionsCore.BuildFilterDelegate(async ic =>
                    {
                        if (ic.HttpContext.Response.StatusCode == 400)
                        {
                            return (object?)Results.Empty;
                        }
                        var task = handler(ic.GetArgument<global::System.String>(0)!, ic.GetArgument<global::System.String>(1)!, ic.GetArgument<global::System.String?>(2)!, ic.GetArgument<global::System.IServiceProvider>(3)!);
                        var result = await task;
                        return (object?)result;
                    },
                    options.EndpointBuilder,
                    handler.Method);
                }
 
                async Task RequestHandler(HttpContext httpContext)
                {
                    var wasParamCheckFailure = false;
                    // Endpoint Parameter: userId (Type = string, IsOptional = False, IsParsable = False, IsArray = False, Source = Query)
                    var userId_raw = httpContext.Request.Query["userId"];
                    if (StringValues.IsNullOrEmpty(userId_raw))
                    {
                        wasParamCheckFailure = true;
                        logOrThrowExceptionHelper.RequiredParameterNotProvided("string", "userId", "query string");
                    }
                    var userId_temp = (string?)userId_raw;
                    string userId_local = userId_temp!;
                    // Endpoint Parameter: code (Type = string, IsOptional = False, IsParsable = False, IsArray = False, Source = Query)
                    var code_raw = httpContext.Request.Query["code"];
                    if (StringValues.IsNullOrEmpty(code_raw))
                    {
                        wasParamCheckFailure = true;
                        logOrThrowExceptionHelper.RequiredParameterNotProvided("string", "code", "query string");
                    }
                    var code_temp = (string?)code_raw;
                    string code_local = code_temp!;
                    // Endpoint Parameter: changedEmail (Type = string?, IsOptional = True, IsParsable = False, IsArray = False, Source = Query)
                    var changedEmail_raw = httpContext.Request.Query["changedEmail"];
                    var changedEmail_temp = changedEmail_raw.Count > 0 ? (string?)changedEmail_raw : null;
                    string changedEmail_local = changedEmail_temp!;
                    // Endpoint Parameter: sp (Type = System.IServiceProvider, IsOptional = False, IsParsable = False, IsArray = False, Source = Service)
                    var sp_local = httpContext.RequestServices.GetRequiredService<global::System.IServiceProvider>();
 
                    if (wasParamCheckFailure)
                    {
                        httpContext.Response.StatusCode = 400;
                        return;
                    }
                    var task = handler(userId_local, code_local, changedEmail_local, sp_local);
                    var result = await task;
                    if (result == null)
                    {
                        throw new InvalidOperationException("The IResult returned by the Delegate must not be null.");
                    }
                    await GeneratedRouteBuilderExtensionsCore.ExecuteAsyncExplicit(result, httpContext);
                }
 
                async Task RequestHandlerFiltered(HttpContext httpContext)
                {
                    var wasParamCheckFailure = false;
                    // Endpoint Parameter: userId (Type = string, IsOptional = False, IsParsable = False, IsArray = False, Source = Query)
                    var userId_raw = httpContext.Request.Query["userId"];
                    if (StringValues.IsNullOrEmpty(userId_raw))
                    {
                        wasParamCheckFailure = true;
                        logOrThrowExceptionHelper.RequiredParameterNotProvided("string", "userId", "query string");
                    }
                    var userId_temp = (string?)userId_raw;
                    string userId_local = userId_temp!;
                    // Endpoint Parameter: code (Type = string, IsOptional = False, IsParsable = False, IsArray = False, Source = Query)
                    var code_raw = httpContext.Request.Query["code"];
                    if (StringValues.IsNullOrEmpty(code_raw))
                    {
                        wasParamCheckFailure = true;
                        logOrThrowExceptionHelper.RequiredParameterNotProvided("string", "code", "query string");
                    }
                    var code_temp = (string?)code_raw;
                    string code_local = code_temp!;
                    // Endpoint Parameter: changedEmail (Type = string?, IsOptional = True, IsParsable = False, IsArray = False, Source = Query)
                    var changedEmail_raw = httpContext.Request.Query["changedEmail"];
                    var changedEmail_temp = changedEmail_raw.Count > 0 ? (string?)changedEmail_raw : null;
                    string changedEmail_local = changedEmail_temp!;
                    // Endpoint Parameter: sp (Type = System.IServiceProvider, IsOptional = False, IsParsable = False, IsArray = False, Source = Service)
                    var sp_local = httpContext.RequestServices.GetRequiredService<global::System.IServiceProvider>();
 
                    if (wasParamCheckFailure)
                    {
                        httpContext.Response.StatusCode = 400;
                    }
                    var result = await filteredInvocation(EndpointFilterInvocationContext.Create<global::System.String, global::System.String, global::System.String?, global::System.IServiceProvider>(httpContext, userId_local, code_local, changedEmail_local, sp_local));
                    if (result is not null)
                    {
                        await GeneratedRouteBuilderExtensionsCore.ExecuteReturnAsync(result, httpContext, objectJsonTypeInfo);
                    }
                }
 
                RequestDelegate targetDelegate = filteredInvocation is null ? RequestHandler : RequestHandlerFiltered;
                var metadata = inferredMetadataResult?.EndpointMetadata ?? ReadOnlyCollection<object>.Empty;
                return new RequestDelegateResult(targetDelegate, metadata);
            };
            var castHandler = Cast(handler, global::System.Threading.Tasks.Task<global::Microsoft.AspNetCore.Http.HttpResults.Results<global::Microsoft.AspNetCore.Http.HttpResults.ContentHttpResult, global::Microsoft.AspNetCore.Http.HttpResults.UnauthorizedHttpResult>> (global::System.String arg0, global::System.String arg1, global::System.String? arg2, global::System.IServiceProvider arg3) => throw null!);
            return MapCore(
                endpoints,
                pattern,
                handler,
                GetVerb,
                populateMetadata,
                createRequestDelegate,
                castHandler.Method);
        }
 
        [global::System.Runtime.CompilerServices.InterceptsLocationAttribute(1, "J4fwklE6dqSkeKxd+PIY05QkAABJZGVudGl0eUFwaUVuZHBvaW50Um91dGVCdWlsZGVyRXh0ZW5zaW9ucy5jcw==")]
        internal static RouteHandlerBuilder MapPost4(
            this IEndpointRouteBuilder endpoints,
            [StringSyntax("Route")] string pattern,
            Delegate handler)
        {
            MetadataPopulator populateMetadata = (methodInfo, options) =>
            {
                Debug.Assert(options != null, "RequestDelegateFactoryOptions not found.");
                Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found.");
                options.EndpointBuilder.Metadata.Add(new System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.AspNetCore.Http.RequestDelegateGenerator, Version=42.42.42.42, Culture=neutral, PublicKeyToken=adb9793829ddae60", "42.42.42.42"));
                options.EndpointBuilder.Metadata.Add(new AcceptsMetadata(type: typeof(global::Microsoft.AspNetCore.Identity.Data.ResendConfirmationEmailRequest), isOptional: false, contentTypes: GeneratedMetadataConstants.JsonContentType));
                var parameters = methodInfo.GetParameters();
                options.EndpointBuilder.Metadata.Add(new ParameterBindingMetadata("resendRequest", parameters[0], hasTryParse: false, hasBindAsync: false, isOptional: false));
                options.EndpointBuilder.Metadata.Add(new ParameterBindingMetadata("context", parameters[1], hasTryParse: false, hasBindAsync: false, isOptional: false));
                options.EndpointBuilder.Metadata.Add(new ParameterBindingMetadata("sp", parameters[2], hasTryParse: false, hasBindAsync: false, isOptional: false));
                PopulateMetadataForEndpoint<global::Microsoft.AspNetCore.Http.HttpResults.Ok>(methodInfo, options.EndpointBuilder);
                return new RequestDelegateMetadataResult { EndpointMetadata = options.EndpointBuilder.Metadata.AsReadOnly() };
            };
            RequestDelegateFactoryFunc createRequestDelegate = (del, options, inferredMetadataResult) =>
            {
                Debug.Assert(options != null, "RequestDelegateFactoryOptions not found.");
                Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found.");
                Debug.Assert(options.EndpointBuilder.ApplicationServices != null, "ApplicationServices not found.");
                Debug.Assert(options.EndpointBuilder.FilterFactories != null, "FilterFactories not found.");
                var handler = Cast(del, global::System.Threading.Tasks.Task<global::Microsoft.AspNetCore.Http.HttpResults.Ok> (global::Microsoft.AspNetCore.Identity.Data.ResendConfirmationEmailRequest arg0, global::Microsoft.AspNetCore.Http.HttpContext arg1, global::System.IServiceProvider arg2) => throw null!);
                EndpointFilterDelegate? filteredInvocation = null;
                var serviceProvider = options.ServiceProvider ?? options.EndpointBuilder.ApplicationServices;
                var logOrThrowExceptionHelper = new LogOrThrowExceptionHelper(serviceProvider, options);
                var jsonOptions = serviceProvider?.GetService<IOptions<JsonOptions>>()?.Value ?? FallbackJsonOptions;
                var jsonSerializerOptions = jsonOptions.SerializerOptions;
                jsonSerializerOptions.MakeReadOnly();
                var objectJsonTypeInfo = (JsonTypeInfo<object?>)jsonSerializerOptions.GetTypeInfo(typeof(object));
                var resendRequest_JsonTypeInfo = (JsonTypeInfo<global::Microsoft.AspNetCore.Identity.Data.ResendConfirmationEmailRequest>)jsonSerializerOptions.GetTypeInfo(typeof(global::Microsoft.AspNetCore.Identity.Data.ResendConfirmationEmailRequest));
 
                if (options.EndpointBuilder.FilterFactories.Count > 0)
                {
                    filteredInvocation = GeneratedRouteBuilderExtensionsCore.BuildFilterDelegate(async ic =>
                    {
                        if (ic.HttpContext.Response.StatusCode == 400)
                        {
                            return (object?)Results.Empty;
                        }
                        var task = handler(ic.GetArgument<global::Microsoft.AspNetCore.Identity.Data.ResendConfirmationEmailRequest>(0)!, ic.GetArgument<global::Microsoft.AspNetCore.Http.HttpContext>(1)!, ic.GetArgument<global::System.IServiceProvider>(2)!);
                        var result = await task;
                        return (object?)result;
                    },
                    options.EndpointBuilder,
                    handler.Method);
                }
 
                async Task RequestHandler(HttpContext httpContext)
                {
                    var wasParamCheckFailure = false;
                    // Endpoint Parameter: resendRequest (Type = Microsoft.AspNetCore.Identity.Data.ResendConfirmationEmailRequest, IsOptional = False, IsParsable = False, IsArray = False, Source = JsonBody)
                    var resendRequest_resolveBodyResult = await GeneratedRouteBuilderExtensionsCore.TryResolveBodyAsync<global::Microsoft.AspNetCore.Identity.Data.ResendConfirmationEmailRequest>(httpContext, logOrThrowExceptionHelper, false, "ResendConfirmationEmailRequest", "resendRequest", resendRequest_JsonTypeInfo);
                    var resendRequest_local = resendRequest_resolveBodyResult.Item2;
                    if (!resendRequest_resolveBodyResult.Item1)
                    {
                        return;
                    }
                    var context_local = httpContext;
                    // Endpoint Parameter: sp (Type = System.IServiceProvider, IsOptional = False, IsParsable = False, IsArray = False, Source = Service)
                    var sp_local = httpContext.RequestServices.GetRequiredService<global::System.IServiceProvider>();
 
                    if (wasParamCheckFailure)
                    {
                        httpContext.Response.StatusCode = 400;
                        return;
                    }
                    var task = handler(resendRequest_local!, context_local, sp_local);
                    var result = await task;
                    if (result == null)
                    {
                        throw new InvalidOperationException("The IResult returned by the Delegate must not be null.");
                    }
                    await GeneratedRouteBuilderExtensionsCore.ExecuteAsyncExplicit(result, httpContext);
                }
 
                async Task RequestHandlerFiltered(HttpContext httpContext)
                {
                    var wasParamCheckFailure = false;
                    // Endpoint Parameter: resendRequest (Type = Microsoft.AspNetCore.Identity.Data.ResendConfirmationEmailRequest, IsOptional = False, IsParsable = False, IsArray = False, Source = JsonBody)
                    var resendRequest_resolveBodyResult = await GeneratedRouteBuilderExtensionsCore.TryResolveBodyAsync<global::Microsoft.AspNetCore.Identity.Data.ResendConfirmationEmailRequest>(httpContext, logOrThrowExceptionHelper, false, "ResendConfirmationEmailRequest", "resendRequest", resendRequest_JsonTypeInfo);
                    var resendRequest_local = resendRequest_resolveBodyResult.Item2;
                    if (!resendRequest_resolveBodyResult.Item1)
                    {
                        return;
                    }
                    var context_local = httpContext;
                    // Endpoint Parameter: sp (Type = System.IServiceProvider, IsOptional = False, IsParsable = False, IsArray = False, Source = Service)
                    var sp_local = httpContext.RequestServices.GetRequiredService<global::System.IServiceProvider>();
 
                    if (wasParamCheckFailure)
                    {
                        httpContext.Response.StatusCode = 400;
                    }
                    var result = await filteredInvocation(EndpointFilterInvocationContext.Create<global::Microsoft.AspNetCore.Identity.Data.ResendConfirmationEmailRequest, global::Microsoft.AspNetCore.Http.HttpContext, global::System.IServiceProvider>(httpContext, resendRequest_local!, context_local, sp_local));
                    if (result is not null)
                    {
                        await GeneratedRouteBuilderExtensionsCore.ExecuteReturnAsync(result, httpContext, objectJsonTypeInfo);
                    }
                }
 
                RequestDelegate targetDelegate = filteredInvocation is null ? RequestHandler : RequestHandlerFiltered;
                var metadata = inferredMetadataResult?.EndpointMetadata ?? ReadOnlyCollection<object>.Empty;
                return new RequestDelegateResult(targetDelegate, metadata);
            };
            var castHandler = Cast(handler, global::System.Threading.Tasks.Task<global::Microsoft.AspNetCore.Http.HttpResults.Ok> (global::Microsoft.AspNetCore.Identity.Data.ResendConfirmationEmailRequest arg0, global::Microsoft.AspNetCore.Http.HttpContext arg1, global::System.IServiceProvider arg2) => throw null!);
            return MapCore(
                endpoints,
                pattern,
                handler,
                PostVerb,
                populateMetadata,
                createRequestDelegate,
                castHandler.Method);
        }
 
        [global::System.Runtime.CompilerServices.InterceptsLocationAttribute(1, "J4fwklE6dqSkeKxd+PIY0/AmAABJZGVudGl0eUFwaUVuZHBvaW50Um91dGVCdWlsZGVyRXh0ZW5zaW9ucy5jcw==")]
        internal static RouteHandlerBuilder MapPost5(
            this IEndpointRouteBuilder endpoints,
            [StringSyntax("Route")] string pattern,
            Delegate handler)
        {
            MetadataPopulator populateMetadata = (methodInfo, options) =>
            {
                Debug.Assert(options != null, "RequestDelegateFactoryOptions not found.");
                Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found.");
                options.EndpointBuilder.Metadata.Add(new System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.AspNetCore.Http.RequestDelegateGenerator, Version=42.42.42.42, Culture=neutral, PublicKeyToken=adb9793829ddae60", "42.42.42.42"));
                options.EndpointBuilder.Metadata.Add(new AcceptsMetadata(type: typeof(global::Microsoft.AspNetCore.Identity.Data.ForgotPasswordRequest), isOptional: false, contentTypes: GeneratedMetadataConstants.JsonContentType));
                var parameters = methodInfo.GetParameters();
                options.EndpointBuilder.Metadata.Add(new ParameterBindingMetadata("resetRequest", parameters[0], hasTryParse: false, hasBindAsync: false, isOptional: false));
                options.EndpointBuilder.Metadata.Add(new ParameterBindingMetadata("sp", parameters[1], hasTryParse: false, hasBindAsync: false, isOptional: false));
                PopulateMetadataForEndpoint<global::Microsoft.AspNetCore.Http.HttpResults.Results<global::Microsoft.AspNetCore.Http.HttpResults.Ok, global::Microsoft.AspNetCore.Http.HttpResults.ValidationProblem>>(methodInfo, options.EndpointBuilder);
                return new RequestDelegateMetadataResult { EndpointMetadata = options.EndpointBuilder.Metadata.AsReadOnly() };
            };
            RequestDelegateFactoryFunc createRequestDelegate = (del, options, inferredMetadataResult) =>
            {
                Debug.Assert(options != null, "RequestDelegateFactoryOptions not found.");
                Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found.");
                Debug.Assert(options.EndpointBuilder.ApplicationServices != null, "ApplicationServices not found.");
                Debug.Assert(options.EndpointBuilder.FilterFactories != null, "FilterFactories not found.");
                var handler = Cast(del, global::System.Threading.Tasks.Task<global::Microsoft.AspNetCore.Http.HttpResults.Results<global::Microsoft.AspNetCore.Http.HttpResults.Ok, global::Microsoft.AspNetCore.Http.HttpResults.ValidationProblem>> (global::Microsoft.AspNetCore.Identity.Data.ForgotPasswordRequest arg0, global::System.IServiceProvider arg1) => throw null!);
                EndpointFilterDelegate? filteredInvocation = null;
                var serviceProvider = options.ServiceProvider ?? options.EndpointBuilder.ApplicationServices;
                var logOrThrowExceptionHelper = new LogOrThrowExceptionHelper(serviceProvider, options);
                var jsonOptions = serviceProvider?.GetService<IOptions<JsonOptions>>()?.Value ?? FallbackJsonOptions;
                var jsonSerializerOptions = jsonOptions.SerializerOptions;
                jsonSerializerOptions.MakeReadOnly();
                var objectJsonTypeInfo = (JsonTypeInfo<object?>)jsonSerializerOptions.GetTypeInfo(typeof(object));
                var resetRequest_JsonTypeInfo = (JsonTypeInfo<global::Microsoft.AspNetCore.Identity.Data.ForgotPasswordRequest>)jsonSerializerOptions.GetTypeInfo(typeof(global::Microsoft.AspNetCore.Identity.Data.ForgotPasswordRequest));
 
                if (options.EndpointBuilder.FilterFactories.Count > 0)
                {
                    filteredInvocation = GeneratedRouteBuilderExtensionsCore.BuildFilterDelegate(async ic =>
                    {
                        if (ic.HttpContext.Response.StatusCode == 400)
                        {
                            return (object?)Results.Empty;
                        }
                        var task = handler(ic.GetArgument<global::Microsoft.AspNetCore.Identity.Data.ForgotPasswordRequest>(0)!, ic.GetArgument<global::System.IServiceProvider>(1)!);
                        var result = await task;
                        return (object?)result;
                    },
                    options.EndpointBuilder,
                    handler.Method);
                }
 
                async Task RequestHandler(HttpContext httpContext)
                {
                    var wasParamCheckFailure = false;
                    // Endpoint Parameter: resetRequest (Type = Microsoft.AspNetCore.Identity.Data.ForgotPasswordRequest, IsOptional = False, IsParsable = False, IsArray = False, Source = JsonBody)
                    var resetRequest_resolveBodyResult = await GeneratedRouteBuilderExtensionsCore.TryResolveBodyAsync<global::Microsoft.AspNetCore.Identity.Data.ForgotPasswordRequest>(httpContext, logOrThrowExceptionHelper, false, "ForgotPasswordRequest", "resetRequest", resetRequest_JsonTypeInfo);
                    var resetRequest_local = resetRequest_resolveBodyResult.Item2;
                    if (!resetRequest_resolveBodyResult.Item1)
                    {
                        return;
                    }
                    // Endpoint Parameter: sp (Type = System.IServiceProvider, IsOptional = False, IsParsable = False, IsArray = False, Source = Service)
                    var sp_local = httpContext.RequestServices.GetRequiredService<global::System.IServiceProvider>();
 
                    if (wasParamCheckFailure)
                    {
                        httpContext.Response.StatusCode = 400;
                        return;
                    }
                    var task = handler(resetRequest_local!, sp_local);
                    var result = await task;
                    if (result == null)
                    {
                        throw new InvalidOperationException("The IResult returned by the Delegate must not be null.");
                    }
                    await GeneratedRouteBuilderExtensionsCore.ExecuteAsyncExplicit(result, httpContext);
                }
 
                async Task RequestHandlerFiltered(HttpContext httpContext)
                {
                    var wasParamCheckFailure = false;
                    // Endpoint Parameter: resetRequest (Type = Microsoft.AspNetCore.Identity.Data.ForgotPasswordRequest, IsOptional = False, IsParsable = False, IsArray = False, Source = JsonBody)
                    var resetRequest_resolveBodyResult = await GeneratedRouteBuilderExtensionsCore.TryResolveBodyAsync<global::Microsoft.AspNetCore.Identity.Data.ForgotPasswordRequest>(httpContext, logOrThrowExceptionHelper, false, "ForgotPasswordRequest", "resetRequest", resetRequest_JsonTypeInfo);
                    var resetRequest_local = resetRequest_resolveBodyResult.Item2;
                    if (!resetRequest_resolveBodyResult.Item1)
                    {
                        return;
                    }
                    // Endpoint Parameter: sp (Type = System.IServiceProvider, IsOptional = False, IsParsable = False, IsArray = False, Source = Service)
                    var sp_local = httpContext.RequestServices.GetRequiredService<global::System.IServiceProvider>();
 
                    if (wasParamCheckFailure)
                    {
                        httpContext.Response.StatusCode = 400;
                    }
                    var result = await filteredInvocation(EndpointFilterInvocationContext.Create<global::Microsoft.AspNetCore.Identity.Data.ForgotPasswordRequest, global::System.IServiceProvider>(httpContext, resetRequest_local!, sp_local));
                    if (result is not null)
                    {
                        await GeneratedRouteBuilderExtensionsCore.ExecuteReturnAsync(result, httpContext, objectJsonTypeInfo);
                    }
                }
 
                RequestDelegate targetDelegate = filteredInvocation is null ? RequestHandler : RequestHandlerFiltered;
                var metadata = inferredMetadataResult?.EndpointMetadata ?? ReadOnlyCollection<object>.Empty;
                return new RequestDelegateResult(targetDelegate, metadata);
            };
            var castHandler = Cast(handler, global::System.Threading.Tasks.Task<global::Microsoft.AspNetCore.Http.HttpResults.Results<global::Microsoft.AspNetCore.Http.HttpResults.Ok, global::Microsoft.AspNetCore.Http.HttpResults.ValidationProblem>> (global::Microsoft.AspNetCore.Identity.Data.ForgotPasswordRequest arg0, global::System.IServiceProvider arg1) => throw null!);
            return MapCore(
                endpoints,
                pattern,
                handler,
                PostVerb,
                populateMetadata,
                createRequestDelegate,
                castHandler.Method);
        }
 
        [global::System.Runtime.CompilerServices.InterceptsLocationAttribute(1, "J4fwklE6dqSkeKxd+PIY0+kqAABJZGVudGl0eUFwaUVuZHBvaW50Um91dGVCdWlsZGVyRXh0ZW5zaW9ucy5jcw==")]
        internal static RouteHandlerBuilder MapPost6(
            this IEndpointRouteBuilder endpoints,
            [StringSyntax("Route")] string pattern,
            Delegate handler)
        {
            MetadataPopulator populateMetadata = (methodInfo, options) =>
            {
                Debug.Assert(options != null, "RequestDelegateFactoryOptions not found.");
                Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found.");
                options.EndpointBuilder.Metadata.Add(new System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.AspNetCore.Http.RequestDelegateGenerator, Version=42.42.42.42, Culture=neutral, PublicKeyToken=adb9793829ddae60", "42.42.42.42"));
                options.EndpointBuilder.Metadata.Add(new AcceptsMetadata(type: typeof(global::Microsoft.AspNetCore.Identity.Data.ResetPasswordRequest), isOptional: false, contentTypes: GeneratedMetadataConstants.JsonContentType));
                var parameters = methodInfo.GetParameters();
                options.EndpointBuilder.Metadata.Add(new ParameterBindingMetadata("resetRequest", parameters[0], hasTryParse: false, hasBindAsync: false, isOptional: false));
                options.EndpointBuilder.Metadata.Add(new ParameterBindingMetadata("sp", parameters[1], hasTryParse: false, hasBindAsync: false, isOptional: false));
                PopulateMetadataForEndpoint<global::Microsoft.AspNetCore.Http.HttpResults.Results<global::Microsoft.AspNetCore.Http.HttpResults.Ok, global::Microsoft.AspNetCore.Http.HttpResults.ValidationProblem>>(methodInfo, options.EndpointBuilder);
                return new RequestDelegateMetadataResult { EndpointMetadata = options.EndpointBuilder.Metadata.AsReadOnly() };
            };
            RequestDelegateFactoryFunc createRequestDelegate = (del, options, inferredMetadataResult) =>
            {
                Debug.Assert(options != null, "RequestDelegateFactoryOptions not found.");
                Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found.");
                Debug.Assert(options.EndpointBuilder.ApplicationServices != null, "ApplicationServices not found.");
                Debug.Assert(options.EndpointBuilder.FilterFactories != null, "FilterFactories not found.");
                var handler = Cast(del, global::System.Threading.Tasks.Task<global::Microsoft.AspNetCore.Http.HttpResults.Results<global::Microsoft.AspNetCore.Http.HttpResults.Ok, global::Microsoft.AspNetCore.Http.HttpResults.ValidationProblem>> (global::Microsoft.AspNetCore.Identity.Data.ResetPasswordRequest arg0, global::System.IServiceProvider arg1) => throw null!);
                EndpointFilterDelegate? filteredInvocation = null;
                var serviceProvider = options.ServiceProvider ?? options.EndpointBuilder.ApplicationServices;
                var logOrThrowExceptionHelper = new LogOrThrowExceptionHelper(serviceProvider, options);
                var jsonOptions = serviceProvider?.GetService<IOptions<JsonOptions>>()?.Value ?? FallbackJsonOptions;
                var jsonSerializerOptions = jsonOptions.SerializerOptions;
                jsonSerializerOptions.MakeReadOnly();
                var objectJsonTypeInfo = (JsonTypeInfo<object?>)jsonSerializerOptions.GetTypeInfo(typeof(object));
                var resetRequest_JsonTypeInfo = (JsonTypeInfo<global::Microsoft.AspNetCore.Identity.Data.ResetPasswordRequest>)jsonSerializerOptions.GetTypeInfo(typeof(global::Microsoft.AspNetCore.Identity.Data.ResetPasswordRequest));
 
                if (options.EndpointBuilder.FilterFactories.Count > 0)
                {
                    filteredInvocation = GeneratedRouteBuilderExtensionsCore.BuildFilterDelegate(async ic =>
                    {
                        if (ic.HttpContext.Response.StatusCode == 400)
                        {
                            return (object?)Results.Empty;
                        }
                        var task = handler(ic.GetArgument<global::Microsoft.AspNetCore.Identity.Data.ResetPasswordRequest>(0)!, ic.GetArgument<global::System.IServiceProvider>(1)!);
                        var result = await task;
                        return (object?)result;
                    },
                    options.EndpointBuilder,
                    handler.Method);
                }
 
                async Task RequestHandler(HttpContext httpContext)
                {
                    var wasParamCheckFailure = false;
                    // Endpoint Parameter: resetRequest (Type = Microsoft.AspNetCore.Identity.Data.ResetPasswordRequest, IsOptional = False, IsParsable = False, IsArray = False, Source = JsonBody)
                    var resetRequest_resolveBodyResult = await GeneratedRouteBuilderExtensionsCore.TryResolveBodyAsync<global::Microsoft.AspNetCore.Identity.Data.ResetPasswordRequest>(httpContext, logOrThrowExceptionHelper, false, "ResetPasswordRequest", "resetRequest", resetRequest_JsonTypeInfo);
                    var resetRequest_local = resetRequest_resolveBodyResult.Item2;
                    if (!resetRequest_resolveBodyResult.Item1)
                    {
                        return;
                    }
                    // Endpoint Parameter: sp (Type = System.IServiceProvider, IsOptional = False, IsParsable = False, IsArray = False, Source = Service)
                    var sp_local = httpContext.RequestServices.GetRequiredService<global::System.IServiceProvider>();
 
                    if (wasParamCheckFailure)
                    {
                        httpContext.Response.StatusCode = 400;
                        return;
                    }
                    var task = handler(resetRequest_local!, sp_local);
                    var result = await task;
                    if (result == null)
                    {
                        throw new InvalidOperationException("The IResult returned by the Delegate must not be null.");
                    }
                    await GeneratedRouteBuilderExtensionsCore.ExecuteAsyncExplicit(result, httpContext);
                }
 
                async Task RequestHandlerFiltered(HttpContext httpContext)
                {
                    var wasParamCheckFailure = false;
                    // Endpoint Parameter: resetRequest (Type = Microsoft.AspNetCore.Identity.Data.ResetPasswordRequest, IsOptional = False, IsParsable = False, IsArray = False, Source = JsonBody)
                    var resetRequest_resolveBodyResult = await GeneratedRouteBuilderExtensionsCore.TryResolveBodyAsync<global::Microsoft.AspNetCore.Identity.Data.ResetPasswordRequest>(httpContext, logOrThrowExceptionHelper, false, "ResetPasswordRequest", "resetRequest", resetRequest_JsonTypeInfo);
                    var resetRequest_local = resetRequest_resolveBodyResult.Item2;
                    if (!resetRequest_resolveBodyResult.Item1)
                    {
                        return;
                    }
                    // Endpoint Parameter: sp (Type = System.IServiceProvider, IsOptional = False, IsParsable = False, IsArray = False, Source = Service)
                    var sp_local = httpContext.RequestServices.GetRequiredService<global::System.IServiceProvider>();
 
                    if (wasParamCheckFailure)
                    {
                        httpContext.Response.StatusCode = 400;
                    }
                    var result = await filteredInvocation(EndpointFilterInvocationContext.Create<global::Microsoft.AspNetCore.Identity.Data.ResetPasswordRequest, global::System.IServiceProvider>(httpContext, resetRequest_local!, sp_local));
                    if (result is not null)
                    {
                        await GeneratedRouteBuilderExtensionsCore.ExecuteReturnAsync(result, httpContext, objectJsonTypeInfo);
                    }
                }
 
                RequestDelegate targetDelegate = filteredInvocation is null ? RequestHandler : RequestHandlerFiltered;
                var metadata = inferredMetadataResult?.EndpointMetadata ?? ReadOnlyCollection<object>.Empty;
                return new RequestDelegateResult(targetDelegate, metadata);
            };
            var castHandler = Cast(handler, global::System.Threading.Tasks.Task<global::Microsoft.AspNetCore.Http.HttpResults.Results<global::Microsoft.AspNetCore.Http.HttpResults.Ok, global::Microsoft.AspNetCore.Http.HttpResults.ValidationProblem>> (global::Microsoft.AspNetCore.Identity.Data.ResetPasswordRequest arg0, global::System.IServiceProvider arg1) => throw null!);
            return MapCore(
                endpoints,
                pattern,
                handler,
                PostVerb,
                populateMetadata,
                createRequestDelegate,
                castHandler.Method);
        }
 
        [global::System.Runtime.CompilerServices.InterceptsLocationAttribute(1, "J4fwklE6dqSkeKxd+PIY088wAABJZGVudGl0eUFwaUVuZHBvaW50Um91dGVCdWlsZGVyRXh0ZW5zaW9ucy5jcw==")]
        internal static RouteHandlerBuilder MapPost7(
            this IEndpointRouteBuilder endpoints,
            [StringSyntax("Route")] string pattern,
            Delegate handler)
        {
            MetadataPopulator populateMetadata = (methodInfo, options) =>
            {
                Debug.Assert(options != null, "RequestDelegateFactoryOptions not found.");
                Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found.");
                options.EndpointBuilder.Metadata.Add(new System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.AspNetCore.Http.RequestDelegateGenerator, Version=42.42.42.42, Culture=neutral, PublicKeyToken=adb9793829ddae60", "42.42.42.42"));
                options.EndpointBuilder.Metadata.Add(new AcceptsMetadata(type: typeof(global::Microsoft.AspNetCore.Identity.Data.TwoFactorRequest), isOptional: false, contentTypes: GeneratedMetadataConstants.JsonContentType));
                var parameters = methodInfo.GetParameters();
                options.EndpointBuilder.Metadata.Add(new ParameterBindingMetadata("claimsPrincipal", parameters[0], hasTryParse: false, hasBindAsync: false, isOptional: false));
                options.EndpointBuilder.Metadata.Add(new ParameterBindingMetadata("tfaRequest", parameters[1], hasTryParse: false, hasBindAsync: false, isOptional: false));
                options.EndpointBuilder.Metadata.Add(new ParameterBindingMetadata("sp", parameters[2], hasTryParse: false, hasBindAsync: false, isOptional: false));
                PopulateMetadataForEndpoint<global::Microsoft.AspNetCore.Http.HttpResults.Results<global::Microsoft.AspNetCore.Http.HttpResults.Ok<global::Microsoft.AspNetCore.Identity.Data.TwoFactorResponse>, global::Microsoft.AspNetCore.Http.HttpResults.ValidationProblem, global::Microsoft.AspNetCore.Http.HttpResults.NotFound>>(methodInfo, options.EndpointBuilder);
                return new RequestDelegateMetadataResult { EndpointMetadata = options.EndpointBuilder.Metadata.AsReadOnly() };
            };
            RequestDelegateFactoryFunc createRequestDelegate = (del, options, inferredMetadataResult) =>
            {
                Debug.Assert(options != null, "RequestDelegateFactoryOptions not found.");
                Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found.");
                Debug.Assert(options.EndpointBuilder.ApplicationServices != null, "ApplicationServices not found.");
                Debug.Assert(options.EndpointBuilder.FilterFactories != null, "FilterFactories not found.");
                var handler = Cast(del, global::System.Threading.Tasks.Task<global::Microsoft.AspNetCore.Http.HttpResults.Results<global::Microsoft.AspNetCore.Http.HttpResults.Ok<global::Microsoft.AspNetCore.Identity.Data.TwoFactorResponse>, global::Microsoft.AspNetCore.Http.HttpResults.ValidationProblem, global::Microsoft.AspNetCore.Http.HttpResults.NotFound>> (global::System.Security.Claims.ClaimsPrincipal arg0, global::Microsoft.AspNetCore.Identity.Data.TwoFactorRequest arg1, global::System.IServiceProvider arg2) => throw null!);
                EndpointFilterDelegate? filteredInvocation = null;
                var serviceProvider = options.ServiceProvider ?? options.EndpointBuilder.ApplicationServices;
                var logOrThrowExceptionHelper = new LogOrThrowExceptionHelper(serviceProvider, options);
                var jsonOptions = serviceProvider?.GetService<IOptions<JsonOptions>>()?.Value ?? FallbackJsonOptions;
                var jsonSerializerOptions = jsonOptions.SerializerOptions;
                jsonSerializerOptions.MakeReadOnly();
                var objectJsonTypeInfo = (JsonTypeInfo<object?>)jsonSerializerOptions.GetTypeInfo(typeof(object));
                var tfaRequest_JsonTypeInfo = (JsonTypeInfo<global::Microsoft.AspNetCore.Identity.Data.TwoFactorRequest>)jsonSerializerOptions.GetTypeInfo(typeof(global::Microsoft.AspNetCore.Identity.Data.TwoFactorRequest));
 
                if (options.EndpointBuilder.FilterFactories.Count > 0)
                {
                    filteredInvocation = GeneratedRouteBuilderExtensionsCore.BuildFilterDelegate(async ic =>
                    {
                        if (ic.HttpContext.Response.StatusCode == 400)
                        {
                            return (object?)Results.Empty;
                        }
                        var task = handler(ic.GetArgument<global::System.Security.Claims.ClaimsPrincipal>(0)!, ic.GetArgument<global::Microsoft.AspNetCore.Identity.Data.TwoFactorRequest>(1)!, ic.GetArgument<global::System.IServiceProvider>(2)!);
                        var result = await task;
                        return (object?)result;
                    },
                    options.EndpointBuilder,
                    handler.Method);
                }
 
                async Task RequestHandler(HttpContext httpContext)
                {
                    var wasParamCheckFailure = false;
                    var claimsPrincipal_local = httpContext.User;
                    // Endpoint Parameter: tfaRequest (Type = Microsoft.AspNetCore.Identity.Data.TwoFactorRequest, IsOptional = False, IsParsable = False, IsArray = False, Source = JsonBody)
                    var tfaRequest_resolveBodyResult = await GeneratedRouteBuilderExtensionsCore.TryResolveBodyAsync<global::Microsoft.AspNetCore.Identity.Data.TwoFactorRequest>(httpContext, logOrThrowExceptionHelper, false, "TwoFactorRequest", "tfaRequest", tfaRequest_JsonTypeInfo);
                    var tfaRequest_local = tfaRequest_resolveBodyResult.Item2;
                    if (!tfaRequest_resolveBodyResult.Item1)
                    {
                        return;
                    }
                    // Endpoint Parameter: sp (Type = System.IServiceProvider, IsOptional = False, IsParsable = False, IsArray = False, Source = Service)
                    var sp_local = httpContext.RequestServices.GetRequiredService<global::System.IServiceProvider>();
 
                    if (wasParamCheckFailure)
                    {
                        httpContext.Response.StatusCode = 400;
                        return;
                    }
                    var task = handler(claimsPrincipal_local, tfaRequest_local!, sp_local);
                    var result = await task;
                    if (result == null)
                    {
                        throw new InvalidOperationException("The IResult returned by the Delegate must not be null.");
                    }
                    await GeneratedRouteBuilderExtensionsCore.ExecuteAsyncExplicit(result, httpContext);
                }
 
                async Task RequestHandlerFiltered(HttpContext httpContext)
                {
                    var wasParamCheckFailure = false;
                    var claimsPrincipal_local = httpContext.User;
                    // Endpoint Parameter: tfaRequest (Type = Microsoft.AspNetCore.Identity.Data.TwoFactorRequest, IsOptional = False, IsParsable = False, IsArray = False, Source = JsonBody)
                    var tfaRequest_resolveBodyResult = await GeneratedRouteBuilderExtensionsCore.TryResolveBodyAsync<global::Microsoft.AspNetCore.Identity.Data.TwoFactorRequest>(httpContext, logOrThrowExceptionHelper, false, "TwoFactorRequest", "tfaRequest", tfaRequest_JsonTypeInfo);
                    var tfaRequest_local = tfaRequest_resolveBodyResult.Item2;
                    if (!tfaRequest_resolveBodyResult.Item1)
                    {
                        return;
                    }
                    // Endpoint Parameter: sp (Type = System.IServiceProvider, IsOptional = False, IsParsable = False, IsArray = False, Source = Service)
                    var sp_local = httpContext.RequestServices.GetRequiredService<global::System.IServiceProvider>();
 
                    if (wasParamCheckFailure)
                    {
                        httpContext.Response.StatusCode = 400;
                    }
                    var result = await filteredInvocation(EndpointFilterInvocationContext.Create<global::System.Security.Claims.ClaimsPrincipal, global::Microsoft.AspNetCore.Identity.Data.TwoFactorRequest, global::System.IServiceProvider>(httpContext, claimsPrincipal_local, tfaRequest_local!, sp_local));
                    if (result is not null)
                    {
                        await GeneratedRouteBuilderExtensionsCore.ExecuteReturnAsync(result, httpContext, objectJsonTypeInfo);
                    }
                }
 
                RequestDelegate targetDelegate = filteredInvocation is null ? RequestHandler : RequestHandlerFiltered;
                var metadata = inferredMetadataResult?.EndpointMetadata ?? ReadOnlyCollection<object>.Empty;
                return new RequestDelegateResult(targetDelegate, metadata);
            };
            var castHandler = Cast(handler, global::System.Threading.Tasks.Task<global::Microsoft.AspNetCore.Http.HttpResults.Results<global::Microsoft.AspNetCore.Http.HttpResults.Ok<global::Microsoft.AspNetCore.Identity.Data.TwoFactorResponse>, global::Microsoft.AspNetCore.Http.HttpResults.ValidationProblem, global::Microsoft.AspNetCore.Http.HttpResults.NotFound>> (global::System.Security.Claims.ClaimsPrincipal arg0, global::Microsoft.AspNetCore.Identity.Data.TwoFactorRequest arg1, global::System.IServiceProvider arg2) => throw null!);
            return MapCore(
                endpoints,
                pattern,
                handler,
                PostVerb,
                populateMetadata,
                createRequestDelegate,
                castHandler.Method);
        }
 
        [global::System.Runtime.CompilerServices.InterceptsLocationAttribute(1, "J4fwklE6dqSkeKxd+PIY06w+AABJZGVudGl0eUFwaUVuZHBvaW50Um91dGVCdWlsZGVyRXh0ZW5zaW9ucy5jcw==")]
        internal static RouteHandlerBuilder MapGet8(
            this IEndpointRouteBuilder endpoints,
            [StringSyntax("Route")] string pattern,
            Delegate handler)
        {
            MetadataPopulator populateMetadata = (methodInfo, options) =>
            {
                Debug.Assert(options != null, "RequestDelegateFactoryOptions not found.");
                Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found.");
                options.EndpointBuilder.Metadata.Add(new System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.AspNetCore.Http.RequestDelegateGenerator, Version=42.42.42.42, Culture=neutral, PublicKeyToken=adb9793829ddae60", "42.42.42.42"));
                var parameters = methodInfo.GetParameters();
                options.EndpointBuilder.Metadata.Add(new ParameterBindingMetadata("claimsPrincipal", parameters[0], hasTryParse: false, hasBindAsync: false, isOptional: false));
                options.EndpointBuilder.Metadata.Add(new ParameterBindingMetadata("sp", parameters[1], hasTryParse: false, hasBindAsync: false, isOptional: false));
                PopulateMetadataForEndpoint<global::Microsoft.AspNetCore.Http.HttpResults.Results<global::Microsoft.AspNetCore.Http.HttpResults.Ok<global::Microsoft.AspNetCore.Identity.Data.InfoResponse>, global::Microsoft.AspNetCore.Http.HttpResults.ValidationProblem, global::Microsoft.AspNetCore.Http.HttpResults.NotFound>>(methodInfo, options.EndpointBuilder);
                return new RequestDelegateMetadataResult { EndpointMetadata = options.EndpointBuilder.Metadata.AsReadOnly() };
            };
            RequestDelegateFactoryFunc createRequestDelegate = (del, options, inferredMetadataResult) =>
            {
                Debug.Assert(options != null, "RequestDelegateFactoryOptions not found.");
                Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found.");
                Debug.Assert(options.EndpointBuilder.ApplicationServices != null, "ApplicationServices not found.");
                Debug.Assert(options.EndpointBuilder.FilterFactories != null, "FilterFactories not found.");
                var handler = Cast(del, global::System.Threading.Tasks.Task<global::Microsoft.AspNetCore.Http.HttpResults.Results<global::Microsoft.AspNetCore.Http.HttpResults.Ok<global::Microsoft.AspNetCore.Identity.Data.InfoResponse>, global::Microsoft.AspNetCore.Http.HttpResults.ValidationProblem, global::Microsoft.AspNetCore.Http.HttpResults.NotFound>> (global::System.Security.Claims.ClaimsPrincipal arg0, global::System.IServiceProvider arg1) => throw null!);
                EndpointFilterDelegate? filteredInvocation = null;
                var serviceProvider = options.ServiceProvider ?? options.EndpointBuilder.ApplicationServices;
                var logOrThrowExceptionHelper = new LogOrThrowExceptionHelper(serviceProvider, options);
                var jsonOptions = serviceProvider?.GetService<IOptions<JsonOptions>>()?.Value ?? FallbackJsonOptions;
                var jsonSerializerOptions = jsonOptions.SerializerOptions;
                jsonSerializerOptions.MakeReadOnly();
                var objectJsonTypeInfo = (JsonTypeInfo<object?>)jsonSerializerOptions.GetTypeInfo(typeof(object));
 
                if (options.EndpointBuilder.FilterFactories.Count > 0)
                {
                    filteredInvocation = GeneratedRouteBuilderExtensionsCore.BuildFilterDelegate(async ic =>
                    {
                        if (ic.HttpContext.Response.StatusCode == 400)
                        {
                            return (object?)Results.Empty;
                        }
                        var task = handler(ic.GetArgument<global::System.Security.Claims.ClaimsPrincipal>(0)!, ic.GetArgument<global::System.IServiceProvider>(1)!);
                        var result = await task;
                        return (object?)result;
                    },
                    options.EndpointBuilder,
                    handler.Method);
                }
 
                async Task RequestHandler(HttpContext httpContext)
                {
                    var wasParamCheckFailure = false;
                    var claimsPrincipal_local = httpContext.User;
                    // Endpoint Parameter: sp (Type = System.IServiceProvider, IsOptional = False, IsParsable = False, IsArray = False, Source = Service)
                    var sp_local = httpContext.RequestServices.GetRequiredService<global::System.IServiceProvider>();
 
                    if (wasParamCheckFailure)
                    {
                        httpContext.Response.StatusCode = 400;
                        return;
                    }
                    var task = handler(claimsPrincipal_local, sp_local);
                    var result = await task;
                    if (result == null)
                    {
                        throw new InvalidOperationException("The IResult returned by the Delegate must not be null.");
                    }
                    await GeneratedRouteBuilderExtensionsCore.ExecuteAsyncExplicit(result, httpContext);
                }
 
                async Task RequestHandlerFiltered(HttpContext httpContext)
                {
                    var wasParamCheckFailure = false;
                    var claimsPrincipal_local = httpContext.User;
                    // Endpoint Parameter: sp (Type = System.IServiceProvider, IsOptional = False, IsParsable = False, IsArray = False, Source = Service)
                    var sp_local = httpContext.RequestServices.GetRequiredService<global::System.IServiceProvider>();
 
                    if (wasParamCheckFailure)
                    {
                        httpContext.Response.StatusCode = 400;
                    }
                    var result = await filteredInvocation(EndpointFilterInvocationContext.Create<global::System.Security.Claims.ClaimsPrincipal, global::System.IServiceProvider>(httpContext, claimsPrincipal_local, sp_local));
                    if (result is not null)
                    {
                        await GeneratedRouteBuilderExtensionsCore.ExecuteReturnAsync(result, httpContext, objectJsonTypeInfo);
                    }
                }
 
                RequestDelegate targetDelegate = filteredInvocation is null ? RequestHandler : RequestHandlerFiltered;
                var metadata = inferredMetadataResult?.EndpointMetadata ?? ReadOnlyCollection<object>.Empty;
                return new RequestDelegateResult(targetDelegate, metadata);
            };
            var castHandler = Cast(handler, global::System.Threading.Tasks.Task<global::Microsoft.AspNetCore.Http.HttpResults.Results<global::Microsoft.AspNetCore.Http.HttpResults.Ok<global::Microsoft.AspNetCore.Identity.Data.InfoResponse>, global::Microsoft.AspNetCore.Http.HttpResults.ValidationProblem, global::Microsoft.AspNetCore.Http.HttpResults.NotFound>> (global::System.Security.Claims.ClaimsPrincipal arg0, global::System.IServiceProvider arg1) => throw null!);
            return MapCore(
                endpoints,
                pattern,
                handler,
                GetVerb,
                populateMetadata,
                createRequestDelegate,
                castHandler.Method);
        }
 
        [global::System.Runtime.CompilerServices.InterceptsLocationAttribute(1, "J4fwklE6dqSkeKxd+PIY08tAAABJZGVudGl0eUFwaUVuZHBvaW50Um91dGVCdWlsZGVyRXh0ZW5zaW9ucy5jcw==")]
        internal static RouteHandlerBuilder MapPost9(
            this IEndpointRouteBuilder endpoints,
            [StringSyntax("Route")] string pattern,
            Delegate handler)
        {
            MetadataPopulator populateMetadata = (methodInfo, options) =>
            {
                Debug.Assert(options != null, "RequestDelegateFactoryOptions not found.");
                Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found.");
                options.EndpointBuilder.Metadata.Add(new System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.AspNetCore.Http.RequestDelegateGenerator, Version=42.42.42.42, Culture=neutral, PublicKeyToken=adb9793829ddae60", "42.42.42.42"));
                options.EndpointBuilder.Metadata.Add(new AcceptsMetadata(type: typeof(global::Microsoft.AspNetCore.Identity.Data.InfoRequest), isOptional: false, contentTypes: GeneratedMetadataConstants.JsonContentType));
                var parameters = methodInfo.GetParameters();
                options.EndpointBuilder.Metadata.Add(new ParameterBindingMetadata("claimsPrincipal", parameters[0], hasTryParse: false, hasBindAsync: false, isOptional: false));
                options.EndpointBuilder.Metadata.Add(new ParameterBindingMetadata("infoRequest", parameters[1], hasTryParse: false, hasBindAsync: false, isOptional: false));
                options.EndpointBuilder.Metadata.Add(new ParameterBindingMetadata("context", parameters[2], hasTryParse: false, hasBindAsync: false, isOptional: false));
                options.EndpointBuilder.Metadata.Add(new ParameterBindingMetadata("sp", parameters[3], hasTryParse: false, hasBindAsync: false, isOptional: false));
                PopulateMetadataForEndpoint<global::Microsoft.AspNetCore.Http.HttpResults.Results<global::Microsoft.AspNetCore.Http.HttpResults.Ok<global::Microsoft.AspNetCore.Identity.Data.InfoResponse>, global::Microsoft.AspNetCore.Http.HttpResults.ValidationProblem, global::Microsoft.AspNetCore.Http.HttpResults.NotFound>>(methodInfo, options.EndpointBuilder);
                return new RequestDelegateMetadataResult { EndpointMetadata = options.EndpointBuilder.Metadata.AsReadOnly() };
            };
            RequestDelegateFactoryFunc createRequestDelegate = (del, options, inferredMetadataResult) =>
            {
                Debug.Assert(options != null, "RequestDelegateFactoryOptions not found.");
                Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found.");
                Debug.Assert(options.EndpointBuilder.ApplicationServices != null, "ApplicationServices not found.");
                Debug.Assert(options.EndpointBuilder.FilterFactories != null, "FilterFactories not found.");
                var handler = Cast(del, global::System.Threading.Tasks.Task<global::Microsoft.AspNetCore.Http.HttpResults.Results<global::Microsoft.AspNetCore.Http.HttpResults.Ok<global::Microsoft.AspNetCore.Identity.Data.InfoResponse>, global::Microsoft.AspNetCore.Http.HttpResults.ValidationProblem, global::Microsoft.AspNetCore.Http.HttpResults.NotFound>> (global::System.Security.Claims.ClaimsPrincipal arg0, global::Microsoft.AspNetCore.Identity.Data.InfoRequest arg1, global::Microsoft.AspNetCore.Http.HttpContext arg2, global::System.IServiceProvider arg3) => throw null!);
                EndpointFilterDelegate? filteredInvocation = null;
                var serviceProvider = options.ServiceProvider ?? options.EndpointBuilder.ApplicationServices;
                var logOrThrowExceptionHelper = new LogOrThrowExceptionHelper(serviceProvider, options);
                var jsonOptions = serviceProvider?.GetService<IOptions<JsonOptions>>()?.Value ?? FallbackJsonOptions;
                var jsonSerializerOptions = jsonOptions.SerializerOptions;
                jsonSerializerOptions.MakeReadOnly();
                var objectJsonTypeInfo = (JsonTypeInfo<object?>)jsonSerializerOptions.GetTypeInfo(typeof(object));
                var infoRequest_JsonTypeInfo = (JsonTypeInfo<global::Microsoft.AspNetCore.Identity.Data.InfoRequest>)jsonSerializerOptions.GetTypeInfo(typeof(global::Microsoft.AspNetCore.Identity.Data.InfoRequest));
 
                if (options.EndpointBuilder.FilterFactories.Count > 0)
                {
                    filteredInvocation = GeneratedRouteBuilderExtensionsCore.BuildFilterDelegate(async ic =>
                    {
                        if (ic.HttpContext.Response.StatusCode == 400)
                        {
                            return (object?)Results.Empty;
                        }
                        var task = handler(ic.GetArgument<global::System.Security.Claims.ClaimsPrincipal>(0)!, ic.GetArgument<global::Microsoft.AspNetCore.Identity.Data.InfoRequest>(1)!, ic.GetArgument<global::Microsoft.AspNetCore.Http.HttpContext>(2)!, ic.GetArgument<global::System.IServiceProvider>(3)!);
                        var result = await task;
                        return (object?)result;
                    },
                    options.EndpointBuilder,
                    handler.Method);
                }
 
                async Task RequestHandler(HttpContext httpContext)
                {
                    var wasParamCheckFailure = false;
                    var claimsPrincipal_local = httpContext.User;
                    // Endpoint Parameter: infoRequest (Type = Microsoft.AspNetCore.Identity.Data.InfoRequest, IsOptional = False, IsParsable = False, IsArray = False, Source = JsonBody)
                    var infoRequest_resolveBodyResult = await GeneratedRouteBuilderExtensionsCore.TryResolveBodyAsync<global::Microsoft.AspNetCore.Identity.Data.InfoRequest>(httpContext, logOrThrowExceptionHelper, false, "InfoRequest", "infoRequest", infoRequest_JsonTypeInfo);
                    var infoRequest_local = infoRequest_resolveBodyResult.Item2;
                    if (!infoRequest_resolveBodyResult.Item1)
                    {
                        return;
                    }
                    var context_local = httpContext;
                    // Endpoint Parameter: sp (Type = System.IServiceProvider, IsOptional = False, IsParsable = False, IsArray = False, Source = Service)
                    var sp_local = httpContext.RequestServices.GetRequiredService<global::System.IServiceProvider>();
 
                    if (wasParamCheckFailure)
                    {
                        httpContext.Response.StatusCode = 400;
                        return;
                    }
                    var task = handler(claimsPrincipal_local, infoRequest_local!, context_local, sp_local);
                    var result = await task;
                    if (result == null)
                    {
                        throw new InvalidOperationException("The IResult returned by the Delegate must not be null.");
                    }
                    await GeneratedRouteBuilderExtensionsCore.ExecuteAsyncExplicit(result, httpContext);
                }
 
                async Task RequestHandlerFiltered(HttpContext httpContext)
                {
                    var wasParamCheckFailure = false;
                    var claimsPrincipal_local = httpContext.User;
                    // Endpoint Parameter: infoRequest (Type = Microsoft.AspNetCore.Identity.Data.InfoRequest, IsOptional = False, IsParsable = False, IsArray = False, Source = JsonBody)
                    var infoRequest_resolveBodyResult = await GeneratedRouteBuilderExtensionsCore.TryResolveBodyAsync<global::Microsoft.AspNetCore.Identity.Data.InfoRequest>(httpContext, logOrThrowExceptionHelper, false, "InfoRequest", "infoRequest", infoRequest_JsonTypeInfo);
                    var infoRequest_local = infoRequest_resolveBodyResult.Item2;
                    if (!infoRequest_resolveBodyResult.Item1)
                    {
                        return;
                    }
                    var context_local = httpContext;
                    // Endpoint Parameter: sp (Type = System.IServiceProvider, IsOptional = False, IsParsable = False, IsArray = False, Source = Service)
                    var sp_local = httpContext.RequestServices.GetRequiredService<global::System.IServiceProvider>();
 
                    if (wasParamCheckFailure)
                    {
                        httpContext.Response.StatusCode = 400;
                    }
                    var result = await filteredInvocation(EndpointFilterInvocationContext.Create<global::System.Security.Claims.ClaimsPrincipal, global::Microsoft.AspNetCore.Identity.Data.InfoRequest, global::Microsoft.AspNetCore.Http.HttpContext, global::System.IServiceProvider>(httpContext, claimsPrincipal_local, infoRequest_local!, context_local, sp_local));
                    if (result is not null)
                    {
                        await GeneratedRouteBuilderExtensionsCore.ExecuteReturnAsync(result, httpContext, objectJsonTypeInfo);
                    }
                }
 
                RequestDelegate targetDelegate = filteredInvocation is null ? RequestHandler : RequestHandlerFiltered;
                var metadata = inferredMetadataResult?.EndpointMetadata ?? ReadOnlyCollection<object>.Empty;
                return new RequestDelegateResult(targetDelegate, metadata);
            };
            var castHandler = Cast(handler, global::System.Threading.Tasks.Task<global::Microsoft.AspNetCore.Http.HttpResults.Results<global::Microsoft.AspNetCore.Http.HttpResults.Ok<global::Microsoft.AspNetCore.Identity.Data.InfoResponse>, global::Microsoft.AspNetCore.Http.HttpResults.ValidationProblem, global::Microsoft.AspNetCore.Http.HttpResults.NotFound>> (global::System.Security.Claims.ClaimsPrincipal arg0, global::Microsoft.AspNetCore.Identity.Data.InfoRequest arg1, global::Microsoft.AspNetCore.Http.HttpContext arg2, global::System.IServiceProvider arg3) => throw null!);
            return MapCore(
                endpoints,
                pattern,
                handler,
                PostVerb,
                populateMetadata,
                createRequestDelegate,
                castHandler.Method);
        }
 
 
 
        internal static RouteHandlerBuilder MapCore(
            this IEndpointRouteBuilder routes,
            string pattern,
            Delegate handler,
            IEnumerable<string>? httpMethods,
            MetadataPopulator populateMetadata,
            RequestDelegateFactoryFunc createRequestDelegate,
            MethodInfo methodInfo)
        {
            return RouteHandlerServices.Map(routes, pattern, handler, httpMethods, populateMetadata, createRequestDelegate, methodInfo);
        }
 
        private static T Cast<T>(Delegate d, T _) where T : Delegate
        {
            return (T)d;
        }
 
        private static EndpointFilterDelegate BuildFilterDelegate(EndpointFilterDelegate filteredInvocation, EndpointBuilder builder, MethodInfo mi)
        {
            var routeHandlerFilters =  builder.FilterFactories;
            var context0 = new EndpointFilterFactoryContext
            {
                MethodInfo = mi,
                ApplicationServices = builder.ApplicationServices,
            };
            var initialFilteredInvocation = filteredInvocation;
            for (var i = routeHandlerFilters.Count - 1; i >= 0; i--)
            {
                var filterFactory = routeHandlerFilters[i];
                filteredInvocation = filterFactory(context0, filteredInvocation);
            }
            return filteredInvocation;
        }
 
        private static Task ExecuteReturnAsync(object? obj, HttpContext httpContext, JsonTypeInfo<object?> jsonTypeInfo)
        {
            if (obj is IResult r)
            {
                return r.ExecuteAsync(httpContext);
            }
            else if (obj is string s)
            {
                return httpContext.Response.WriteAsync(s);
            }
            else
            {
                return WriteJsonResponseAsync(httpContext.Response, obj, jsonTypeInfo);
            }
        }
 
        [UnconditionalSuppressMessage("Trimming", "IL2026:RequiresUnreferencedCode",
            Justification = "The 'JsonSerializer.IsReflectionEnabledByDefault' feature switch, which is set to false by default for trimmed ASP.NET apps, ensures the JsonSerializer doesn't use Reflection.")]
        [UnconditionalSuppressMessage("AOT", "IL3050:RequiresDynamicCode", Justification = "See above.")]
        private static Task WriteJsonResponseAsync<T>(HttpResponse response, T? value, JsonTypeInfo<T?> jsonTypeInfo)
        {
            var runtimeType = value?.GetType();
 
            if (jsonTypeInfo.ShouldUseWith(runtimeType))
            {
                return HttpResponseJsonExtensions.WriteAsJsonAsync(response, value, jsonTypeInfo, default);
            }
 
            return response.WriteAsJsonAsync<object?>(value, jsonTypeInfo.Options);
        }
 
        private static bool HasKnownPolymorphism(this JsonTypeInfo jsonTypeInfo)
            => jsonTypeInfo.Type.IsSealed || jsonTypeInfo.Type.IsValueType || jsonTypeInfo.PolymorphismOptions is not null;
 
        private static bool ShouldUseWith(this JsonTypeInfo jsonTypeInfo, [NotNullWhen(false)] Type? runtimeType)
            => runtimeType is null || jsonTypeInfo.Type == runtimeType || jsonTypeInfo.HasKnownPolymorphism();
 
        private static async ValueTask<(bool, T?)> TryResolveBodyAsync<T>(HttpContext httpContext, LogOrThrowExceptionHelper logOrThrowExceptionHelper, bool allowEmpty, string parameterTypeName, string parameterName, JsonTypeInfo<T> jsonTypeInfo, bool isInferred = false)
        {
            var feature = httpContext.Features.Get<Microsoft.AspNetCore.Http.Features.IHttpRequestBodyDetectionFeature>();
            T? bodyValue = default;
            var bodyValueSet = false;
 
            if (feature?.CanHaveBody == true)
            {
                if (!httpContext.Request.HasJsonContentType())
                {
                    logOrThrowExceptionHelper.UnexpectedJsonContentType(httpContext.Request.ContentType);
                    httpContext.Response.StatusCode = StatusCodes.Status415UnsupportedMediaType;
                    return (false, default);
                }
                try
                {
                    bodyValue = await httpContext.Request.ReadFromJsonAsync(jsonTypeInfo);
                    bodyValueSet = bodyValue != null;
                }
                catch (BadHttpRequestException badHttpRequestException)
                {
                    logOrThrowExceptionHelper.RequestBodyIOException(badHttpRequestException);
                    httpContext.Response.StatusCode = badHttpRequestException.StatusCode;
                    return (false, default);
                }
                catch (IOException ioException)
                {
                    logOrThrowExceptionHelper.RequestBodyIOException(ioException);
                    httpContext.Response.StatusCode = StatusCodes.Status400BadRequest;
                    return (false, default);
                }
                catch (System.Text.Json.JsonException jsonException)
                {
                    logOrThrowExceptionHelper.InvalidJsonRequestBody(parameterTypeName, parameterName, jsonException);
                    httpContext.Response.StatusCode = StatusCodes.Status400BadRequest;
                    return (false, default);
                }
            }
 
            if (!allowEmpty && !bodyValueSet)
            {
                if (!isInferred)
                {
                    logOrThrowExceptionHelper.RequiredParameterNotProvided(parameterTypeName, parameterName, "body");
                }
                else
                {
                    logOrThrowExceptionHelper.ImplicitBodyNotProvided(parameterName);
                }
                httpContext.Response.StatusCode = StatusCodes.Status400BadRequest;
                return (false, bodyValue);
            }
 
            return (true, bodyValue);
        }
        private static bool TryParseExplicit<T>(string? s, IFormatProvider? provider, [MaybeNullWhen(returnValue: false)] out T result) where T: IParsable<T>
            => T.TryParse(s, provider, out result);
        private static Task ExecuteAsyncExplicit(IResult result, HttpContext httpContext)
            => result.ExecuteAsync(httpContext);
        private static void PopulateMetadataForEndpoint<T>(MethodInfo method, EndpointBuilder builder)
            where T : IEndpointMetadataProvider
        {
            T.PopulateMetadata(method, builder);
        }
 
    }
 
    file sealed class DisableCookieRedirectMetadata : IDisableCookieRedirectMetadata
    {
        public static readonly DisableCookieRedirectMetadata Instance = new();
 
        private DisableCookieRedirectMetadata()
        {
        }
 
        public static void AddMetadataIfMissing(EndpointBuilder builder)
        {
            if (!builder.Metadata.Any(m => m is IDisableCookieRedirectMetadata))
            {
                builder.Metadata.Add(Instance);
            }
        }
    }
    [System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.AspNetCore.Http.RequestDelegateGenerator, Version=42.42.42.42, Culture=neutral, PublicKeyToken=adb9793829ddae60", "42.42.42.42")]
    file static class GeneratedMetadataConstants
    {
        public static readonly string[] JsonContentType = new [] { "application/json" };
        public static readonly string[] PlaintextContentType = new [] { "text/plain" };
        public static readonly string[] FormFileContentType = new[] { "multipart/form-data" };
        public static readonly string[] FormContentType = new[] { "multipart/form-data", "application/x-www-form-urlencoded" };
    }
 
    [System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.AspNetCore.Http.RequestDelegateGenerator, Version=42.42.42.42, Culture=neutral, PublicKeyToken=adb9793829ddae60", "42.42.42.42")]
    file sealed class ParameterBindingMetadata: IParameterBindingMetadata
    {
        internal ParameterBindingMetadata(
            string name,
            ParameterInfo parameterInfo,
            bool hasTryParse = false,
            bool hasBindAsync = false,
            bool isOptional = false)
        {
            Name = name;
            ParameterInfo = parameterInfo;
            HasTryParse = hasTryParse;
            HasBindAsync = hasBindAsync;
            IsOptional = isOptional;
        }
 
        public string Name { get; }
 
        public bool HasTryParse { get; }
 
        public bool HasBindAsync { get; }
 
        public ParameterInfo ParameterInfo { get; }
 
        public bool IsOptional { get; }
    }
 
    [System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.AspNetCore.Http.RequestDelegateGenerator, Version=42.42.42.42, Culture=neutral, PublicKeyToken=adb9793829ddae60", "42.42.42.42")]
    file sealed class LogOrThrowExceptionHelper
    {
        private readonly ILogger? _rdgLogger;
        private readonly bool _shouldThrow;
 
        public LogOrThrowExceptionHelper(IServiceProvider? serviceProvider, RequestDelegateFactoryOptions? options)
        {
            var loggerFactory = serviceProvider?.GetRequiredService<ILoggerFactory>();
            _rdgLogger = loggerFactory?.CreateLogger("Microsoft.AspNetCore.Http.RequestDelegateGenerator.RequestDelegateGenerator");
            _shouldThrow = options?.ThrowOnBadRequest ?? false;
        }
 
        public void RequestBodyIOException(IOException exception)
        {
            if (_rdgLogger != null)
            {
                _requestBodyIOException(_rdgLogger, exception);
            }
        }
 
        private static readonly Action<ILogger, Exception?> _requestBodyIOException =
            LoggerMessage.Define(LogLevel.Debug, new EventId(1, "RequestBodyIOException"), "Reading the request body failed with an IOException.");
 
        public void InvalidJsonRequestBody(string parameterTypeName, string parameterName, Exception exception)
        {
            if (_shouldThrow)
            {
                var message = string.Format(CultureInfo.InvariantCulture, "Failed to read parameter \"{0} {1}\" from the request body as JSON.", parameterTypeName, parameterName);
                throw new BadHttpRequestException(message, exception);
            }
 
            if (_rdgLogger != null)
            {
                _invalidJsonRequestBody(_rdgLogger, parameterTypeName, parameterName, exception);
            }
        }
 
        private static readonly Action<ILogger, string, string, Exception?> _invalidJsonRequestBody =
            LoggerMessage.Define<string, string>(LogLevel.Debug, new EventId(2, "InvalidJsonRequestBody"), "Failed to read parameter \"{ParameterType} {ParameterName}\" from the request body as JSON.");
 
        public void ParameterBindingFailed(string parameterTypeName, string parameterName, string sourceValue)
        {
            if (_shouldThrow)
            {
                var message = string.Format(CultureInfo.InvariantCulture, "Failed to bind parameter \"{0} {1}\" from \"{2}\".", parameterTypeName, parameterName, sourceValue);
                throw new BadHttpRequestException(message);
            }
 
            if (_rdgLogger != null)
            {
                _parameterBindingFailed(_rdgLogger, parameterTypeName, parameterName, sourceValue, null);
            }
        }
 
        private static readonly Action<ILogger, string, string, string, Exception?> _parameterBindingFailed =
            LoggerMessage.Define<string, string, string>(LogLevel.Debug, new EventId(3, "ParameterBindingFailed"), "Failed to bind parameter \"{ParameterType} {ParameterName}\" from \"{SourceValue}\".");
 
        public void RequiredParameterNotProvided(string parameterTypeName, string parameterName, string source)
        {
            if (_shouldThrow)
            {
                var message = string.Format(CultureInfo.InvariantCulture, "Required parameter \"{0} {1}\" was not provided from {2}.", parameterTypeName, parameterName, source);
                throw new BadHttpRequestException(message);
            }
 
            if (_rdgLogger != null)
            {
                _requiredParameterNotProvided(_rdgLogger, parameterTypeName, parameterName, source, null);
            }
        }
 
        private static readonly Action<ILogger, string, string, string, Exception?> _requiredParameterNotProvided =
            LoggerMessage.Define<string, string, string>(LogLevel.Debug, new EventId(4, "RequiredParameterNotProvided"), "Required parameter \"{ParameterType} {ParameterName}\" was not provided from {Source}.");
 
        public void ImplicitBodyNotProvided(string parameterName)
        {
            if (_shouldThrow)
            {
                var message = string.Format(CultureInfo.InvariantCulture, "Implicit body inferred for parameter \"{0}\" but no body was provided. Did you mean to use a Service instead?", parameterName);
                throw new BadHttpRequestException(message);
            }
 
            if (_rdgLogger != null)
            {
                _implicitBodyNotProvided(_rdgLogger, parameterName, null);
            }
        }
 
        private static readonly Action<ILogger, string, Exception?> _implicitBodyNotProvided =
            LoggerMessage.Define<string>(LogLevel.Debug, new EventId(5, "ImplicitBodyNotProvided"), "Implicit body inferred for parameter \"{ParameterName}\" but no body was provided. Did you mean to use a Service instead?");
 
        public void UnexpectedJsonContentType(string? contentType)
        {
            if (_shouldThrow)
            {
                var message = string.Format(CultureInfo.InvariantCulture, "Expected a supported JSON media type but got \"{0}\".", contentType);
                throw new BadHttpRequestException(message, StatusCodes.Status415UnsupportedMediaType);
            }
 
            if (_rdgLogger != null)
            {
                _unexpectedJsonContentType(_rdgLogger, contentType ?? "(none)", null);
            }
        }
 
        private static readonly Action<ILogger, string, Exception?> _unexpectedJsonContentType =
            LoggerMessage.Define<string>(LogLevel.Debug, new EventId(6, "UnexpectedContentType"), "Expected a supported JSON media type but got \"{ContentType}\".");
 
        public void UnexpectedNonFormContentType(string? contentType)
        {
            if (_shouldThrow)
            {
                var message = string.Format(CultureInfo.InvariantCulture, "Expected a supported form media type but got \"{0}\".", contentType);
                throw new BadHttpRequestException(message, StatusCodes.Status415UnsupportedMediaType);
            }
 
            if (_rdgLogger != null)
            {
                _unexpectedNonFormContentType(_rdgLogger, contentType ?? "(none)", null);
            }
        }
 
        private static readonly Action<ILogger, string, Exception?> _unexpectedNonFormContentType =
            LoggerMessage.Define<string>(LogLevel.Debug, new EventId(7, "UnexpectedNonFormContentType"), "Expected a supported form media type but got \"{ContentType}\".");
 
        public void InvalidFormRequestBody(string parameterTypeName, string parameterName, Exception exception)
        {
            if (_shouldThrow)
            {
                var message = string.Format(CultureInfo.InvariantCulture, "Failed to read parameter \"{0} {1}\" from the request body as form.", parameterTypeName, parameterName);
                throw new BadHttpRequestException(message, exception);
            }
 
            if (_rdgLogger != null)
            {
                _invalidFormRequestBody(_rdgLogger, parameterTypeName, parameterName, exception);
            }
        }
 
        private static readonly Action<ILogger, string, string, Exception?> _invalidFormRequestBody =
            LoggerMessage.Define<string, string>(LogLevel.Debug, new EventId(8, "InvalidFormRequestBody"), "Failed to read parameter \"{ParameterType} {ParameterName}\" from the request body as form.");
    }
}