// <auto-generated/>
#nullable enable
 
namespace Microsoft.AspNetCore.SignalR.Client
{
    partial class HubConnection
    {
        partial class Log
        {
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, string, int, global::System.Exception?> __PreparingNonBlockingInvocationCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define<string, int>(global::Microsoft.Extensions.Logging.LogLevel.Trace, new global::Microsoft.Extensions.Logging.EventId(1, "PreparingNonBlockingInvocation"), "Preparing non-blocking invocation of '{Target}', with {ArgumentCount} argument(s).", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
            /// <summary>
            /// <para><b>Message:</b> Preparing non-blocking invocation of &apos;{Target}&apos;, with {ArgumentCount} argument(s).</para>
            /// <para><b>Level:</b> Trace</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            public static partial void PreparingNonBlockingInvocation(global::Microsoft.Extensions.Logging.ILogger logger, string target, int argumentCount)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Trace))
                {
                    __PreparingNonBlockingInvocationCallback(logger, target, argumentCount, null);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, string, string, string, int, global::System.Exception?> __PreparingBlockingInvocationCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define<string, string, string, int>(global::Microsoft.Extensions.Logging.LogLevel.Trace, new global::Microsoft.Extensions.Logging.EventId(2, "PreparingBlockingInvocation"), "Preparing blocking invocation '{InvocationId}' of '{Target}', with return type '{ReturnType}' and {ArgumentCount} argument(s).", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
            /// <summary>
            /// <para><b>Message:</b> Preparing blocking invocation &apos;{InvocationId}&apos; of &apos;{Target}&apos;, with return type &apos;{ReturnType}&apos; and {ArgumentCount} argument(s).</para>
            /// <para><b>Level:</b> Trace</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            public static partial void PreparingBlockingInvocation(global::Microsoft.Extensions.Logging.ILogger logger, string invocationId, string target, string returnType, int argumentCount)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Trace))
                {
                    __PreparingBlockingInvocationCallback(logger, invocationId, target, returnType, argumentCount, null);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, string, global::System.Exception?> __RegisteringInvocationCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define<string>(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(3, "RegisteringInvocation"), "Registering Invocation ID '{InvocationId}' for tracking.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
            /// <summary>
            /// <para><b>Message:</b> Registering Invocation ID &apos;{InvocationId}&apos; for tracking.</para>
            /// <para><b>Level:</b> Debug</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            public static partial void RegisteringInvocation(global::Microsoft.Extensions.Logging.ILogger logger, string invocationId)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
                {
                    __RegisteringInvocationCallback(logger, invocationId, null);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, string, string, string, string, global::System.Exception?> __IssuingInvocationCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define<string, string, string, string>(global::Microsoft.Extensions.Logging.LogLevel.Trace, new global::Microsoft.Extensions.Logging.EventId(4, "IssuingInvocation"), "Issuing Invocation '{InvocationId}': {ReturnType} {MethodName}({Args}).", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
            /// <summary>
            /// <para><b>Message:</b> Issuing Invocation &apos;{InvocationId}&apos;: {ReturnType} {MethodName}({Args}).</para>
            /// <para><b>Level:</b> Trace</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            private static partial void IssuingInvocation(global::Microsoft.Extensions.Logging.ILogger logger, string invocationId, string returnType, string methodName, string args)
            {
                __IssuingInvocationCallback(logger, invocationId, returnType, methodName, args, null);
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, string, string?, global::System.Exception?> __SendingMessageCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define<string, string?>(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(5, "SendingMessage"), "Sending {MessageType} message '{InvocationId}'.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
            /// <summary>
            /// <para><b>Message:</b> Sending {MessageType} message &apos;{InvocationId}&apos;.</para>
            /// <para><b>Level:</b> Debug</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            private static partial void SendingMessage(global::Microsoft.Extensions.Logging.ILogger logger, string messageType, string? invocationId)
            {
                __SendingMessageCallback(logger, messageType, invocationId, null);
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, string, global::System.Exception?> __SendingMessageGenericCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define<string>(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(59, "SendingMessageGeneric"), "Sending {MessageType} message.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
            /// <summary>
            /// <para><b>Message:</b> Sending {MessageType} message.</para>
            /// <para><b>Level:</b> Debug</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            private static partial void SendingMessageGeneric(global::Microsoft.Extensions.Logging.ILogger logger, string messageType)
            {
                __SendingMessageGenericCallback(logger, messageType, null);
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, string, string?, global::System.Exception?> __MessageSentCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define<string, string?>(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(6, "MessageSent"), "Sending {MessageType} message '{InvocationId}' completed.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
            /// <summary>
            /// <para><b>Message:</b> Sending {MessageType} message &apos;{InvocationId}&apos; completed.</para>
            /// <para><b>Level:</b> Debug</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            private static partial void MessageSent(global::Microsoft.Extensions.Logging.ILogger logger, string messageType, string? invocationId)
            {
                __MessageSentCallback(logger, messageType, invocationId, null);
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, string, global::System.Exception?> __MessageSentGenericCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define<string>(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(60, "MessageSentGeneric"), "Sending {MessageType} message completed.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
            /// <summary>
            /// <para><b>Message:</b> Sending {MessageType} message completed.</para>
            /// <para><b>Level:</b> Debug</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            private static partial void MessageSentGeneric(global::Microsoft.Extensions.Logging.ILogger logger, string messageType)
            {
                __MessageSentGenericCallback(logger, messageType, null);
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, string, global::System.Exception?> __FailedToSendInvocationCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define<string>(global::Microsoft.Extensions.Logging.LogLevel.Error, new global::Microsoft.Extensions.Logging.EventId(7, "FailedToSendInvocation"), "Sending Invocation '{InvocationId}' failed.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
            /// <summary>
            /// <para><b>Message:</b> Sending Invocation &apos;{InvocationId}&apos; failed.</para>
            /// <para><b>Level:</b> Error</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            public static partial void FailedToSendInvocation(global::Microsoft.Extensions.Logging.ILogger logger, string invocationId, global::System.Exception exception)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Error))
                {
                    __FailedToSendInvocationCallback(logger, invocationId, exception);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, string?, string, string, global::System.Exception?> __ReceivedInvocationCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define<string?, string, string>(global::Microsoft.Extensions.Logging.LogLevel.Trace, new global::Microsoft.Extensions.Logging.EventId(8, "ReceivedInvocation"), "Received Invocation '{InvocationId}': {MethodName}({Args}).", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
            /// <summary>
            /// <para><b>Message:</b> Received Invocation &apos;{InvocationId}&apos;: {MethodName}({Args}).</para>
            /// <para><b>Level:</b> Trace</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            private static partial void ReceivedInvocation(global::Microsoft.Extensions.Logging.ILogger logger, string? invocationId, string methodName, string args)
            {
                __ReceivedInvocationCallback(logger, invocationId, methodName, args, null);
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, string, global::System.Exception?> __DroppedCompletionMessageCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define<string>(global::Microsoft.Extensions.Logging.LogLevel.Warning, new global::Microsoft.Extensions.Logging.EventId(9, "DroppedCompletionMessage"), "Dropped unsolicited Completion message for invocation '{InvocationId}'.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
            /// <summary>
            /// <para><b>Message:</b> Dropped unsolicited Completion message for invocation &apos;{InvocationId}&apos;.</para>
            /// <para><b>Level:</b> Warning</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            public static partial void DroppedCompletionMessage(global::Microsoft.Extensions.Logging.ILogger logger, string invocationId)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Warning))
                {
                    __DroppedCompletionMessageCallback(logger, invocationId, null);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, string, global::System.Exception?> __DroppedStreamMessageCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define<string>(global::Microsoft.Extensions.Logging.LogLevel.Warning, new global::Microsoft.Extensions.Logging.EventId(10, "DroppedStreamMessage"), "Dropped unsolicited StreamItem message for invocation '{InvocationId}'.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
            /// <summary>
            /// <para><b>Message:</b> Dropped unsolicited StreamItem message for invocation &apos;{InvocationId}&apos;.</para>
            /// <para><b>Level:</b> Warning</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            public static partial void DroppedStreamMessage(global::Microsoft.Extensions.Logging.ILogger logger, string invocationId)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Warning))
                {
                    __DroppedStreamMessageCallback(logger, invocationId, null);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, global::System.Exception?> __ShutdownConnectionCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define(global::Microsoft.Extensions.Logging.LogLevel.Trace, new global::Microsoft.Extensions.Logging.EventId(11, "ShutdownConnection"), "Shutting down connection.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
            /// <summary>
            /// <para><b>Message:</b> Shutting down connection.</para>
            /// <para><b>Level:</b> Trace</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            public static partial void ShutdownConnection(global::Microsoft.Extensions.Logging.ILogger logger)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Trace))
                {
                    __ShutdownConnectionCallback(logger, null);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, global::System.Exception?> __ShutdownWithErrorCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define(global::Microsoft.Extensions.Logging.LogLevel.Error, new global::Microsoft.Extensions.Logging.EventId(12, "ShutdownWithError"), "Connection is shutting down due to an error.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
            /// <summary>
            /// <para><b>Message:</b> Connection is shutting down due to an error.</para>
            /// <para><b>Level:</b> Error</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            public static partial void ShutdownWithError(global::Microsoft.Extensions.Logging.ILogger logger, global::System.Exception exception)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Error))
                {
                    __ShutdownWithErrorCallback(logger, exception);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, string, global::System.Exception?> __RemovingInvocationCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define<string>(global::Microsoft.Extensions.Logging.LogLevel.Trace, new global::Microsoft.Extensions.Logging.EventId(13, "RemovingInvocation"), "Removing pending invocation {InvocationId}.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
            /// <summary>
            /// <para><b>Message:</b> Removing pending invocation {InvocationId}.</para>
            /// <para><b>Level:</b> Trace</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            public static partial void RemovingInvocation(global::Microsoft.Extensions.Logging.ILogger logger, string invocationId)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Trace))
                {
                    __RemovingInvocationCallback(logger, invocationId, null);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, string, global::System.Exception?> __MissingHandlerCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define<string>(global::Microsoft.Extensions.Logging.LogLevel.Warning, new global::Microsoft.Extensions.Logging.EventId(14, "MissingHandler"), "Failed to find handler for '{Target}' method.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
            /// <summary>
            /// <para><b>Message:</b> Failed to find handler for &apos;{Target}&apos; method.</para>
            /// <para><b>Level:</b> Warning</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            public static partial void MissingHandler(global::Microsoft.Extensions.Logging.ILogger logger, string target)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Warning))
                {
                    __MissingHandlerCallback(logger, target, null);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, string, global::System.Exception?> __ReceivedStreamItemCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define<string>(global::Microsoft.Extensions.Logging.LogLevel.Trace, new global::Microsoft.Extensions.Logging.EventId(15, "ReceivedStreamItem"), "Received StreamItem for Invocation {InvocationId}.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
            /// <summary>
            /// <para><b>Message:</b> Received StreamItem for Invocation {InvocationId}.</para>
            /// <para><b>Level:</b> Trace</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            public static partial void ReceivedStreamItem(global::Microsoft.Extensions.Logging.ILogger logger, string invocationId)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Trace))
                {
                    __ReceivedStreamItemCallback(logger, invocationId, null);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, string, global::System.Exception?> __CancelingStreamItemCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define<string>(global::Microsoft.Extensions.Logging.LogLevel.Trace, new global::Microsoft.Extensions.Logging.EventId(16, "CancelingStreamItem"), "Canceling dispatch of StreamItem message for Invocation {InvocationId}. The invocation was canceled.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
            /// <summary>
            /// <para><b>Message:</b> Canceling dispatch of StreamItem message for Invocation {InvocationId}. The invocation was canceled.</para>
            /// <para><b>Level:</b> Trace</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            public static partial void CancelingStreamItem(global::Microsoft.Extensions.Logging.ILogger logger, string invocationId)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Trace))
                {
                    __CancelingStreamItemCallback(logger, invocationId, null);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, string, global::System.Exception?> __ReceivedStreamItemAfterCloseCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define<string>(global::Microsoft.Extensions.Logging.LogLevel.Warning, new global::Microsoft.Extensions.Logging.EventId(17, "ReceivedStreamItemAfterClose"), "Invocation {InvocationId} received stream item after channel was closed.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
            /// <summary>
            /// <para><b>Message:</b> Invocation {InvocationId} received stream item after channel was closed.</para>
            /// <para><b>Level:</b> Warning</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            public static partial void ReceivedStreamItemAfterClose(global::Microsoft.Extensions.Logging.ILogger logger, string invocationId)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Warning))
                {
                    __ReceivedStreamItemAfterCloseCallback(logger, invocationId, null);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, string, global::System.Exception?> __ReceivedInvocationCompletionCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define<string>(global::Microsoft.Extensions.Logging.LogLevel.Trace, new global::Microsoft.Extensions.Logging.EventId(18, "ReceivedInvocationCompletion"), "Received Completion for Invocation {InvocationId}.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
            /// <summary>
            /// <para><b>Message:</b> Received Completion for Invocation {InvocationId}.</para>
            /// <para><b>Level:</b> Trace</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            public static partial void ReceivedInvocationCompletion(global::Microsoft.Extensions.Logging.ILogger logger, string invocationId)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Trace))
                {
                    __ReceivedInvocationCompletionCallback(logger, invocationId, null);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, string, global::System.Exception?> __CancelingInvocationCompletionCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define<string>(global::Microsoft.Extensions.Logging.LogLevel.Trace, new global::Microsoft.Extensions.Logging.EventId(19, "CancelingInvocationCompletion"), "Canceling dispatch of Completion message for Invocation {InvocationId}. The invocation was canceled.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
            /// <summary>
            /// <para><b>Message:</b> Canceling dispatch of Completion message for Invocation {InvocationId}. The invocation was canceled.</para>
            /// <para><b>Level:</b> Trace</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            public static partial void CancelingInvocationCompletion(global::Microsoft.Extensions.Logging.ILogger logger, string invocationId)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Trace))
                {
                    __CancelingInvocationCompletionCallback(logger, invocationId, null);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, global::System.Exception?> __StoppedCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(21, "Stopped"), "HubConnection stopped.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
            /// <summary>
            /// <para><b>Message:</b> HubConnection stopped.</para>
            /// <para><b>Level:</b> Debug</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            public static partial void Stopped(global::Microsoft.Extensions.Logging.ILogger logger)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
                {
                    __StoppedCallback(logger, null);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, string, global::System.Exception?> __InvocationAlreadyInUseCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define<string>(global::Microsoft.Extensions.Logging.LogLevel.Critical, new global::Microsoft.Extensions.Logging.EventId(22, "InvocationAlreadyInUse"), "Invocation ID '{InvocationId}' is already in use.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
            /// <summary>
            /// <para><b>Message:</b> Invocation ID &apos;{InvocationId}&apos; is already in use.</para>
            /// <para><b>Level:</b> Critical</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            public static partial void InvocationAlreadyInUse(global::Microsoft.Extensions.Logging.ILogger logger, string invocationId)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Critical))
                {
                    __InvocationAlreadyInUseCallback(logger, invocationId, null);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, string, global::System.Exception?> __ReceivedUnexpectedResponseCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define<string>(global::Microsoft.Extensions.Logging.LogLevel.Error, new global::Microsoft.Extensions.Logging.EventId(23, "ReceivedUnexpectedResponse"), "Unsolicited response received for invocation '{InvocationId}'.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
            /// <summary>
            /// <para><b>Message:</b> Unsolicited response received for invocation &apos;{InvocationId}&apos;.</para>
            /// <para><b>Level:</b> Error</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            public static partial void ReceivedUnexpectedResponse(global::Microsoft.Extensions.Logging.ILogger logger, string invocationId)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Error))
                {
                    __ReceivedUnexpectedResponseCallback(logger, invocationId, null);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, string, int, global::System.Exception?> __HubProtocolCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define<string, int>(global::Microsoft.Extensions.Logging.LogLevel.Information, new global::Microsoft.Extensions.Logging.EventId(24, "HubProtocol"), "Using HubProtocol '{Protocol} v{Version}'.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
            /// <summary>
            /// <para><b>Message:</b> Using HubProtocol &apos;{Protocol} v{Version}&apos;.</para>
            /// <para><b>Level:</b> Information</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            public static partial void HubProtocol(global::Microsoft.Extensions.Logging.ILogger logger, string protocol, int version)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Information))
                {
                    __HubProtocolCallback(logger, protocol, version, null);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, string, string, string, int, global::System.Exception?> __PreparingStreamingInvocationCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define<string, string, string, int>(global::Microsoft.Extensions.Logging.LogLevel.Trace, new global::Microsoft.Extensions.Logging.EventId(25, "PreparingStreamingInvocation"), "Preparing streaming invocation '{InvocationId}' of '{Target}', with return type '{ReturnType}' and {ArgumentCount} argument(s).", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
            /// <summary>
            /// <para><b>Message:</b> Preparing streaming invocation &apos;{InvocationId}&apos; of &apos;{Target}&apos;, with return type &apos;{ReturnType}&apos; and {ArgumentCount} argument(s).</para>
            /// <para><b>Level:</b> Trace</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            public static partial void PreparingStreamingInvocation(global::Microsoft.Extensions.Logging.ILogger logger, string invocationId, string target, string returnType, int argumentCount)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Trace))
                {
                    __PreparingStreamingInvocationCallback(logger, invocationId, target, returnType, argumentCount, null);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, global::System.Exception?> __ResettingKeepAliveTimerCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define(global::Microsoft.Extensions.Logging.LogLevel.Trace, new global::Microsoft.Extensions.Logging.EventId(26, "ResettingKeepAliveTimer"), "Resetting keep-alive timer, received a message from the server.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
            /// <summary>
            /// <para><b>Message:</b> Resetting keep-alive timer, received a message from the server.</para>
            /// <para><b>Level:</b> Trace</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            public static partial void ResettingKeepAliveTimer(global::Microsoft.Extensions.Logging.ILogger logger)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Trace))
                {
                    __ResettingKeepAliveTimerCallback(logger, null);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, global::System.Exception?> __ErrorDuringClosedEventCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define(global::Microsoft.Extensions.Logging.LogLevel.Error, new global::Microsoft.Extensions.Logging.EventId(27, "ErrorDuringClosedEvent"), "An exception was thrown in the handler for the Closed event.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
            /// <summary>
            /// <para><b>Message:</b> An exception was thrown in the handler for the Closed event.</para>
            /// <para><b>Level:</b> Error</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            public static partial void ErrorDuringClosedEvent(global::Microsoft.Extensions.Logging.ILogger logger, global::System.Exception exception)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Error))
                {
                    __ErrorDuringClosedEventCallback(logger, exception);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, global::System.Exception?> __SendingHubHandshakeCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(28, "SendingHubHandshake"), "Sending Hub Handshake.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
            /// <summary>
            /// <para><b>Message:</b> Sending Hub Handshake.</para>
            /// <para><b>Level:</b> Debug</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            public static partial void SendingHubHandshake(global::Microsoft.Extensions.Logging.ILogger logger)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
                {
                    __SendingHubHandshakeCallback(logger, null);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, global::System.Exception?> __ReceivedPingCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define(global::Microsoft.Extensions.Logging.LogLevel.Trace, new global::Microsoft.Extensions.Logging.EventId(31, "ReceivedPing"), "Received a ping message.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
            /// <summary>
            /// <para><b>Message:</b> Received a ping message.</para>
            /// <para><b>Level:</b> Trace</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            public static partial void ReceivedPing(global::Microsoft.Extensions.Logging.ILogger logger)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Trace))
                {
                    __ReceivedPingCallback(logger, null);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, string, global::System.Exception?> __ErrorInvokingClientSideMethodCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define<string>(global::Microsoft.Extensions.Logging.LogLevel.Error, new global::Microsoft.Extensions.Logging.EventId(34, "ErrorInvokingClientSideMethod"), "Invoking client side method '{MethodName}' failed.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
            /// <summary>
            /// <para><b>Message:</b> Invoking client side method &apos;{MethodName}&apos; failed.</para>
            /// <para><b>Level:</b> Error</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            public static partial void ErrorInvokingClientSideMethod(global::Microsoft.Extensions.Logging.ILogger logger, string methodName, global::System.Exception exception)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Error))
                {
                    __ErrorInvokingClientSideMethodCallback(logger, methodName, exception);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, global::System.Exception?> __ErrorReceivingHandshakeResponseCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define(global::Microsoft.Extensions.Logging.LogLevel.Error, new global::Microsoft.Extensions.Logging.EventId(35, "ErrorReceivingHandshakeResponse"), "The underlying connection closed while processing the handshake response. See exception for details.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
            /// <summary>
            /// <para><b>Message:</b> The underlying connection closed while processing the handshake response. See exception for details.</para>
            /// <para><b>Level:</b> Error</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            public static partial void ErrorReceivingHandshakeResponse(global::Microsoft.Extensions.Logging.ILogger logger, global::System.Exception exception)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Error))
                {
                    __ErrorReceivingHandshakeResponseCallback(logger, exception);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, string, global::System.Exception?> __HandshakeServerErrorCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define<string>(global::Microsoft.Extensions.Logging.LogLevel.Error, new global::Microsoft.Extensions.Logging.EventId(36, "HandshakeServerError"), "Server returned handshake error: {Error}", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
            /// <summary>
            /// <para><b>Message:</b> Server returned handshake error: {Error}</para>
            /// <para><b>Level:</b> Error</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            public static partial void HandshakeServerError(global::Microsoft.Extensions.Logging.ILogger logger, string error)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Error))
                {
                    __HandshakeServerErrorCallback(logger, error, null);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, global::System.Exception?> __ReceivedCloseCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(37, "ReceivedClose"), "Received close message.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
            /// <summary>
            /// <para><b>Message:</b> Received close message.</para>
            /// <para><b>Level:</b> Debug</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            public static partial void ReceivedClose(global::Microsoft.Extensions.Logging.ILogger logger)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
                {
                    __ReceivedCloseCallback(logger, null);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, string, global::System.Exception?> __ReceivedCloseWithErrorCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define<string>(global::Microsoft.Extensions.Logging.LogLevel.Error, new global::Microsoft.Extensions.Logging.EventId(38, "ReceivedCloseWithError"), "Received close message with an error: {Error}", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
            /// <summary>
            /// <para><b>Message:</b> Received close message with an error: {Error}</para>
            /// <para><b>Level:</b> Error</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            public static partial void ReceivedCloseWithError(global::Microsoft.Extensions.Logging.ILogger logger, string error)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Error))
                {
                    __ReceivedCloseWithErrorCallback(logger, error, null);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, global::System.Exception?> __HandshakeCompleteCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(39, "HandshakeComplete"), "Handshake with server complete.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
            /// <summary>
            /// <para><b>Message:</b> Handshake with server complete.</para>
            /// <para><b>Level:</b> Debug</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            public static partial void HandshakeComplete(global::Microsoft.Extensions.Logging.ILogger logger)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
                {
                    __HandshakeCompleteCallback(logger, null);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, string, global::System.Exception?> __RegisteringHandlerCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define<string>(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(40, "RegisteringHandler"), "Registering handler for client method '{MethodName}'.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
            /// <summary>
            /// <para><b>Message:</b> Registering handler for client method &apos;{MethodName}&apos;.</para>
            /// <para><b>Level:</b> Debug</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            public static partial void RegisteringHandler(global::Microsoft.Extensions.Logging.ILogger logger, string methodName)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
                {
                    __RegisteringHandlerCallback(logger, methodName, null);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, string, global::System.Exception?> __RemovingHandlersCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define<string>(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(58, "RemovingHandlers"), "Removing handlers for client method '{MethodName}'.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
            /// <summary>
            /// <para><b>Message:</b> Removing handlers for client method &apos;{MethodName}&apos;.</para>
            /// <para><b>Level:</b> Debug</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            public static partial void RemovingHandlers(global::Microsoft.Extensions.Logging.ILogger logger, string methodName)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
                {
                    __RemovingHandlersCallback(logger, methodName, null);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, global::System.Exception?> __StartingCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(41, "Starting"), "Starting HubConnection.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
            /// <summary>
            /// <para><b>Message:</b> Starting HubConnection.</para>
            /// <para><b>Level:</b> Debug</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            public static partial void Starting(global::Microsoft.Extensions.Logging.ILogger logger)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
                {
                    __StartingCallback(logger, null);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, global::System.Exception?> __ErrorStartingConnectionCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define(global::Microsoft.Extensions.Logging.LogLevel.Error, new global::Microsoft.Extensions.Logging.EventId(43, "ErrorStartingConnection"), "Error starting connection.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
            /// <summary>
            /// <para><b>Message:</b> Error starting connection.</para>
            /// <para><b>Level:</b> Error</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            public static partial void ErrorStartingConnection(global::Microsoft.Extensions.Logging.ILogger logger, global::System.Exception ex)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Error))
                {
                    __ErrorStartingConnectionCallback(logger, ex);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, global::System.Exception?> __StartedCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define(global::Microsoft.Extensions.Logging.LogLevel.Information, new global::Microsoft.Extensions.Logging.EventId(44, "Started"), "HubConnection started.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
            /// <summary>
            /// <para><b>Message:</b> HubConnection started.</para>
            /// <para><b>Level:</b> Information</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            public static partial void Started(global::Microsoft.Extensions.Logging.ILogger logger)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Information))
                {
                    __StartedCallback(logger, null);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, string, global::System.Exception?> __SendingCancellationCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define<string>(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(45, "SendingCancellation"), "Sending Cancellation for Invocation '{InvocationId}'.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
            /// <summary>
            /// <para><b>Message:</b> Sending Cancellation for Invocation &apos;{InvocationId}&apos;.</para>
            /// <para><b>Level:</b> Debug</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            public static partial void SendingCancellation(global::Microsoft.Extensions.Logging.ILogger logger, string invocationId)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
                {
                    __SendingCancellationCallback(logger, invocationId, null);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, global::System.Exception?> __CancelingOutstandingInvocationsCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(46, "CancelingOutstandingInvocations"), "Canceling all outstanding invocations.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
            /// <summary>
            /// <para><b>Message:</b> Canceling all outstanding invocations.</para>
            /// <para><b>Level:</b> Debug</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            public static partial void CancelingOutstandingInvocations(global::Microsoft.Extensions.Logging.ILogger logger)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
                {
                    __CancelingOutstandingInvocationsCallback(logger, null);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, global::System.Exception?> __ReceiveLoopStartingCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(47, "ReceiveLoopStarting"), "Receive loop starting.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
            /// <summary>
            /// <para><b>Message:</b> Receive loop starting.</para>
            /// <para><b>Level:</b> Debug</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            public static partial void ReceiveLoopStarting(global::Microsoft.Extensions.Logging.ILogger logger)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
                {
                    __ReceiveLoopStartingCallback(logger, null);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, double, global::System.Exception?> __StartingServerTimeoutTimerCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define<double>(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(48, "StartingServerTimeoutTimer"), "Starting server timeout timer. Duration: {ServerTimeout:0.00}ms", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
            /// <summary>
            /// <para><b>Message:</b> Starting server timeout timer. Duration: {ServerTimeout:0.00}ms</para>
            /// <para><b>Level:</b> Debug</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            public static partial void StartingServerTimeoutTimer(global::Microsoft.Extensions.Logging.ILogger logger, double serverTimeout)
            {
                __StartingServerTimeoutTimerCallback(logger, serverTimeout, null);
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, global::System.Exception?> __NotUsingServerTimeoutCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(49, "NotUsingServerTimeout"), "Not using server timeout because the transport inherently tracks server availability.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
            /// <summary>
            /// <para><b>Message:</b> Not using server timeout because the transport inherently tracks server availability.</para>
            /// <para><b>Level:</b> Debug</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            public static partial void NotUsingServerTimeout(global::Microsoft.Extensions.Logging.ILogger logger)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
                {
                    __NotUsingServerTimeoutCallback(logger, null);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, global::System.Exception?> __ServerDisconnectedWithErrorCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define(global::Microsoft.Extensions.Logging.LogLevel.Error, new global::Microsoft.Extensions.Logging.EventId(50, "ServerDisconnectedWithError"), "The server connection was terminated with an error.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
            /// <summary>
            /// <para><b>Message:</b> The server connection was terminated with an error.</para>
            /// <para><b>Level:</b> Error</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            public static partial void ServerDisconnectedWithError(global::Microsoft.Extensions.Logging.ILogger logger, global::System.Exception ex)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Error))
                {
                    __ServerDisconnectedWithErrorCallback(logger, ex);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, global::System.Exception?> __InvokingClosedEventHandlerCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(51, "InvokingClosedEventHandler"), "Invoking the Closed event handler.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
            /// <summary>
            /// <para><b>Message:</b> Invoking the Closed event handler.</para>
            /// <para><b>Level:</b> Debug</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            public static partial void InvokingClosedEventHandler(global::Microsoft.Extensions.Logging.ILogger logger)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
                {
                    __InvokingClosedEventHandlerCallback(logger, null);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, global::System.Exception?> __StoppingCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(52, "Stopping"), "Stopping HubConnection.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
            /// <summary>
            /// <para><b>Message:</b> Stopping HubConnection.</para>
            /// <para><b>Level:</b> Debug</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            public static partial void Stopping(global::Microsoft.Extensions.Logging.ILogger logger)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
                {
                    __StoppingCallback(logger, null);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, global::System.Exception?> __TerminatingReceiveLoopCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(53, "TerminatingReceiveLoop"), "Terminating receive loop.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
            /// <summary>
            /// <para><b>Message:</b> Terminating receive loop.</para>
            /// <para><b>Level:</b> Debug</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            public static partial void TerminatingReceiveLoop(global::Microsoft.Extensions.Logging.ILogger logger)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
                {
                    __TerminatingReceiveLoopCallback(logger, null);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, global::System.Exception?> __WaitingForReceiveLoopToTerminateCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(54, "WaitingForReceiveLoopToTerminate"), "Waiting for the receive loop to terminate.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
            /// <summary>
            /// <para><b>Message:</b> Waiting for the receive loop to terminate.</para>
            /// <para><b>Level:</b> Debug</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            public static partial void WaitingForReceiveLoopToTerminate(global::Microsoft.Extensions.Logging.ILogger logger)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
                {
                    __WaitingForReceiveLoopToTerminateCallback(logger, null);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, long, global::System.Exception?> __ProcessingMessageCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define<long>(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(56, "ProcessingMessage"), "Processing {MessageLength} byte message from server.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
            /// <summary>
            /// <para><b>Message:</b> Processing {MessageLength} byte message from server.</para>
            /// <para><b>Level:</b> Debug</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            public static partial void ProcessingMessage(global::Microsoft.Extensions.Logging.ILogger logger, long messageLength)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
                {
                    __ProcessingMessageCallback(logger, messageLength, null);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, string?, string?, int, global::System.Exception?> __WaitingOnConnectionLockCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define<string?, string?, int>(global::Microsoft.Extensions.Logging.LogLevel.Trace, new global::Microsoft.Extensions.Logging.EventId(42, "WaitingOnConnectionLock"), "Waiting on Connection Lock in {MethodName} ({FilePath}:{LineNumber}).", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
            /// <summary>
            /// <para><b>Message:</b> Waiting on Connection Lock in {MethodName} ({FilePath}:{LineNumber}).</para>
            /// <para><b>Level:</b> Trace</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            public static partial void WaitingOnConnectionLock(global::Microsoft.Extensions.Logging.ILogger logger, string? methodName, string? filePath, int lineNumber)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Trace))
                {
                    __WaitingOnConnectionLockCallback(logger, methodName, filePath, lineNumber, null);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, string?, string?, int, global::System.Exception?> __ReleasingConnectionLockCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define<string?, string?, int>(global::Microsoft.Extensions.Logging.LogLevel.Trace, new global::Microsoft.Extensions.Logging.EventId(20, "ReleasingConnectionLock"), "Releasing Connection Lock in {MethodName} ({FilePath}:{LineNumber}).", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
            /// <summary>
            /// <para><b>Message:</b> Releasing Connection Lock in {MethodName} ({FilePath}:{LineNumber}).</para>
            /// <para><b>Level:</b> Trace</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            public static partial void ReleasingConnectionLock(global::Microsoft.Extensions.Logging.ILogger logger, string? methodName, string? filePath, int lineNumber)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Trace))
                {
                    __ReleasingConnectionLockCallback(logger, methodName, filePath, lineNumber, null);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, string, global::System.Exception?> __UnableToSendCancellationCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define<string>(global::Microsoft.Extensions.Logging.LogLevel.Trace, new global::Microsoft.Extensions.Logging.EventId(55, "UnableToSendCancellation"), "Unable to send cancellation for invocation '{InvocationId}'. The connection is inactive.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
            /// <summary>
            /// <para><b>Message:</b> Unable to send cancellation for invocation &apos;{InvocationId}&apos;. The connection is inactive.</para>
            /// <para><b>Level:</b> Trace</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            public static partial void UnableToSendCancellation(global::Microsoft.Extensions.Logging.ILogger logger, string invocationId)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Trace))
                {
                    __UnableToSendCancellationCallback(logger, invocationId, null);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, string?, string, global::System.Exception?> __ArgumentBindingFailureCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define<string?, string>(global::Microsoft.Extensions.Logging.LogLevel.Error, new global::Microsoft.Extensions.Logging.EventId(57, "ArgumentBindingFailure"), "Failed to bind arguments received in invocation '{InvocationId}' of '{MethodName}'.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
            /// <summary>
            /// <para><b>Message:</b> Failed to bind arguments received in invocation &apos;{InvocationId}&apos; of &apos;{MethodName}&apos;.</para>
            /// <para><b>Level:</b> Error</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            public static partial void ArgumentBindingFailure(global::Microsoft.Extensions.Logging.ILogger logger, string? invocationId, string methodName, global::System.Exception exception)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Error))
                {
                    __ArgumentBindingFailureCallback(logger, invocationId, methodName, exception);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, global::System.Exception?> __AcquiredConnectionLockForPingCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define(global::Microsoft.Extensions.Logging.LogLevel.Trace, new global::Microsoft.Extensions.Logging.EventId(61, "AcquiredConnectionLockForPing"), "Acquired the Connection Lock in order to ping the server.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
            /// <summary>
            /// <para><b>Message:</b> Acquired the Connection Lock in order to ping the server.</para>
            /// <para><b>Level:</b> Trace</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            public static partial void AcquiredConnectionLockForPing(global::Microsoft.Extensions.Logging.ILogger logger)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Trace))
                {
                    __AcquiredConnectionLockForPingCallback(logger, null);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, global::System.Exception?> __UnableToAcquireConnectionLockForPingCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define(global::Microsoft.Extensions.Logging.LogLevel.Trace, new global::Microsoft.Extensions.Logging.EventId(62, "UnableToAcquireConnectionLockForPing"), "Skipping ping because a send is already in progress.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
            /// <summary>
            /// <para><b>Message:</b> Skipping ping because a send is already in progress.</para>
            /// <para><b>Level:</b> Trace</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            public static partial void UnableToAcquireConnectionLockForPing(global::Microsoft.Extensions.Logging.ILogger logger)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Trace))
                {
                    __UnableToAcquireConnectionLockForPingCallback(logger, null);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, string, global::System.Exception?> __StartingStreamCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define<string>(global::Microsoft.Extensions.Logging.LogLevel.Trace, new global::Microsoft.Extensions.Logging.EventId(63, "StartingStream"), "Initiating stream '{StreamId}'.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
            /// <summary>
            /// <para><b>Message:</b> Initiating stream &apos;{StreamId}&apos;.</para>
            /// <para><b>Level:</b> Trace</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            public static partial void StartingStream(global::Microsoft.Extensions.Logging.ILogger logger, string streamId)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Trace))
                {
                    __StartingStreamCallback(logger, streamId, null);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, string, global::System.Exception?> __SendingStreamItemCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define<string>(global::Microsoft.Extensions.Logging.LogLevel.Trace, new global::Microsoft.Extensions.Logging.EventId(64, "StreamItemSent"), "Sending item for stream '{StreamId}'.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
            /// <summary>
            /// <para><b>Message:</b> Sending item for stream &apos;{StreamId}&apos;.</para>
            /// <para><b>Level:</b> Trace</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            public static partial void SendingStreamItem(global::Microsoft.Extensions.Logging.ILogger logger, string streamId)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Trace))
                {
                    __SendingStreamItemCallback(logger, streamId, null);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, string, global::System.Exception?> __CancelingStreamCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define<string>(global::Microsoft.Extensions.Logging.LogLevel.Trace, new global::Microsoft.Extensions.Logging.EventId(65, "CancelingStream"), "Stream '{StreamId}' has been canceled by client.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
            /// <summary>
            /// <para><b>Message:</b> Stream &apos;{StreamId}&apos; has been canceled by client.</para>
            /// <para><b>Level:</b> Trace</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            public static partial void CancelingStream(global::Microsoft.Extensions.Logging.ILogger logger, string streamId)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Trace))
                {
                    __CancelingStreamCallback(logger, streamId, null);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, string, global::System.Exception?> __CompletingStreamCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define<string>(global::Microsoft.Extensions.Logging.LogLevel.Trace, new global::Microsoft.Extensions.Logging.EventId(66, "CompletingStream"), "Sending completion message for stream '{StreamId}'.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
            /// <summary>
            /// <para><b>Message:</b> Sending completion message for stream &apos;{StreamId}&apos;.</para>
            /// <para><b>Level:</b> Trace</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            public static partial void CompletingStream(global::Microsoft.Extensions.Logging.ILogger logger, string streamId)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Trace))
                {
                    __CompletingStreamCallback(logger, streamId, null);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, global::Microsoft.AspNetCore.SignalR.Client.HubConnectionState, global::Microsoft.AspNetCore.SignalR.Client.HubConnectionState, global::Microsoft.AspNetCore.SignalR.Client.HubConnectionState, global::System.Exception?> __StateTransitionFailedCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define<global::Microsoft.AspNetCore.SignalR.Client.HubConnectionState, global::Microsoft.AspNetCore.SignalR.Client.HubConnectionState, global::Microsoft.AspNetCore.SignalR.Client.HubConnectionState>(global::Microsoft.Extensions.Logging.LogLevel.Error, new global::Microsoft.Extensions.Logging.EventId(67, "StateTransitionFailed"), "The HubConnection failed to transition from the {ExpectedState} state to the {NewState} state because it was actually in the {ActualState} state.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
            /// <summary>
            /// <para><b>Message:</b> The HubConnection failed to transition from the {ExpectedState} state to the {NewState} state because it was actually in the {ActualState} state.</para>
            /// <para><b>Level:</b> Error</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            public static partial void StateTransitionFailed(global::Microsoft.Extensions.Logging.ILogger logger, global::Microsoft.AspNetCore.SignalR.Client.HubConnectionState expectedState, global::Microsoft.AspNetCore.SignalR.Client.HubConnectionState newState, global::Microsoft.AspNetCore.SignalR.Client.HubConnectionState actualState)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Error))
                {
                    __StateTransitionFailedCallback(logger, expectedState, newState, actualState, null);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, global::System.Exception?> __ReconnectingCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define(global::Microsoft.Extensions.Logging.LogLevel.Information, new global::Microsoft.Extensions.Logging.EventId(68, "Reconnecting"), "HubConnection reconnecting.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
            /// <summary>
            /// <para><b>Message:</b> HubConnection reconnecting.</para>
            /// <para><b>Level:</b> Information</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            public static partial void Reconnecting(global::Microsoft.Extensions.Logging.ILogger logger)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Information))
                {
                    __ReconnectingCallback(logger, null);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, global::System.Exception?> __ReconnectingWithErrorCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define(global::Microsoft.Extensions.Logging.LogLevel.Error, new global::Microsoft.Extensions.Logging.EventId(69, "ReconnectingWithError"), "HubConnection reconnecting due to an error.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
            /// <summary>
            /// <para><b>Message:</b> HubConnection reconnecting due to an error.</para>
            /// <para><b>Level:</b> Error</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            public static partial void ReconnectingWithError(global::Microsoft.Extensions.Logging.ILogger logger, global::System.Exception exception)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Error))
                {
                    __ReconnectingWithErrorCallback(logger, exception);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, long, global::System.TimeSpan, global::System.Exception?> __ReconnectedCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define<long, global::System.TimeSpan>(global::Microsoft.Extensions.Logging.LogLevel.Information, new global::Microsoft.Extensions.Logging.EventId(70, "Reconnected"), "HubConnection reconnected successfully after {ReconnectAttempts} attempts and {ElapsedTime} elapsed.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
            /// <summary>
            /// <para><b>Message:</b> HubConnection reconnected successfully after {ReconnectAttempts} attempts and {ElapsedTime} elapsed.</para>
            /// <para><b>Level:</b> Information</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            public static partial void Reconnected(global::Microsoft.Extensions.Logging.ILogger logger, long reconnectAttempts, global::System.TimeSpan elapsedTime)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Information))
                {
                    __ReconnectedCallback(logger, reconnectAttempts, elapsedTime, null);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, long, global::System.TimeSpan, global::System.Exception?> __ReconnectAttemptsExhaustedCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define<long, global::System.TimeSpan>(global::Microsoft.Extensions.Logging.LogLevel.Information, new global::Microsoft.Extensions.Logging.EventId(71, "ReconnectAttemptsExhausted"), "Reconnect retries have been exhausted after {ReconnectAttempts} failed attempts and {ElapsedTime} elapsed. Disconnecting.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
            /// <summary>
            /// <para><b>Message:</b> Reconnect retries have been exhausted after {ReconnectAttempts} failed attempts and {ElapsedTime} elapsed. Disconnecting.</para>
            /// <para><b>Level:</b> Information</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            public static partial void ReconnectAttemptsExhausted(global::Microsoft.Extensions.Logging.ILogger logger, long reconnectAttempts, global::System.TimeSpan elapsedTime)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Information))
                {
                    __ReconnectAttemptsExhaustedCallback(logger, reconnectAttempts, elapsedTime, null);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, long, global::System.TimeSpan, global::System.Exception?> __AwaitingReconnectRetryDelayCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define<long, global::System.TimeSpan>(global::Microsoft.Extensions.Logging.LogLevel.Trace, new global::Microsoft.Extensions.Logging.EventId(72, "AwaitingReconnectRetryDelay"), "Reconnect attempt number {ReconnectAttempts} will start in {RetryDelay}.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
            /// <summary>
            /// <para><b>Message:</b> Reconnect attempt number {ReconnectAttempts} will start in {RetryDelay}.</para>
            /// <para><b>Level:</b> Trace</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            public static partial void AwaitingReconnectRetryDelay(global::Microsoft.Extensions.Logging.ILogger logger, long reconnectAttempts, global::System.TimeSpan retryDelay)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Trace))
                {
                    __AwaitingReconnectRetryDelayCallback(logger, reconnectAttempts, retryDelay, null);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, global::System.Exception?> __ReconnectAttemptFailedCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define(global::Microsoft.Extensions.Logging.LogLevel.Trace, new global::Microsoft.Extensions.Logging.EventId(73, "ReconnectAttemptFailed"), "Reconnect attempt failed.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
            /// <summary>
            /// <para><b>Message:</b> Reconnect attempt failed.</para>
            /// <para><b>Level:</b> Trace</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            public static partial void ReconnectAttemptFailed(global::Microsoft.Extensions.Logging.ILogger logger, global::System.Exception exception)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Trace))
                {
                    __ReconnectAttemptFailedCallback(logger, exception);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, global::System.Exception?> __ErrorDuringReconnectingEventCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define(global::Microsoft.Extensions.Logging.LogLevel.Error, new global::Microsoft.Extensions.Logging.EventId(74, "ErrorDuringReconnectingEvent"), "An exception was thrown in the handler for the Reconnecting event.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
            /// <summary>
            /// <para><b>Message:</b> An exception was thrown in the handler for the Reconnecting event.</para>
            /// <para><b>Level:</b> Error</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            public static partial void ErrorDuringReconnectingEvent(global::Microsoft.Extensions.Logging.ILogger logger, global::System.Exception exception)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Error))
                {
                    __ErrorDuringReconnectingEventCallback(logger, exception);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, global::System.Exception?> __ErrorDuringReconnectedEventCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define(global::Microsoft.Extensions.Logging.LogLevel.Error, new global::Microsoft.Extensions.Logging.EventId(75, "ErrorDuringReconnectedEvent"), "An exception was thrown in the handler for the Reconnected event.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
            /// <summary>
            /// <para><b>Message:</b> An exception was thrown in the handler for the Reconnected event.</para>
            /// <para><b>Level:</b> Error</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            public static partial void ErrorDuringReconnectedEvent(global::Microsoft.Extensions.Logging.ILogger logger, global::System.Exception exception)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Error))
                {
                    __ErrorDuringReconnectedEventCallback(logger, exception);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, global::System.Exception?> __ErrorDuringNextRetryDelayCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define(global::Microsoft.Extensions.Logging.LogLevel.Error, new global::Microsoft.Extensions.Logging.EventId(76, "ErrorDuringNextRetryDelay"), "An exception was thrown from IRetryPolicy.NextRetryDelay().", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
            /// <summary>
            /// <para><b>Message:</b> An exception was thrown from IRetryPolicy.NextRetryDelay().</para>
            /// <para><b>Level:</b> Error</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            public static partial void ErrorDuringNextRetryDelay(global::Microsoft.Extensions.Logging.ILogger logger, global::System.Exception exception)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Error))
                {
                    __ErrorDuringNextRetryDelayCallback(logger, exception);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, global::System.Exception?> __FirstReconnectRetryDelayNullCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define(global::Microsoft.Extensions.Logging.LogLevel.Warning, new global::Microsoft.Extensions.Logging.EventId(77, "FirstReconnectRetryDelayNull"), "Connection not reconnecting because the IRetryPolicy returned null on the first reconnect attempt.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
            /// <summary>
            /// <para><b>Message:</b> Connection not reconnecting because the IRetryPolicy returned null on the first reconnect attempt.</para>
            /// <para><b>Level:</b> Warning</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            public static partial void FirstReconnectRetryDelayNull(global::Microsoft.Extensions.Logging.ILogger logger)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Warning))
                {
                    __FirstReconnectRetryDelayNullCallback(logger, null);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, global::System.Exception?> __ReconnectingStoppedDuringRetryDelayCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define(global::Microsoft.Extensions.Logging.LogLevel.Trace, new global::Microsoft.Extensions.Logging.EventId(78, "ReconnectingStoppedDueToStateChangeDuringRetryDelay"), "Connection stopped during reconnect delay. Done reconnecting.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
            /// <summary>
            /// <para><b>Message:</b> Connection stopped during reconnect delay. Done reconnecting.</para>
            /// <para><b>Level:</b> Trace</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            public static partial void ReconnectingStoppedDuringRetryDelay(global::Microsoft.Extensions.Logging.ILogger logger)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Trace))
                {
                    __ReconnectingStoppedDuringRetryDelayCallback(logger, null);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, global::System.Exception?> __ReconnectingStoppedDuringReconnectAttemptCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define(global::Microsoft.Extensions.Logging.LogLevel.Trace, new global::Microsoft.Extensions.Logging.EventId(79, "ReconnectingStoppedDueToStateChangeDuringReconnectAttempt"), "Connection stopped during reconnect attempt. Done reconnecting.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
            /// <summary>
            /// <para><b>Message:</b> Connection stopped during reconnect attempt. Done reconnecting.</para>
            /// <para><b>Level:</b> Trace</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            public static partial void ReconnectingStoppedDuringReconnectAttempt(global::Microsoft.Extensions.Logging.ILogger logger)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Trace))
                {
                    __ReconnectingStoppedDuringReconnectAttemptCallback(logger, null);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, global::Microsoft.AspNetCore.SignalR.Client.HubConnectionState, global::Microsoft.AspNetCore.SignalR.Client.HubConnectionState, global::System.Exception?> __AttemptingStateTransitionCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define<global::Microsoft.AspNetCore.SignalR.Client.HubConnectionState, global::Microsoft.AspNetCore.SignalR.Client.HubConnectionState>(global::Microsoft.Extensions.Logging.LogLevel.Trace, new global::Microsoft.Extensions.Logging.EventId(80, "AttemptingStateTransition"), "The HubConnection is attempting to transition from the {ExpectedState} state to the {NewState} state.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
            /// <summary>
            /// <para><b>Message:</b> The HubConnection is attempting to transition from the {ExpectedState} state to the {NewState} state.</para>
            /// <para><b>Level:</b> Trace</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            public static partial void AttemptingStateTransition(global::Microsoft.Extensions.Logging.ILogger logger, global::Microsoft.AspNetCore.SignalR.Client.HubConnectionState expectedState, global::Microsoft.AspNetCore.SignalR.Client.HubConnectionState newState)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Trace))
                {
                    __AttemptingStateTransitionCallback(logger, expectedState, newState, null);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, global::System.Exception?> __ErrorInvalidHandshakeResponseCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define(global::Microsoft.Extensions.Logging.LogLevel.Error, new global::Microsoft.Extensions.Logging.EventId(81, "ErrorInvalidHandshakeResponse"), "Received an invalid handshake response.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
            /// <summary>
            /// <para><b>Message:</b> Received an invalid handshake response.</para>
            /// <para><b>Level:</b> Error</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            public static partial void ErrorInvalidHandshakeResponse(global::Microsoft.Extensions.Logging.ILogger logger, global::System.Exception exception)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Error))
                {
                    __ErrorInvalidHandshakeResponseCallback(logger, exception);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, double, global::System.Exception?> __ErrorHandshakeTimedOutCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define<double>(global::Microsoft.Extensions.Logging.LogLevel.Error, new global::Microsoft.Extensions.Logging.EventId(82, "ErrorHandshakeTimedOut"), "The handshake timed out after {HandshakeTimeoutSeconds} seconds.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
            /// <summary>
            /// <para><b>Message:</b> The handshake timed out after {HandshakeTimeoutSeconds} seconds.</para>
            /// <para><b>Level:</b> Error</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            private static partial void ErrorHandshakeTimedOut(global::Microsoft.Extensions.Logging.ILogger logger, double HandshakeTimeoutSeconds, global::System.Exception exception)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Error))
                {
                    __ErrorHandshakeTimedOutCallback(logger, HandshakeTimeoutSeconds, exception);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, global::System.Exception?> __ErrorHandshakeCanceledCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define(global::Microsoft.Extensions.Logging.LogLevel.Error, new global::Microsoft.Extensions.Logging.EventId(83, "ErrorHandshakeCanceled"), "The handshake was canceled by the client.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
            /// <summary>
            /// <para><b>Message:</b> The handshake was canceled by the client.</para>
            /// <para><b>Level:</b> Error</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            public static partial void ErrorHandshakeCanceled(global::Microsoft.Extensions.Logging.ILogger logger, global::System.Exception exception)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Error))
                {
                    __ErrorHandshakeCanceledCallback(logger, exception);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, string, global::System.Exception?> __ErroredStreamCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define<string>(global::Microsoft.Extensions.Logging.LogLevel.Trace, new global::Microsoft.Extensions.Logging.EventId(84, "ErroredStream"), "Client threw an error for stream '{StreamId}'.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
            /// <summary>
            /// <para><b>Message:</b> Client threw an error for stream &apos;{StreamId}&apos;.</para>
            /// <para><b>Level:</b> Trace</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            public static partial void ErroredStream(global::Microsoft.Extensions.Logging.ILogger logger, string streamId, global::System.Exception exception)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Trace))
                {
                    __ErroredStreamCallback(logger, streamId, exception);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, string, global::System.Exception?> __MissingResultHandlerCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define<string>(global::Microsoft.Extensions.Logging.LogLevel.Warning, new global::Microsoft.Extensions.Logging.EventId(85, "MissingResultHandler"), "Failed to find a value returning handler for '{Target}' method. Sending error to server.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
            /// <summary>
            /// <para><b>Message:</b> Failed to find a value returning handler for &apos;{Target}&apos; method. Sending error to server.</para>
            /// <para><b>Level:</b> Warning</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            public static partial void MissingResultHandler(global::Microsoft.Extensions.Logging.ILogger logger, string target)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Warning))
                {
                    __MissingResultHandlerCallback(logger, target, null);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, string, global::System.Exception?> __ResultNotExpectedCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define<string>(global::Microsoft.Extensions.Logging.LogLevel.Warning, new global::Microsoft.Extensions.Logging.EventId(86, "ResultNotExpected"), "Result given for '{Target}' method but server is not expecting a result.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
            /// <summary>
            /// <para><b>Message:</b> Result given for &apos;{Target}&apos; method but server is not expecting a result.</para>
            /// <para><b>Level:</b> Warning</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            public static partial void ResultNotExpected(global::Microsoft.Extensions.Logging.ILogger logger, string target)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Warning))
                {
                    __ResultNotExpectedCallback(logger, target, null);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, string, global::System.Exception?> __CompletingStreamNotSentCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define<string>(global::Microsoft.Extensions.Logging.LogLevel.Trace, new global::Microsoft.Extensions.Logging.EventId(87, "CompletingStreamNotSent"), "Completion message for stream '{StreamId}' was not sent because the connection is closed.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
            /// <summary>
            /// <para><b>Message:</b> Completion message for stream &apos;{StreamId}&apos; was not sent because the connection is closed.</para>
            /// <para><b>Level:</b> Trace</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            public static partial void CompletingStreamNotSent(global::Microsoft.Extensions.Logging.ILogger logger, string streamId)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Trace))
                {
                    __CompletingStreamNotSentCallback(logger, streamId, null);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, string, string, global::System.Exception?> __ErrorSendingInvocationResultCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define<string, string>(global::Microsoft.Extensions.Logging.LogLevel.Warning, new global::Microsoft.Extensions.Logging.EventId(88, "ErrorSendingInvocationResult"), "Error returning result for invocation '{InvocationId}' for method '{Target}' because the underlying connection is closed.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
            /// <summary>
            /// <para><b>Message:</b> Error returning result for invocation &apos;{InvocationId}&apos; for method &apos;{Target}&apos; because the underlying connection is closed.</para>
            /// <para><b>Level:</b> Warning</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            public static partial void ErrorSendingInvocationResult(global::Microsoft.Extensions.Logging.ILogger logger, string invocationId, string target, global::System.Exception exception)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Warning))
                {
                    __ErrorSendingInvocationResultCallback(logger, invocationId, target, exception);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, string, global::System.Exception?> __ErrorSendingStreamCompletionCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define<string>(global::Microsoft.Extensions.Logging.LogLevel.Trace, new global::Microsoft.Extensions.Logging.EventId(89, "ErrorSendingStreamCompletion"), "Error sending Completion message for stream '{StreamId}'.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
            /// <summary>
            /// <para><b>Message:</b> Error sending Completion message for stream &apos;{StreamId}&apos;.</para>
            /// <para><b>Level:</b> Trace</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            public static partial void ErrorSendingStreamCompletion(global::Microsoft.Extensions.Logging.ILogger logger, string streamId, global::System.Exception exception)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Trace))
                {
                    __ErrorSendingStreamCompletionCallback(logger, streamId, exception);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, string, string?, global::System.Exception?> __DroppingMessageCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define<string, string?>(global::Microsoft.Extensions.Logging.LogLevel.Trace, new global::Microsoft.Extensions.Logging.EventId(90, "DroppingMessage"), "Dropping {MessageType} with ID '{InvocationId}'.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
            /// <summary>
            /// <para><b>Message:</b> Dropping {MessageType} with ID &apos;{InvocationId}&apos;.</para>
            /// <para><b>Level:</b> Trace</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            public static partial void DroppingMessage(global::Microsoft.Extensions.Logging.ILogger logger, string messageType, string? invocationId)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Trace))
                {
                    __DroppingMessageCallback(logger, messageType, invocationId, null);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, long, global::System.Exception?> __ReceivedAckMessageCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define<long>(global::Microsoft.Extensions.Logging.LogLevel.Trace, new global::Microsoft.Extensions.Logging.EventId(91, "ReceivedAckMessage"), "Received AckMessage with Sequence ID '{SequenceId}'.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
            /// <summary>
            /// <para><b>Message:</b> Received AckMessage with Sequence ID &apos;{SequenceId}&apos;.</para>
            /// <para><b>Level:</b> Trace</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            public static partial void ReceivedAckMessage(global::Microsoft.Extensions.Logging.ILogger logger, long sequenceId)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Trace))
                {
                    __ReceivedAckMessageCallback(logger, sequenceId, null);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, long, global::System.Exception?> __ReceivedSequenceMessageCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define<long>(global::Microsoft.Extensions.Logging.LogLevel.Trace, new global::Microsoft.Extensions.Logging.EventId(92, "ReceivedSequenceMessage"), "Received SequenceMessage with Sequence ID '{SequenceId}'.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
            /// <summary>
            /// <para><b>Message:</b> Received SequenceMessage with Sequence ID &apos;{SequenceId}&apos;.</para>
            /// <para><b>Level:</b> Trace</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            public static partial void ReceivedSequenceMessage(global::Microsoft.Extensions.Logging.ILogger logger, long sequenceId)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Trace))
                {
                    __ReceivedSequenceMessageCallback(logger, sequenceId, null);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, string, int, global::System.Exception?> __DisablingReconnectCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define<string, int>(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(93, "DisablingReconnect"), "HubProtocol '{Protocol} v{Version}' does not support Stateful Reconnect. Disabling the feature.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
            /// <summary>
            /// <para><b>Message:</b> HubProtocol &apos;{Protocol} v{Version}&apos; does not support Stateful Reconnect. Disabling the feature.</para>
            /// <para><b>Level:</b> Debug</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            public static partial void DisablingReconnect(global::Microsoft.Extensions.Logging.ILogger logger, string protocol, int version)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
                {
                    __DisablingReconnectCallback(logger, protocol, version, null);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, string?, global::System.Exception?> __StreamBindingFailureCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define<string?>(global::Microsoft.Extensions.Logging.LogLevel.Error, new global::Microsoft.Extensions.Logging.EventId(94, "StreamBindingFailure"), "Failed to bind argument received in stream '{StreamId}'.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
            /// <summary>
            /// <para><b>Message:</b> Failed to bind argument received in stream &apos;{StreamId}&apos;.</para>
            /// <para><b>Level:</b> Error</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            public static partial void StreamBindingFailure(global::Microsoft.Extensions.Logging.ILogger logger, string? streamId, global::System.Exception exception)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Error))
                {
                    __StreamBindingFailureCallback(logger, streamId, exception);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, global::System.Exception?> __AuthenticationRefreshStartingCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(95, "AuthenticationRefreshStarting"), "Starting authentication token refresh.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
            /// <summary>
            /// <para><b>Message:</b> Starting authentication token refresh.</para>
            /// <para><b>Level:</b> Debug</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            public static partial void AuthenticationRefreshStarting(global::Microsoft.Extensions.Logging.ILogger logger)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
                {
                    __AuthenticationRefreshStartingCallback(logger, null);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, global::System.TimeSpan?, global::System.Exception?> __AuthenticationRefreshCompletedCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define<global::System.TimeSpan?>(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(96, "AuthenticationRefreshCompleted"), "Authentication token refresh completed. New TTL: {TokenLifetime}.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
            /// <summary>
            /// <para><b>Message:</b> Authentication token refresh completed. New TTL: {TokenLifetime}.</para>
            /// <para><b>Level:</b> Debug</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            public static partial void AuthenticationRefreshCompleted(global::Microsoft.Extensions.Logging.ILogger logger, global::System.TimeSpan? tokenLifetime)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
                {
                    __AuthenticationRefreshCompletedCallback(logger, tokenLifetime, null);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, global::System.Exception?> __AuthenticationRefreshFailedCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define(global::Microsoft.Extensions.Logging.LogLevel.Error, new global::Microsoft.Extensions.Logging.EventId(97, "AuthenticationRefreshFailed"), "Authentication token refresh failed.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
            /// <summary>
            /// <para><b>Message:</b> Authentication token refresh failed.</para>
            /// <para><b>Level:</b> Error</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            public static partial void AuthenticationRefreshFailed(global::Microsoft.Extensions.Logging.ILogger logger, global::System.Exception exception)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Error))
                {
                    __AuthenticationRefreshFailedCallback(logger, exception);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, global::System.Exception?> __AuthenticationRefreshCallbackFailedCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define(global::Microsoft.Extensions.Logging.LogLevel.Error, new global::Microsoft.Extensions.Logging.EventId(98, "AuthenticationRefreshCallbackFailed"), "Authentication refresh user callback threw an exception.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
            /// <summary>
            /// <para><b>Message:</b> Authentication refresh user callback threw an exception.</para>
            /// <para><b>Level:</b> Error</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            public static partial void AuthenticationRefreshCallbackFailed(global::Microsoft.Extensions.Logging.ILogger logger, global::System.Exception exception)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Error))
                {
                    __AuthenticationRefreshCallbackFailedCallback(logger, exception);
                }
            }
        }
    }
}
namespace Microsoft.AspNetCore.SignalR.Client.Internal
{
    partial class InvocationRequest
    {
        partial class Log
        {
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, string, global::System.Exception?> __InvocationCreatedCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define<string>(global::Microsoft.Extensions.Logging.LogLevel.Trace, new global::Microsoft.Extensions.Logging.EventId(1, "InvocationCreated"), "Invocation {InvocationId} created.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
            /// <summary>
            /// <para><b>Message:</b> Invocation {InvocationId} created.</para>
            /// <para><b>Level:</b> Trace</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            public static partial void InvocationCreated(global::Microsoft.Extensions.Logging.ILogger logger, string invocationId)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Trace))
                {
                    __InvocationCreatedCallback(logger, invocationId, null);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, string, global::System.Exception?> __InvocationDisposedCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define<string>(global::Microsoft.Extensions.Logging.LogLevel.Trace, new global::Microsoft.Extensions.Logging.EventId(2, "InvocationDisposed"), "Invocation {InvocationId} disposed.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
            /// <summary>
            /// <para><b>Message:</b> Invocation {InvocationId} disposed.</para>
            /// <para><b>Level:</b> Trace</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            public static partial void InvocationDisposed(global::Microsoft.Extensions.Logging.ILogger logger, string invocationId)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Trace))
                {
                    __InvocationDisposedCallback(logger, invocationId, null);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, string, global::System.Exception?> __InvocationCompletedCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define<string>(global::Microsoft.Extensions.Logging.LogLevel.Trace, new global::Microsoft.Extensions.Logging.EventId(3, "InvocationCompleted"), "Invocation {InvocationId} marked as completed.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
            /// <summary>
            /// <para><b>Message:</b> Invocation {InvocationId} marked as completed.</para>
            /// <para><b>Level:</b> Trace</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            public static partial void InvocationCompleted(global::Microsoft.Extensions.Logging.ILogger logger, string invocationId)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Trace))
                {
                    __InvocationCompletedCallback(logger, invocationId, null);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, string, global::System.Exception?> __InvocationFailedCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define<string>(global::Microsoft.Extensions.Logging.LogLevel.Trace, new global::Microsoft.Extensions.Logging.EventId(4, "InvocationFailed"), "Invocation {InvocationId} marked as failed.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
            /// <summary>
            /// <para><b>Message:</b> Invocation {InvocationId} marked as failed.</para>
            /// <para><b>Level:</b> Trace</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            public static partial void InvocationFailed(global::Microsoft.Extensions.Logging.ILogger logger, string invocationId)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Trace))
                {
                    __InvocationFailedCallback(logger, invocationId, null);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, string, global::System.Exception?> __ErrorWritingStreamItemCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define<string>(global::Microsoft.Extensions.Logging.LogLevel.Error, new global::Microsoft.Extensions.Logging.EventId(5, "ErrorWritingStreamItem"), "Invocation {InvocationId} caused an error trying to write a stream item.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
            /// <summary>
            /// <para><b>Message:</b> Invocation {InvocationId} caused an error trying to write a stream item.</para>
            /// <para><b>Level:</b> Error</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            public static partial void ErrorWritingStreamItem(global::Microsoft.Extensions.Logging.ILogger logger, string invocationId, global::System.Exception exception)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Error))
                {
                    __ErrorWritingStreamItemCallback(logger, invocationId, exception);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, string, global::System.Exception?> __ReceivedUnexpectedCompleteCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define<string>(global::Microsoft.Extensions.Logging.LogLevel.Error, new global::Microsoft.Extensions.Logging.EventId(6, "ReceivedUnexpectedComplete"), "Invocation {InvocationId} received a completion result, but was invoked as a streaming invocation.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
            /// <summary>
            /// <para><b>Message:</b> Invocation {InvocationId} received a completion result, but was invoked as a streaming invocation.</para>
            /// <para><b>Level:</b> Error</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            public static partial void ReceivedUnexpectedComplete(global::Microsoft.Extensions.Logging.ILogger logger, string invocationId)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Error))
                {
                    __ReceivedUnexpectedCompleteCallback(logger, invocationId, null);
                }
            }
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, string, global::System.Exception?> __StreamItemOnNonStreamInvocationCallback =
                global::Microsoft.Extensions.Logging.LoggerMessage.Define<string>(global::Microsoft.Extensions.Logging.LogLevel.Error, new global::Microsoft.Extensions.Logging.EventId(7, "StreamItemOnNonStreamInvocation"), "Invocation {InvocationId} received stream item but was invoked as a non-streamed invocation.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
            /// <summary>
            /// <para><b>Message:</b> Invocation {InvocationId} received stream item but was invoked as a non-streamed invocation.</para>
            /// <para><b>Level:</b> Error</para>
            /// </summary>
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "12.0.14.46214")]
            public static partial void StreamItemOnNonStreamInvocation(global::Microsoft.Extensions.Logging.ILogger logger, string invocationId)
            {
                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Error))
                {
                    __StreamItemOnNonStreamInvocationCallback(logger, invocationId, null);
                }
            }
        }
    }
}