@digitaldefiance/ecies-lib 4.4.13 → 4.4.15

package/src/translations/en-US.ts

@@ -1,262 +0,0 @@
-import { EciesStringKey } from '../enumerations';
-import { createPluralString, PluralString } from '@digitaldefiance/i18n-lib';
-
- export const englishTranslations: Record<EciesStringKey, string | PluralString> = {
-    // ECIES Error Types - buildReasonMap(ECIESErrorTypeEnum, 'Error', 'ECIESError')
-    [EciesStringKey.Error_ECIESError_InvalidECIESMultipleEncryptedKeySize]:
-      'Invalid ECIES multiple encrypted key size',
-    [EciesStringKey.Error_ECIESError_InvalidECIESPublicKeyLength]:
-      'Invalid ECIES public key length',
-    [EciesStringKey.Error_ECIESError_InvalidECIESMultipleRecipientCountSize]:
-      'Invalid ECIES multiple recipient count size',
-    [EciesStringKey.Error_ECIESError_InvalidECIESMultipleDataLengthSize]:
-      'Invalid ECIES multiple data length size',
-    [EciesStringKey.Error_ECIESError_InvalidECIESMultipleRecipientIdSize]:
-      'Invalid ECIES multiple recipient ID size',
-    [EciesStringKey.Error_ECIESError_CRCError]: 'CRC error',
-    [EciesStringKey.Error_ECIESError_InvalidEncryptionType]:
-      'Invalid encryption type',
-    [EciesStringKey.Error_ECIESError_InvalidEncryptionTypeTemplate]: 'Invalid encryption type: {encryptionType}',
-    [EciesStringKey.Error_ECIESError_InvalidIVLength]: 'Invalid IV length',
-    [EciesStringKey.Error_ECIESError_InvalidAuthTagLength]:
-      'Invalid auth tag length',
-    [EciesStringKey.Error_ECIESError_InvalidHeaderLength]:
-      'Invalid header length',
-    [EciesStringKey.Error_ECIESError_InvalidDataLength]: 'Invalid data length',
-    [EciesStringKey.Error_ECIESError_InvalidPrivateKey]: 'Invalid private key',
-    [EciesStringKey.Error_ECIESError_InvalidIV]: 'Invalid initialization vector (IV)',
-    [EciesStringKey.Error_ECIESError_InvalidAuthTag]: 'Invalid authentication tag',
-    [EciesStringKey.Error_ECIESError_InvalidSharedSecret]: 'Invalid shared secret',
-    [EciesStringKey.Error_ECIESError_InvalidPublicKeyNotOnCurve]: 'Invalid public key: not on curve',
-    [EciesStringKey.Error_ECIESError_InvalidEncryptedDataLength]:
-      'Invalid encrypted data length',
-    [EciesStringKey.Error_ECIESError_InvalidMessageCrc]: 'Invalid message CRC',
-    [EciesStringKey.Error_ECIESError_InvalidMnemonic]: 'Invalid mnemonic',
-    [EciesStringKey.Error_ECIESError_InvalidOperation]: 'Invalid operation',
-    [EciesStringKey.Error_ECIESError_MessageLengthMismatch]:
-      'Message length mismatch',
-    [EciesStringKey.Error_ECIESError_InvalidEncryptedKeyLength]:
-      'Invalid encrypted key length',
-    [EciesStringKey.Error_ECIESError_InvalidEphemeralPublicKey]:
-      'Invalid ephemeral public key',
-    [EciesStringKey.Error_ECIESError_MissingEphemeralPublicKey]:
-      'Missing ephemeral public key',
-    [EciesStringKey.Error_ECIESError_RecipientNotFound]:
-      'Recipient not found in recipient IDs',
-    [EciesStringKey.Error_ECIESError_InvalidSignature]: 'Invalid signature',
-    [EciesStringKey.Error_ECIESError_InvalidSenderPublicKey]:
-      'Invalid sender public key',
-    [EciesStringKey.Error_ECIESError_TooManyRecipients]:
-      'Too many recipients: exceeds maximum allowed',
-    [EciesStringKey.Error_ECIESError_PrivateKeyNotLoaded]:
-      'Private key not loaded',
-    [EciesStringKey.Error_ECIESError_RecipientKeyCountMismatch]:
-      'Recipient count does not match key count',
-    [EciesStringKey.Error_ECIESError_InvalidRecipientCount]:
-      'Invalid recipient count',
-    [EciesStringKey.Error_ECIESError_FileSizeTooLarge]: 'File size too large',
-    [EciesStringKey.Error_ECIESError_DecryptionFailed]:
-      'Decryption operation failed',
-    [EciesStringKey.Error_ECIESError_InvalidRecipientPublicKey]:
-      'Invalid recipient public key provided for encryption',
-    [EciesStringKey.Error_ECIESError_SecretComputationFailed]:
-      'Failed to compute shared secret during ECIES operation',
-    [EciesStringKey.Error_ECIESError_AuthenticationTagIsRequiredForKeyEncryption]:
-      'Authentication tag is required for key encryption',
-    [EciesStringKey.Error_ECIESError_InvalidEncryptedKeyLengthTemplate]:
-      'Invalid encrypted key length: expected {keySize}, got {encryptedKeyLength}',
-    [EciesStringKey.Error_ECIESError_FailedToDecryptKey]: 'Failed to decrypt key',
-    [EciesStringKey.Error_ECIESError_TooManyRecipientsTemplate]: 'Too many recipients: {recipientsCount}',
-    [EciesStringKey.Error_ECIESError_MessageTooLarge]: 'Message too large',
-    [EciesStringKey.Error_ECIESError_MessageTooLargeTemplate]: 'Message too large: {length}',
-    [EciesStringKey.Error_ECIESError_AuthenticationTagIsRequiredForECIESEncryption]: 'Authentication tag is required for ECIES encryption',
-    [EciesStringKey.Error_ECIESError_AuthenticationTagIsRequiredForMultiRecipientECIESEncryption]: 'Authentication tag is required for multi-recipient ECIES encryption',
-    [EciesStringKey.Error_ECIESError_DecryptedDataLengthMismatch]: 'Decrypted data length mismatch',
-    [EciesStringKey.Error_ECIESError_RecipientCountMismatch]: 'Recipient count mismatch',
-    [EciesStringKey.Error_ECIESError_DataTooShortForMultiRecipientHeader]: 'Data too short for multi-recipient header',
-    [EciesStringKey.Error_ECIESError_FailedToDecryptChallengeTemplate]: 'Failed to decrypt challenge: {error}',
-    [EciesStringKey.Error_ECIESError_InvalidChallengeSignature]: 'Invalid challenge signature',
-    [EciesStringKey.Error_ECIESError_FailedToDervivePrivateKey]: 'Failed to derive private key',
-    [EciesStringKey.Error_ECIESError_InvalidPublicKeyFormatOrLengthTemplate]: 'Invalid public key format or length: {keyLength}',
-    [EciesStringKey.Error_ECIESError_ReceivedNullOrUndefinedPublicKey]: 'Received null or undefined public key',
-    [EciesStringKey.Error_ECIESError_MessageLengthExceedsMaximumAllowedSizeTemplate]: 'Message length exceeds maximum allowed size: {messageLength}',
-    [EciesStringKey.Error_ECIESError_MultipleEncryptionTypeNotSupportedInSingleRecipientMode]: 'Multiple encryption type not supported in single recipient mode',
-    [EciesStringKey.Error_ECIESError_EncryptionTypeMismatchTemplate]: 'Encryption type mismatch: expected {encryptionType}, got {actualEncryptionType}',
-    [EciesStringKey.Error_ECIESError_DataTooShortTemplate]: 'Data too short: required {requiredSize}, got {dataLength}',
-    [EciesStringKey.Error_ECIESError_DataLengthMismatchTemplate]: 'Data length mismatch: expected {expectedDataLength}, got {receivedDataLength}',
-    [EciesStringKey.Error_ECIESError_CombinedDataTooShortForComponents]: 'Combined data is too short to contain required components',
-    [EciesStringKey.Error_ECIESError_InvalidChecksumConstants]: 'Invalid checksum constants',
-    [EciesStringKey.Error_ECIESError_CannotOverwriteDefaultConfiguration]: 'Cannot overwrite the default configuration',
-    [EciesStringKey.Error_ECIESError_InvalidAESKeyLength]: 'Invalid AES key length: must be 16, 24, or 32 bytes',
-    [EciesStringKey.Error_ECIESError_CannotEncryptEmptyData]: 'Cannot encrypt empty data',
-    [EciesStringKey.Error_ECIESError_CannotDecryptEmptyData]: 'Cannot decrypt empty data',
-    [EciesStringKey.Error_ECIESError_EncryptedSizeExceedsExpected]: 'Encrypted size exceeds expected maximum',
-
-    // Member Error Types - buildReasonMap(MemberErrorType, 'Error', 'MemberError')
-    [EciesStringKey.Error_MemberError_MissingMemberName]:
-      'Member name is required',
-    [EciesStringKey.Error_MemberError_InvalidMemberNameWhitespace]:
-      'Member name contains trailing or leading whitespace.',
-    [EciesStringKey.Error_MemberError_InvalidEmail]: 'Invalid email.',
-    [EciesStringKey.Error_MemberError_InvalidMemberName]:
-      'Invalid member name.',
-    [EciesStringKey.Error_MemberError_InvalidMemberStatus]:
-      'Invalid member status.',
-    [EciesStringKey.Error_MemberError_MissingEmail]: 'Missing email.',
-    [EciesStringKey.Error_MemberError_InvalidEmailWhitespace]:
-      'Email contains trailing or leading whitespace.',
-    [EciesStringKey.Error_MemberError_MissingPrivateKey]:
-      'Missing private key.',
-    [EciesStringKey.Error_MemberError_NoWallet]: 'No wallet loaded.',
-    [EciesStringKey.Error_MemberError_WalletAlreadyLoaded]:
-      'Wallet already loaded.',
-    [EciesStringKey.Error_MemberError_InvalidMnemonic]:
-      'Invalid wallet mnemonic.',
-    [EciesStringKey.Error_MemberError_IncorrectOrInvalidPrivateKey]:
-      'Incorrect or invalid private key for public key',
-    [EciesStringKey.Error_MemberError_MemberNotFound]: 'Member not found.',
-    [EciesStringKey.Error_MemberError_MemberAlreadyExists]:
-      'Member already exists.',
-    [EciesStringKey.Error_MemberError_FailedToHydrateMember]:
-      'Failed to hydrate member.',
-    [EciesStringKey.Error_MemberError_InvalidMemberData]:
-      'Invalid member data.',
-    [EciesStringKey.Error_MemberError_FailedToConvertMemberData]:
-      'Failed to convert member data.',
-    [EciesStringKey.Error_MemberError_MissingEncryptionData]:
-      'Missing encryption data.',
-    [EciesStringKey.Error_MemberError_EncryptionDataTooLarge]:
-      'Encryption data too large.',
-    [EciesStringKey.Error_MemberError_InvalidEncryptionData]:
-      'Invalid encryption data.',
-
-    // Length Error Types - buildReasonMap(LengthErrorType, 'Error', 'LengthError')
-    [EciesStringKey.Error_LengthError_LengthIsTooShort]: 'Length is too short.',
-    [EciesStringKey.Error_LengthError_LengthIsTooLong]: 'Length is too long.',
-    [EciesStringKey.Error_LengthError_LengthIsInvalidType]:
-      'Length is of an invalid type.',
-
-    // PBKDF2 Error Types - buildReasonMap(Pbkdf2ErrorType, 'Error', 'Pbkdf2Error')
-    [EciesStringKey.Error_Pbkdf2Error_InvalidProfile]:
-      'Invalid PBKDF2 profile specified',
-    [EciesStringKey.Error_Pbkdf2Error_InvalidSaltLength]:
-      'Salt length does not match expected length',
-    [EciesStringKey.Error_Pbkdf2Error_InvalidHashLength]:
-      'Hash length does not match expected length',
-
-    // Secure Storage Error Types - buildReasonMap(SecureStorageErrorType, 'Error', 'SecureStorageError')
-    [EciesStringKey.Error_SecureStorageError_DecryptedValueLengthMismatch]:
-      'Decrypted value length does not match expected length',
-    [EciesStringKey.Error_SecureStorageError_DecryptedValueChecksumMismatch]:
-      'Decrypted value checksum does not match',
-    [EciesStringKey.Error_SecureStorageError_ValueIsNull]:
-      'Secure storage value is null',
-    [EciesStringKey.Error_InvalidEmailError_Invalid]: 'Invalid email address.',
-    [EciesStringKey.Error_InvalidEmailError_Missing]: 'Email address is required.',
-    [EciesStringKey.Error_InvalidEmailError_Whitespace]: 'Email address contains leading or trailing whitespace.',
-    [EciesStringKey.Error_Utils_EncryptionFailedNoAuthTag]:
-      'Encryption failed: no authentication tag generated',
-    [EciesStringKey.Error_PasswordLoginError_FailedToStoreLoginData]:
-      'Failed to store password login data',
-    [EciesStringKey.Error_PasswordLoginError_PasswordLoginNotSetUp]:
-      'Password login is not set up',
-    [EciesStringKey.Error_PhoneNumber_InvalidTemplate]: 'Invalid phone number: {phoneNumber}',
-
-    // Multi-recipient and Streaming Error Types
-    [EciesStringKey.Error_MultiRecipient_InvalidRecipientCountTemplate]: 'Invalid recipient count: {count}',
-    [EciesStringKey.Error_MultiRecipient_SymmetricKeyMust32Bytes]: 'Symmetric key must be 32 bytes',
-    [EciesStringKey.Error_MultiRecipient_InvalidChunkIndexTemplate]: 'Invalid chunk index: {index}',
-    [EciesStringKey.Error_MultiRecipient_DataSizeExceedsMaximumTemplate]: 'Data size exceeds maximum: {size}',
-    [EciesStringKey.Error_MultiRecipient_DuplicateRecipientId]: 'Duplicate recipient ID detected',
-    [EciesStringKey.Error_MultiRecipient_RecipientIdMust32Bytes]: 'Recipient ID must be 32 bytes',
-    [EciesStringKey.Error_MultiRecipient_RecipientHeadersSizeOverflow]: 'Recipient headers size overflow',
-    [EciesStringKey.Error_MultiRecipient_ChunkSizeOverflow]: 'Chunk size overflow: too many recipients or data too large',
-    [EciesStringKey.Error_MultiRecipient_ChunkTooSmall]: 'Chunk too small',
-    [EciesStringKey.Error_MultiRecipient_InvalidChunkMagic]: 'Invalid multi-recipient chunk magic',
-    [EciesStringKey.Error_MultiRecipient_UnsupportedVersionTemplate]: 'Unsupported version: {version}',
-    [EciesStringKey.Error_MultiRecipient_ChunkTooSmallForEncryptedSize]: 'Chunk too small for declared encrypted size',
-    [EciesStringKey.Error_MultiRecipient_ChunkTruncatedRecipientId]: 'Chunk truncated: not enough data for recipient ID',
-    [EciesStringKey.Error_MultiRecipient_ChunkTruncatedKeySize]: 'Chunk truncated: not enough data for key size',
-    [EciesStringKey.Error_MultiRecipient_InvalidKeySizeTemplate]: 'Invalid key size: {size}',
-    [EciesStringKey.Error_MultiRecipient_ChunkTruncatedEncryptedKey]: 'Chunk truncated: not enough data for encrypted key',
-    [EciesStringKey.Error_MultiRecipient_RecipientNotFoundInChunk]: 'Recipient not found in chunk',
-    [EciesStringKey.Error_Stream_DataTooShortForHeader]: 'Data too short for stream header',
-    [EciesStringKey.Error_Stream_InvalidMagicBytes]: 'Invalid stream magic bytes',
-    [EciesStringKey.Error_Stream_UnsupportedVersion]: 'Unsupported stream version',
-    [EciesStringKey.Error_Stream_InvalidPublicKeyLength]: 'Invalid public key: must be 33 (compressed) or 65 (uncompressed) bytes',
-    [EciesStringKey.Error_Stream_BufferOverflowTemplate]: 'Buffer overflow: source chunk exceeds {max} bytes',
-    [EciesStringKey.Error_Stream_EncryptionCancelled]: 'Encryption cancelled',
-    [EciesStringKey.Error_Stream_AtLeastOneRecipientRequired]: 'At least one recipient required',
-    [EciesStringKey.Error_Stream_MaxRecipientsExceeded]: 'Maximum 65535 recipients supported',
-    [EciesStringKey.Error_Stream_InvalidRecipientPublicKeyLength]: 'Invalid recipient public key: must be 33 (compressed) or 65 (uncompressed) bytes',
-    [EciesStringKey.Error_Stream_InvalidRecipientIdLength]: 'Invalid recipient ID: must be 32 bytes',
-    [EciesStringKey.Error_Stream_InvalidRecipientIdLengthTemplate]: 'Invalid recipient ID: must be {expected} bytes',
-    [EciesStringKey.Error_Stream_InvalidRecipientIdMust32Bytes]: 'Invalid recipient ID: must be 32 bytes',
-    [EciesStringKey.Error_Stream_InvalidPrivateKeyMust32Bytes]: 'Invalid private key: must be 32 bytes',
-    [EciesStringKey.Error_Stream_ChunkSequenceErrorTemplate]: 'Chunk sequence error: expected {expected}, got {actual}',
-    [EciesStringKey.Error_Stream_DecryptionCancelled]: 'Decryption cancelled',
-    [EciesStringKey.Error_Chunk_DataTooShortForHeader]: 'Data too short for chunk header',
-    [EciesStringKey.Error_Chunk_InvalidMagicBytes]: 'Invalid chunk magic bytes',
-    [EciesStringKey.Error_Chunk_UnsupportedVersion]: 'Unsupported chunk version',
-    [EciesStringKey.Error_Chunk_EncryptedSizeMismatchTemplate]: 'Encrypted size mismatch: expected {expectedSize}, got {actualSize}',
-    [EciesStringKey.Error_Chunk_ChecksumMismatch]: 'Chunk checksum mismatch',
-    [EciesStringKey.Error_Chunk_DecryptedSizeMismatch]: 'Decrypted size mismatch',
-    [EciesStringKey.Error_Progress_ChunkBytesCannotBeNegative]: 'Chunk bytes cannot be negative',
-    [EciesStringKey.Error_Resumable_AutoSaveIntervalMustBePositive]: 'Auto-save interval must be positive',
-    [EciesStringKey.Error_Resumable_PublicKeyMismatch]: 'Public key mismatch with saved state',
-    [EciesStringKey.Error_Resumable_ChunkSizeMismatch]: 'Chunk size mismatch with saved state',
-    [EciesStringKey.Error_Resumable_IncludeChecksumsMismatch]: 'Include checksums mismatch with saved state',
-    [EciesStringKey.Error_Resumable_NoStateToSave]: 'No state to save',
-    [EciesStringKey.Error_Resumable_UnsupportedStateVersionTemplate]: 'Unsupported state version: {version}',
-    [EciesStringKey.Error_Resumable_InvalidChunkIndex]: 'Invalid chunk index',
-    [EciesStringKey.Error_Resumable_StateTooOld]: 'State too old (>24 hours)',
-    [EciesStringKey.Error_Resumable_InvalidPublicKeyInState]: 'Invalid public key in state',
-    [EciesStringKey.Error_Resumable_StateIntegrityCheckFailed]: 'State integrity check failed: HMAC mismatch',
-    [EciesStringKey.Error_Builder_MnemonicGenerationNotImplemented]: 'Mnemonic generation not yet implemented in v2',
-    [EciesStringKey.Error_Builder_MemberNotMigrated]: 'Member not yet migrated to v2',
-    [EciesStringKey.Error_Builder_ECIESServiceNotMigrated]: 'ECIESService not yet migrated to v2',
-    [EciesStringKey.Error_Service_InvalidDataLength]: 'Invalid data length',
-    [EciesStringKey.Error_Service_InvalidEncryptionType]: 'Invalid encryption type',
-    [EciesStringKey.Error_Service_InvalidEncryptedDataLength]: 'Invalid encrypted data length',
-    [EciesStringKey.Error_Service_ComputedDecryptedLengthNegative]: 'Computed decrypted length is negative',
-    [EciesStringKey.Error_Service_MultiRecipientNotImplemented]: 'Multi-recipient encryption not yet implemented',
-    [EciesStringKey.Error_Service_InvalidEncryptionTypeOrRecipientCountTemplate]: 'Invalid encryption type or number of recipients: {encryptionType}, {recipientCount}',
-    [EciesStringKey.Error_Container_ServiceNotFoundTemplate]: 'Service {service} not found in container',
-    [EciesStringKey.Error_Utils_InvalidHexString]: 'Invalid hex string',
-    [EciesStringKey.Error_Utils_HexStringMustHaveEvenLength]: 'Hex string must have even length',
-    [EciesStringKey.Error_Utils_HexStringContainsInvalidCharacters]: 'Hex string contains invalid characters',
-    [EciesStringKey.Error_Utils_ValueExceedsSafeIntegerRange]: 'Value exceeds safe integer range',
-    [EciesStringKey.Error_Utils_ValueBelowSafeIntegerRange]: 'Value below safe integer range',
-    [EciesStringKey.Error_Builder_ECIESServiceMustBeSetBeforeGeneratingMnemonic]: 'ECIESService must be set before generating mnemonic',
-    [EciesStringKey.Error_Builder_ECIESServiceIsRequired]: 'ECIESService is required',
-    [EciesStringKey.Error_Builder_TypeNameAndEmailAreRequired]: 'Type, name, and email are required',
-    [EciesStringKey.Error_DisposedError_ObjectDisposed]: 'Object has been disposed',
-    [EciesStringKey.Error_GuidError_InvalidGuid]: 'Invalid GUID.',
-    [EciesStringKey.Error_GuidError_InvalidGuidWithDetailsTemplate]: 'Invalid GUID: {GUID}',
-    [EciesStringKey.Error_GuidError_InvalidGuidUnknownBrandTemplate]:
-      'Unknown GUID brand: {BRAND}.',
-    [EciesStringKey.Error_GuidError_InvalidGuidUnknownLengthTemplate]:
-      'Invalid GUID length: {LENGTH}.',
-    [EciesStringKey.Error_IdProviderError_InvalidLength]: 'ID length mismatch: expected {expected} bytes, got {actual} bytes in {context}',
-    [EciesStringKey.Error_IdProviderError_InputMustBeString]: 'Input must be a string',
-    [EciesStringKey.Error_IdProviderError_InvalidStringLength]: 'Invalid string length: expected {expected} characters, got {actual}',
-    [EciesStringKey.Error_IdProviderError_InvalidCharacters]: 'String contains invalid characters',
-    [EciesStringKey.Error_IdProviderError_InvalidDeserializedId]: 'Deserialized ID failed validation',
-    [EciesStringKey.Error_IdProviderError_InvalidByteLengthParameter]: 'Byte length must be an integer between 1 and 255, got {value}',
-    [EciesStringKey.Error_IdProviderError_ParseFailed]: 'Failed to parse ID: {message}',
-    [EciesStringKey.Error_IdProviderError_InvalidGuidBuffer]: 'Invalid GUID buffer: {message}',
-    [EciesStringKey.Error_IdProviderError_InvalidUuidFormat]: 'Invalid UUID format: {input}',
-
-    // Invariant Validation Errors
-    [EciesStringKey.Error_Invariant_ValidationFailedTemplate]: 'Invariant validation failed: {message}',
-    [EciesStringKey.Error_Invariant_UnknownInvariantTemplate]: 'Unknown invariant: {name}',
-    [EciesStringKey.Error_Invariant_ConfigurationValidationFailedMultipleTemplate]: createPluralString({
-      one: 'Configuration validation failed ({count} invariant):\n\n{failures}',
-      other: 'Configuration validation failed ({count} invariants):\n\n{failures}'
-    }),
-    [EciesStringKey.Error_ECIESError_RecipientIdSizeTooLargeTemplate]: 'Recipient ID size {size} exceeds maximum of 255 bytes',
-    [EciesStringKey.Error_ECIESError_InvalidVersion]: 'Invalid ECIES version',
-    [EciesStringKey.Error_ECIESError_InvalidVersionTemplate]: 'Invalid ECIES version: {version}',
-    [EciesStringKey.Error_ECIESError_InvalidCipherSuite]: 'Invalid ECIES cipher suite',
-    [EciesStringKey.Error_ECIESError_InvalidCipherSuiteTemplate]: 'Invalid ECIES cipher suite: {cipherSuite}',
-  };

package/src/translations/es.ts

@@ -1,271 +0,0 @@
-import { EciesStringKey } from '../enumerations';
-import { createPluralString, PluralString } from '@digitaldefiance/i18n-lib';
-
-export const spanishTranslations: Record<EciesStringKey, string | PluralString> = {
-    // ECIES Error Types - buildReasonMap(ECIESErrorTypeEnum, 'Error', 'ECIESError')
-    [EciesStringKey.Error_ECIESError_InvalidECIESMultipleEncryptedKeySize]:
-      'Tamaño de clave cifrada múltiple de ECIES no válido',
-    [EciesStringKey.Error_ECIESError_InvalidECIESPublicKeyLength]:
-      'Longitud de clave pública de ECIES no válida',
-    [EciesStringKey.Error_ECIESError_InvalidECIESMultipleRecipientCountSize]:
-      'Tamaño del contador de destinatarios múltiples de ECIES no válido',
-    [EciesStringKey.Error_ECIESError_InvalidECIESMultipleDataLengthSize]:
-      'Tamaño de la longitud de datos múltiples de ECIES no válido',
-    [EciesStringKey.Error_ECIESError_InvalidECIESMultipleRecipientIdSize]:
-      'Tamaño de ID de destinatario múltiple de ECIES no válido',
-    [EciesStringKey.Error_ECIESError_CRCError]: 'Error CRC',
-    [EciesStringKey.Error_ECIESError_InvalidEncryptionType]:
-      'Tipo de cifrado no válido',
-    [EciesStringKey.Error_ECIESError_InvalidEncryptionTypeTemplate]: 'Tipo de cifrado no válido: {encryptionType}',
-    [EciesStringKey.Error_ECIESError_InvalidIVLength]:
-      'Longitud de IV no válida',
-    [EciesStringKey.Error_ECIESError_InvalidAuthTagLength]:
-      'Longitud de etiqueta de autenticación no válida',
-    [EciesStringKey.Error_ECIESError_InvalidHeaderLength]:
-      'Longitud de encabezado no válida',
-    [EciesStringKey.Error_ECIESError_InvalidDataLength]:
-      'Longitud de datos no válida',
-    [EciesStringKey.Error_ECIESError_InvalidPrivateKey]: 'Clave privada no válida',
-    [EciesStringKey.Error_ECIESError_InvalidIV]: 'Vector de inicialización (IV) no válido',
-    [EciesStringKey.Error_ECIESError_InvalidAuthTag]: 'Etiqueta de autenticación no válida',
-    [EciesStringKey.Error_ECIESError_InvalidSharedSecret]: 'Secreto compartido no válido',
-    [EciesStringKey.Error_ECIESError_InvalidPublicKeyNotOnCurve]: 'Clave pública no válida: no está en la curva',
-    [EciesStringKey.Error_ECIESError_InvalidAESKeyLength]: 'Longitud de clave AES no válida: debe ser 16, 24 o 32 bytes',
-    [EciesStringKey.Error_ECIESError_CannotEncryptEmptyData]: 'No se pueden cifrar datos vacíos',
-    [EciesStringKey.Error_ECIESError_CannotDecryptEmptyData]: 'No se pueden descifrar datos vacíos',
-    [EciesStringKey.Error_ECIESError_EncryptedSizeExceedsExpected]: 'El tamaño cifrado excede el máximo esperado',
-    [EciesStringKey.Error_ECIESError_InvalidEncryptedDataLength]:
-      'Longitud de datos cifrados no válida',
-    [EciesStringKey.Error_ECIESError_InvalidMessageCrc]:
-      'CRC de mensaje no válido',
-    [EciesStringKey.Error_ECIESError_InvalidMnemonic]: 'Mnemónico no válido',
-    [EciesStringKey.Error_ECIESError_InvalidOperation]: 'Operación no válida',
-    [EciesStringKey.Error_ECIESError_MessageLengthMismatch]:
-      'Desajuste en la longitud del mensaje',
-    [EciesStringKey.Error_ECIESError_InvalidEncryptedKeyLength]:
-      'Longitud de clave cifrada no válida',
-    [EciesStringKey.Error_ECIESError_InvalidEphemeralPublicKey]:
-      'Clave pública efímera no válida',
-    [EciesStringKey.Error_ECIESError_MissingEphemeralPublicKey]:
-      'Falta la clave pública efímera',
-    [EciesStringKey.Error_ECIESError_RecipientNotFound]:
-      'Destinatario no encontrado en los identificadores de destinatarios',
-    [EciesStringKey.Error_ECIESError_InvalidSignature]: 'Firma no válida',
-    [EciesStringKey.Error_ECIESError_InvalidSenderPublicKey]:
-      'Clave pública del remitente no válida',
-    [EciesStringKey.Error_ECIESError_TooManyRecipients]:
-      'Demasiados destinatarios: excede el máximo permitido',
-    [EciesStringKey.Error_ECIESError_PrivateKeyNotLoaded]:
-      'Clave privada no cargada',
-    [EciesStringKey.Error_ECIESError_RecipientKeyCountMismatch]:
-      'El número de destinatarios no coincide con el número de claves',
-    [EciesStringKey.Error_ECIESError_InvalidRecipientCount]:
-      'Número de destinatarios no válido',
-    [EciesStringKey.Error_ECIESError_FileSizeTooLarge]:
-      'Tamaño de archivo demasiado grande',
-    [EciesStringKey.Error_ECIESError_DecryptionFailed]:
-      'Falló la operación de descifrado',
-    [EciesStringKey.Error_ECIESError_InvalidRecipientPublicKey]:
-      'Clave pública del destinatario no válida proporcionada para el cifrado',
-    [EciesStringKey.Error_ECIESError_SecretComputationFailed]:
-      'Error al calcular el secreto compartido durante la operación ECIES',
-    [EciesStringKey.Error_ECIESError_AuthenticationTagIsRequiredForKeyEncryption]:
-      'Se requiere una etiqueta de autenticación para el cifrado de claves',
-    [EciesStringKey.Error_ECIESError_InvalidEncryptedKeyLengthTemplate]:
-      'Longitud de clave cifrada no válida: se esperaba {keySize}, se obtuvo {encryptedKeyLength}.',
-    [EciesStringKey.Error_ECIESError_FailedToDecryptKey]: 'Error al descifrar la clave',
-    [EciesStringKey.Error_ECIESError_TooManyRecipientsTemplate]: 'Demasiados destinatarios: {recipientsCount}',
-    [EciesStringKey.Error_ECIESError_MessageTooLarge]: 'Mensaje demasiado grande',
-    [EciesStringKey.Error_ECIESError_MessageTooLargeTemplate]: 'Mensaje demasiado grande: {length}',
-    [EciesStringKey.Error_ECIESError_AuthenticationTagIsRequiredForECIESEncryption]: 'Se requiere una etiqueta de autenticación para el cifrado ECIES.',
-    [EciesStringKey.Error_ECIESError_AuthenticationTagIsRequiredForMultiRecipientECIESEncryption]: 'Se requiere una etiqueta de autenticación para el cifrado ECIES a múltiples destinatarios.',
-    [EciesStringKey.Error_ECIESError_DecryptedDataLengthMismatch]: 'Incoherencia de longitud de datos descifrados',
-    [EciesStringKey.Error_ECIESError_RecipientCountMismatch]: 'Incoherencia del número de destinatarios',
-    [EciesStringKey.Error_ECIESError_DataTooShortForMultiRecipientHeader]: 'Datos demasiado cortos para el encabezado de múltiples destinatarios',
-    [EciesStringKey.Error_ECIESError_FailedToDecryptChallengeTemplate]: 'Error al descifrar el desafío: {error}',
-    [EciesStringKey.Error_ECIESError_InvalidChallengeSignature]: 'Firma de desafío no válida',
-    [EciesStringKey.Error_ECIESError_FailedToDervivePrivateKey]: 'Error al derivar la clave privada',
-    [EciesStringKey.Error_ECIESError_InvalidPublicKeyFormatOrLengthTemplate]: 'Formato o longitud de clave pública no válidos: {keyLength}',
-    [EciesStringKey.Error_ECIESError_ReceivedNullOrUndefinedPublicKey]: 'Se recibió una clave pública nula o indefinida',
-    [EciesStringKey.Error_ECIESError_MessageLengthExceedsMaximumAllowedSizeTemplate]: 'La longitud del mensaje excede el tamaño máximo permitido: {messageLength}',
-    [EciesStringKey.Error_ECIESError_MultipleEncryptionTypeNotSupportedInSingleRecipientMode]: 'No se admite el tipo de cifrado múltiple en el modo de un solo destinatario.',
-    [EciesStringKey.Error_ECIESError_EncryptionTypeMismatchTemplate]: 'Incoherencia de tipo de cifrado: se esperaba {encryptionType}, se obtuvo {actualEncryptionType}.',
-    [EciesStringKey.Error_ECIESError_DataTooShortTemplate]: 'Datos demasiado cortos: se requiere {requiredSize}, se obtuvo {dataLength}.',
-    [EciesStringKey.Error_ECIESError_DataLengthMismatchTemplate]: 'Incoherencia de longitud de datos: se esperaba {expectedDataLength}, se obtuvo {receivedDataLength}.',
-    [EciesStringKey.Error_ECIESError_CombinedDataTooShortForComponents]: 'Los datos combinados son demasiado cortos para contener los componentes requeridos.',
-    [EciesStringKey.Error_ECIESError_InvalidChecksumConstants]: 'Constantes de suma de control no válidas',
-    [EciesStringKey.Error_ECIESError_CannotOverwriteDefaultConfiguration]: 'No se puede sobrescribir la configuración predeterminada.',
-    [EciesStringKey.Error_ECIESError_RecipientIdSizeTooLargeTemplate]: 'Recipient ID size {size} exceeds maximum of 255 bytes',
-    [EciesStringKey.Error_ECIESError_InvalidVersion]: 'Versión ECIES inválida',
-    [EciesStringKey.Error_ECIESError_InvalidVersionTemplate]: 'Versión ECIES inválida: {version}',
-    [EciesStringKey.Error_ECIESError_InvalidCipherSuite]: 'Suite de cifrado ECIES inválida',
-    [EciesStringKey.Error_ECIESError_InvalidCipherSuiteTemplate]: 'Suite de cifrado ECIES inválida: {cipherSuite}',
-
-    // Member Error Types - buildReasonMap(MemberErrorType, 'Error', 'MemberError')
-    [EciesStringKey.Error_MemberError_MissingMemberName]:
-      'Se requiere el nombre del miembro',
-    [EciesStringKey.Error_MemberError_InvalidMemberNameWhitespace]:
-      'El nombre del miembro contiene espacios al inicio o al final.',
-    [EciesStringKey.Error_MemberError_InvalidEmail]:
-      'Correo electrónico no válido.',
-    [EciesStringKey.Error_MemberError_InvalidMemberName]:
-      'Nombre de miembro no válido.',
-    [EciesStringKey.Error_MemberError_InvalidMemberStatus]:
-      'Estado del miembro no válido.',
-    [EciesStringKey.Error_MemberError_MissingEmail]:
-      'Falta el correo electrónico.',
-    [EciesStringKey.Error_MemberError_InvalidEmailWhitespace]:
-      'El correo electrónico contiene espacios al inicio o al final.',
-    [EciesStringKey.Error_MemberError_MissingPrivateKey]:
-      'Falta la clave privada.',
-    [EciesStringKey.Error_MemberError_NoWallet]: 'No se cargó ningún monedero.',
-    [EciesStringKey.Error_MemberError_WalletAlreadyLoaded]:
-      'El monedero ya está cargado.',
-    [EciesStringKey.Error_MemberError_InvalidMnemonic]:
-      'Mnemónico del monedero no válido.',
-    [EciesStringKey.Error_MemberError_IncorrectOrInvalidPrivateKey]:
-      'Clave privada incorrecta o no válida para la clave pública',
-    [EciesStringKey.Error_MemberError_MemberNotFound]: 'Miembro no encontrado.',
-    [EciesStringKey.Error_MemberError_MemberAlreadyExists]:
-      'El miembro ya existe.',
-    [EciesStringKey.Error_MemberError_FailedToHydrateMember]:
-      'Error al hidratar al miembro.',
-    [EciesStringKey.Error_MemberError_InvalidMemberData]:
-      'Datos del miembro no válidos.',
-    [EciesStringKey.Error_MemberError_FailedToConvertMemberData]:
-      'Error al convertir los datos del miembro.',
-    [EciesStringKey.Error_MemberError_MissingEncryptionData]:
-      'Faltan datos de cifrado.',
-    [EciesStringKey.Error_MemberError_EncryptionDataTooLarge]:
-      'Datos de cifrado demasiado grandes.',
-    [EciesStringKey.Error_MemberError_InvalidEncryptionData]:
-      'Datos de cifrado no válidos.',
-
-    // Length Error Types - buildReasonMap(LengthErrorType, 'Error', 'LengthError')
-    [EciesStringKey.Error_LengthError_LengthIsTooShort]:
-      'La longitud es demasiado corta.',
-    [EciesStringKey.Error_LengthError_LengthIsTooLong]:
-      'La longitud es demasiado larga.',
-    [EciesStringKey.Error_LengthError_LengthIsInvalidType]:
-      'La longitud es de un tipo no válido.',
-
-    // PBKDF2 Error Types - buildReasonMap(Pbkdf2ErrorType, 'Error', 'Pbkdf2Error')
-    [EciesStringKey.Error_Pbkdf2Error_InvalidProfile]:
-      'Perfil PBKDF2 inválido especificado',
-    [EciesStringKey.Error_Pbkdf2Error_InvalidSaltLength]:
-      'La longitud de la sal no coincide con la esperada',
-    [EciesStringKey.Error_Pbkdf2Error_InvalidHashLength]:
-      'La longitud del hash no coincide con la esperada',
-
-    // Secure Storage Error Types - buildReasonMap(SecureStorageErrorType, 'Error', 'SecureStorageError')
-    [EciesStringKey.Error_SecureStorageError_DecryptedValueLengthMismatch]:
-      'La longitud del valor descifrado no coincide con la esperada',
-    [EciesStringKey.Error_SecureStorageError_DecryptedValueChecksumMismatch]:
-      'La suma de verificación del valor descifrado no coincide',
-    [EciesStringKey.Error_SecureStorageError_ValueIsNull]:
-      'El valor del almacenamiento seguro es nulo',
-    [EciesStringKey.Error_InvalidEmailError_Invalid]:
-      'Dirección de correo electrónico no válida.',
-    [EciesStringKey.Error_InvalidEmailError_Missing]:
-      'Se requiere dirección de correo electrónico.',
-    [EciesStringKey.Error_InvalidEmailError_Whitespace]:
-      'La dirección de correo electrónico contiene espacios al inicio o al final.',
-    [EciesStringKey.Error_Utils_EncryptionFailedNoAuthTag]:
-      'Error de cifrado: no se generó ninguna etiqueta de autenticación',
-    [EciesStringKey.Error_PasswordLoginError_FailedToStoreLoginData]:
-      'Error al almacenar los datos de inicio de sesión de contraseña',
-    [EciesStringKey.Error_PasswordLoginError_PasswordLoginNotSetUp]:
-      'El inicio de sesión con contraseña no está configurado',
-    [EciesStringKey.Error_PhoneNumber_InvalidTemplate]: 'Número de teléfono no válido: {phoneNumber}',
-
-    // Multi-recipient and Streaming Error Types
-    [EciesStringKey.Error_MultiRecipient_InvalidRecipientCountTemplate]: 'Número de destinatarios no válido: {count}',
-    [EciesStringKey.Error_MultiRecipient_SymmetricKeyMust32Bytes]: 'La clave simétrica debe ser de 32 bytes',
-    [EciesStringKey.Error_MultiRecipient_InvalidChunkIndexTemplate]: 'Índice de bloque no válido: {index}',
-    [EciesStringKey.Error_MultiRecipient_DataSizeExceedsMaximumTemplate]: 'El tamaño de los datos excede el máximo: {size}',
-    [EciesStringKey.Error_MultiRecipient_DuplicateRecipientId]: 'ID de destinatario duplicado detectado',
-    [EciesStringKey.Error_MultiRecipient_RecipientIdMust32Bytes]: 'El ID del destinatario debe ser de 32 bytes',
-    [EciesStringKey.Error_MultiRecipient_RecipientHeadersSizeOverflow]: 'Desbordamiento del tamaño de los encabezados de destinatarios',
-    [EciesStringKey.Error_MultiRecipient_ChunkSizeOverflow]: 'Desbordamiento del tamaño del bloque: demasiados destinatarios o datos demasiado grandes',
-    [EciesStringKey.Error_MultiRecipient_ChunkTooSmall]: 'Bloque demasiado pequeño',
-    [EciesStringKey.Error_MultiRecipient_InvalidChunkMagic]: 'Número mágico de bloque multi-destinatario no válido',
-    [EciesStringKey.Error_MultiRecipient_UnsupportedVersionTemplate]: 'Versión no compatible: {version}',
-    [EciesStringKey.Error_MultiRecipient_ChunkTooSmallForEncryptedSize]: 'Bloque demasiado pequeño para el tamaño cifrado declarado',
-    [EciesStringKey.Error_MultiRecipient_ChunkTruncatedRecipientId]: 'Bloque truncado: no hay suficientes datos para el ID del destinatario',
-    [EciesStringKey.Error_MultiRecipient_ChunkTruncatedKeySize]: 'Bloque truncado: no hay suficientes datos para el tamaño de la clave',
-    [EciesStringKey.Error_MultiRecipient_InvalidKeySizeTemplate]: 'Tamaño de clave no válido: {size}',
-    [EciesStringKey.Error_MultiRecipient_ChunkTruncatedEncryptedKey]: 'Bloque truncado: no hay suficientes datos para la clave cifrada',
-    [EciesStringKey.Error_MultiRecipient_RecipientNotFoundInChunk]: 'Destinatario no encontrado en el bloque',
-    [EciesStringKey.Error_Stream_DataTooShortForHeader]: 'Datos demasiado cortos para el encabezado de flujo',
-    [EciesStringKey.Error_Stream_InvalidMagicBytes]: 'Bytes mágicos de flujo no válidos',
-    [EciesStringKey.Error_Stream_UnsupportedVersion]: 'Versión de flujo no compatible',
-    [EciesStringKey.Error_Stream_InvalidPublicKeyLength]: 'Clave pública no válida: debe ser de 33 (comprimida) o 65 (sin comprimir) bytes',
-    [EciesStringKey.Error_Stream_BufferOverflowTemplate]: 'Desbordamiento de búfer: el bloque de origen excede {max} bytes',
-    [EciesStringKey.Error_Stream_EncryptionCancelled]: 'Cifrado cancelado',
-    [EciesStringKey.Error_Stream_AtLeastOneRecipientRequired]: 'Se requiere al menos un destinatario',
-    [EciesStringKey.Error_Stream_MaxRecipientsExceeded]: 'Máximo de 65535 destinatarios admitidos',
-    [EciesStringKey.Error_Stream_InvalidRecipientPublicKeyLength]: 'Clave pública del destinatario no válida: debe ser de 33 (comprimida) o 65 (sin comprimir) bytes',
-    [EciesStringKey.Error_Stream_InvalidRecipientIdLength]: 'ID de destinatario no válido: debe tener 32 bytes',
-    [EciesStringKey.Error_Stream_InvalidRecipientIdLengthTemplate]: 'ID de destinatario no válido: debe tener {expected} bytes',
-    [EciesStringKey.Error_Stream_InvalidRecipientIdMust32Bytes]: 'ID de destinatario no válido: debe tener 32 bytes',
-    [EciesStringKey.Error_Stream_InvalidPrivateKeyMust32Bytes]: 'Clave privada no válida: debe ser de 32 bytes',
-    [EciesStringKey.Error_Stream_ChunkSequenceErrorTemplate]: 'Error de secuencia de bloque: se esperaba {expected}, se obtuvo {actual}',
-    [EciesStringKey.Error_Stream_DecryptionCancelled]: 'Descifrado cancelado',
-    [EciesStringKey.Error_Chunk_DataTooShortForHeader]: 'Datos demasiado cortos para el encabezado del fragmento',
-    [EciesStringKey.Error_Chunk_InvalidMagicBytes]: 'Bytes mágicos del fragmento no válidos',
-    [EciesStringKey.Error_Chunk_UnsupportedVersion]: 'Versión del fragmento no compatible',
-    [EciesStringKey.Error_Chunk_EncryptedSizeMismatchTemplate]: 'Tamaño cifrado no coincide: esperado {expectedSize}, obtenido {actualSize}',
-    [EciesStringKey.Error_Chunk_ChecksumMismatch]: 'Suma de verificación del fragmento no coincide',
-    [EciesStringKey.Error_Chunk_DecryptedSizeMismatch]: 'Tamaño descifrado no coincide',
-    [EciesStringKey.Error_Progress_ChunkBytesCannotBeNegative]: 'Los bytes del fragmento no pueden ser negativos',
-    [EciesStringKey.Error_Resumable_AutoSaveIntervalMustBePositive]: 'El intervalo de guardado automático debe ser positivo',
-    [EciesStringKey.Error_Resumable_PublicKeyMismatch]: 'Clave pública no coincide con el estado guardado',
-    [EciesStringKey.Error_Resumable_ChunkSizeMismatch]: 'Tamaño del fragmento no coincide con el estado guardado',
-    [EciesStringKey.Error_Resumable_IncludeChecksumsMismatch]: 'Inclusión de sumas de verificación no coincide con el estado guardado',
-    [EciesStringKey.Error_Resumable_NoStateToSave]: 'No hay estado para guardar',
-    [EciesStringKey.Error_Resumable_UnsupportedStateVersionTemplate]: 'Versión de estado no compatible: {version}',
-    [EciesStringKey.Error_Resumable_InvalidChunkIndex]: 'Índice de fragmento no válido',
-    [EciesStringKey.Error_Resumable_StateTooOld]: 'Estado demasiado antiguo (>24 horas)',
-    [EciesStringKey.Error_Resumable_InvalidPublicKeyInState]: 'Clave pública no válida en el estado',
-    [EciesStringKey.Error_Resumable_StateIntegrityCheckFailed]: 'Error en la verificación de integridad del estado: HMAC no coincide',
-    [EciesStringKey.Error_Builder_MnemonicGenerationNotImplemented]: 'Generación de mnemónico aún no implementada en v2',
-    [EciesStringKey.Error_Builder_MemberNotMigrated]: 'Miembro aún no migrado a v2',
-    [EciesStringKey.Error_Builder_ECIESServiceNotMigrated]: 'ECIESService aún no migrado a v2',
-    [EciesStringKey.Error_Service_InvalidDataLength]: 'Longitud de datos no válida',
-    [EciesStringKey.Error_Service_InvalidEncryptionType]: 'Tipo de cifrado no válido',
-    [EciesStringKey.Error_Service_InvalidEncryptedDataLength]: 'Longitud de datos cifrados no válida',
-    [EciesStringKey.Error_Service_ComputedDecryptedLengthNegative]: 'La longitud descifrada calculada es negativa',
-    [EciesStringKey.Error_Service_MultiRecipientNotImplemented]: 'Cifrado multi-destinatario aún no implementado',
-    [EciesStringKey.Error_Service_InvalidEncryptionTypeOrRecipientCountTemplate]: 'Tipo de cifrado o número de destinatarios no válido: {encryptionType}, {recipientCount}',
-    [EciesStringKey.Error_Container_ServiceNotFoundTemplate]: 'Servicio {service} no encontrado en el contenedor',
-    [EciesStringKey.Error_Utils_InvalidHexString]: 'Cadena hexadecimal no válida',
-    [EciesStringKey.Error_Utils_HexStringMustHaveEvenLength]: 'La cadena hexadecimal debe tener longitud par',
-    [EciesStringKey.Error_Utils_HexStringContainsInvalidCharacters]: 'La cadena hexadecimal contiene caracteres no válidos',
-    [EciesStringKey.Error_Utils_ValueExceedsSafeIntegerRange]: 'El valor excede el rango de enteros seguros',
-    [EciesStringKey.Error_Utils_ValueBelowSafeIntegerRange]: 'El valor está por debajo del rango de enteros seguros',
-    [EciesStringKey.Error_Builder_ECIESServiceMustBeSetBeforeGeneratingMnemonic]: 'ECIESService debe configurarse antes de generar el mnemónico',
-    [EciesStringKey.Error_Builder_ECIESServiceIsRequired]: 'ECIESService es obligatorio',
-    [EciesStringKey.Error_Builder_TypeNameAndEmailAreRequired]: 'El tipo, nombre y correo electrónico son obligatorios',
-    [EciesStringKey.Error_DisposedError_ObjectDisposed]: 'El objeto ha sido eliminado',
-    [EciesStringKey.Error_GuidError_InvalidGuid]: 'GUID invalido.',
-    [EciesStringKey.Error_GuidError_InvalidGuidWithDetailsTemplate]: 'GUID invalido: {GUID}',
-    [EciesStringKey.Error_GuidError_InvalidGuidUnknownBrandTemplate]: 'Marca de GUID desconocida: {BRAND}.',
-    [EciesStringKey.Error_GuidError_InvalidGuidUnknownLengthTemplate]: 'Longitud de GUID inválida: {LENGTH}.',
-    [EciesStringKey.Error_IdProviderError_InvalidLength]: 'Longitud de ID incorrecta: se esperaban {expected} bytes, se recibieron {actual} en {context}',
-    [EciesStringKey.Error_IdProviderError_InputMustBeString]: 'La entrada debe ser una cadena',
-    [EciesStringKey.Error_IdProviderError_InvalidStringLength]: 'Longitud de cadena no válida: se esperaban {expected} caracteres, se recibieron {actual}',
-    [EciesStringKey.Error_IdProviderError_InvalidCharacters]: 'La cadena contiene caracteres no válidos',
-    [EciesStringKey.Error_IdProviderError_InvalidDeserializedId]: 'El ID deserializado falló la validación',
-    [EciesStringKey.Error_IdProviderError_InvalidByteLengthParameter]: 'La longitud en bytes debe ser un entero entre 1 y 255, se recibió {value}',
-    [EciesStringKey.Error_IdProviderError_ParseFailed]: 'Error al analizar ID: {message}',
-    [EciesStringKey.Error_IdProviderError_InvalidGuidBuffer]: 'Búfer GUID inválido: {message}',
-    [EciesStringKey.Error_IdProviderError_InvalidUuidFormat]: 'Formato UUID inválido: {input}',
-
-    // Invariant Validation Errors
-    [EciesStringKey.Error_Invariant_ValidationFailedTemplate]: 'Validación de invariante falló: {message}',
-    [EciesStringKey.Error_Invariant_UnknownInvariantTemplate]: 'Invariante desconocido: {name}',
-    [EciesStringKey.Error_Invariant_ConfigurationValidationFailedMultipleTemplate]: createPluralString({
-      one: 'Validación de configuración falló ({count} invariante):\n\n{failures}',
-      other: 'Validación de configuración falló ({count} invariantes):\n\n{failures}'
-    }),
-  };