// <auto-generated/>
#nullable enable

namespace Microsoft.AspNetCore.Components.Server
{
    partial class CircuitDisconnectMiddleware
    {
        partial class Log
        {
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, global::Microsoft.AspNetCore.Components.Server.Circuits.CircuitId, global::System.Exception?> __CircuitTerminatingGracefullyCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define<global::Microsoft.AspNetCore.Components.Server.Circuits.CircuitId>(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(1, "CircuitTerminatingGracefully"), "Circuit with id '{CircuitId}' terminating gracefully.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });

            /// <summary>
            /// <para><b>Message:</b> Circuit with id &apos;{CircuitId}&apos; terminating gracefully.</para>
            /// <para><b>Level:</b> Debug</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            public static partial void CircuitTerminatingGracefully(global::Microsoft.Extensions.Logging.ILogger logger, global::Microsoft.AspNetCore.Components.Server.Circuits.CircuitId circuitId)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
                {
                    __CircuitTerminatingGracefullyCallback(logger, circuitId, null);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, global::Microsoft.AspNetCore.Components.Server.Circuits.CircuitId, global::System.Exception?> __CircuitTerminatedGracefullyCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define<global::Microsoft.AspNetCore.Components.Server.Circuits.CircuitId>(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(2, "CircuitTerminatedGracefully"), "Circuit with id '{CircuitId}' terminated gracefully.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });

            /// <summary>
            /// <para><b>Message:</b> Circuit with id &apos;{CircuitId}&apos; terminated gracefully.</para>
            /// <para><b>Level:</b> Debug</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            public static partial void CircuitTerminatedGracefully(global::Microsoft.Extensions.Logging.ILogger logger, global::Microsoft.AspNetCore.Components.Server.Circuits.CircuitId circuitId)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
                {
                    __CircuitTerminatedGracefullyCallback(logger, circuitId, null);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, string, global::System.Exception?> __InvalidCircuitIdCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define<string>(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(3, "InvalidCircuitId"), "CircuitDisconnectMiddleware received an invalid circuit id '{CircuitIdSecret}'.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });

            /// <summary>
            /// <para><b>Message:</b> CircuitDisconnectMiddleware received an invalid circuit id &apos;{CircuitIdSecret}&apos;.</para>
            /// <para><b>Level:</b> Debug</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            public static partial void InvalidCircuitId(global::Microsoft.Extensions.Logging.ILogger logger, string circuitIdSecret)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
                {
                    __InvalidCircuitIdCallback(logger, circuitIdSecret, null);
                }
            }
        }
    }
}
namespace Microsoft.AspNetCore.Components.Server.Circuits
{
    partial class CircuitFactory
    {
        partial class Log
        {
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, string, string, global::System.Exception?> __CreatedCircuitCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define<string, string>(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(1, "CreatedCircuit"), "Created circuit {CircuitId} for connection {ConnectionId}", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });

            /// <summary>
            /// <para><b>Message:</b> Created circuit {CircuitId} for connection {ConnectionId}</para>
            /// <para><b>Level:</b> Debug</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            private static partial void CreatedCircuit(global::Microsoft.Extensions.Logging.ILogger logger, string circuitId, string connectionId)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
                {
                    __CreatedCircuitCallback(logger, circuitId, connectionId, null);
                }
            }
        }
    }
}
namespace Microsoft.AspNetCore.Components.Server.Circuits
{
    partial class CircuitHost
    {
        partial class Log
        {
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, global::System.Exception?> __InitializationStartedCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(100, "InitializationStarted"), "Circuit initialization started.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });

            /// <summary>
            /// <para><b>Message:</b> Circuit initialization started.</para>
            /// <para><b>Level:</b> Debug</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            public static partial void InitializationStarted(global::Microsoft.Extensions.Logging.ILogger logger)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
                {
                    __InitializationStartedCallback(logger, null);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, global::System.Exception?> __InitializationSucceededCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(101, "InitializationSucceeded"), "Circuit initialization succeeded.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });

            /// <summary>
            /// <para><b>Message:</b> Circuit initialization succeeded.</para>
            /// <para><b>Level:</b> Debug</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            public static partial void InitializationSucceeded(global::Microsoft.Extensions.Logging.ILogger logger)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
                {
                    __InitializationSucceededCallback(logger, null);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, global::System.Exception?> __InitializationFailedCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(102, "InitializationFailed"), "Circuit initialization failed.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });

            /// <summary>
            /// <para><b>Message:</b> Circuit initialization failed.</para>
            /// <para><b>Level:</b> Debug</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            public static partial void InitializationFailed(global::Microsoft.Extensions.Logging.ILogger logger, global::System.Exception exception)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
                {
                    __InitializationFailedCallback(logger, exception);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, global::Microsoft.AspNetCore.Components.Server.Circuits.CircuitId, global::System.Exception?> __DisposeStartedCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define<global::Microsoft.AspNetCore.Components.Server.Circuits.CircuitId>(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(103, "DisposeStarted"), "Disposing circuit '{CircuitId}' started.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });

            /// <summary>
            /// <para><b>Message:</b> Disposing circuit &apos;{CircuitId}&apos; started.</para>
            /// <para><b>Level:</b> Debug</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            public static partial void DisposeStarted(global::Microsoft.Extensions.Logging.ILogger logger, global::Microsoft.AspNetCore.Components.Server.Circuits.CircuitId circuitId)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
                {
                    __DisposeStartedCallback(logger, circuitId, null);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, global::Microsoft.AspNetCore.Components.Server.Circuits.CircuitId, global::System.Exception?> __DisposeSucceededCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define<global::Microsoft.AspNetCore.Components.Server.Circuits.CircuitId>(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(104, "DisposeSucceeded"), "Disposing circuit '{CircuitId}' succeeded.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });

            /// <summary>
            /// <para><b>Message:</b> Disposing circuit &apos;{CircuitId}&apos; succeeded.</para>
            /// <para><b>Level:</b> Debug</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            public static partial void DisposeSucceeded(global::Microsoft.Extensions.Logging.ILogger logger, global::Microsoft.AspNetCore.Components.Server.Circuits.CircuitId circuitId)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
                {
                    __DisposeSucceededCallback(logger, circuitId, null);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, global::Microsoft.AspNetCore.Components.Server.Circuits.CircuitId, global::System.Exception?> __DisposeFailedCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define<global::Microsoft.AspNetCore.Components.Server.Circuits.CircuitId>(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(105, "DisposeFailed"), "Disposing circuit '{CircuitId}' failed.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });

            /// <summary>
            /// <para><b>Message:</b> Disposing circuit &apos;{CircuitId}&apos; failed.</para>
            /// <para><b>Level:</b> Debug</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            public static partial void DisposeFailed(global::Microsoft.Extensions.Logging.ILogger logger, global::Microsoft.AspNetCore.Components.Server.Circuits.CircuitId circuitId, global::System.Exception exception)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
                {
                    __DisposeFailedCallback(logger, circuitId, exception);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, global::Microsoft.AspNetCore.Components.Server.Circuits.CircuitId, global::System.Exception?> __CircuitOpenedCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define<global::Microsoft.AspNetCore.Components.Server.Circuits.CircuitId>(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(106, "OnCircuitOpened"), "Opening circuit with id '{CircuitId}'.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });

            /// <summary>
            /// <para><b>Message:</b> Opening circuit with id &apos;{CircuitId}&apos;.</para>
            /// <para><b>Level:</b> Debug</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            public static partial void CircuitOpened(global::Microsoft.Extensions.Logging.ILogger logger, global::Microsoft.AspNetCore.Components.Server.Circuits.CircuitId circuitId)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
                {
                    __CircuitOpenedCallback(logger, circuitId, null);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, global::Microsoft.AspNetCore.Components.Server.Circuits.CircuitId, string, global::System.Exception?> __ConnectionUpCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define<global::Microsoft.AspNetCore.Components.Server.Circuits.CircuitId, string>(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(107, "OnConnectionUp"), "Circuit id '{CircuitId}' connected using connection '{ConnectionId}'.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });

            /// <summary>
            /// <para><b>Message:</b> Circuit id &apos;{CircuitId}&apos; connected using connection &apos;{ConnectionId}&apos;.</para>
            /// <para><b>Level:</b> Debug</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            public static partial void ConnectionUp(global::Microsoft.Extensions.Logging.ILogger logger, global::Microsoft.AspNetCore.Components.Server.Circuits.CircuitId circuitId, string connectionId)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
                {
                    __ConnectionUpCallback(logger, circuitId, connectionId, null);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, global::Microsoft.AspNetCore.Components.Server.Circuits.CircuitId, string, global::System.Exception?> __ConnectionDownCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define<global::Microsoft.AspNetCore.Components.Server.Circuits.CircuitId, string>(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(108, "OnConnectionDown"), "Circuit id '{CircuitId}' disconnected from connection '{ConnectionId}'.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });

            /// <summary>
            /// <para><b>Message:</b> Circuit id &apos;{CircuitId}&apos; disconnected from connection &apos;{ConnectionId}&apos;.</para>
            /// <para><b>Level:</b> Debug</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            public static partial void ConnectionDown(global::Microsoft.Extensions.Logging.ILogger logger, global::Microsoft.AspNetCore.Components.Server.Circuits.CircuitId circuitId, string connectionId)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
                {
                    __ConnectionDownCallback(logger, circuitId, connectionId, null);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, global::Microsoft.AspNetCore.Components.Server.Circuits.CircuitId, global::System.Exception?> __CircuitClosedCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define<global::Microsoft.AspNetCore.Components.Server.Circuits.CircuitId>(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(109, "OnCircuitClosed"), "Closing circuit with id '{CircuitId}'.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });

            /// <summary>
            /// <para><b>Message:</b> Closing circuit with id &apos;{CircuitId}&apos;.</para>
            /// <para><b>Level:</b> Debug</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            public static partial void CircuitClosed(global::Microsoft.Extensions.Logging.ILogger logger, global::Microsoft.AspNetCore.Components.Server.Circuits.CircuitId circuitId)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
                {
                    __CircuitClosedCallback(logger, circuitId, null);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, global::System.Type, string, string, global::System.Exception?> __CircuitHandlerFailedCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define<global::System.Type, string, string>(global::Microsoft.Extensions.Logging.LogLevel.Error, new global::Microsoft.Extensions.Logging.EventId(110, "CircuitHandlerFailed"), "Unhandled error invoking circuit handler type {handlerType}.{handlerMethod}: {Message}", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });

            /// <summary>
            /// <para><b>Message:</b> Unhandled error invoking circuit handler type {handlerType}.{handlerMethod}: {Message}</para>
            /// <para><b>Level:</b> Error</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            private static partial void CircuitHandlerFailed(global::Microsoft.Extensions.Logging.ILogger logger, global::System.Type handlerType, string handlerMethod, string message, global::System.Exception exception)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Error))
                {
                    __CircuitHandlerFailedCallback(logger, handlerType, handlerMethod, message, exception);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, global::System.Exception?> __UpdateRootComponentsStartedCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(111, "UpdateRootComponentsStarted"), "Update root components started.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });

            /// <summary>
            /// <para><b>Message:</b> Update root components started.</para>
            /// <para><b>Level:</b> Debug</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            public static partial void UpdateRootComponentsStarted(global::Microsoft.Extensions.Logging.ILogger logger)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
                {
                    __UpdateRootComponentsStartedCallback(logger, null);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, global::System.Exception?> __UpdateRootComponentsSucceededCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(112, "UpdateRootComponentsSucceeded"), "Update root components succeeded.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });

            /// <summary>
            /// <para><b>Message:</b> Update root components succeeded.</para>
            /// <para><b>Level:</b> Debug</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            public static partial void UpdateRootComponentsSucceeded(global::Microsoft.Extensions.Logging.ILogger logger)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
                {
                    __UpdateRootComponentsSucceededCallback(logger, null);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, global::System.Exception?> __UpdateRootComponentsFailedCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(113, "UpdateRootComponentsFailed"), "Update root components failed.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });

            /// <summary>
            /// <para><b>Message:</b> Update root components failed.</para>
            /// <para><b>Level:</b> Debug</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            public static partial void UpdateRootComponentsFailed(global::Microsoft.Extensions.Logging.ILogger logger, global::System.Exception exception)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
                {
                    __UpdateRootComponentsFailedCallback(logger, exception);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, global::Microsoft.AspNetCore.Components.Server.Circuits.CircuitId, global::System.Exception?> __CircuitUnhandledExceptionCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define<global::Microsoft.AspNetCore.Components.Server.Circuits.CircuitId>(global::Microsoft.Extensions.Logging.LogLevel.Error, new global::Microsoft.Extensions.Logging.EventId(111, "CircuitUnhandledException"), "Unhandled exception in circuit '{CircuitId}'.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });

            /// <summary>
            /// <para><b>Message:</b> Unhandled exception in circuit &apos;{CircuitId}&apos;.</para>
            /// <para><b>Level:</b> Error</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            public static partial void CircuitUnhandledException(global::Microsoft.Extensions.Logging.ILogger logger, global::Microsoft.AspNetCore.Components.Server.Circuits.CircuitId circuitId, global::System.Exception exception)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Error))
                {
                    __CircuitUnhandledExceptionCallback(logger, circuitId, exception);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, global::Microsoft.AspNetCore.Components.Server.Circuits.CircuitId, global::System.Exception?> __CircuitTransmittingClientErrorCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define<global::Microsoft.AspNetCore.Components.Server.Circuits.CircuitId>(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(112, "CircuitTransmittingClientError"), "About to notify client of an error in circuit '{CircuitId}'.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });

            /// <summary>
            /// <para><b>Message:</b> About to notify client of an error in circuit &apos;{CircuitId}&apos;.</para>
            /// <para><b>Level:</b> Debug</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            public static partial void CircuitTransmittingClientError(global::Microsoft.Extensions.Logging.ILogger logger, global::Microsoft.AspNetCore.Components.Server.Circuits.CircuitId circuitId)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
                {
                    __CircuitTransmittingClientErrorCallback(logger, circuitId, null);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, global::Microsoft.AspNetCore.Components.Server.Circuits.CircuitId, global::System.Exception?> __CircuitTransmittedClientErrorSuccessCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define<global::Microsoft.AspNetCore.Components.Server.Circuits.CircuitId>(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(113, "CircuitTransmittedClientErrorSuccess"), "Successfully transmitted error to client in circuit '{CircuitId}'.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });

            /// <summary>
            /// <para><b>Message:</b> Successfully transmitted error to client in circuit &apos;{CircuitId}&apos;.</para>
            /// <para><b>Level:</b> Debug</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            public static partial void CircuitTransmittedClientErrorSuccess(global::Microsoft.Extensions.Logging.ILogger logger, global::Microsoft.AspNetCore.Components.Server.Circuits.CircuitId circuitId)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
                {
                    __CircuitTransmittedClientErrorSuccessCallback(logger, circuitId, null);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, global::Microsoft.AspNetCore.Components.Server.Circuits.CircuitId, global::System.Exception?> __CircuitTransmitErrorFailedCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define<global::Microsoft.AspNetCore.Components.Server.Circuits.CircuitId>(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(114, "CircuitTransmitErrorFailed"), "Failed to transmit exception to client in circuit '{CircuitId}'.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });

            /// <summary>
            /// <para><b>Message:</b> Failed to transmit exception to client in circuit &apos;{CircuitId}&apos;.</para>
            /// <para><b>Level:</b> Debug</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            public static partial void CircuitTransmitErrorFailed(global::Microsoft.Extensions.Logging.ILogger logger, global::Microsoft.AspNetCore.Components.Server.Circuits.CircuitId circuitId, global::System.Exception exception)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
                {
                    __CircuitTransmitErrorFailedCallback(logger, circuitId, exception);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, global::Microsoft.AspNetCore.Components.Server.Circuits.CircuitId, global::System.Exception?> __UnhandledExceptionClientDisconnectedCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define<global::Microsoft.AspNetCore.Components.Server.Circuits.CircuitId>(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(115, "UnhandledExceptionClientDisconnected"), "An exception occurred on the circuit host '{CircuitId}' while the client is disconnected.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });

            /// <summary>
            /// <para><b>Message:</b> An exception occurred on the circuit host &apos;{CircuitId}&apos; while the client is disconnected.</para>
            /// <para><b>Level:</b> Debug</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            public static partial void UnhandledExceptionClientDisconnected(global::Microsoft.Extensions.Logging.ILogger logger, global::Microsoft.AspNetCore.Components.Server.Circuits.CircuitId circuitId, global::System.Exception exception)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
                {
                    __UnhandledExceptionClientDisconnectedCallback(logger, circuitId, exception);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, string, global::System.Exception?> __InvalidComponentTypeForUpdateCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define<string>(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(116, "InvalidComponentTypeForUpdate"), "The root component operation of type 'Update' was invalid: {Message}", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });

            /// <summary>
            /// <para><b>Message:</b> The root component operation of type &apos;Update&apos; was invalid: {Message}</para>
            /// <para><b>Level:</b> Debug</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            public static partial void InvalidComponentTypeForUpdate(global::Microsoft.Extensions.Logging.ILogger logger, string message)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
                {
                    __InvalidComponentTypeForUpdateCallback(logger, message, null);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, global::System.Exception?> __DispatchEventFailedToParseEventDataCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(200, "DispatchEventFailedToParseEventData"), "Failed to parse the event data when trying to dispatch an event.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });

            /// <summary>
            /// <para><b>Message:</b> Failed to parse the event data when trying to dispatch an event.</para>
            /// <para><b>Level:</b> Debug</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            public static partial void DispatchEventFailedToParseEventData(global::Microsoft.Extensions.Logging.ILogger logger, global::System.Exception ex)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
                {
                    __DispatchEventFailedToParseEventDataCallback(logger, ex);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, string, global::System.Exception?> __DispatchEventFailedToDispatchEventCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define<string>(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(201, "DispatchEventFailedToDispatchEvent"), "There was an error dispatching the event '{EventHandlerId}' to the application.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });

            /// <summary>
            /// <para><b>Message:</b> There was an error dispatching the event &apos;{EventHandlerId}&apos; to the application.</para>
            /// <para><b>Level:</b> Debug</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            public static partial void DispatchEventFailedToDispatchEvent(global::Microsoft.Extensions.Logging.ILogger logger, string eventHandlerId, global::System.Exception ex)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
                {
                    __DispatchEventFailedToDispatchEventCallback(logger, eventHandlerId, ex);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, string, long, string, global::System.Exception?> __BeginInvokeDotNetCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define<string, long, string>(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(202, "BeginInvokeDotNet"), "Invoking instance method '{MethodIdentifier}' on instance '{DotNetObjectId}' with callback id '{CallId}'.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });

            /// <summary>
            /// <para><b>Message:</b> Invoking instance method &apos;{MethodIdentifier}&apos; on instance &apos;{DotNetObjectId}&apos; with callback id &apos;{CallId}&apos;.</para>
            /// <para><b>Level:</b> Debug</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            private static partial void BeginInvokeDotNet(global::Microsoft.Extensions.Logging.ILogger logger, string methodIdentifier, long dotNetObjectId, string callId)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
                {
                    __BeginInvokeDotNetCallback(logger, methodIdentifier, dotNetObjectId, callId, null);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, string, long, string, global::System.Exception?> __BeginInvokeDotNetFailedCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define<string, long, string>(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(203, "BeginInvokeDotNetFailed"), "Failed to invoke instance method '{MethodIdentifier}' on instance '{DotNetObjectId}' with callback id '{CallId}'.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });

            /// <summary>
            /// <para><b>Message:</b> Failed to invoke instance method &apos;{MethodIdentifier}&apos; on instance &apos;{DotNetObjectId}&apos; with callback id &apos;{CallId}&apos;.</para>
            /// <para><b>Level:</b> Debug</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            private static partial void BeginInvokeDotNetFailed(global::Microsoft.Extensions.Logging.ILogger logger, string methodIdentifier, long dotNetObjectId, string callId, global::System.Exception exception)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
                {
                    __BeginInvokeDotNetFailedCallback(logger, methodIdentifier, dotNetObjectId, callId, exception);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, global::System.Exception?> __EndInvokeDispatchExceptionCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(204, "EndInvokeDispatchException"), "There was an error invoking 'Microsoft.JSInterop.DotNetDispatcher.EndInvoke'.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });

            /// <summary>
            /// <para><b>Message:</b> There was an error invoking &apos;Microsoft.JSInterop.DotNetDispatcher.EndInvoke&apos;.</para>
            /// <para><b>Level:</b> Debug</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            public static partial void EndInvokeDispatchException(global::Microsoft.Extensions.Logging.ILogger logger, global::System.Exception ex)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
                {
                    __EndInvokeDispatchExceptionCallback(logger, ex);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, long, string, global::System.Exception?> __EndInvokeJSFailedCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define<long, string>(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(205, "EndInvokeJSFailed"), "The JS interop call with callback id '{AsyncCall}' with arguments {Arguments}.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });

            /// <summary>
            /// <para><b>Message:</b> The JS interop call with callback id &apos;{AsyncCall}&apos; with arguments {Arguments}.</para>
            /// <para><b>Level:</b> Debug</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            public static partial void EndInvokeJSFailed(global::Microsoft.Extensions.Logging.ILogger logger, long asyncCall, string arguments)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
                {
                    __EndInvokeJSFailedCallback(logger, asyncCall, arguments, null);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, long, global::System.Exception?> __EndInvokeJSSucceededCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define<long>(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(206, "EndInvokeJSSucceeded"), "The JS interop call with callback id '{AsyncCall}' succeeded.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });

            /// <summary>
            /// <para><b>Message:</b> The JS interop call with callback id &apos;{AsyncCall}&apos; succeeded.</para>
            /// <para><b>Level:</b> Debug</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            public static partial void EndInvokeJSSucceeded(global::Microsoft.Extensions.Logging.ILogger logger, long asyncCall)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
                {
                    __EndInvokeJSSucceededCallback(logger, asyncCall, null);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, string, global::Microsoft.AspNetCore.Components.Server.Circuits.CircuitId, global::System.Exception?> __LocationChangeCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define<string, global::Microsoft.AspNetCore.Components.Server.Circuits.CircuitId>(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(208, "LocationChange"), "Location changing to {URI} in circuit '{CircuitId}'.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });

            /// <summary>
            /// <para><b>Message:</b> Location changing to {URI} in circuit &apos;{CircuitId}&apos;.</para>
            /// <para><b>Level:</b> Debug</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            public static partial void LocationChange(global::Microsoft.Extensions.Logging.ILogger logger, string uri, global::Microsoft.AspNetCore.Components.Server.Circuits.CircuitId circuitId)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
                {
                    __LocationChangeCallback(logger, uri, circuitId, null);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, string, global::Microsoft.AspNetCore.Components.Server.Circuits.CircuitId, global::System.Exception?> __LocationChangeSucceededCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define<string, global::Microsoft.AspNetCore.Components.Server.Circuits.CircuitId>(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(209, "LocationChangeSucceeded"), "Location change to '{URI}' in circuit '{CircuitId}' succeeded.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });

            /// <summary>
            /// <para><b>Message:</b> Location change to &apos;{URI}&apos; in circuit &apos;{CircuitId}&apos; succeeded.</para>
            /// <para><b>Level:</b> Debug</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            public static partial void LocationChangeSucceeded(global::Microsoft.Extensions.Logging.ILogger logger, string uri, global::Microsoft.AspNetCore.Components.Server.Circuits.CircuitId circuitId)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
                {
                    __LocationChangeSucceededCallback(logger, uri, circuitId, null);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, string, global::Microsoft.AspNetCore.Components.Server.Circuits.CircuitId, global::System.Exception?> __LocationChangeFailedCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define<string, global::Microsoft.AspNetCore.Components.Server.Circuits.CircuitId>(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(210, "LocationChangeFailed"), "Location change to '{URI}' in circuit '{CircuitId}' failed.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });

            /// <summary>
            /// <para><b>Message:</b> Location change to &apos;{URI}&apos; in circuit &apos;{CircuitId}&apos; failed.</para>
            /// <para><b>Level:</b> Debug</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            public static partial void LocationChangeFailed(global::Microsoft.Extensions.Logging.ILogger logger, string uri, global::Microsoft.AspNetCore.Components.Server.Circuits.CircuitId circuitId, global::System.Exception exception)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
                {
                    __LocationChangeFailedCallback(logger, uri, circuitId, exception);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, string, global::Microsoft.AspNetCore.Components.Server.Circuits.CircuitId, global::System.Exception?> __LocationChangingCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define<string, global::Microsoft.AspNetCore.Components.Server.Circuits.CircuitId>(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(211, "LocationChanging"), "Location is about to change to {URI} in ciruit '{CircuitId}'.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });

            /// <summary>
            /// <para><b>Message:</b> Location is about to change to {URI} in ciruit &apos;{CircuitId}&apos;.</para>
            /// <para><b>Level:</b> Debug</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            public static partial void LocationChanging(global::Microsoft.Extensions.Logging.ILogger logger, string uri, global::Microsoft.AspNetCore.Components.Server.Circuits.CircuitId circuitId)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
                {
                    __LocationChangingCallback(logger, uri, circuitId, null);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, long, global::Microsoft.AspNetCore.Components.Server.Circuits.CircuitId, global::System.Exception?> __OnRenderCompletedFailedCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define<long, global::Microsoft.AspNetCore.Components.Server.Circuits.CircuitId>(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(212, "OnRenderCompletedFailed"), "Failed to complete render batch '{RenderId}' in circuit host '{CircuitId}'.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });

            /// <summary>
            /// <para><b>Message:</b> Failed to complete render batch &apos;{RenderId}&apos; in circuit host &apos;{CircuitId}&apos;.</para>
            /// <para><b>Level:</b> Debug</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            public static partial void OnRenderCompletedFailed(global::Microsoft.Extensions.Logging.ILogger logger, long renderId, global::Microsoft.AspNetCore.Components.Server.Circuits.CircuitId circuitId, global::System.Exception e)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
                {
                    __OnRenderCompletedFailedCallback(logger, renderId, circuitId, e);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, long, global::System.Exception?> __ReceiveByteArraySuccessCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define<long>(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(213, "ReceiveByteArraySucceeded"), "The ReceiveByteArray call with id '{id}' succeeded.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });

            /// <summary>
            /// <para><b>Message:</b> The ReceiveByteArray call with id &apos;{id}&apos; succeeded.</para>
            /// <para><b>Level:</b> Debug</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            public static partial void ReceiveByteArraySuccess(global::Microsoft.Extensions.Logging.ILogger logger, long id)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
                {
                    __ReceiveByteArraySuccessCallback(logger, id, null);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, long, global::System.Exception?> __ReceiveByteArrayExceptionCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define<long>(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(214, "ReceiveByteArrayException"), "The ReceiveByteArray call with id '{id}' failed.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });

            /// <summary>
            /// <para><b>Message:</b> The ReceiveByteArray call with id &apos;{id}&apos; failed.</para>
            /// <para><b>Level:</b> Debug</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            public static partial void ReceiveByteArrayException(global::Microsoft.Extensions.Logging.ILogger logger, long id, global::System.Exception ex)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
                {
                    __ReceiveByteArrayExceptionCallback(logger, id, ex);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, long, global::System.Exception?> __ReceiveJSDataChunkExceptionCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define<long>(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(215, "ReceiveJSDataChunkException"), "The ReceiveJSDataChunk call with stream id '{streamId}' failed.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });

            /// <summary>
            /// <para><b>Message:</b> The ReceiveJSDataChunk call with stream id &apos;{streamId}&apos; failed.</para>
            /// <para><b>Level:</b> Debug</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            public static partial void ReceiveJSDataChunkException(global::Microsoft.Extensions.Logging.ILogger logger, long streamId, global::System.Exception ex)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
                {
                    __ReceiveJSDataChunkExceptionCallback(logger, streamId, ex);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, long, global::System.Exception?> __SendDotNetStreamExceptionCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define<long>(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(216, "SendDotNetStreamException"), "The SendDotNetStreamAsync call with id '{id}' failed.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });

            /// <summary>
            /// <para><b>Message:</b> The SendDotNetStreamAsync call with id &apos;{id}&apos; failed.</para>
            /// <para><b>Level:</b> Debug</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            public static partial void SendDotNetStreamException(global::Microsoft.Extensions.Logging.ILogger logger, long id, global::System.Exception ex)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
                {
                    __SendDotNetStreamExceptionCallback(logger, id, ex);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, string, string, string, global::System.Exception?> __BeginInvokeDotNetStaticCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define<string, string, string>(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(217, "BeginInvokeDotNetStatic"), "Invoking static method with identifier '{MethodIdentifier}' on assembly '{Assembly}' with callback id '{CallId}'.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });

            /// <summary>
            /// <para><b>Message:</b> Invoking static method with identifier &apos;{MethodIdentifier}&apos; on assembly &apos;{Assembly}&apos; with callback id &apos;{CallId}&apos;.</para>
            /// <para><b>Level:</b> Debug</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            private static partial void BeginInvokeDotNetStatic(global::Microsoft.Extensions.Logging.ILogger logger, string methodIdentifier, string assembly, string callId)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
                {
                    __BeginInvokeDotNetStaticCallback(logger, methodIdentifier, assembly, callId, null);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, string, string, string, global::System.Exception?> __BeginInvokeDotNetStaticFailedCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define<string, string, string>(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(218, "BeginInvokeDotNetStaticFailed"), "Failed to invoke static method with identifier '{MethodIdentifier}' on assembly '{Assembly}' with callback id '{CallId}'.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });

            /// <summary>
            /// <para><b>Message:</b> Failed to invoke static method with identifier &apos;{MethodIdentifier}&apos; on assembly &apos;{Assembly}&apos; with callback id &apos;{CallId}&apos;.</para>
            /// <para><b>Level:</b> Debug</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            private static partial void BeginInvokeDotNetStaticFailed(global::Microsoft.Extensions.Logging.ILogger logger, string methodIdentifier, string assembly, string callId, global::System.Exception exception)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
                {
                    __BeginInvokeDotNetStaticFailedCallback(logger, methodIdentifier, assembly, callId, exception);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, string, global::Microsoft.AspNetCore.Components.Server.Circuits.CircuitId, global::System.Exception?> __LocationChangeFailedInCircuitCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define<string, global::Microsoft.AspNetCore.Components.Server.Circuits.CircuitId>(global::Microsoft.Extensions.Logging.LogLevel.Error, new global::Microsoft.Extensions.Logging.EventId(219, "LocationChangeFailedInCircuit"), "Location change to '{URI}' in circuit '{CircuitId}' failed.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });

            /// <summary>
            /// <para><b>Message:</b> Location change to &apos;{URI}&apos; in circuit &apos;{CircuitId}&apos; failed.</para>
            /// <para><b>Level:</b> Error</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            public static partial void LocationChangeFailedInCircuit(global::Microsoft.Extensions.Logging.ILogger logger, string uri, global::Microsoft.AspNetCore.Components.Server.Circuits.CircuitId circuitId, global::System.Exception exception)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Error))
                {
                    __LocationChangeFailedInCircuitCallback(logger, uri, circuitId, exception);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, global::Microsoft.AspNetCore.Components.Server.Circuits.CircuitId, global::System.Exception?> __FailedToSaveStateToClientCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define<global::Microsoft.AspNetCore.Components.Server.Circuits.CircuitId>(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(220, "FailedToSaveStateToClient"), "Failed to save state to client in circuit '{CircuitId}'.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });

            /// <summary>
            /// <para><b>Message:</b> Failed to save state to client in circuit &apos;{CircuitId}&apos;.</para>
            /// <para><b>Level:</b> Debug</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            public static partial void FailedToSaveStateToClient(global::Microsoft.Extensions.Logging.ILogger logger, global::Microsoft.AspNetCore.Components.Server.Circuits.CircuitId circuitId, global::System.Exception exception)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
                {
                    __FailedToSaveStateToClientCallback(logger, circuitId, exception);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, global::Microsoft.AspNetCore.Components.Server.Circuits.CircuitId, global::System.Exception?> __ServerPauseRequestedCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define<global::Microsoft.AspNetCore.Components.Server.Circuits.CircuitId>(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(120, "ServerPauseRequested"), "Server-initiated pause requested for circuit '{CircuitId}'.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });

            /// <summary>
            /// <para><b>Message:</b> Server-initiated pause requested for circuit &apos;{CircuitId}&apos;.</para>
            /// <para><b>Level:</b> Debug</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            public static partial void ServerPauseRequested(global::Microsoft.Extensions.Logging.ILogger logger, global::Microsoft.AspNetCore.Components.Server.Circuits.CircuitId circuitId)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
                {
                    __ServerPauseRequestedCallback(logger, circuitId, null);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, global::Microsoft.AspNetCore.Components.Server.Circuits.CircuitId, global::System.Exception?> __ServerPauseAcceptedCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define<global::Microsoft.AspNetCore.Components.Server.Circuits.CircuitId>(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(121, "ServerPauseAccepted"), "Server-initiated pause request accepted for circuit '{CircuitId}'. Client has been asked to begin pausing.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });

            /// <summary>
            /// <para><b>Message:</b> Server-initiated pause request accepted for circuit &apos;{CircuitId}&apos;. Client has been asked to begin pausing.</para>
            /// <para><b>Level:</b> Debug</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            public static partial void ServerPauseAccepted(global::Microsoft.Extensions.Logging.ILogger logger, global::Microsoft.AspNetCore.Components.Server.Circuits.CircuitId circuitId)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
                {
                    __ServerPauseAcceptedCallback(logger, circuitId, null);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, global::Microsoft.AspNetCore.Components.Server.Circuits.CircuitId, global::System.Exception?> __ServerPauseRejectedCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define<global::Microsoft.AspNetCore.Components.Server.Circuits.CircuitId>(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(122, "ServerPauseRejected"), "Server-initiated pause request rejected for circuit '{CircuitId}'. Circuit is not in a connected state.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });

            /// <summary>
            /// <para><b>Message:</b> Server-initiated pause request rejected for circuit &apos;{CircuitId}&apos;. Circuit is not in a connected state.</para>
            /// <para><b>Level:</b> Debug</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            public static partial void ServerPauseRejected(global::Microsoft.Extensions.Logging.ILogger logger, global::Microsoft.AspNetCore.Components.Server.Circuits.CircuitId circuitId)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
                {
                    __ServerPauseRejectedCallback(logger, circuitId, null);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, global::Microsoft.AspNetCore.Components.Server.Circuits.CircuitId, global::System.Exception?> __ServerPauseFailedCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define<global::Microsoft.AspNetCore.Components.Server.Circuits.CircuitId>(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(123, "ServerPauseFailed"), "Server-initiated pause request failed for circuit '{CircuitId}'.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });

            /// <summary>
            /// <para><b>Message:</b> Server-initiated pause request failed for circuit &apos;{CircuitId}&apos;.</para>
            /// <para><b>Level:</b> Debug</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            public static partial void ServerPauseFailed(global::Microsoft.Extensions.Logging.ILogger logger, global::Microsoft.AspNetCore.Components.Server.Circuits.CircuitId circuitId, global::System.Exception exception)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
                {
                    __ServerPauseFailedCallback(logger, circuitId, exception);
                }
            }
        }
    }
}
namespace Microsoft.AspNetCore.Components.Server.Circuits
{
    partial class CircuitRegistry
    {
        partial class Log
        {
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, string, global::System.Exception?> __UnhandledExceptionDisposingCircuitHostCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define<string>(global::Microsoft.Extensions.Logging.LogLevel.Error, new global::Microsoft.Extensions.Logging.EventId(100, "ExceptionDisposingCircuit"), "Unhandled exception disposing circuit host: {Message}", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });

            /// <summary>
            /// <para><b>Message:</b> Unhandled exception disposing circuit host: {Message}</para>
            /// <para><b>Level:</b> Error</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            private static partial void UnhandledExceptionDisposingCircuitHost(global::Microsoft.Extensions.Logging.ILogger logger, string message, global::System.Exception exception)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Error))
                {
                    __UnhandledExceptionDisposingCircuitHostCallback(logger, message, exception);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, string, global::System.Exception?> __ExceptionDisposingTokenSourceCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define<string>(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(101, "ExceptionDisposingTokenSource"), "Exception thrown when disposing token source: {Message}", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });

            /// <summary>
            /// <para><b>Message:</b> Exception thrown when disposing token source: {Message}</para>
            /// <para><b>Level:</b> Debug</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            private static partial void ExceptionDisposingTokenSource(global::Microsoft.Extensions.Logging.ILogger logger, string message, global::System.Exception exception)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
                {
                    __ExceptionDisposingTokenSourceCallback(logger, message, exception);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, global::Microsoft.AspNetCore.Components.Server.Circuits.CircuitId, global::System.Exception?> __CircuitConnectStartedCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define<global::Microsoft.AspNetCore.Components.Server.Circuits.CircuitId>(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(102, "AttemptingToReconnect"), "Attempting to reconnect to Circuit with secret {CircuitHost}.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });

            /// <summary>
            /// <para><b>Message:</b> Attempting to reconnect to Circuit with secret {CircuitHost}.</para>
            /// <para><b>Level:</b> Debug</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            public static partial void CircuitConnectStarted(global::Microsoft.Extensions.Logging.ILogger logger, global::Microsoft.AspNetCore.Components.Server.Circuits.CircuitId circuitHost)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
                {
                    __CircuitConnectStartedCallback(logger, circuitHost, null);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, global::Microsoft.AspNetCore.Components.Server.Circuits.CircuitId, global::System.Exception?> __FailedToFindCircuitCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define<global::Microsoft.AspNetCore.Components.Server.Circuits.CircuitId>(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(104, "FailedToFindCircuit"), "Failed to find a matching circuit for circuit secret {CircuitHost}.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });

            /// <summary>
            /// <para><b>Message:</b> Failed to find a matching circuit for circuit secret {CircuitHost}.</para>
            /// <para><b>Level:</b> Debug</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            public static partial void FailedToFindCircuit(global::Microsoft.Extensions.Logging.ILogger logger, global::Microsoft.AspNetCore.Components.Server.Circuits.CircuitId circuitHost)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
                {
                    __FailedToFindCircuitCallback(logger, circuitHost, null);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, global::Microsoft.AspNetCore.Components.Server.Circuits.CircuitId, string, global::System.Exception?> __ConnectingToActiveCircuitCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define<global::Microsoft.AspNetCore.Components.Server.Circuits.CircuitId, string>(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(105, "ConnectingToActiveCircuit"), "Transferring active circuit {CircuitId} to connection {ConnectionId}.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });

            /// <summary>
            /// <para><b>Message:</b> Transferring active circuit {CircuitId} to connection {ConnectionId}.</para>
            /// <para><b>Level:</b> Debug</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            public static partial void ConnectingToActiveCircuit(global::Microsoft.Extensions.Logging.ILogger logger, global::Microsoft.AspNetCore.Components.Server.Circuits.CircuitId circuitId, string connectionId)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
                {
                    __ConnectingToActiveCircuitCallback(logger, circuitId, connectionId, null);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, global::Microsoft.AspNetCore.Components.Server.Circuits.CircuitId, string, global::System.Exception?> __ConnectingToDisconnectedCircuitCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define<global::Microsoft.AspNetCore.Components.Server.Circuits.CircuitId, string>(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(106, "ConnectingToDisconnectedCircuit"), "Transferring disconnected circuit {CircuitId} to connection {ConnectionId}.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });

            /// <summary>
            /// <para><b>Message:</b> Transferring disconnected circuit {CircuitId} to connection {ConnectionId}.</para>
            /// <para><b>Level:</b> Debug</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            public static partial void ConnectingToDisconnectedCircuit(global::Microsoft.Extensions.Logging.ILogger logger, global::Microsoft.AspNetCore.Components.Server.Circuits.CircuitId circuitId, string connectionId)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
                {
                    __ConnectingToDisconnectedCircuitCallback(logger, circuitId, connectionId, null);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, global::Microsoft.AspNetCore.Components.Server.Circuits.CircuitId, global::System.Exception?> __FailedToReconnectToCircuitCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define<global::Microsoft.AspNetCore.Components.Server.Circuits.CircuitId>(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(107, "FailedToReconnectToCircuit"), "Failed to reconnect to a circuit with id {CircuitId}.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });

            /// <summary>
            /// <para><b>Message:</b> Failed to reconnect to a circuit with id {CircuitId}.</para>
            /// <para><b>Level:</b> Debug</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            public static partial void FailedToReconnectToCircuit(global::Microsoft.Extensions.Logging.ILogger logger, global::Microsoft.AspNetCore.Components.Server.Circuits.CircuitId circuitId, global::System.Exception exception)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
                {
                    __FailedToReconnectToCircuitCallback(logger, circuitId, exception);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, global::Microsoft.AspNetCore.Components.Server.Circuits.CircuitId, string, global::System.Exception?> __CircuitDisconnectStartedCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define<global::Microsoft.AspNetCore.Components.Server.Circuits.CircuitId, string>(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(108, "CircuitDisconnectStarted"), "Attempting to disconnect circuit with id {CircuitId} from connection {ConnectionId}.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });

            /// <summary>
            /// <para><b>Message:</b> Attempting to disconnect circuit with id {CircuitId} from connection {ConnectionId}.</para>
            /// <para><b>Level:</b> Debug</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            public static partial void CircuitDisconnectStarted(global::Microsoft.Extensions.Logging.ILogger logger, global::Microsoft.AspNetCore.Components.Server.Circuits.CircuitId circuitId, string connectionId)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
                {
                    __CircuitDisconnectStartedCallback(logger, circuitId, connectionId, null);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, global::Microsoft.AspNetCore.Components.Server.Circuits.CircuitId, global::System.Exception?> __CircuitNotActiveCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define<global::Microsoft.AspNetCore.Components.Server.Circuits.CircuitId>(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(109, "CircuitNotActive"), "Failed to disconnect circuit with id {CircuitId}. The circuit is not active.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });

            /// <summary>
            /// <para><b>Message:</b> Failed to disconnect circuit with id {CircuitId}. The circuit is not active.</para>
            /// <para><b>Level:</b> Debug</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            public static partial void CircuitNotActive(global::Microsoft.Extensions.Logging.ILogger logger, global::Microsoft.AspNetCore.Components.Server.Circuits.CircuitId circuitId)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
                {
                    __CircuitNotActiveCallback(logger, circuitId, null);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, global::Microsoft.AspNetCore.Components.Server.Circuits.CircuitId, string, global::System.Exception?> __CircuitConnectedToDifferentConnectionCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define<global::Microsoft.AspNetCore.Components.Server.Circuits.CircuitId, string>(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(110, "CircuitConnectedToDifferentConnection"), "Failed to disconnect circuit with id {CircuitId}. The circuit is connected to {ConnectionId}.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });

            /// <summary>
            /// <para><b>Message:</b> Failed to disconnect circuit with id {CircuitId}. The circuit is connected to {ConnectionId}.</para>
            /// <para><b>Level:</b> Debug</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            public static partial void CircuitConnectedToDifferentConnection(global::Microsoft.Extensions.Logging.ILogger logger, global::Microsoft.AspNetCore.Components.Server.Circuits.CircuitId circuitId, string connectionId)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
                {
                    __CircuitConnectedToDifferentConnectionCallback(logger, circuitId, connectionId, null);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, global::Microsoft.AspNetCore.Components.Server.Circuits.CircuitId, global::System.Exception?> __CircuitMarkedDisconnectedCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define<global::Microsoft.AspNetCore.Components.Server.Circuits.CircuitId>(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(111, "CircuitMarkedDisconnected"), "Circuit with id {CircuitId} is disconnected.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });

            /// <summary>
            /// <para><b>Message:</b> Circuit with id {CircuitId} is disconnected.</para>
            /// <para><b>Level:</b> Debug</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            public static partial void CircuitMarkedDisconnected(global::Microsoft.Extensions.Logging.ILogger logger, global::Microsoft.AspNetCore.Components.Server.Circuits.CircuitId circuitId)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
                {
                    __CircuitMarkedDisconnectedCallback(logger, circuitId, null);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, global::Microsoft.AspNetCore.Components.Server.Circuits.CircuitId, global::Microsoft.Extensions.Caching.Memory.EvictionReason, global::System.Exception?> __CircuitEvictedCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define<global::Microsoft.AspNetCore.Components.Server.Circuits.CircuitId, global::Microsoft.Extensions.Caching.Memory.EvictionReason>(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(112, "CircuitEvicted"), "Circuit with id {CircuitId} evicted due to {EvictionReason}.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });

            /// <summary>
            /// <para><b>Message:</b> Circuit with id {CircuitId} evicted due to {EvictionReason}.</para>
            /// <para><b>Level:</b> Debug</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            public static partial void CircuitEvicted(global::Microsoft.Extensions.Logging.ILogger logger, global::Microsoft.AspNetCore.Components.Server.Circuits.CircuitId circuitId, global::Microsoft.Extensions.Caching.Memory.EvictionReason evictionReason)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
                {
                    __CircuitEvictedCallback(logger, circuitId, evictionReason, null);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, global::Microsoft.AspNetCore.Components.Server.Circuits.CircuitId, global::System.Exception?> __CircuitDisconnectedPermanentlyCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define<global::Microsoft.AspNetCore.Components.Server.Circuits.CircuitId>(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(113, "CircuitDisconnectedPermanently"), "Circuit with id {CircuitId} has been removed from the registry for permanent disconnection.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });

            /// <summary>
            /// <para><b>Message:</b> Circuit with id {CircuitId} has been removed from the registry for permanent disconnection.</para>
            /// <para><b>Level:</b> Debug</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            public static partial void CircuitDisconnectedPermanently(global::Microsoft.Extensions.Logging.ILogger logger, global::Microsoft.AspNetCore.Components.Server.Circuits.CircuitId circuitId)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
                {
                    __CircuitDisconnectedPermanentlyCallback(logger, circuitId, null);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, global::Microsoft.AspNetCore.Components.Server.Circuits.CircuitId, global::System.Exception?> __CircuitExceptionHandlerFailedCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define<global::Microsoft.AspNetCore.Components.Server.Circuits.CircuitId>(global::Microsoft.Extensions.Logging.LogLevel.Error, new global::Microsoft.Extensions.Logging.EventId(114, "CircuitExceptionHandlerFailed"), "Exception handler for {CircuitId} failed.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });

            /// <summary>
            /// <para><b>Message:</b> Exception handler for {CircuitId} failed.</para>
            /// <para><b>Level:</b> Error</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            public static partial void CircuitExceptionHandlerFailed(global::Microsoft.Extensions.Logging.ILogger logger, global::Microsoft.AspNetCore.Components.Server.Circuits.CircuitId circuitId, global::System.Exception exception)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Error))
                {
                    __CircuitExceptionHandlerFailedCallback(logger, circuitId, exception);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, global::Microsoft.AspNetCore.Components.Server.Circuits.CircuitId, global::System.Exception?> __ReconnectionSucceededCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define<global::Microsoft.AspNetCore.Components.Server.Circuits.CircuitId>(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(115, "ReconnectionSucceeded"), "Reconnect to circuit with id {CircuitId} succeeded.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });

            /// <summary>
            /// <para><b>Message:</b> Reconnect to circuit with id {CircuitId} succeeded.</para>
            /// <para><b>Level:</b> Debug</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            public static partial void ReconnectionSucceeded(global::Microsoft.Extensions.Logging.ILogger logger, global::Microsoft.AspNetCore.Components.Server.Circuits.CircuitId circuitId)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
                {
                    __ReconnectionSucceededCallback(logger, circuitId, null);
                }
            }
            /// <summary> This API supports the logging infrastructure and is not intended to be used directly from your code. It is subject to change in the future. </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Never)]
            private readonly struct __PersistedCircuitStateDiscardedStruct : global::System.Collections.Generic.IReadOnlyList<global::System.Collections.Generic.KeyValuePair<string, object?>>
            {
                private readonly global::Microsoft.AspNetCore.Components.Server.Circuits.CircuitId _circuitId;

                public __PersistedCircuitStateDiscardedStruct(global::Microsoft.AspNetCore.Components.Server.Circuits.CircuitId circuitId)
                {
                    this._circuitId = circuitId;

                }

                public override string ToString()
                {
                    var CircuitId = this._circuitId;

                    return string.Create(global::System.Globalization.CultureInfo.InvariantCulture, $"Circuit {CircuitId} was not resumed. Persisted circuit state for {CircuitId} discarded.");
                }

                public static readonly global::System.Func<__PersistedCircuitStateDiscardedStruct, global::System.Exception?, string> Format = (state, ex) => state.ToString();

                public int Count => 2;

                public global::System.Collections.Generic.KeyValuePair<string, object?> this[int index]
                {
                    get => index switch
                    {
                        0 => new global::System.Collections.Generic.KeyValuePair<string, object?>("CircuitId", this._circuitId),
                        1 => new global::System.Collections.Generic.KeyValuePair<string, object?>("{OriginalFormat}", "Circuit {CircuitId} was not resumed. Persisted circuit state for {CircuitId} discarded."),

                        _ => throw new global::System.IndexOutOfRangeException(),  // return the same exception LoggerMessage.Define returns in this case
                    };
            }

                public global::System.Collections.Generic.IEnumerator<global::System.Collections.Generic.KeyValuePair<string, object?>> GetEnumerator()
                {
                    for (int i = 0; i < 2; i++)
                    {
                        yield return this[i];
                    }
                }

                global::System.Collections.IEnumerator global::System.Collections.IEnumerable.GetEnumerator() => GetEnumerator();
            }

            /// <summary>
            /// <para><b>Message:</b> Circuit {CircuitId} was not resumed. Persisted circuit state for {CircuitId} discarded.</para>
            /// <para><b>Level:</b> Debug</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            public static partial void PersistedCircuitStateDiscarded(global::Microsoft.Extensions.Logging.ILogger logger, global::Microsoft.AspNetCore.Components.Server.Circuits.CircuitId circuitId)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
                {
                    logger.Log(
                        global::Microsoft.Extensions.Logging.LogLevel.Debug,
                        new global::Microsoft.Extensions.Logging.EventId(116, "PersistedCircuitStateDiscarded"),
                        new __PersistedCircuitStateDiscardedStruct(circuitId),
                        null,
                        __PersistedCircuitStateDiscardedStruct.Format);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, global::Microsoft.AspNetCore.Components.Server.Circuits.CircuitId, string, global::System.Exception?> __CircuitPauseStartedCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define<global::Microsoft.AspNetCore.Components.Server.Circuits.CircuitId, string>(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(117, "CircuitPauseStarted"), "Pausing circuit with id {CircuitId} from connection {ConnectionId}.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });

            /// <summary>
            /// <para><b>Message:</b> Pausing circuit with id {CircuitId} from connection {ConnectionId}.</para>
            /// <para><b>Level:</b> Debug</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            public static partial void CircuitPauseStarted(global::Microsoft.Extensions.Logging.ILogger logger, global::Microsoft.AspNetCore.Components.Server.Circuits.CircuitId circuitId, string connectionId)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
                {
                    __CircuitPauseStartedCallback(logger, circuitId, connectionId, null);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, global::Microsoft.AspNetCore.Components.Server.Circuits.CircuitId, string, global::System.Exception?> __CircuitPauseFailedCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define<global::Microsoft.AspNetCore.Components.Server.Circuits.CircuitId, string>(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(118, "CircuitPauseFailed"), "Failed to pause circuit with id {CircuitId} from connection {ConnectionId}.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });

            /// <summary>
            /// <para><b>Message:</b> Failed to pause circuit with id {CircuitId} from connection {ConnectionId}.</para>
            /// <para><b>Level:</b> Debug</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            public static partial void CircuitPauseFailed(global::Microsoft.Extensions.Logging.ILogger logger, global::Microsoft.AspNetCore.Components.Server.Circuits.CircuitId circuitId, string connectionId)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
                {
                    __CircuitPauseFailedCallback(logger, circuitId, connectionId, null);
                }
            }
        }
    }
}
namespace Microsoft.AspNetCore.Components.Server.Circuits
{
    partial class DefaultInMemoryCircuitPersistenceProvider
    {
        partial class Log
        {
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, global::Microsoft.AspNetCore.Components.Server.Circuits.CircuitId, global::Microsoft.Extensions.Caching.Memory.EvictionReason, global::System.Exception?> __CircuitStateEvictedCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define<global::Microsoft.AspNetCore.Components.Server.Circuits.CircuitId, global::Microsoft.Extensions.Caching.Memory.EvictionReason>(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(101, "CircuitStateEvicted"), "Circuit state evicted for circuit {CircuitId} due to {Reason}", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });

            /// <summary>
            /// <para><b>Message:</b> Circuit state evicted for circuit {CircuitId} due to {Reason}</para>
            /// <para><b>Level:</b> Debug</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            public static partial void CircuitStateEvicted(global::Microsoft.Extensions.Logging.ILogger logger, global::Microsoft.AspNetCore.Components.Server.Circuits.CircuitId circuitId, global::Microsoft.Extensions.Caching.Memory.EvictionReason reason)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
                {
                    __CircuitStateEvictedCallback(logger, circuitId, reason, null);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, global::Microsoft.AspNetCore.Components.Server.Circuits.CircuitId, global::System.Exception?> __CircuitResumeStartedCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define<global::Microsoft.AspNetCore.Components.Server.Circuits.CircuitId>(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(102, "CircuitResumeStarted"), "Resuming circuit with ID {CircuitId}", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });

            /// <summary>
            /// <para><b>Message:</b> Resuming circuit with ID {CircuitId}</para>
            /// <para><b>Level:</b> Debug</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            public static partial void CircuitResumeStarted(global::Microsoft.Extensions.Logging.ILogger logger, global::Microsoft.AspNetCore.Components.Server.Circuits.CircuitId circuitId)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
                {
                    __CircuitResumeStartedCallback(logger, circuitId, null);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, global::Microsoft.AspNetCore.Components.Server.Circuits.CircuitId, global::System.Exception?> __FailedToFindCircuitStateCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define<global::Microsoft.AspNetCore.Components.Server.Circuits.CircuitId>(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(103, "FailedToFindCircuitState"), "Failed to find persisted circuit with ID {CircuitId}", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });

            /// <summary>
            /// <para><b>Message:</b> Failed to find persisted circuit with ID {CircuitId}</para>
            /// <para><b>Level:</b> Debug</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            public static partial void FailedToFindCircuitState(global::Microsoft.Extensions.Logging.ILogger logger, global::Microsoft.AspNetCore.Components.Server.Circuits.CircuitId circuitId)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
                {
                    __FailedToFindCircuitStateCallback(logger, circuitId, null);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, global::Microsoft.AspNetCore.Components.Server.Circuits.CircuitId, global::System.Exception?> __CircuitStateFoundCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define<global::Microsoft.AspNetCore.Components.Server.Circuits.CircuitId>(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(104, "CircuitStateFound"), "Circuit state found for circuit {CircuitId}", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });

            /// <summary>
            /// <para><b>Message:</b> Circuit state found for circuit {CircuitId}</para>
            /// <para><b>Level:</b> Debug</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            public static partial void CircuitStateFound(global::Microsoft.Extensions.Logging.ILogger logger, global::Microsoft.AspNetCore.Components.Server.Circuits.CircuitId circuitId)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
                {
                    __CircuitStateFoundCallback(logger, circuitId, null);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, global::System.Exception?> __ExceptionDisposingTokenSourceCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define(global::Microsoft.Extensions.Logging.LogLevel.Error, new global::Microsoft.Extensions.Logging.EventId(105, "ExceptionDisposingTokenSource"), "An exception occurred while disposing the token source.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });

            /// <summary>
            /// <para><b>Message:</b> An exception occurred while disposing the token source.</para>
            /// <para><b>Level:</b> Error</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            public static partial void ExceptionDisposingTokenSource(global::Microsoft.Extensions.Logging.ILogger logger, global::System.Exception exception)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Error))
                {
                    __ExceptionDisposingTokenSourceCallback(logger, exception);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, global::Microsoft.AspNetCore.Components.Server.Circuits.CircuitId, global::System.Exception?> __CircuitPauseStartedCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define<global::Microsoft.AspNetCore.Components.Server.Circuits.CircuitId>(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(106, "CircuitPauseStarted"), "Pausing circuit with ID {CircuitId}", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });

            /// <summary>
            /// <para><b>Message:</b> Pausing circuit with ID {CircuitId}</para>
            /// <para><b>Level:</b> Debug</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            public static partial void CircuitPauseStarted(global::Microsoft.Extensions.Logging.ILogger logger, global::Microsoft.AspNetCore.Components.Server.Circuits.CircuitId circuitId)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
                {
                    __CircuitPauseStartedCallback(logger, circuitId, null);
                }
            }
        }
    }
}
namespace Microsoft.AspNetCore.Components.Server.Circuits
{
    partial class HybridCacheCircuitPersistenceProvider
    {
        partial class Log
        {
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, global::Microsoft.AspNetCore.Components.Server.Circuits.CircuitId, string, global::System.Exception?> __CircuitStateEvictedCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define<global::Microsoft.AspNetCore.Components.Server.Circuits.CircuitId, string>(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(201, "CircuitStateEvicted"), "Circuit state evicted for circuit {CircuitId} due to {Reason}", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });

            /// <summary>
            /// <para><b>Message:</b> Circuit state evicted for circuit {CircuitId} due to {Reason}</para>
            /// <para><b>Level:</b> Debug</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            public static partial void CircuitStateEvicted(global::Microsoft.Extensions.Logging.ILogger logger, global::Microsoft.AspNetCore.Components.Server.Circuits.CircuitId circuitId, string reason)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
                {
                    __CircuitStateEvictedCallback(logger, circuitId, reason, null);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, global::Microsoft.AspNetCore.Components.Server.Circuits.CircuitId, global::System.Exception?> __CircuitResumeStartedCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define<global::Microsoft.AspNetCore.Components.Server.Circuits.CircuitId>(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(202, "CircuitResumeStarted"), "Resuming circuit with ID {CircuitId}", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });

            /// <summary>
            /// <para><b>Message:</b> Resuming circuit with ID {CircuitId}</para>
            /// <para><b>Level:</b> Debug</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            public static partial void CircuitResumeStarted(global::Microsoft.Extensions.Logging.ILogger logger, global::Microsoft.AspNetCore.Components.Server.Circuits.CircuitId circuitId)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
                {
                    __CircuitResumeStartedCallback(logger, circuitId, null);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, global::Microsoft.AspNetCore.Components.Server.Circuits.CircuitId, global::System.Exception?> __FailedToFindCircuitStateCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define<global::Microsoft.AspNetCore.Components.Server.Circuits.CircuitId>(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(203, "FailedToFindCircuitState"), "Failed to find persisted circuit with ID {CircuitId}", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });

            /// <summary>
            /// <para><b>Message:</b> Failed to find persisted circuit with ID {CircuitId}</para>
            /// <para><b>Level:</b> Debug</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            public static partial void FailedToFindCircuitState(global::Microsoft.Extensions.Logging.ILogger logger, global::Microsoft.AspNetCore.Components.Server.Circuits.CircuitId circuitId)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
                {
                    __FailedToFindCircuitStateCallback(logger, circuitId, null);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, global::Microsoft.AspNetCore.Components.Server.Circuits.CircuitId, global::System.Exception?> __CircuitStateFoundCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define<global::Microsoft.AspNetCore.Components.Server.Circuits.CircuitId>(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(204, "CircuitStateFound"), "Circuit state found for circuit {CircuitId}", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });

            /// <summary>
            /// <para><b>Message:</b> Circuit state found for circuit {CircuitId}</para>
            /// <para><b>Level:</b> Debug</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            public static partial void CircuitStateFound(global::Microsoft.Extensions.Logging.ILogger logger, global::Microsoft.AspNetCore.Components.Server.Circuits.CircuitId circuitId)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
                {
                    __CircuitStateFoundCallback(logger, circuitId, null);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, global::System.Exception?> __ExceptionDisposingTokenSourceCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define(global::Microsoft.Extensions.Logging.LogLevel.Error, new global::Microsoft.Extensions.Logging.EventId(205, "ExceptionDisposingTokenSource"), "An exception occurred while disposing the token source.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });

            /// <summary>
            /// <para><b>Message:</b> An exception occurred while disposing the token source.</para>
            /// <para><b>Level:</b> Error</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            public static partial void ExceptionDisposingTokenSource(global::Microsoft.Extensions.Logging.ILogger logger, global::System.Exception exception)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Error))
                {
                    __ExceptionDisposingTokenSourceCallback(logger, exception);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, global::Microsoft.AspNetCore.Components.Server.Circuits.CircuitId, global::System.Exception?> __CircuitPauseStartedCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define<global::Microsoft.AspNetCore.Components.Server.Circuits.CircuitId>(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(206, "CircuitPauseStarted"), "Pausing circuit with ID {CircuitId}", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });

            /// <summary>
            /// <para><b>Message:</b> Pausing circuit with ID {CircuitId}</para>
            /// <para><b>Level:</b> Debug</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            public static partial void CircuitPauseStarted(global::Microsoft.Extensions.Logging.ILogger logger, global::Microsoft.AspNetCore.Components.Server.Circuits.CircuitId circuitId)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
                {
                    __CircuitPauseStartedCallback(logger, circuitId, null);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, global::Microsoft.AspNetCore.Components.Server.Circuits.CircuitId, global::System.Exception?> __ExceptionPersistingCircuitCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define<global::Microsoft.AspNetCore.Components.Server.Circuits.CircuitId>(global::Microsoft.Extensions.Logging.LogLevel.Error, new global::Microsoft.Extensions.Logging.EventId(207, "ExceptionPersistingCircuit"), "An exception occurred while persisting circuit {CircuitId}.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });

            /// <summary>
            /// <para><b>Message:</b> An exception occurred while persisting circuit {CircuitId}.</para>
            /// <para><b>Level:</b> Error</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            public static partial void ExceptionPersistingCircuit(global::Microsoft.Extensions.Logging.ILogger logger, global::Microsoft.AspNetCore.Components.Server.Circuits.CircuitId circuitId, global::System.Exception exception)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Error))
                {
                    __ExceptionPersistingCircuitCallback(logger, circuitId, exception);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, global::Microsoft.AspNetCore.Components.Server.Circuits.CircuitId, global::System.Exception?> __ExceptionRestoringCircuitCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define<global::Microsoft.AspNetCore.Components.Server.Circuits.CircuitId>(global::Microsoft.Extensions.Logging.LogLevel.Error, new global::Microsoft.Extensions.Logging.EventId(208, "ExceptionRestoringCircuit"), "An exception occurred while restoring circuit {CircuitId}.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });

            /// <summary>
            /// <para><b>Message:</b> An exception occurred while restoring circuit {CircuitId}.</para>
            /// <para><b>Level:</b> Error</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            public static partial void ExceptionRestoringCircuit(global::Microsoft.Extensions.Logging.ILogger logger, global::Microsoft.AspNetCore.Components.Server.Circuits.CircuitId circuitId, global::System.Exception exception)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Error))
                {
                    __ExceptionRestoringCircuitCallback(logger, circuitId, exception);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, global::Microsoft.AspNetCore.Components.Server.Circuits.CircuitId, global::System.Exception?> __ExceptionDuringExpirationCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define<global::Microsoft.AspNetCore.Components.Server.Circuits.CircuitId>(global::Microsoft.Extensions.Logging.LogLevel.Error, new global::Microsoft.Extensions.Logging.EventId(209, "ExceptionDuringExpiration"), "An exception occurred during expiration handling for circuit {CircuitId}.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });

            /// <summary>
            /// <para><b>Message:</b> An exception occurred during expiration handling for circuit {CircuitId}.</para>
            /// <para><b>Level:</b> Error</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            public static partial void ExceptionDuringExpiration(global::Microsoft.Extensions.Logging.ILogger logger, global::Microsoft.AspNetCore.Components.Server.Circuits.CircuitId circuitId, global::System.Exception exception)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Error))
                {
                    __ExceptionDuringExpirationCallback(logger, circuitId, exception);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, global::Microsoft.AspNetCore.Components.Server.Circuits.CircuitId, global::System.Exception?> __ExceptionRemovingExpiredCircuitCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define<global::Microsoft.AspNetCore.Components.Server.Circuits.CircuitId>(global::Microsoft.Extensions.Logging.LogLevel.Error, new global::Microsoft.Extensions.Logging.EventId(210, "ExceptionRemovingExpiredCircuit"), "An exception occurred while removing expired circuit {CircuitId}.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });

            /// <summary>
            /// <para><b>Message:</b> An exception occurred while removing expired circuit {CircuitId}.</para>
            /// <para><b>Level:</b> Error</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            public static partial void ExceptionRemovingExpiredCircuit(global::Microsoft.Extensions.Logging.ILogger logger, global::Microsoft.AspNetCore.Components.Server.Circuits.CircuitId circuitId, global::System.Exception exception)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Error))
                {
                    __ExceptionRemovingExpiredCircuitCallback(logger, circuitId, exception);
                }
            }
        }
    }
}
namespace Microsoft.AspNetCore.Components.Server.Circuits
{
    partial class RemoteErrorBoundaryLogger
    {
        partial class Log
        {
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, string, global::System.Exception?> __ExceptionCaughtByErrorBoundaryCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define<string>(global::Microsoft.Extensions.Logging.LogLevel.Warning, new global::Microsoft.Extensions.Logging.EventId(100, "ExceptionCaughtByErrorBoundary"), "Unhandled exception rendering component: {Message}", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });

            /// <summary>
            /// <para><b>Message:</b> Unhandled exception rendering component: {Message}</para>
            /// <para><b>Level:</b> Warning</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            public static partial void ExceptionCaughtByErrorBoundary(global::Microsoft.Extensions.Logging.ILogger logger, string message, global::System.Exception exception)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Warning))
                {
                    __ExceptionCaughtByErrorBoundaryCallback(logger, message, exception);
                }
            }
        }
    }
}
namespace Microsoft.AspNetCore.Components.Server.Circuits
{
    partial class RemoteJSRuntime
    {
        partial class Log
        {
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, long, string, global::System.Exception?> __BeginInvokeJSCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define<long, string>(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(1, "BeginInvokeJS"), "Begin invoke JS interop '{AsyncHandle}': '{FunctionIdentifier}'", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });

            /// <summary>
            /// <para><b>Message:</b> Begin invoke JS interop &apos;{AsyncHandle}&apos;: &apos;{FunctionIdentifier}&apos;</para>
            /// <para><b>Level:</b> Debug</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            internal static partial void BeginInvokeJS(global::Microsoft.Extensions.Logging.ILogger logger, long asyncHandle, string functionIdentifier)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
                {
                    __BeginInvokeJSCallback(logger, asyncHandle, functionIdentifier, null);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, string, string, string?, global::System.Exception?> __InvokeStaticDotNetMethodExceptionCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define<string, string, string?>(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(2, "InvokeStaticDotNetMethodException"), "There was an error invoking the static method '[{AssemblyName}]::{MethodIdentifier}' with callback id '{CallbackId}'.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });

            /// <summary>
            /// <para><b>Message:</b> There was an error invoking the static method &apos;[{AssemblyName}]::{MethodIdentifier}&apos; with callback id &apos;{CallbackId}&apos;.</para>
            /// <para><b>Level:</b> Debug</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            private static partial void InvokeStaticDotNetMethodException(global::Microsoft.Extensions.Logging.ILogger logger, string assemblyName, string methodIdentifier, string? callbackId, global::System.Exception exception)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
                {
                    __InvokeStaticDotNetMethodExceptionCallback(logger, assemblyName, methodIdentifier, callbackId, exception);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, string, long, string?, global::System.Exception?> __InvokeInstanceDotNetMethodExceptionCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define<string, long, string?>(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(4, "InvokeInstanceDotNetMethodException"), "There was an error invoking the instance method '{MethodIdentifier}' on reference '{DotNetObjectReference}' with callback id '{CallbackId}'.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });

            /// <summary>
            /// <para><b>Message:</b> There was an error invoking the instance method &apos;{MethodIdentifier}&apos; on reference &apos;{DotNetObjectReference}&apos; with callback id &apos;{CallbackId}&apos;.</para>
            /// <para><b>Level:</b> Debug</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            private static partial void InvokeInstanceDotNetMethodException(global::Microsoft.Extensions.Logging.ILogger logger, string methodIdentifier, long dotNetObjectReference, string? callbackId, global::System.Exception exception)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
                {
                    __InvokeInstanceDotNetMethodExceptionCallback(logger, methodIdentifier, dotNetObjectReference, callbackId, exception);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, string, string, string?, global::System.Exception?> __InvokeStaticDotNetMethodSuccessCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define<string, string, string?>(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(3, "InvokeStaticDotNetMethodSuccess"), "Invocation of '[{AssemblyName}]::{MethodIdentifier}' with callback id '{CallbackId}' completed successfully.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });

            /// <summary>
            /// <para><b>Message:</b> Invocation of &apos;[{AssemblyName}]::{MethodIdentifier}&apos; with callback id &apos;{CallbackId}&apos; completed successfully.</para>
            /// <para><b>Level:</b> Debug</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            private static partial void InvokeStaticDotNetMethodSuccess(global::Microsoft.Extensions.Logging.ILogger<global::Microsoft.AspNetCore.Components.Server.Circuits.RemoteJSRuntime> logger, string assemblyName, string methodIdentifier, string? callbackId)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
                {
                    __InvokeStaticDotNetMethodSuccessCallback(logger, assemblyName, methodIdentifier, callbackId, null);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, string, long, string?, global::System.Exception?> __InvokeInstanceDotNetMethodSuccessCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define<string, long, string?>(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(5, "InvokeInstanceDotNetMethodSuccess"), "Invocation of '{MethodIdentifier}' on reference '{DotNetObjectReference}' with callback id '{CallbackId}' completed successfully.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });

            /// <summary>
            /// <para><b>Message:</b> Invocation of &apos;{MethodIdentifier}&apos; on reference &apos;{DotNetObjectReference}&apos; with callback id &apos;{CallbackId}&apos; completed successfully.</para>
            /// <para><b>Level:</b> Debug</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            private static partial void InvokeInstanceDotNetMethodSuccess(global::Microsoft.Extensions.Logging.ILogger<global::Microsoft.AspNetCore.Components.Server.Circuits.RemoteJSRuntime> logger, string methodIdentifier, long dotNetObjectReference, string? callbackId)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
                {
                    __InvokeInstanceDotNetMethodSuccessCallback(logger, methodIdentifier, dotNetObjectReference, callbackId, null);
                }
            }
        }
    }
}
namespace Microsoft.AspNetCore.Components.Server.Circuits
{
    partial class RemoteNavigationManager
    {
        partial class Log
        {
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, string, bool, bool, global::System.Exception?> __RequestingNavigationCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define<string, bool, bool>(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(1, "RequestingNavigation"), "Requesting navigation to URI {Uri} with forceLoad={ForceLoad}, replace={Replace}", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });

            /// <summary>
            /// <para><b>Message:</b> Requesting navigation to URI {Uri} with forceLoad={ForceLoad}, replace={Replace}</para>
            /// <para><b>Level:</b> Debug</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            private static partial void RequestingNavigation(global::Microsoft.Extensions.Logging.ILogger logger, string uri, bool forceLoad, bool replace)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
                {
                    __RequestingNavigationCallback(logger, uri, forceLoad, replace, null);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, string, bool, global::System.Exception?> __ReceivedLocationChangedNotificationCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define<string, bool>(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(2, "ReceivedLocationChangedNotification"), "Received notification that the URI has changed to {Uri} with isIntercepted={IsIntercepted}", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });

            /// <summary>
            /// <para><b>Message:</b> Received notification that the URI has changed to {Uri} with isIntercepted={IsIntercepted}</para>
            /// <para><b>Level:</b> Debug</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            public static partial void ReceivedLocationChangedNotification(global::Microsoft.Extensions.Logging.ILogger logger, string uri, bool isIntercepted)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
                {
                    __ReceivedLocationChangedNotificationCallback(logger, uri, isIntercepted, null);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, string, global::System.Exception?> __NavigationCanceledCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define<string>(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(3, "NavigationCanceled"), "Navigation canceled when changing the location to {Uri}", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });

            /// <summary>
            /// <para><b>Message:</b> Navigation canceled when changing the location to {Uri}</para>
            /// <para><b>Level:</b> Debug</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            public static partial void NavigationCanceled(global::Microsoft.Extensions.Logging.ILogger logger, string uri)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
                {
                    __NavigationCanceledCallback(logger, uri, null);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, string, global::System.Exception?> __NavigationFailedCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define<string>(global::Microsoft.Extensions.Logging.LogLevel.Error, new global::Microsoft.Extensions.Logging.EventId(4, "NavigationFailed"), "Navigation failed when changing the location to {Uri}", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });

            /// <summary>
            /// <para><b>Message:</b> Navigation failed when changing the location to {Uri}</para>
            /// <para><b>Level:</b> Error</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            public static partial void NavigationFailed(global::Microsoft.Extensions.Logging.ILogger logger, string uri, global::System.Exception exception)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Error))
                {
                    __NavigationFailedCallback(logger, uri, exception);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, global::System.Exception?> __RefreshFailedCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define(global::Microsoft.Extensions.Logging.LogLevel.Error, new global::Microsoft.Extensions.Logging.EventId(5, "RefreshFailed"), "Failed to refresh", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });

            /// <summary>
            /// <para><b>Message:</b> Failed to refresh</para>
            /// <para><b>Level:</b> Error</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            public static partial void RefreshFailed(global::Microsoft.Extensions.Logging.ILogger logger, global::System.Exception exception)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Error))
                {
                    __RefreshFailedCallback(logger, exception);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, global::System.Exception?> __RequestingNotFoundCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(1, "RequestingNotFound"), "Requesting not found", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });

            /// <summary>
            /// <para><b>Message:</b> Requesting not found</para>
            /// <para><b>Level:</b> Debug</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            public static partial void RequestingNotFound(global::Microsoft.Extensions.Logging.ILogger logger)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
                {
                    __RequestingNotFoundCallback(logger, null);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, string, global::System.Exception?> __NavigationCompletedCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define<string>(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(6, "NavigationCompleted"), "Navigation completed when changing the location to {Uri}", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });

            /// <summary>
            /// <para><b>Message:</b> Navigation completed when changing the location to {Uri}</para>
            /// <para><b>Level:</b> Debug</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            public static partial void NavigationCompleted(global::Microsoft.Extensions.Logging.ILogger logger, string uri)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
                {
                    __NavigationCompletedCallback(logger, uri, null);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, string, global::System.Exception?> __NavigationStoppedSessionEndedCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define<string>(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(7, "NavigationStoppedSessionEnded"), "Navigation stopped because the session ended when navigating to {Uri}", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });

            /// <summary>
            /// <para><b>Message:</b> Navigation stopped because the session ended when navigating to {Uri}</para>
            /// <para><b>Level:</b> Debug</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            public static partial void NavigationStoppedSessionEnded(global::Microsoft.Extensions.Logging.ILogger logger, string uri)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
                {
                    __NavigationStoppedSessionEndedCallback(logger, uri, null);
                }
            }
        }
    }
}
namespace Microsoft.AspNetCore.Components.Server.Circuits
{
    partial class RemoteRenderer
    {
        partial class Log
        {
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, string, global::System.Exception?> __UnhandledExceptionRenderingComponentCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define<string>(global::Microsoft.Extensions.Logging.LogLevel.Warning, new global::Microsoft.Extensions.Logging.EventId(100, "ExceptionRenderingComponent"), "Unhandled exception rendering component: {Message}", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });

            /// <summary>
            /// <para><b>Message:</b> Unhandled exception rendering component: {Message}</para>
            /// <para><b>Level:</b> Warning</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            private static partial void UnhandledExceptionRenderingComponent(global::Microsoft.Extensions.Logging.ILogger logger, string message, global::System.Exception exception)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Warning))
                {
                    __UnhandledExceptionRenderingComponentCallback(logger, message, exception);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, long, int, string, global::System.Exception?> __BeginUpdateDisplayAsyncCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define<long, int, string>(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(101, "BeginUpdateDisplayAsync"), "Sending render batch {BatchId} of size {DataLength} bytes to client {ConnectionId}.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });

            /// <summary>
            /// <para><b>Message:</b> Sending render batch {BatchId} of size {DataLength} bytes to client {ConnectionId}.</para>
            /// <para><b>Level:</b> Debug</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            public static partial void BeginUpdateDisplayAsync(global::Microsoft.Extensions.Logging.ILogger logger, long batchId, int dataLength, string connectionId)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
                {
                    __BeginUpdateDisplayAsyncCallback(logger, batchId, dataLength, connectionId, null);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, string, global::System.Exception?> __BufferingRenderDisconnectedClientCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define<string>(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(102, "SkipUpdateDisplayAsync"), "Buffering remote render because the client on connection {ConnectionId} is disconnected.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });

            /// <summary>
            /// <para><b>Message:</b> Buffering remote render because the client on connection {ConnectionId} is disconnected.</para>
            /// <para><b>Level:</b> Debug</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            public static partial void BufferingRenderDisconnectedClient(global::Microsoft.Extensions.Logging.ILogger logger, string connectionId)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
                {
                    __BufferingRenderDisconnectedClientCallback(logger, connectionId, null);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, string, global::System.Exception?> __SendBatchDataFailedCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define<string>(global::Microsoft.Extensions.Logging.LogLevel.Information, new global::Microsoft.Extensions.Logging.EventId(103, "SendBatchDataFailed"), "Sending data for batch failed: {Message}", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });

            /// <summary>
            /// <para><b>Message:</b> Sending data for batch failed: {Message}</para>
            /// <para><b>Level:</b> Information</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            private static partial void SendBatchDataFailed(global::Microsoft.Extensions.Logging.ILogger logger, string message, global::System.Exception exception)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Information))
                {
                    __SendBatchDataFailedCallback(logger, message, exception);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, long, string, double, global::System.Exception?> __CompletingBatchWithErrorCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define<long, string, double>(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(104, "CompletingBatchWithError"), "Completing batch {BatchId} with error: {ErrorMessage} in {ElapsedMilliseconds}ms.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });

            /// <summary>
            /// <para><b>Message:</b> Completing batch {BatchId} with error: {ErrorMessage} in {ElapsedMilliseconds}ms.</para>
            /// <para><b>Level:</b> Debug</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            private static partial void CompletingBatchWithError(global::Microsoft.Extensions.Logging.ILogger logger, long batchId, string errorMessage, double elapsedMilliseconds)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
                {
                    __CompletingBatchWithErrorCallback(logger, batchId, errorMessage, elapsedMilliseconds, null);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, long, double, global::System.Exception?> __CompletingBatchWithoutErrorCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define<long, double>(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(105, "CompletingBatchWithoutError"), "Completing batch {BatchId} without error in {ElapsedMilliseconds}ms.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });

            /// <summary>
            /// <para><b>Message:</b> Completing batch {BatchId} without error in {ElapsedMilliseconds}ms.</para>
            /// <para><b>Level:</b> Debug</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            private static partial void CompletingBatchWithoutError(global::Microsoft.Extensions.Logging.ILogger logger, long batchId, double elapsedMilliseconds)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
                {
                    __CompletingBatchWithoutErrorCallback(logger, batchId, elapsedMilliseconds, null);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, long, global::System.Exception?> __ReceivedDuplicateBatchAckCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define<long>(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(106, "ReceivedDuplicateBatchAcknowledgement"), "Received a duplicate ACK for batch id '{IncomingBatchId}'.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });

            /// <summary>
            /// <para><b>Message:</b> Received a duplicate ACK for batch id &apos;{IncomingBatchId}&apos;.</para>
            /// <para><b>Level:</b> Debug</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            public static partial void ReceivedDuplicateBatchAck(global::Microsoft.Extensions.Logging.ILogger logger, long incomingBatchId)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
                {
                    __ReceivedDuplicateBatchAckCallback(logger, incomingBatchId, null);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, global::System.Exception?> __FullUnacknowledgedRenderBatchesQueueCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(107, "FullUnacknowledgedRenderBatchesQueue"), "The queue of unacknowledged render batches is full.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });

            /// <summary>
            /// <para><b>Message:</b> The queue of unacknowledged render batches is full.</para>
            /// <para><b>Level:</b> Debug</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            public static partial void FullUnacknowledgedRenderBatchesQueue(global::Microsoft.Extensions.Logging.ILogger logger)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
                {
                    __FullUnacknowledgedRenderBatchesQueueCallback(logger, null);
                }
            }
        }
    }
}
namespace Microsoft.AspNetCore.Components.Server
{
    partial class ComponentHub
    {
        partial class Log
        {
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, long, global::System.Exception?> __ReceivedConfirmationForBatchCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define<long>(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(1, "ReceivedConfirmationForBatch"), "Received confirmation for batch {BatchId}", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });

            /// <summary>
            /// <para><b>Message:</b> Received confirmation for batch {BatchId}</para>
            /// <para><b>Level:</b> Debug</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            public static partial void ReceivedConfirmationForBatch(global::Microsoft.Extensions.Logging.ILogger logger, long batchId)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
                {
                    __ReceivedConfirmationForBatchCallback(logger, batchId, null);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, global::Microsoft.AspNetCore.Components.Server.Circuits.CircuitId, global::System.Exception?> __CircuitAlreadyInitializedCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define<global::Microsoft.AspNetCore.Components.Server.Circuits.CircuitId>(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(2, "CircuitAlreadyInitialized"), "The circuit host '{CircuitId}' has already been initialized", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });

            /// <summary>
            /// <para><b>Message:</b> The circuit host &apos;{CircuitId}&apos; has already been initialized</para>
            /// <para><b>Level:</b> Debug</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            public static partial void CircuitAlreadyInitialized(global::Microsoft.Extensions.Logging.ILogger logger, global::Microsoft.AspNetCore.Components.Server.Circuits.CircuitId circuitId)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
                {
                    __CircuitAlreadyInitializedCallback(logger, circuitId, null);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, string, global::System.Exception?> __CircuitHostNotInitializedCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define<string>(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(3, "CircuitHostNotInitialized"), "Call to '{CallSite}' received before the circuit host initialization", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });

            /// <summary>
            /// <para><b>Message:</b> Call to &apos;{CallSite}&apos; received before the circuit host initialization</para>
            /// <para><b>Level:</b> Debug</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            public static partial void CircuitHostNotInitialized(global::Microsoft.Extensions.Logging.ILogger logger, string callSite)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
                {
                    __CircuitHostNotInitializedCallback(logger, callSite, null);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, string, global::System.Exception?> __CircuitHostShutdownCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define<string>(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(4, "CircuitHostShutdown"), "Call to '{CallSite}' received after the circuit was shut down", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });

            /// <summary>
            /// <para><b>Message:</b> Call to &apos;{CallSite}&apos; received after the circuit was shut down</para>
            /// <para><b>Level:</b> Debug</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            public static partial void CircuitHostShutdown(global::Microsoft.Extensions.Logging.ILogger logger, string callSite)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
                {
                    __CircuitHostShutdownCallback(logger, callSite, null);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, string, global::System.Exception?> __InvalidInputDataCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define<string>(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(5, "InvalidInputData"), "Call to '{CallSite}' received invalid input data", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });

            /// <summary>
            /// <para><b>Message:</b> Call to &apos;{CallSite}&apos; received invalid input data</para>
            /// <para><b>Level:</b> Debug</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            public static partial void InvalidInputData(global::Microsoft.Extensions.Logging.ILogger logger, string callSite)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
                {
                    __InvalidInputDataCallback(logger, callSite, null);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, global::System.Exception?> __CircuitInitializationFailedCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(6, "CircuitInitializationFailed"), "Circuit initialization failed", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });

            /// <summary>
            /// <para><b>Message:</b> Circuit initialization failed</para>
            /// <para><b>Level:</b> Debug</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            public static partial void CircuitInitializationFailed(global::Microsoft.Extensions.Logging.ILogger logger, global::System.Exception exception)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
                {
                    __CircuitInitializationFailedCallback(logger, exception);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, global::Microsoft.AspNetCore.Components.Server.Circuits.CircuitId, string, string, global::System.Exception?> __CreatedCircuitCoreCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define<global::Microsoft.AspNetCore.Components.Server.Circuits.CircuitId, string, string>(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(7, "CreatedCircuit"), "Created circuit '{CircuitId}' with secret '{CircuitIdSecret}' for '{ConnectionId}'", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });

            /// <summary>
            /// <para><b>Message:</b> Created circuit &apos;{CircuitId}&apos; with secret &apos;{CircuitIdSecret}&apos; for &apos;{ConnectionId}&apos;</para>
            /// <para><b>Level:</b> Debug</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            private static partial void CreatedCircuitCore(global::Microsoft.Extensions.Logging.ILogger logger, global::Microsoft.AspNetCore.Components.Server.Circuits.CircuitId circuitId, string circuitIdSecret, string connectionId)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
                {
                    __CreatedCircuitCoreCallback(logger, circuitId, circuitIdSecret, connectionId, null);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, string, global::System.Exception?> __InvalidCircuitIdCoreCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define<string>(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(8, "InvalidCircuitId"), "ConnectAsync received an invalid circuit id '{CircuitIdSecret}'", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });

            /// <summary>
            /// <para><b>Message:</b> ConnectAsync received an invalid circuit id &apos;{CircuitIdSecret}&apos;</para>
            /// <para><b>Level:</b> Debug</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            private static partial void InvalidCircuitIdCore(global::Microsoft.Extensions.Logging.ILogger logger, string circuitIdSecret)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
                {
                    __InvalidCircuitIdCoreCallback(logger, circuitIdSecret, null);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, string, global::System.Exception?> __ResumeInvalidCircuitIdCoreCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define<string>(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(9, "ResumeInvalidCircuitId"), "ResumeCircuit received an invalid circuit id '{CircuitIdSecret}'", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });

            /// <summary>
            /// <para><b>Message:</b> ResumeCircuit received an invalid circuit id &apos;{CircuitIdSecret}&apos;</para>
            /// <para><b>Level:</b> Debug</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            private static partial void ResumeInvalidCircuitIdCore(global::Microsoft.Extensions.Logging.ILogger logger, string circuitIdSecret)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
                {
                    __ResumeInvalidCircuitIdCoreCallback(logger, circuitIdSecret, null);
                }
            }
        }
    }
}
namespace Microsoft.AspNetCore.Components.Server
{
    partial class ComponentParameterDeserializer
    {
        partial class Log
        {
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, global::System.Exception?> __ParameterValuesInvalidFormatCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(1, "ParameterValuesInvalidFormat"), "Parameter values must be an array.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });

            /// <summary>
            /// <para><b>Message:</b> Parameter values must be an array.</para>
            /// <para><b>Level:</b> Debug</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            internal static partial void ParameterValuesInvalidFormat(global::Microsoft.Extensions.Logging.ILogger<global::Microsoft.AspNetCore.Components.Server.ComponentParameterDeserializer> logger)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
                {
                    __ParameterValuesInvalidFormatCallback(logger, null);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, string, string, string, global::System.Exception?> __IncompleteParameterDefinitionCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define<string, string, string>(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(2, "IncompleteParameterDefinition"), "The parameter definition for '{ParameterName}' is incomplete: Type='{TypeName}' Assembly='{Assembly}'.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });

            /// <summary>
            /// <para><b>Message:</b> The parameter definition for &apos;{ParameterName}&apos; is incomplete: Type=&apos;{TypeName}&apos; Assembly=&apos;{Assembly}&apos;.</para>
            /// <para><b>Level:</b> Debug</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            internal static partial void IncompleteParameterDefinition(global::Microsoft.Extensions.Logging.ILogger<global::Microsoft.AspNetCore.Components.Server.ComponentParameterDeserializer> logger, string parameterName, string typeName, string assembly)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
                {
                    __IncompleteParameterDefinitionCallback(logger, parameterName, typeName, assembly, null);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, string, string, string, global::System.Exception?> __InvalidParameterTypeCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define<string, string, string>(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(3, "InvalidParameterType"), "The parameter '{ParameterName} with type '{TypeName}' in assembly '{Assembly}' could not be found.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });

            /// <summary>
            /// <para><b>Message:</b> The parameter &apos;{ParameterName} with type &apos;{TypeName}&apos; in assembly &apos;{Assembly}&apos; could not be found.</para>
            /// <para><b>Level:</b> Debug</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            internal static partial void InvalidParameterType(global::Microsoft.Extensions.Logging.ILogger<global::Microsoft.AspNetCore.Components.Server.ComponentParameterDeserializer> logger, string parameterName, string typeName, string assembly)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
                {
                    __InvalidParameterTypeCallback(logger, parameterName, typeName, assembly, null);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, string, string, string, global::System.Exception?> __InvalidParameterValueCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define<string, string, string>(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(4, "InvalidParameterValue"), "Could not parse the parameter value for parameter '{Name}' of type '{TypeName}' and assembly '{Assembly}'.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });

            /// <summary>
            /// <para><b>Message:</b> Could not parse the parameter value for parameter &apos;{Name}&apos; of type &apos;{TypeName}&apos; and assembly &apos;{Assembly}&apos;.</para>
            /// <para><b>Level:</b> Debug</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            internal static partial void InvalidParameterValue(global::Microsoft.Extensions.Logging.ILogger<global::Microsoft.AspNetCore.Components.Server.ComponentParameterDeserializer> logger, string name, string typeName, string assembly, global::System.Exception e)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
                {
                    __InvalidParameterValueCallback(logger, name, typeName, assembly, e);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, global::System.Exception?> __FailedToParseParameterDefinitionsCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(5, "FailedToParseParameterDefinitions"), "Failed to parse the parameter definitions.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });

            /// <summary>
            /// <para><b>Message:</b> Failed to parse the parameter definitions.</para>
            /// <para><b>Level:</b> Debug</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            internal static partial void FailedToParseParameterDefinitions(global::Microsoft.Extensions.Logging.ILogger<global::Microsoft.AspNetCore.Components.Server.ComponentParameterDeserializer> logger, global::System.Exception e)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
                {
                    __FailedToParseParameterDefinitionsCallback(logger, e);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, global::System.Exception?> __FailedToParseParameterValuesCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(6, "FailedToParseParameterValues"), "Failed to parse the parameter values.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });

            /// <summary>
            /// <para><b>Message:</b> Failed to parse the parameter values.</para>
            /// <para><b>Level:</b> Debug</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            internal static partial void FailedToParseParameterValues(global::Microsoft.Extensions.Logging.ILogger<global::Microsoft.AspNetCore.Components.Server.ComponentParameterDeserializer> logger, global::System.Exception e)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
                {
                    __FailedToParseParameterValuesCallback(logger, e);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, int, int, global::System.Exception?> __MismatchedParameterAndDefinitionsCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define<int, int>(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(7, "MismatchedParameterAndDefinitions"), "The number of parameter definitions '{DescriptorsLength}' does not match the number parameter values '{ValuesLength}'.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });

            /// <summary>
            /// <para><b>Message:</b> The number of parameter definitions &apos;{DescriptorsLength}&apos; does not match the number parameter values &apos;{ValuesLength}&apos;.</para>
            /// <para><b>Level:</b> Debug</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            internal static partial void MismatchedParameterAndDefinitions(global::Microsoft.Extensions.Logging.ILogger<global::Microsoft.AspNetCore.Components.Server.ComponentParameterDeserializer> logger, int descriptorsLength, int valuesLength)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
                {
                    __MismatchedParameterAndDefinitionsCallback(logger, descriptorsLength, valuesLength, null);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, global::System.Exception?> __MissingParameterDefinitionNameCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(8, "MissingParameterDefinitionName"), "The name is missing in a parameter definition.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });

            /// <summary>
            /// <para><b>Message:</b> The name is missing in a parameter definition.</para>
            /// <para><b>Level:</b> Debug</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            internal static partial void MissingParameterDefinitionName(global::Microsoft.Extensions.Logging.ILogger<global::Microsoft.AspNetCore.Components.Server.ComponentParameterDeserializer> logger)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
                {
                    __MissingParameterDefinitionNameCallback(logger, null);
                }
            }
        }
    }
}
namespace Microsoft.AspNetCore.Components.Server
{
    partial class ServerComponentDeserializer
    {
        partial class Log
        {
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, global::System.Exception?> __FailedToDeserializeDescriptorCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(1, "FailedToDeserializeDescriptor"), "Failed to deserialize the component descriptor.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });

            /// <summary>
            /// <para><b>Message:</b> Failed to deserialize the component descriptor.</para>
            /// <para><b>Level:</b> Debug</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            public static partial void FailedToDeserializeDescriptor(global::Microsoft.Extensions.Logging.ILogger<global::Microsoft.AspNetCore.Components.Server.ServerComponentDeserializer> logger, global::System.Exception e)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
                {
                    __FailedToDeserializeDescriptorCallback(logger, e);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, string, string, global::System.Exception?> __FailedToFindComponentCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define<string, string>(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(2, "FailedToFindComponent"), "Failed to find component '{ComponentName}' in assembly '{Assembly}'.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });

            /// <summary>
            /// <para><b>Message:</b> Failed to find component &apos;{ComponentName}&apos; in assembly &apos;{Assembly}&apos;.</para>
            /// <para><b>Level:</b> Debug</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            public static partial void FailedToFindComponent(global::Microsoft.Extensions.Logging.ILogger<global::Microsoft.AspNetCore.Components.Server.ServerComponentDeserializer> logger, string componentName, string assembly)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
                {
                    __FailedToFindComponentCallback(logger, componentName, assembly, null);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, global::System.Exception?> __FailedToUnprotectDescriptorCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(3, "FailedToUnprotectDescriptor"), "Failed to unprotect the component descriptor.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });

            /// <summary>
            /// <para><b>Message:</b> Failed to unprotect the component descriptor.</para>
            /// <para><b>Level:</b> Debug</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            public static partial void FailedToUnprotectDescriptor(global::Microsoft.Extensions.Logging.ILogger<global::Microsoft.AspNetCore.Components.Server.ServerComponentDeserializer> logger, global::System.Exception e)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
                {
                    __FailedToUnprotectDescriptorCallback(logger, e);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, string, global::System.Exception?> __InvalidMarkerTypeCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define<string>(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(4, "InvalidMarkerType"), "Invalid component marker type '{MarkerType}'.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });

            /// <summary>
            /// <para><b>Message:</b> Invalid component marker type &apos;{MarkerType}&apos;.</para>
            /// <para><b>Level:</b> Debug</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            public static partial void InvalidMarkerType(global::Microsoft.Extensions.Logging.ILogger<global::Microsoft.AspNetCore.Components.Server.ServerComponentDeserializer> logger, string markerType)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
                {
                    __InvalidMarkerTypeCallback(logger, markerType, null);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, global::System.Exception?> __MissingMarkerDescriptorCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(5, "MissingMarkerDescriptor"), "The component marker is missing the descriptor.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });

            /// <summary>
            /// <para><b>Message:</b> The component marker is missing the descriptor.</para>
            /// <para><b>Level:</b> Debug</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            public static partial void MissingMarkerDescriptor(global::Microsoft.Extensions.Logging.ILogger<global::Microsoft.AspNetCore.Components.Server.ServerComponentDeserializer> logger)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
                {
                    __MissingMarkerDescriptorCallback(logger, null);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, string, string, global::System.Exception?> __MismatchedInvocationIdCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define<string, string>(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(6, "MismatchedInvocationId"), "The descriptor invocationId is '{invocationId}' and got a descriptor with invocationId '{currentInvocationId}'.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });

            /// <summary>
            /// <para><b>Message:</b> The descriptor invocationId is &apos;{invocationId}&apos; and got a descriptor with invocationId &apos;{currentInvocationId}&apos;.</para>
            /// <para><b>Level:</b> Debug</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            public static partial void MismatchedInvocationId(global::Microsoft.Extensions.Logging.ILogger<global::Microsoft.AspNetCore.Components.Server.ServerComponentDeserializer> logger, string invocationId, string currentInvocationId)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
                {
                    __MismatchedInvocationIdCallback(logger, invocationId, currentInvocationId, null);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, int, int, global::System.Exception?> __OutOfSequenceDescriptorCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define<int, int>(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(7, "OutOfSequenceDescriptor"), "The last descriptor sequence was '{lastSequence}' and got a descriptor with sequence '{sequence}'.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });

            /// <summary>
            /// <para><b>Message:</b> The last descriptor sequence was &apos;{lastSequence}&apos; and got a descriptor with sequence &apos;{sequence}&apos;.</para>
            /// <para><b>Level:</b> Debug</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            public static partial void OutOfSequenceDescriptor(global::Microsoft.Extensions.Logging.ILogger<global::Microsoft.AspNetCore.Components.Server.ServerComponentDeserializer> logger, int lastSequence, int sequence)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
                {
                    __OutOfSequenceDescriptorCallback(logger, lastSequence, sequence, null);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, int, global::System.Exception?> __DescriptorSequenceMustStartAtZeroCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define<int>(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(8, "DescriptorSequenceMustStartAtZero"), "The descriptor sequence '{sequence}' is an invalid start sequence.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });

            /// <summary>
            /// <para><b>Message:</b> The descriptor sequence &apos;{sequence}&apos; is an invalid start sequence.</para>
            /// <para><b>Level:</b> Debug</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            public static partial void DescriptorSequenceMustStartAtZero(global::Microsoft.Extensions.Logging.ILogger<global::Microsoft.AspNetCore.Components.Server.ServerComponentDeserializer> logger, int sequence)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
                {
                    __DescriptorSequenceMustStartAtZeroCallback(logger, sequence, null);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, string, global::System.Exception?> __ExpiredInvocationIdCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define<string>(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(9, "ExpiredInvocationId"), "The descriptor invocationId '{invocationId}' has expired.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });

            /// <summary>
            /// <para><b>Message:</b> The descriptor invocationId &apos;{invocationId}&apos; has expired.</para>
            /// <para><b>Level:</b> Debug</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            public static partial void ExpiredInvocationId(global::Microsoft.Extensions.Logging.ILogger<global::Microsoft.AspNetCore.Components.Server.ServerComponentDeserializer> logger, string invocationId)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
                {
                    __ExpiredInvocationIdCallback(logger, invocationId, null);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, int, string, global::System.Exception?> __ReusedDescriptorSequenceCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define<int, string>(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(10, "ReusedDescriptorSequence"), "The descriptor with sequence '{sequence}' was already used for the current invocationId '{invocationId}'.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });

            /// <summary>
            /// <para><b>Message:</b> The descriptor with sequence &apos;{sequence}&apos; was already used for the current invocationId &apos;{invocationId}&apos;.</para>
            /// <para><b>Level:</b> Debug</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            public static partial void ReusedDescriptorSequence(global::Microsoft.Extensions.Logging.ILogger<global::Microsoft.AspNetCore.Components.Server.ServerComponentDeserializer> logger, int sequence, string invocationId)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
                {
                    __ReusedDescriptorSequenceCallback(logger, sequence, invocationId, null);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, global::Microsoft.AspNetCore.Components.RootComponentOperationType, string, global::System.Exception?> __InvalidRootComponentOperationCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define<global::Microsoft.AspNetCore.Components.RootComponentOperationType, string>(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(11, "InvalidRootComponentOperation"), "The root component operation of type '{OperationType}' was invalid: {Message}", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });

            /// <summary>
            /// <para><b>Message:</b> The root component operation of type &apos;{OperationType}&apos; was invalid: {Message}</para>
            /// <para><b>Level:</b> Debug</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            public static partial void InvalidRootComponentOperation(global::Microsoft.Extensions.Logging.ILogger logger, global::Microsoft.AspNetCore.Components.RootComponentOperationType operationType, string message)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
                {
                    __InvalidRootComponentOperationCallback(logger, operationType, message, null);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, global::System.Exception?> __FailedToProcessRootComponentOperationsCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(12, "FailedToProcessRootComponentOperations"), "Failed to parse root component operations", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });

            /// <summary>
            /// <para><b>Message:</b> Failed to parse root component operations</para>
            /// <para><b>Level:</b> Debug</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            public static partial void FailedToProcessRootComponentOperations(global::Microsoft.Extensions.Logging.ILogger logger, global::System.Exception exception)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
                {
                    __FailedToProcessRootComponentOperationsCallback(logger, exception);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, global::System.Exception?> __InvalidRootComponentKeyCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(13, "InvalidRootComponentKey"), "The provided root component key was not valid.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });

            /// <summary>
            /// <para><b>Message:</b> The provided root component key was not valid.</para>
            /// <para><b>Level:</b> Debug</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "11.0.14.26904")]
            public static partial void InvalidRootComponentKey(global::Microsoft.Extensions.Logging.ILogger logger)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
                {
                    __InvalidRootComponentKeyCallback(logger, null);
                }
            }
        }
    }
}