// <auto-generated/>
#nullable enable
 
namespace Microsoft.Extensions.Logging
{
    partial class LoggingExtensions
    {
        [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.Guid, global::System.DateTimeOffset, global::System.Exception?> __UsingFallbackKeyWithExpirationAsDefaultKeyCallback =
            global::Microsoft.Extensions.Logging.LoggerMessage.Define<global::System.Guid, global::System.DateTimeOffset>(global::Microsoft.Extensions.Logging.LogLevel.Warning, new global::Microsoft.Extensions.Logging.EventId(1, "UsingFallbackKeyWithExpirationAsDefaultKey"), "Policy resolution states that a new key should be added to the key ring, but automatic generation of keys is disabled. Using fallback key {KeyId:B} with expiration {ExpirationDate:u} as default key.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
        /// <summary>
        /// <para><b>Message:</b> Policy resolution states that a new key should be added to the key ring, but automatic generation of keys is disabled. Using fallback key {KeyId:B} with expiration {ExpirationDate:u} as default key.</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 UsingFallbackKeyWithExpirationAsDefaultKey(this global::Microsoft.Extensions.Logging.ILogger logger, global::System.Guid keyId, global::System.DateTimeOffset expirationDate)
        {
            if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Warning))
            {
                __UsingFallbackKeyWithExpirationAsDefaultKeyCallback(logger, keyId, expirationDate, 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.Guid, global::System.Exception?> __UsingKeyAsDefaultKeyCallback =
            global::Microsoft.Extensions.Logging.LoggerMessage.Define<global::System.Guid>(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(2, "UsingKeyAsDefaultKey"), "Using key {KeyId:B} as the default key.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
        /// <summary>
        /// <para><b>Message:</b> Using key {KeyId:B} as the default key.</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 UsingKeyAsDefaultKey(this global::Microsoft.Extensions.Logging.ILogger logger, global::System.Guid keyId)
        {
            if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
            {
                __UsingKeyAsDefaultKeyCallback(logger, keyId, 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?> __OpeningCNGAlgorithmFromProviderWithHMACCallback =
            global::Microsoft.Extensions.Logging.LoggerMessage.Define<string, string?>(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(3, "OpeningCNGAlgorithmFromProviderWithHMAC"), "Opening CNG algorithm '{HashAlgorithm}' from provider '{HashAlgorithmProvider}' with HMAC.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
        /// <summary>
        /// <para><b>Message:</b> Opening CNG algorithm &apos;{HashAlgorithm}&apos; from provider &apos;{HashAlgorithmProvider}&apos; with HMAC.</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 OpeningCNGAlgorithmFromProviderWithHMAC(this global::Microsoft.Extensions.Logging.ILogger logger, string hashAlgorithm, string? hashAlgorithmProvider)
        {
            if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
            {
                __OpeningCNGAlgorithmFromProviderWithHMACCallback(logger, hashAlgorithm, hashAlgorithmProvider, 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?> __OpeningCNGAlgorithmFromProviderWithChainingModeCBCCallback =
            global::Microsoft.Extensions.Logging.LoggerMessage.Define<string, string?>(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(4, "OpeningCNGAlgorithmFromProviderWithChainingModeCBC"), "Opening CNG algorithm '{EncryptionAlgorithm}' from provider '{EncryptionAlgorithmProvider}' with chaining mode CBC.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
        /// <summary>
        /// <para><b>Message:</b> Opening CNG algorithm &apos;{EncryptionAlgorithm}&apos; from provider &apos;{EncryptionAlgorithmProvider}&apos; with chaining mode CBC.</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 OpeningCNGAlgorithmFromProviderWithChainingModeCBC(this global::Microsoft.Extensions.Logging.ILogger logger, string encryptionAlgorithm, string? encryptionAlgorithmProvider)
        {
            if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
            {
                __OpeningCNGAlgorithmFromProviderWithChainingModeCBCCallback(logger, encryptionAlgorithm, encryptionAlgorithmProvider, 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.Guid, string, global::System.Exception?> __PerformingUnprotectOperationToKeyWithPurposesCallback =
            global::Microsoft.Extensions.Logging.LoggerMessage.Define<global::System.Guid, string>(global::Microsoft.Extensions.Logging.LogLevel.Trace, new global::Microsoft.Extensions.Logging.EventId(5, "PerformingUnprotectOperationToKeyWithPurposes"), "Performing unprotect operation to key {KeyId:B} with purposes {Purposes}.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
        /// <summary>
        /// <para><b>Message:</b> Performing unprotect operation to key {KeyId:B} with purposes {Purposes}.</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 PerformingUnprotectOperationToKeyWithPurposes(this global::Microsoft.Extensions.Logging.ILogger logger, global::System.Guid keyId, string purposes)
        {
            if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Trace))
            {
                __PerformingUnprotectOperationToKeyWithPurposesCallback(logger, keyId, purposes, 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.Guid, global::System.Exception?> __KeyWasNotFoundInTheKeyRingUnprotectOperationCannotProceedCallback =
            global::Microsoft.Extensions.Logging.LoggerMessage.Define<global::System.Guid>(global::Microsoft.Extensions.Logging.LogLevel.Trace, new global::Microsoft.Extensions.Logging.EventId(6, "KeyWasNotFoundInTheKeyRingUnprotectOperationCannotProceed"), "Key {KeyId:B} was not found in the key ring. Unprotect operation cannot proceed.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
        /// <summary>
        /// <para><b>Message:</b> Key {KeyId:B} was not found in the key ring. Unprotect operation cannot proceed.</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 KeyWasNotFoundInTheKeyRingUnprotectOperationCannotProceed(this global::Microsoft.Extensions.Logging.ILogger logger, global::System.Guid keyId)
        {
            if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Trace))
            {
                __KeyWasNotFoundInTheKeyRingUnprotectOperationCannotProceedCallback(logger, keyId, 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.Guid, global::System.Exception?> __KeyWasRevokedCallerRequestedUnprotectOperationProceedRegardlessCallback =
            global::Microsoft.Extensions.Logging.LoggerMessage.Define<global::System.Guid>(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(7, "KeyWasRevokedCallerRequestedUnprotectOperationProceedRegardless"), "Key {KeyId:B} was revoked. Caller requested unprotect operation proceed regardless.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
        /// <summary>
        /// <para><b>Message:</b> Key {KeyId:B} was revoked. Caller requested unprotect operation proceed regardless.</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 KeyWasRevokedCallerRequestedUnprotectOperationProceedRegardless(this global::Microsoft.Extensions.Logging.ILogger logger, global::System.Guid keyId)
        {
            if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
            {
                __KeyWasRevokedCallerRequestedUnprotectOperationProceedRegardlessCallback(logger, keyId, 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.Guid, global::System.Exception?> __KeyWasRevokedUnprotectOperationCannotProceedCallback =
            global::Microsoft.Extensions.Logging.LoggerMessage.Define<global::System.Guid>(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(8, "KeyWasRevokedUnprotectOperationCannotProceed"), "Key {KeyId:B} was revoked. Unprotect operation cannot proceed.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
        /// <summary>
        /// <para><b>Message:</b> Key {KeyId:B} was revoked. Unprotect operation cannot proceed.</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 KeyWasRevokedUnprotectOperationCannotProceed(this global::Microsoft.Extensions.Logging.ILogger logger, global::System.Guid keyId)
        {
            if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
            {
                __KeyWasRevokedUnprotectOperationCannotProceedCallback(logger, keyId, 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?> __OpeningCNGAlgorithmFromProviderWithChainingModeGCMCallback =
            global::Microsoft.Extensions.Logging.LoggerMessage.Define<string, string?>(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(9, "OpeningCNGAlgorithmFromProviderWithChainingModeGCM"), "Opening CNG algorithm '{EncryptionAlgorithm}' from provider '{EncryptionAlgorithmProvider}' with chaining mode GCM.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
        /// <summary>
        /// <para><b>Message:</b> Opening CNG algorithm &apos;{EncryptionAlgorithm}&apos; from provider &apos;{EncryptionAlgorithmProvider}&apos; with chaining mode GCM.</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 OpeningCNGAlgorithmFromProviderWithChainingModeGCM(this global::Microsoft.Extensions.Logging.ILogger logger, string encryptionAlgorithm, string? encryptionAlgorithmProvider)
        {
            if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
            {
                __OpeningCNGAlgorithmFromProviderWithChainingModeGCMCallback(logger, encryptionAlgorithm, encryptionAlgorithmProvider, 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?> __UsingManagedKeyedHashAlgorithmCallback =
            global::Microsoft.Extensions.Logging.LoggerMessage.Define<string>(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(10, "UsingManagedKeyedHashAlgorithm"), "Using managed keyed hash algorithm '{FullName}'.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
        /// <summary>
        /// <para><b>Message:</b> Using managed keyed hash algorithm &apos;{FullName}&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 UsingManagedKeyedHashAlgorithm(this global::Microsoft.Extensions.Logging.ILogger logger, string fullName)
        {
            if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
            {
                __UsingManagedKeyedHashAlgorithmCallback(logger, fullName, 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?> __UsingManagedSymmetricAlgorithmCallback =
            global::Microsoft.Extensions.Logging.LoggerMessage.Define<string>(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(11, "UsingManagedSymmetricAlgorithm"), "Using managed symmetric algorithm '{FullName}'.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
        /// <summary>
        /// <para><b>Message:</b> Using managed symmetric algorithm &apos;{FullName}&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 UsingManagedSymmetricAlgorithm(this global::Microsoft.Extensions.Logging.ILogger logger, string fullName)
        {
            if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
            {
                __UsingManagedSymmetricAlgorithmCallback(logger, fullName, 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.Guid, string, global::System.Exception?> __KeyIsIneligibleToBeTheDefaultKeyBecauseItsMethodFailedCallback =
            global::Microsoft.Extensions.Logging.LoggerMessage.Define<global::System.Guid, string>(global::Microsoft.Extensions.Logging.LogLevel.Warning, new global::Microsoft.Extensions.Logging.EventId(12, "KeyIsIneligibleToBeTheDefaultKeyBecauseItsMethodFailed"), "Key {KeyId:B} is ineligible to be the default key because its {MethodName} method failed after the maximum number of retries.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
        /// <summary>
        /// <para><b>Message:</b> Key {KeyId:B} is ineligible to be the default key because its {MethodName} method failed after the maximum number of retries.</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 KeyIsIneligibleToBeTheDefaultKeyBecauseItsMethodFailed(this global::Microsoft.Extensions.Logging.ILogger logger, global::System.Guid keyId, string methodName, global::System.Exception exception)
        {
            if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Warning))
            {
                __KeyIsIneligibleToBeTheDefaultKeyBecauseItsMethodFailedCallback(logger, keyId, 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.Guid, global::System.DateTimeOffset, global::System.Exception?> __ConsideringKeyWithExpirationDateAsDefaultKeyCallback =
            global::Microsoft.Extensions.Logging.LoggerMessage.Define<global::System.Guid, global::System.DateTimeOffset>(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(13, "ConsideringKeyWithExpirationDateAsDefaultKey"), "Considering key {KeyId:B} with expiration date {ExpirationDate:u} as default key.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
        /// <summary>
        /// <para><b>Message:</b> Considering key {KeyId:B} with expiration date {ExpirationDate:u} as default key.</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 ConsideringKeyWithExpirationDateAsDefaultKey(this global::Microsoft.Extensions.Logging.ILogger logger, global::System.Guid keyId, global::System.DateTimeOffset expirationDate)
        {
            if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
            {
                __ConsideringKeyWithExpirationDateAsDefaultKeyCallback(logger, keyId, expirationDate, 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.Guid, global::System.Exception?> __KeyIsNoLongerUnderConsiderationAsDefaultCallback =
            global::Microsoft.Extensions.Logging.LoggerMessage.Define<global::System.Guid>(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(14, "KeyIsNoLongerUnderConsiderationAsDefault"), "Key {KeyId:B} is no longer under consideration as default key because it is expired, revoked, or cannot be deciphered.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
        /// <summary>
        /// <para><b>Message:</b> Key {KeyId:B} is no longer under consideration as default key because it is expired, revoked, or cannot be deciphered.</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 KeyIsNoLongerUnderConsiderationAsDefault(this global::Microsoft.Extensions.Logging.ILogger logger, global::System.Guid keyId)
        {
            if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
            {
                __KeyIsNoLongerUnderConsiderationAsDefaultCallback(logger, keyId, 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.Xml.Linq.XName, global::System.Exception?> __UnknownElementWithNameFoundInKeyringSkippingCallback =
            global::Microsoft.Extensions.Logging.LoggerMessage.Define<global::System.Xml.Linq.XName>(global::Microsoft.Extensions.Logging.LogLevel.Warning, new global::Microsoft.Extensions.Logging.EventId(15, "UnknownElementWithNameFoundInKeyringSkipping"), "Unknown element with name '{Name}' found in keyring, skipping.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
        /// <summary>
        /// <para><b>Message:</b> Unknown element with name &apos;{Name}&apos; found in keyring, skipping.</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 UnknownElementWithNameFoundInKeyringSkipping(this global::Microsoft.Extensions.Logging.ILogger logger, global::System.Xml.Linq.XName name)
        {
            if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Warning))
            {
                __UnknownElementWithNameFoundInKeyringSkippingCallback(logger, name, 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.Guid, global::System.Exception?> __MarkedKeyAsRevokedInTheKeyringCallback =
            global::Microsoft.Extensions.Logging.LoggerMessage.Define<global::System.Guid>(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(16, "MarkedKeyAsRevokedInTheKeyring"), "Marked key {KeyId:B} as revoked in the keyring.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
        /// <summary>
        /// <para><b>Message:</b> Marked key {KeyId:B} as revoked in the keyring.</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 MarkedKeyAsRevokedInTheKeyring(this global::Microsoft.Extensions.Logging.ILogger logger, global::System.Guid keyId)
        {
            if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
            {
                __MarkedKeyAsRevokedInTheKeyringCallback(logger, keyId, 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.Guid, global::System.Exception?> __TriedToProcessRevocationOfKeyButNoSuchKeyWasFoundCallback =
            global::Microsoft.Extensions.Logging.LoggerMessage.Define<global::System.Guid>(global::Microsoft.Extensions.Logging.LogLevel.Warning, new global::Microsoft.Extensions.Logging.EventId(17, "TriedToProcessRevocationOfKeyButNoSuchKeyWasFound"), "Tried to process revocation of key {KeyId:B}, but no such key was found in keyring. Skipping.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
        /// <summary>
        /// <para><b>Message:</b> Tried to process revocation of key {KeyId:B}, but no such key was found in keyring. Skipping.</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 TriedToProcessRevocationOfKeyButNoSuchKeyWasFound(this global::Microsoft.Extensions.Logging.ILogger logger, global::System.Guid keyId)
        {
            if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Warning))
            {
                __TriedToProcessRevocationOfKeyButNoSuchKeyWasFoundCallback(logger, keyId, 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.Guid, global::System.Exception?> __FoundKeyCallback =
            global::Microsoft.Extensions.Logging.LoggerMessage.Define<global::System.Guid>(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(18, "FoundKey"), "Found key {KeyId:B}.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
        /// <summary>
        /// <para><b>Message:</b> Found key {KeyId:B}.</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 FoundKey(this global::Microsoft.Extensions.Logging.ILogger logger, global::System.Guid keyId)
        {
            if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
            {
                __FoundKeyCallback(logger, keyId, 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.DateTimeOffset, global::System.Exception?> __FoundRevocationOfAllKeysCreatedPriorToCallback =
            global::Microsoft.Extensions.Logging.LoggerMessage.Define<global::System.DateTimeOffset>(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(19, "FoundRevocationOfAllKeysCreatedPriorTo"), "Found revocation of all keys created prior to {RevocationDate:u}.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
        /// <summary>
        /// <para><b>Message:</b> Found revocation of all keys created prior to {RevocationDate:u}.</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 FoundRevocationOfAllKeysCreatedPriorTo(this global::Microsoft.Extensions.Logging.ILogger logger, global::System.DateTimeOffset revocationDate)
        {
            if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
            {
                __FoundRevocationOfAllKeysCreatedPriorToCallback(logger, revocationDate, 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.Guid, global::System.Exception?> __FoundRevocationOfKeyCallback =
            global::Microsoft.Extensions.Logging.LoggerMessage.Define<global::System.Guid>(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(20, "FoundRevocationOfKey"), "Found revocation of key {KeyId:B}.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
        /// <summary>
        /// <para><b>Message:</b> Found revocation of key {KeyId:B}.</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 FoundRevocationOfKey(this global::Microsoft.Extensions.Logging.ILogger logger, global::System.Guid keyId)
        {
            if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
            {
                __FoundRevocationOfKeyCallback(logger, keyId, 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.Xml.Linq.XElement, global::System.Exception?> __ExceptionWhileProcessingRevocationElementCallback =
            global::Microsoft.Extensions.Logging.LoggerMessage.Define<global::System.Xml.Linq.XElement>(global::Microsoft.Extensions.Logging.LogLevel.Error, new global::Microsoft.Extensions.Logging.EventId(21, "ExceptionWhileProcessingRevocationElement"), "An exception occurred while processing the revocation element '{RevocationElement}'. Cannot continue keyring processing.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
        /// <summary>
        /// <para><b>Message:</b> An exception occurred while processing the revocation element &apos;{RevocationElement}&apos;. Cannot continue keyring processing.</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 ExceptionWhileProcessingRevocationElement(this global::Microsoft.Extensions.Logging.ILogger logger, global::System.Xml.Linq.XElement revocationElement, global::System.Exception exception)
        {
            if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Error))
            {
                __ExceptionWhileProcessingRevocationElementCallback(logger, revocationElement, 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.DateTimeOffset, string?, global::System.Exception?> __RevokingAllKeysAsOfForReasonCallback =
            global::Microsoft.Extensions.Logging.LoggerMessage.Define<global::System.DateTimeOffset, string?>(global::Microsoft.Extensions.Logging.LogLevel.Information, new global::Microsoft.Extensions.Logging.EventId(22, "RevokingAllKeysAsOfForReason"), "Revoking all keys as of {RevocationDate:u} for reason '{Reason}'.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
        /// <summary>
        /// <para><b>Message:</b> Revoking all keys as of {RevocationDate:u} for reason &apos;{Reason}&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 RevokingAllKeysAsOfForReason(this global::Microsoft.Extensions.Logging.ILogger logger, global::System.DateTimeOffset revocationDate, string? reason)
        {
            if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Information))
            {
                __RevokingAllKeysAsOfForReasonCallback(logger, revocationDate, reason, 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?> __KeyCacheExpirationTokenTriggeredByOperationCallback =
            global::Microsoft.Extensions.Logging.LoggerMessage.Define<string>(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(23, "KeyCacheExpirationTokenTriggeredByOperation"), "Key cache expiration token triggered by '{OperationName}' operation.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
        /// <summary>
        /// <para><b>Message:</b> Key cache expiration token triggered by &apos;{OperationName}&apos; operation.</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 KeyCacheExpirationTokenTriggeredByOperation(this global::Microsoft.Extensions.Logging.ILogger logger, string operationName)
        {
            if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
            {
                __KeyCacheExpirationTokenTriggeredByOperationCallback(logger, operationName, 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.Xml.Linq.XElement, global::System.Exception?> __ExceptionWhileProcessingKeyElementCallback =
            global::Microsoft.Extensions.Logging.LoggerMessage.Define<global::System.Xml.Linq.XElement>(global::Microsoft.Extensions.Logging.LogLevel.Error, new global::Microsoft.Extensions.Logging.EventId(24, "ExceptionOccurredWhileProcessingTheKeyElement"), "An exception occurred while processing the key element '{Element}'.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
        /// <summary>
        /// <para><b>Message:</b> An exception occurred while processing the key element &apos;{Element}&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 ExceptionWhileProcessingKeyElement(this global::Microsoft.Extensions.Logging.ILogger logger, global::System.Xml.Linq.XElement element, global::System.Exception exception)
        {
            if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Error))
            {
                __ExceptionWhileProcessingKeyElementCallback(logger, element, 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.Xml.Linq.XElement, global::System.Exception?> __AnExceptionOccurredWhileProcessingElementDebugCallback =
            global::Microsoft.Extensions.Logging.LoggerMessage.Define<global::System.Xml.Linq.XElement>(global::Microsoft.Extensions.Logging.LogLevel.Trace, new global::Microsoft.Extensions.Logging.EventId(25, "ExceptionOccurredWhileProcessingTheKeyElementDebug"), "An exception occurred while processing the key element '{Element}'.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
        /// <summary>
        /// <para><b>Message:</b> An exception occurred while processing the key element &apos;{Element}&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 AnExceptionOccurredWhileProcessingElementDebug(this global::Microsoft.Extensions.Logging.ILogger logger, global::System.Xml.Linq.XElement element, global::System.Exception exception)
        {
            if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Trace))
            {
                __AnExceptionOccurredWhileProcessingElementDebugCallback(logger, element, 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?> __EncryptingToWindowsDPAPIForCurrentUserAccountCallback =
            global::Microsoft.Extensions.Logging.LoggerMessage.Define<string>(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(26, "EncryptingToWindowsDPAPIForCurrentUserAccount"), "Encrypting to Windows DPAPI for current user account ({Name}).", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
        /// <summary>
        /// <para><b>Message:</b> Encrypting to Windows DPAPI for current user account ({Name}).</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 EncryptingToWindowsDPAPIForCurrentUserAccount(this global::Microsoft.Extensions.Logging.ILogger logger, string name)
        {
            if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
            {
                __EncryptingToWindowsDPAPIForCurrentUserAccountCallback(logger, name, 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?> __AnErrorOccurredWhileEncryptingToX509CertificateWithThumbprintCallback =
            global::Microsoft.Extensions.Logging.LoggerMessage.Define<string>(global::Microsoft.Extensions.Logging.LogLevel.Error, new global::Microsoft.Extensions.Logging.EventId(28, "ErrorOccurredWhileEncryptingToX509CertificateWithThumbprint"), "An error occurred while encrypting to X.509 certificate with thumbprint '{Thumbprint}'.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
        /// <summary>
        /// <para><b>Message:</b> An error occurred while encrypting to X.509 certificate with thumbprint &apos;{Thumbprint}&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 AnErrorOccurredWhileEncryptingToX509CertificateWithThumbprint(this global::Microsoft.Extensions.Logging.ILogger logger, string thumbprint, global::System.Exception exception)
        {
            if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Error))
            {
                __AnErrorOccurredWhileEncryptingToX509CertificateWithThumbprintCallback(logger, thumbprint, 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?> __EncryptingToX509CertificateWithThumbprintCallback =
            global::Microsoft.Extensions.Logging.LoggerMessage.Define<string>(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(29, "EncryptingToX509CertificateWithThumbprint"), "Encrypting to X.509 certificate with thumbprint '{Thumbprint}'.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
        /// <summary>
        /// <para><b>Message:</b> Encrypting to X.509 certificate with thumbprint &apos;{Thumbprint}&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 EncryptingToX509CertificateWithThumbprint(this global::Microsoft.Extensions.Logging.ILogger logger, string thumbprint)
        {
            if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
            {
                __EncryptingToX509CertificateWithThumbprintCallback(logger, thumbprint, 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?> __ExceptionWhileTryingToResolveCertificateWithThumbprintCallback =
            global::Microsoft.Extensions.Logging.LoggerMessage.Define<string>(global::Microsoft.Extensions.Logging.LogLevel.Error, new global::Microsoft.Extensions.Logging.EventId(30, "ExceptionOccurredWhileTryingToResolveCertificateWithThumbprint"), "An exception occurred while trying to resolve certificate with thumbprint '{Thumbprint}'.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
        /// <summary>
        /// <para><b>Message:</b> An exception occurred while trying to resolve certificate with thumbprint &apos;{Thumbprint}&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 ExceptionWhileTryingToResolveCertificateWithThumbprint(this global::Microsoft.Extensions.Logging.ILogger logger, string thumbprint, global::System.Exception exception)
        {
            if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Error))
            {
                __ExceptionWhileTryingToResolveCertificateWithThumbprintCallback(logger, thumbprint, 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.Guid, string, global::System.Exception?> __PerformingProtectOperationToKeyWithPurposesCallback =
            global::Microsoft.Extensions.Logging.LoggerMessage.Define<global::System.Guid, string>(global::Microsoft.Extensions.Logging.LogLevel.Trace, new global::Microsoft.Extensions.Logging.EventId(31, "PerformingProtectOperationToKeyWithPurposes"), "Performing protect operation to key {KeyId:B} with purposes {Purposes}.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
        /// <summary>
        /// <para><b>Message:</b> Performing protect operation to key {KeyId:B} with purposes {Purposes}.</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 PerformingProtectOperationToKeyWithPurposes(this global::Microsoft.Extensions.Logging.ILogger logger, global::System.Guid keyId, string purposes)
        {
            if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Trace))
            {
                __PerformingProtectOperationToKeyWithPurposesCallback(logger, keyId, purposes, 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.Guid, string, global::System.Exception?> __DescriptorDeserializerTypeForKeyIsCallback =
            global::Microsoft.Extensions.Logging.LoggerMessage.Define<global::System.Guid, string>(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(32, "DescriptorDeserializerTypeForKeyIs"), "Descriptor deserializer type for key {KeyId:B} is '{AssemblyQualifiedName}'.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
        /// <summary>
        /// <para><b>Message:</b> Descriptor deserializer type for key {KeyId:B} is &apos;{AssemblyQualifiedName}&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 DescriptorDeserializerTypeForKeyIs(this global::Microsoft.Extensions.Logging.ILogger logger, global::System.Guid keyId, string assemblyQualifiedName)
        {
            if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
            {
                __DescriptorDeserializerTypeForKeyIsCallback(logger, keyId, assemblyQualifiedName, 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.Guid, global::System.Exception?> __KeyEscrowSinkFoundWritingKeyToEscrowCallback =
            global::Microsoft.Extensions.Logging.LoggerMessage.Define<global::System.Guid>(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(33, "KeyEscrowSinkFoundWritingKeyToEscrow"), "Key escrow sink found. Writing key {KeyId:B} to escrow.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
        /// <summary>
        /// <para><b>Message:</b> Key escrow sink found. Writing key {KeyId:B} to escrow.</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 KeyEscrowSinkFoundWritingKeyToEscrow(this global::Microsoft.Extensions.Logging.ILogger logger, global::System.Guid keyId)
        {
            if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
            {
                __KeyEscrowSinkFoundWritingKeyToEscrowCallback(logger, keyId, 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.Guid, global::System.Exception?> __NoKeyEscrowSinkFoundNotWritingKeyToEscrowCallback =
            global::Microsoft.Extensions.Logging.LoggerMessage.Define<global::System.Guid>(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(34, "NoKeyEscrowSinkFoundNotWritingKeyToEscrow"), "No key escrow sink found. Not writing key {KeyId:B} to escrow.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
        /// <summary>
        /// <para><b>Message:</b> No key escrow sink found. Not writing key {KeyId:B} to escrow.</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 NoKeyEscrowSinkFoundNotWritingKeyToEscrow(this global::Microsoft.Extensions.Logging.ILogger logger, global::System.Guid keyId)
        {
            if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
            {
                __NoKeyEscrowSinkFoundNotWritingKeyToEscrowCallback(logger, keyId, 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.Guid, global::System.Exception?> __NoXMLEncryptorConfiguredKeyMayBePersistedToStorageInUnencryptedFormCallback =
            global::Microsoft.Extensions.Logging.LoggerMessage.Define<global::System.Guid>(global::Microsoft.Extensions.Logging.LogLevel.Warning, new global::Microsoft.Extensions.Logging.EventId(35, "NoXMLEncryptorConfiguredKeyMayBePersistedToStorageInUnencryptedForm"), "No XML encryptor configured. Key {KeyId:B} may be persisted to storage in unencrypted form.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
        /// <summary>
        /// <para><b>Message:</b> No XML encryptor configured. Key {KeyId:B} may be persisted to storage in unencrypted form.</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 NoXMLEncryptorConfiguredKeyMayBePersistedToStorageInUnencryptedForm(this global::Microsoft.Extensions.Logging.ILogger logger, global::System.Guid keyId)
        {
            if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Warning))
            {
                __NoXMLEncryptorConfiguredKeyMayBePersistedToStorageInUnencryptedFormCallback(logger, keyId, 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.Guid, global::System.DateTimeOffset, string?, global::System.Exception?> __RevokingKeyForReasonCallback =
            global::Microsoft.Extensions.Logging.LoggerMessage.Define<global::System.Guid, global::System.DateTimeOffset, string?>(global::Microsoft.Extensions.Logging.LogLevel.Information, new global::Microsoft.Extensions.Logging.EventId(36, "RevokingKeyForReason"), "Revoking key {KeyId:B} at {RevocationDate:u} for reason '{Reason}'.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
        /// <summary>
        /// <para><b>Message:</b> Revoking key {KeyId:B} at {RevocationDate:u} for reason &apos;{Reason}&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 RevokingKeyForReason(this global::Microsoft.Extensions.Logging.ILogger logger, global::System.Guid keyId, global::System.DateTimeOffset revocationDate, string? reason)
        {
            if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Information))
            {
                __RevokingKeyForReasonCallback(logger, keyId, revocationDate, reason, 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?> __ReadingDataFromFileCallback =
            global::Microsoft.Extensions.Logging.LoggerMessage.Define<string>(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(37, "ReadingDataFromFile"), "Reading data from file '{FullPath}'.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
        /// <summary>
        /// <para><b>Message:</b> Reading data from file &apos;{FullPath}&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 ReadingDataFromFile(this global::Microsoft.Extensions.Logging.ILogger logger, string fullPath)
        {
            if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
            {
                __ReadingDataFromFileCallback(logger, fullPath, 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?> __NameIsNotSafeFileNameCallback =
            global::Microsoft.Extensions.Logging.LoggerMessage.Define<string, string>(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(38, "NameIsNotSafeFileName"), "The name '{FriendlyName}' is not a safe file name, using '{NewFriendlyName}' instead.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
        /// <summary>
        /// <para><b>Message:</b> The name &apos;{FriendlyName}&apos; is not a safe file name, using &apos;{NewFriendlyName}&apos; instead.</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 NameIsNotSafeFileName(this global::Microsoft.Extensions.Logging.ILogger logger, string friendlyName, string newFriendlyName)
        {
            if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
            {
                __NameIsNotSafeFileNameCallback(logger, friendlyName, newFriendlyName, 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?> __WritingDataToFileCallback =
            global::Microsoft.Extensions.Logging.LoggerMessage.Define<string>(global::Microsoft.Extensions.Logging.LogLevel.Information, new global::Microsoft.Extensions.Logging.EventId(39, "WritingDataToFile"), "Writing data to file '{FileName}'.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
        /// <summary>
        /// <para><b>Message:</b> Writing data to file &apos;{FileName}&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 WritingDataToFile(this global::Microsoft.Extensions.Logging.ILogger logger, string fileName)
        {
            if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Information))
            {
                __WritingDataToFileCallback(logger, fileName, 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.Win32.RegistryKey, string, global::System.Exception?> __ReadingDataFromRegistryKeyValueCallback =
            global::Microsoft.Extensions.Logging.LoggerMessage.Define<global::Microsoft.Win32.RegistryKey, string>(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(40, "ReadingDataFromRegistryKeyValue"), "Reading data from registry key '{RegistryKeyName}', value '{Value}'.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
        /// <summary>
        /// <para><b>Message:</b> Reading data from registry key &apos;{RegistryKeyName}&apos;, value &apos;{Value}&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 ReadingDataFromRegistryKeyValue(this global::Microsoft.Extensions.Logging.ILogger logger, global::Microsoft.Win32.RegistryKey registryKeyName, string value)
        {
            if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
            {
                __ReadingDataFromRegistryKeyValueCallback(logger, registryKeyName, value, 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?> __NameIsNotSafeRegistryValueNameCallback =
            global::Microsoft.Extensions.Logging.LoggerMessage.Define<string, string>(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(41, "NameIsNotSafeRegistryValueName"), "The name '{FriendlyName}' is not a safe registry value name, using '{NewFriendlyName}' instead.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
        /// <summary>
        /// <para><b>Message:</b> The name &apos;{FriendlyName}&apos; is not a safe registry value name, using &apos;{NewFriendlyName}&apos; instead.</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 NameIsNotSafeRegistryValueName(this global::Microsoft.Extensions.Logging.ILogger logger, string friendlyName, string newFriendlyName)
        {
            if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
            {
                __NameIsNotSafeRegistryValueNameCallback(logger, friendlyName, newFriendlyName, 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?> __DecryptingSecretElementUsingWindowsDPAPINGCallback =
            global::Microsoft.Extensions.Logging.LoggerMessage.Define<string?>(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(42, "DecryptingSecretElementUsingWindowsDPAPING"), "Decrypting secret element using Windows DPAPI-NG with protection descriptor rule '{DescriptorRule}'.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
        /// <summary>
        /// <para><b>Message:</b> Decrypting secret element using Windows DPAPI-NG with protection descriptor rule &apos;{DescriptorRule}&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 DecryptingSecretElementUsingWindowsDPAPING(this global::Microsoft.Extensions.Logging.ILogger logger, string? descriptorRule)
        {
            if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
            {
                __DecryptingSecretElementUsingWindowsDPAPINGCallback(logger, descriptorRule, 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?> __EncryptingToWindowsDPAPINGUsingProtectionDescriptorRuleCallback =
            global::Microsoft.Extensions.Logging.LoggerMessage.Define<string>(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(27, "EncryptingToWindowsDPAPINGUsingProtectionDescriptorRule"), "Encrypting to Windows DPAPI-NG using protection descriptor rule '{DescriptorRule}'.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
        /// <summary>
        /// <para><b>Message:</b> Encrypting to Windows DPAPI-NG using protection descriptor rule &apos;{DescriptorRule}&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 EncryptingToWindowsDPAPINGUsingProtectionDescriptorRule(this global::Microsoft.Extensions.Logging.ILogger logger, string descriptorRule)
        {
            if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
            {
                __EncryptingToWindowsDPAPINGUsingProtectionDescriptorRuleCallback(logger, descriptorRule, 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?> __ExceptionOccurredTryingToDecryptElementCallback =
            global::Microsoft.Extensions.Logging.LoggerMessage.Define(global::Microsoft.Extensions.Logging.LogLevel.Error, new global::Microsoft.Extensions.Logging.EventId(43, "ExceptionOccurredTryingToDecryptElement"), "An exception occurred while trying to decrypt the element.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
        /// <summary>
        /// <para><b>Message:</b> An exception occurred while trying to decrypt the element.</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 ExceptionOccurredTryingToDecryptElement(this global::Microsoft.Extensions.Logging.ILogger logger, global::System.Exception exception)
        {
            if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Error))
            {
                __ExceptionOccurredTryingToDecryptElementCallback(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?> __EncryptingUsingNullEncryptorCallback =
            global::Microsoft.Extensions.Logging.LoggerMessage.Define(global::Microsoft.Extensions.Logging.LogLevel.Warning, new global::Microsoft.Extensions.Logging.EventId(44, "EncryptingUsingNullEncryptor"), "Encrypting using a null encryptor; secret information isn't being protected.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
        /// <summary>
        /// <para><b>Message:</b> Encrypting using a null encryptor; secret information isn&apos;t being protected.</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 EncryptingUsingNullEncryptor(this global::Microsoft.Extensions.Logging.ILogger logger)
        {
            if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Warning))
            {
                __EncryptingUsingNullEncryptorCallback(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?> __UsingEphemeralDataProtectionProviderCallback =
            global::Microsoft.Extensions.Logging.LoggerMessage.Define(global::Microsoft.Extensions.Logging.LogLevel.Information, new global::Microsoft.Extensions.Logging.EventId(45, "UsingEphemeralDataProtectionProvider"), "Using ephemeral data protection provider. Payloads will be undecipherable upon application shutdown.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
        /// <summary>
        /// <para><b>Message:</b> Using ephemeral data protection provider. Payloads will be undecipherable upon application shutdown.</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 UsingEphemeralDataProtectionProvider(this global::Microsoft.Extensions.Logging.ILogger logger)
        {
            if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Information))
            {
                __UsingEphemeralDataProtectionProviderCallback(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?> __ExistingCachedKeyRingIsExpiredCallback =
            global::Microsoft.Extensions.Logging.LoggerMessage.Define(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(46, "ExistingCachedKeyRingIsExpiredRefreshing"), "Existing cached key ring is expired. Refreshing.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
        /// <summary>
        /// <para><b>Message:</b> Existing cached key ring is expired. Refreshing.</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 ExistingCachedKeyRingIsExpired(this global::Microsoft.Extensions.Logging.ILogger logger)
        {
            if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
            {
                __ExistingCachedKeyRingIsExpiredCallback(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?> __ErrorOccurredWhileRefreshingKeyRingCallback =
            global::Microsoft.Extensions.Logging.LoggerMessage.Define(global::Microsoft.Extensions.Logging.LogLevel.Error, new global::Microsoft.Extensions.Logging.EventId(47, "ErrorOccurredWhileRefreshingKeyRing"), "An error occurred while refreshing the key ring. Will try again in 2 minutes.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
        /// <summary>
        /// <para><b>Message:</b> An error occurred while refreshing the key ring. Will try again in 2 minutes.</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 ErrorOccurredWhileRefreshingKeyRing(this global::Microsoft.Extensions.Logging.ILogger logger, global::System.Exception exception)
        {
            if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Error))
            {
                __ErrorOccurredWhileRefreshingKeyRingCallback(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?> __ErrorOccurredWhileReadingKeyRingCallback =
            global::Microsoft.Extensions.Logging.LoggerMessage.Define(global::Microsoft.Extensions.Logging.LogLevel.Error, new global::Microsoft.Extensions.Logging.EventId(48, "ErrorOccurredWhileReadingKeyRing"), "An error occurred while reading the key ring.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
        /// <summary>
        /// <para><b>Message:</b> An error occurred while reading the key ring.</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 ErrorOccurredWhileReadingKeyRing(this global::Microsoft.Extensions.Logging.ILogger logger, global::System.Exception exception)
        {
            if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Error))
            {
                __ErrorOccurredWhileReadingKeyRingCallback(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?> __KeyRingDoesNotContainValidDefaultKeyCallback =
            global::Microsoft.Extensions.Logging.LoggerMessage.Define(global::Microsoft.Extensions.Logging.LogLevel.Error, new global::Microsoft.Extensions.Logging.EventId(49, "KeyRingDoesNotContainValidDefaultKey"), "The key ring does not contain a valid default protection key. The data protection system cannot create a new key because auto-generation of keys is disabled. For more information go to http://aka.ms/dataprotectionwarning", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
        /// <summary>
        /// <para><b>Message:</b> The key ring does not contain a valid default protection key. The data protection system cannot create a new key because auto-generation of keys is disabled. For more information go to http://aka.ms/dataprotectionwarning</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 KeyRingDoesNotContainValidDefaultKey(this global::Microsoft.Extensions.Logging.ILogger logger)
        {
            if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Error))
            {
                __KeyRingDoesNotContainValidDefaultKeyCallback(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?> __UsingInmemoryRepositoryCallback =
            global::Microsoft.Extensions.Logging.LoggerMessage.Define(global::Microsoft.Extensions.Logging.LogLevel.Warning, new global::Microsoft.Extensions.Logging.EventId(50, "UsingInMemoryRepository"), "Using an in-memory repository. Keys will not be persisted to storage.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
        /// <summary>
        /// <para><b>Message:</b> Using an in-memory repository. Keys will not be persisted to storage.</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 UsingInmemoryRepository(this global::Microsoft.Extensions.Logging.ILogger logger)
        {
            if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Warning))
            {
                __UsingInmemoryRepositoryCallback(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?> __DecryptingSecretElementUsingWindowsDPAPICallback =
            global::Microsoft.Extensions.Logging.LoggerMessage.Define(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(51, "DecryptingSecretElementUsingWindowsDPAPI"), "Decrypting secret element using Windows DPAPI.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
        /// <summary>
        /// <para><b>Message:</b> Decrypting secret element using Windows DPAPI.</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 DecryptingSecretElementUsingWindowsDPAPI(this global::Microsoft.Extensions.Logging.ILogger logger)
        {
            if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
            {
                __DecryptingSecretElementUsingWindowsDPAPICallback(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?> __DefaultKeyExpirationImminentAndRepositoryCallback =
            global::Microsoft.Extensions.Logging.LoggerMessage.Define(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(52, "DefaultKeyExpirationImminentAndRepository"), "Default key expiration imminent and repository contains no viable successor. Caller should generate a successor.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
        /// <summary>
        /// <para><b>Message:</b> Default key expiration imminent and repository contains no viable successor. Caller should generate a successor.</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 DefaultKeyExpirationImminentAndRepository(this global::Microsoft.Extensions.Logging.ILogger logger)
        {
            if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
            {
                __DefaultKeyExpirationImminentAndRepositoryCallback(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?> __RepositoryContainsNoViableDefaultKeyCallback =
            global::Microsoft.Extensions.Logging.LoggerMessage.Define(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(53, "RepositoryContainsNoViableDefaultKey"), "Repository contains no viable default key. Caller should generate a key with immediate activation.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
        /// <summary>
        /// <para><b>Message:</b> Repository contains no viable default key. Caller should generate a key with immediate activation.</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 RepositoryContainsNoViableDefaultKey(this global::Microsoft.Extensions.Logging.ILogger logger)
        {
            if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
            {
                __RepositoryContainsNoViableDefaultKeyCallback(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?> __ErrorOccurredWhileEncryptingToWindowsDPAPICallback =
            global::Microsoft.Extensions.Logging.LoggerMessage.Define(global::Microsoft.Extensions.Logging.LogLevel.Error, new global::Microsoft.Extensions.Logging.EventId(54, "ErrorOccurredWhileEncryptingToWindowsDPAPI"), "An error occurred while encrypting to Windows DPAPI.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
        /// <summary>
        /// <para><b>Message:</b> An error occurred while encrypting to Windows DPAPI.</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 ErrorOccurredWhileEncryptingToWindowsDPAPI(this global::Microsoft.Extensions.Logging.ILogger logger, global::System.Exception exception)
        {
            if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Error))
            {
                __ErrorOccurredWhileEncryptingToWindowsDPAPICallback(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?> __EncryptingToWindowsDPAPIForLocalMachineAccountCallback =
            global::Microsoft.Extensions.Logging.LoggerMessage.Define(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(55, "EncryptingToWindowsDPAPIForLocalMachineAccount"), "Encrypting to Windows DPAPI for local machine account.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
        /// <summary>
        /// <para><b>Message:</b> Encrypting to Windows DPAPI for local machine account.</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 EncryptingToWindowsDPAPIForLocalMachineAccount(this global::Microsoft.Extensions.Logging.ILogger logger)
        {
            if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
            {
                __EncryptingToWindowsDPAPIForLocalMachineAccountCallback(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?> __ErrorOccurredWhileEncryptingToWindowsDPAPINGCallback =
            global::Microsoft.Extensions.Logging.LoggerMessage.Define(global::Microsoft.Extensions.Logging.LogLevel.Error, new global::Microsoft.Extensions.Logging.EventId(56, "ErrorOccurredWhileEncryptingToWindowsDPAPING"), "An error occurred while encrypting to Windows DPAPI-NG.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
        /// <summary>
        /// <para><b>Message:</b> An error occurred while encrypting to Windows DPAPI-NG.</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 ErrorOccurredWhileEncryptingToWindowsDPAPING(this global::Microsoft.Extensions.Logging.ILogger logger, global::System.Exception exception)
        {
            if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Error))
            {
                __ErrorOccurredWhileEncryptingToWindowsDPAPINGCallback(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?> __PolicyResolutionStatesThatANewKeyShouldBeAddedToTheKeyRingCallback =
            global::Microsoft.Extensions.Logging.LoggerMessage.Define(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(57, "PolicyResolutionStatesThatANewKeyShouldBeAddedToTheKeyRing"), "Policy resolution states that a new key should be added to the key ring.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
        /// <summary>
        /// <para><b>Message:</b> Policy resolution states that a new key should be added to the key ring.</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 PolicyResolutionStatesThatANewKeyShouldBeAddedToTheKeyRing(this global::Microsoft.Extensions.Logging.ILogger logger)
        {
            if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
            {
                __PolicyResolutionStatesThatANewKeyShouldBeAddedToTheKeyRingCallback(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.Guid, global::System.DateTimeOffset, global::System.DateTimeOffset, global::System.DateTimeOffset, global::System.Exception?> __CreatingKeyCallback =
            global::Microsoft.Extensions.Logging.LoggerMessage.Define<global::System.Guid, global::System.DateTimeOffset, global::System.DateTimeOffset, global::System.DateTimeOffset>(global::Microsoft.Extensions.Logging.LogLevel.Information, new global::Microsoft.Extensions.Logging.EventId(58, "CreatingKey"), "Creating key {KeyId:B} with creation date {CreationDate:u}, activation date {ActivationDate:u}, and expiration date {ExpirationDate:u}.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
        /// <summary>
        /// <para><b>Message:</b> Creating key {KeyId:B} with creation date {CreationDate:u}, activation date {ActivationDate:u}, and expiration date {ExpirationDate:u}.</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 CreatingKey(this global::Microsoft.Extensions.Logging.ILogger logger, global::System.Guid keyId, global::System.DateTimeOffset creationDate, global::System.DateTimeOffset activationDate, global::System.DateTimeOffset expirationDate)
        {
            if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Information))
            {
                __CreatingKeyCallback(logger, keyId, creationDate, activationDate, expirationDate, 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?> __UsingEphemeralKeyRepositoryCallback =
            global::Microsoft.Extensions.Logging.LoggerMessage.Define(global::Microsoft.Extensions.Logging.LogLevel.Warning, new global::Microsoft.Extensions.Logging.EventId(59, "UsingEphemeralKeyRepository"), "Neither user profile nor HKLM registry available. Using an ephemeral key repository. Protected data will be unavailable when application exits.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
        /// <summary>
        /// <para><b>Message:</b> Neither user profile nor HKLM registry available. Using an ephemeral key repository. Protected data will be unavailable when application exits.</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 UsingEphemeralKeyRepository(this global::Microsoft.Extensions.Logging.ILogger logger)
        {
            if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Warning))
            {
                __UsingEphemeralKeyRepositoryCallback(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?> __UsingRegistryAsKeyRepositoryWithDPAPICallback =
            global::Microsoft.Extensions.Logging.LoggerMessage.Define<string>(global::Microsoft.Extensions.Logging.LogLevel.Information, new global::Microsoft.Extensions.Logging.EventId(61, "UsingRegistryAsKeyRepositoryWithDPAPI"), "User profile not available. Using '{Name}' as key repository and Windows DPAPI to encrypt keys at rest.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
        /// <summary>
        /// <para><b>Message:</b> User profile not available. Using &apos;{Name}&apos; as key repository and Windows DPAPI to encrypt keys at rest.</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 UsingRegistryAsKeyRepositoryWithDPAPI(this global::Microsoft.Extensions.Logging.ILogger logger, string name)
        {
            if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Information))
            {
                __UsingRegistryAsKeyRepositoryWithDPAPICallback(logger, name, 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?> __UsingProfileAsKeyRepositoryCallback =
            global::Microsoft.Extensions.Logging.LoggerMessage.Define<string>(global::Microsoft.Extensions.Logging.LogLevel.Information, new global::Microsoft.Extensions.Logging.EventId(62, "UsingProfileAsKeyRepository"), "User profile is available. Using '{FullName}' as key repository; keys will not be encrypted at rest.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
        /// <summary>
        /// <para><b>Message:</b> User profile is available. Using &apos;{FullName}&apos; as key repository; keys will not be encrypted at rest.</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 UsingProfileAsKeyRepository(this global::Microsoft.Extensions.Logging.ILogger logger, string fullName)
        {
            if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Information))
            {
                __UsingProfileAsKeyRepositoryCallback(logger, fullName, 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?> __UsingProfileAsKeyRepositoryWithDPAPICallback =
            global::Microsoft.Extensions.Logging.LoggerMessage.Define<string>(global::Microsoft.Extensions.Logging.LogLevel.Information, new global::Microsoft.Extensions.Logging.EventId(63, "UsingProfileAsKeyRepositoryWithDPAPI"), "User profile is available. Using '{FullName}' as key repository and Windows DPAPI to encrypt keys at rest.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
        /// <summary>
        /// <para><b>Message:</b> User profile is available. Using &apos;{FullName}&apos; as key repository and Windows DPAPI to encrypt keys at rest.</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 UsingProfileAsKeyRepositoryWithDPAPI(this global::Microsoft.Extensions.Logging.ILogger logger, string fullName)
        {
            if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Information))
            {
                __UsingProfileAsKeyRepositoryWithDPAPICallback(logger, fullName, 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?> __UsingAzureAsKeyRepositoryCallback =
            global::Microsoft.Extensions.Logging.LoggerMessage.Define<string>(global::Microsoft.Extensions.Logging.LogLevel.Information, new global::Microsoft.Extensions.Logging.EventId(64, "UsingAzureAsKeyRepository"), "Azure Web Sites environment detected. Using '{FullName}' as key repository; keys will not be encrypted at rest.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
        /// <summary>
        /// <para><b>Message:</b> Azure Web Sites environment detected. Using &apos;{FullName}&apos; as key repository; keys will not be encrypted at rest.</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 UsingAzureAsKeyRepository(this global::Microsoft.Extensions.Logging.ILogger logger, string fullName)
        {
            if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Information))
            {
                __UsingAzureAsKeyRepositoryCallback(logger, fullName, 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.Guid, global::System.Exception?> __KeyRingWasLoadedOnStartupCallback =
            global::Microsoft.Extensions.Logging.LoggerMessage.Define<global::System.Guid>(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(65, "KeyRingWasLoadedOnStartup"), "Key ring with default key {KeyId:B} was loaded during application startup.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
        /// <summary>
        /// <para><b>Message:</b> Key ring with default key {KeyId:B} was loaded during application startup.</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 KeyRingWasLoadedOnStartup(this global::Microsoft.Extensions.Logging.ILogger logger, global::System.Guid keyId)
        {
            if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
            {
                __KeyRingWasLoadedOnStartupCallback(logger, keyId, 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?> __KeyRingFailedToLoadOnStartupCallback =
            global::Microsoft.Extensions.Logging.LoggerMessage.Define(global::Microsoft.Extensions.Logging.LogLevel.Information, new global::Microsoft.Extensions.Logging.EventId(66, "KeyRingFailedToLoadOnStartup"), "Key ring failed to load during application startup.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
        /// <summary>
        /// <para><b>Message:</b> Key ring failed to load during application startup.</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 KeyRingFailedToLoadOnStartup(this global::Microsoft.Extensions.Logging.ILogger logger, global::System.Exception innerException)
        {
            if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Information))
            {
                __KeyRingFailedToLoadOnStartupCallback(logger, innerException);
            }
        }
        [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?> __UsingEphemeralFileSystemLocationInContainerCallback =
            global::Microsoft.Extensions.Logging.LoggerMessage.Define<string>(global::Microsoft.Extensions.Logging.LogLevel.Warning, new global::Microsoft.Extensions.Logging.EventId(60, "UsingEphemeralFileSystemLocationInContainer"), "Storing keys in a directory '{path}' that may not be persisted outside of the container. Protected data will be unavailable when container is destroyed. For more information go to https://aka.ms/aspnet/dataprotectionwarning", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
        /// <summary>
        /// <para><b>Message:</b> Storing keys in a directory &apos;{path}&apos; that may not be persisted outside of the container. Protected data will be unavailable when container is destroyed. For more information go to https://aka.ms/aspnet/dataprotectionwarning</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 UsingEphemeralFileSystemLocationInContainer(this global::Microsoft.Extensions.Logging.ILogger logger, string path)
        {
            if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Warning))
            {
                __UsingEphemeralFileSystemLocationInContainerCallback(logger, path, 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?> __IgnoringReadOnlyConfigurationForNonDefaultOptionsCallback =
            global::Microsoft.Extensions.Logging.LoggerMessage.Define<string, string?>(global::Microsoft.Extensions.Logging.LogLevel.Trace, new global::Microsoft.Extensions.Logging.EventId(61, "IgnoringReadOnlyConfigurationForNonDefaultOptions"), "Ignoring configuration '{PropertyName}' for options instance '{OptionsName}'", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
        /// <summary>
        /// <para><b>Message:</b> Ignoring configuration &apos;{PropertyName}&apos; for options instance &apos;{OptionsName}&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 IgnoringReadOnlyConfigurationForNonDefaultOptions(this global::Microsoft.Extensions.Logging.ILogger logger, string propertyName, string? optionsName)
        {
            if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Trace))
            {
                __IgnoringReadOnlyConfigurationForNonDefaultOptionsCallback(logger, propertyName, optionsName, 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?> __UsingReadOnlyKeyConfigurationCallback =
            global::Microsoft.Extensions.Logging.LoggerMessage.Define<string>(global::Microsoft.Extensions.Logging.LogLevel.Information, new global::Microsoft.Extensions.Logging.EventId(62, "UsingReadOnlyKeyConfiguration"), "Enabling read-only key access with repository directory '{Path}'", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
        /// <summary>
        /// <para><b>Message:</b> Enabling read-only key access with repository directory &apos;{Path}&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 UsingReadOnlyKeyConfiguration(this global::Microsoft.Extensions.Logging.ILogger logger, string path)
        {
            if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Information))
            {
                __UsingReadOnlyKeyConfigurationCallback(logger, path, 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?> __NotUsingReadOnlyKeyConfigurationBecauseOfRepositoryCallback =
            global::Microsoft.Extensions.Logging.LoggerMessage.Define(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(63, "NotUsingReadOnlyKeyConfigurationBecauseOfRepository"), "Not enabling read-only key access because an XML repository has been specified", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
        /// <summary>
        /// <para><b>Message:</b> Not enabling read-only key access because an XML repository has been specified</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 NotUsingReadOnlyKeyConfigurationBecauseOfRepository(this global::Microsoft.Extensions.Logging.ILogger logger)
        {
            if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
            {
                __NotUsingReadOnlyKeyConfigurationBecauseOfRepositoryCallback(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?> __NotUsingReadOnlyKeyConfigurationBecauseOfEncryptorCallback =
            global::Microsoft.Extensions.Logging.LoggerMessage.Define(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(64, "NotUsingReadOnlyKeyConfigurationBecauseOfEncryptor"), "Not enabling read-only key access because an XML encryptor has been specified", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
        /// <summary>
        /// <para><b>Message:</b> Not enabling read-only key access because an XML encryptor has been specified</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 NotUsingReadOnlyKeyConfigurationBecauseOfEncryptor(this global::Microsoft.Extensions.Logging.ILogger logger)
        {
            if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
            {
                __NotUsingReadOnlyKeyConfigurationBecauseOfEncryptorCallback(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.Guid, global::System.Exception?> __KeyRingDefaultKeyIsRevokedCallback =
            global::Microsoft.Extensions.Logging.LoggerMessage.Define<global::System.Guid>(global::Microsoft.Extensions.Logging.LogLevel.Error, new global::Microsoft.Extensions.Logging.EventId(72, "KeyRingDefaultKeyIsRevoked"), "The key ring's default data protection key {KeyId:B} has been revoked.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
        /// <summary>
        /// <para><b>Message:</b> The key ring&apos;s default data protection key {KeyId:B} has been revoked.</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 KeyRingDefaultKeyIsRevoked(this global::Microsoft.Extensions.Logging.ILogger logger, global::System.Guid keyId)
        {
            if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Error))
            {
                __KeyRingDefaultKeyIsRevokedCallback(logger, keyId, 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.Guid, string, global::System.Exception?> __RetryingMethodOfKeyAfterFailureCallback =
            global::Microsoft.Extensions.Logging.LoggerMessage.Define<global::System.Guid, string>(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(73, "RetryingMethodOfKeyAfterFailure"), "Key {KeyId:B} method {MethodName} failed. Retrying.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
        /// <summary>
        /// <para><b>Message:</b> Key {KeyId:B} method {MethodName} failed. Retrying.</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 RetryingMethodOfKeyAfterFailure(this global::Microsoft.Extensions.Logging.ILogger logger, global::System.Guid keyId, string methodName, global::System.Exception exception)
        {
            if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
            {
                __RetryingMethodOfKeyAfterFailureCallback(logger, keyId, 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, string, global::System.Exception?> __DeletingFileCallback =
            global::Microsoft.Extensions.Logging.LoggerMessage.Define<string>(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(74, "DeletingFile"), "Deleting file '{FileName}'.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
        /// <summary>
        /// <para><b>Message:</b> Deleting file &apos;{FileName}&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 DeletingFile(this global::Microsoft.Extensions.Logging.ILogger logger, string fileName)
        {
            if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
            {
                __DeletingFileCallback(logger, fileName, 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?> __FailedToDeleteFileCallback =
            global::Microsoft.Extensions.Logging.LoggerMessage.Define<string>(global::Microsoft.Extensions.Logging.LogLevel.Error, new global::Microsoft.Extensions.Logging.EventId(75, "FailedToDeleteFile"), "Failed to delete file '{FileName}'.  Not attempting further deletions.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
        /// <summary>
        /// <para><b>Message:</b> Failed to delete file &apos;{FileName}&apos;.  Not attempting further deletions.</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 FailedToDeleteFile(this global::Microsoft.Extensions.Logging.ILogger logger, string fileName, global::System.Exception exception)
        {
            if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Error))
            {
                __FailedToDeleteFileCallback(logger, fileName, 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::Microsoft.Win32.RegistryKey, string, global::System.Exception?> __RemovingDataFromRegistryKeyValueCallback =
            global::Microsoft.Extensions.Logging.LoggerMessage.Define<global::Microsoft.Win32.RegistryKey, string>(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(76, "RemovingDataFromRegistryKeyValue"), "Deleting registry key '{RegistryKeyName}', value '{Value}'.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
        /// <summary>
        /// <para><b>Message:</b> Deleting registry key &apos;{RegistryKeyName}&apos;, value &apos;{Value}&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 RemovingDataFromRegistryKeyValue(this global::Microsoft.Extensions.Logging.ILogger logger, global::Microsoft.Win32.RegistryKey registryKeyName, string value)
        {
            if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
            {
                __RemovingDataFromRegistryKeyValueCallback(logger, registryKeyName, value, 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.Win32.RegistryKey, string, global::System.Exception?> __FailedToRemoveDataFromRegistryKeyValueCallback =
            global::Microsoft.Extensions.Logging.LoggerMessage.Define<global::Microsoft.Win32.RegistryKey, string>(global::Microsoft.Extensions.Logging.LogLevel.Error, new global::Microsoft.Extensions.Logging.EventId(77, "FailedToRemoveDataFromRegistryKeyValue"), "Failed to delete registry key '{RegistryKeyName}', value '{ValueName}'.  Not attempting further deletions.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
        /// <summary>
        /// <para><b>Message:</b> Failed to delete registry key &apos;{RegistryKeyName}&apos;, value &apos;{ValueName}&apos;.  Not attempting further deletions.</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 FailedToRemoveDataFromRegistryKeyValue(this global::Microsoft.Extensions.Logging.ILogger logger, global::Microsoft.Win32.RegistryKey registryKeyName, string valueName, global::System.Exception exception)
        {
            if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Error))
            {
                __FailedToRemoveDataFromRegistryKeyValueCallback(logger, registryKeyName, valueName, 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.Guid, global::System.Exception?> __KeyRevokedMultipleTimesCallback =
            global::Microsoft.Extensions.Logging.LoggerMessage.Define<global::System.Guid>(global::Microsoft.Extensions.Logging.LogLevel.Trace, new global::Microsoft.Extensions.Logging.EventId(78, "KeyRevokedMultipleTimes"), "Found multiple revocation entries for key {KeyId:B}.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
        /// <summary>
        /// <para><b>Message:</b> Found multiple revocation entries for key {KeyId:B}.</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 KeyRevokedMultipleTimes(this global::Microsoft.Extensions.Logging.ILogger logger, global::System.Guid keyId)
        {
            if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Trace))
            {
                __KeyRevokedMultipleTimesCallback(logger, keyId, 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.DateTimeOffset, global::System.DateTimeOffset, global::System.Exception?> __DateBasedRevocationSupersededCallback =
            global::Microsoft.Extensions.Logging.LoggerMessage.Define<global::System.DateTimeOffset, global::System.DateTimeOffset>(global::Microsoft.Extensions.Logging.LogLevel.Trace, new global::Microsoft.Extensions.Logging.EventId(79, "DateBasedRevocationSuperseded"), "Ignoring revocation of keys created before {OlderDate:u} in favor of revocation of keys created before {NewerDate:u}.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
        /// <summary>
        /// <para><b>Message:</b> Ignoring revocation of keys created before {OlderDate:u} in favor of revocation of keys created before {NewerDate:u}.</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 DateBasedRevocationSuperseded(this global::Microsoft.Extensions.Logging.ILogger logger, global::System.DateTimeOffset olderDate, global::System.DateTimeOffset newerDate)
        {
            if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Trace))
            {
                __DateBasedRevocationSupersededCallback(logger, olderDate, newerDate, 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.Guid, global::System.Exception?> __DeletingKeyCallback =
            global::Microsoft.Extensions.Logging.LoggerMessage.Define<global::System.Guid>(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(80, "DeletingKey"), "Deleting key {KeyId:B}.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });
 
        /// <summary>
        /// <para><b>Message:</b> Deleting key {KeyId:B}.</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 DeletingKey(this global::Microsoft.Extensions.Logging.ILogger logger, global::System.Guid keyId)
        {
            if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
            {
                __DeletingKeyCallback(logger, keyId, null);
            }
        }
    }
}