@digitaldefiance/node-ecies-lib 4.4.2 → 4.4.5

package/src/i18n/node-ecies-i18n-setup.ts

@@ -0,0 +1,56 @@
+import { getEciesI18nEngine } from '@digitaldefiance/ecies-lib';
+import { ComponentConfig, EngineConfig, I18nEngine, LanguageCodes } from '@digitaldefiance/i18n-lib';
+import { NodeEciesComponentId, NodeEciesStringKey } from './node-keys';
+import {
+  englishTranslations,
+  britishEnglishTranslations,
+  frenchTranslations,
+  spanishTranslations,
+  germanTranslations,
+  mandarinTranslations,
+  japaneseTranslations,
+  ukrainianTranslations,
+} from './translations';
+
+let _nodeEciesI18nEngine: I18nEngine | null = null;
+let _componentRegistered = false;
+
+export function getNodeEciesI18nEngine(config?: EngineConfig): I18nEngine {
+  // Get base ecies engine (uses 'default' key)
+  const baseEngine = getEciesI18nEngine(config);
+  
+  // Register node-ecies component if not already registered
+  if (!_componentRegistered) {
+    baseEngine.registerIfNotExists(createNodeEciesComponentConfig());
+    _componentRegistered = true;
+  }
+  
+  _nodeEciesI18nEngine = baseEngine;
+  return baseEngine;
+}
+
+export function resetNodeEciesI18nEngine(): void {
+  _nodeEciesI18nEngine = null;
+  _componentRegistered = false;
+}
+
+export function createNodeEciesComponentConfig(): ComponentConfig {
+  return {
+    id: NodeEciesComponentId,
+    strings: createNodeEciesStrings(),
+    aliases: [ 'NodeEciesStringKey' ],
+  };
+}
+
+function createNodeEciesStrings(): Record<string, Record<string, string>> {
+  return {
+    [LanguageCodes.EN_US]: englishTranslations,
+    [LanguageCodes.EN_GB]: britishEnglishTranslations,
+    [LanguageCodes.FR]: frenchTranslations,
+    [LanguageCodes.ES]: spanishTranslations,
+    [LanguageCodes.DE]: germanTranslations,
+    [LanguageCodes.ZH_CN]: mandarinTranslations,
+    [LanguageCodes.JA]: japaneseTranslations,
+    [LanguageCodes.UK]: ukrainianTranslations,
+  };
+}

package/src/i18n/node-keys.ts

@@ -0,0 +1,69 @@
+/**
+ * ECIES-specific string keys for the node ECIES library
+ */
+export enum NodeEciesStringKey {
+  Error_LengthError_LengthIsInvalidType = 'error_length_error_length_is_invalid_type',
+
+  // Member errors
+  Error_Member_MissingMemberName = 'error_member_missing_member_name',
+  Error_Member_InvalidMemberNameWhitespace = 'error_member_invalid_member_name_whitespace',
+  Error_Member_NoWallet = 'error_member_no_wallet',
+  Error_Member_WalletAlreadyLoaded = 'error_member_wallet_already_loaded',
+  Error_Member_InvalidMnemonic = 'error_member_invalid_mnemonic',
+  Error_Member_MissingPrivateKey = 'error_member_missing_private_key',
+  Error_Member_MissingEncryptionData = 'error_member_missing_encryption_data',
+  Error_Member_EncryptionDataTooLarge = 'error_member_encryption_data_too_large',
+  Error_Member_MissingEmail = 'error_member_missing_email',
+  Error_Member_InvalidEmailWhitespace = 'error_member_invalid_email_whitespace',
+  Error_InvalidPublicKey = 'error_invalidPublicKey',
+  Error_InvalidPublicKeyFormat = 'error_invalidPublicKeyFormat',
+  Error_MessageLengthExceedsMaximumAllowedSize = 'error_messageLengthExceedsMaximumAllowedSize',
+  Error_InvalidEncryptionTypeOrNumberOfRecipients = 'error_invalidEncryptionTypeOrNumberOfRecipients',
+  Error_EncryptedDataLengthMismatch = 'error_encryptedDataLengthMismatch',
+  Error_EphemeralPublicKeyLengthMismatch = 'error_ephemeralPublicKeyLengthMismatch',
+  Error_EncryptedDataIsEmpty = 'error_encryptedDataIsEmpty',
+  Error_CombinedDataTooShort = 'error_combinedDataTooShort',
+  Error_BufferIsTooShort = 'error_bufferIsTooShort',
+  Error_BufferIsTooShortToReadFullLengthValue = 'error_bufferIsTooShortToReadFullLengthValue',
+  Error_LengthExceedsMaximumSafeInteger = 'error_lengthExceedsMaximumSafeInteger',
+  Error_BufferIsTooShortForDeclaredDataLength = 'error_bufferIsTooShortForDeclaredDataLength',
+  Error_InvalidChecksumConstants = 'error_invalidChecksumConstants',
+
+  // AES-GCM security errors
+  Error_InvalidAESKeyLength = 'error_invalidAESKeyLength',
+  Error_CannotEncryptEmptyData = 'error_cannotEncryptEmptyData',
+  Error_CannotDecryptEmptyData = 'error_cannotDecryptEmptyData',
+  Error_InvalidIVLength = 'error_invalidIVLength',
+  Error_MessageTooLarge = 'error_messageTooLarge',
+  Error_EncryptedSizeExceedsExpected = 'error_encryptedSizeExceedsExpected',
+
+  // PBKDF2 errors
+  Error_Pbkdf2_InvalidSaltLength = 'error_pbkdf2_invalid_salt_length',
+  Error_Pbkdf2_InvalidHashLength = 'error_pbkdf2_invalid_hash_length',
+
+  // Builder errors
+  Error_Builder_ECIESServiceMustBeSetBeforeGeneratingMnemonic = 'error_builder_ecies_service_must_be_set_before_generating_mnemonic',
+  Error_Builder_ECIESServiceIsRequired = 'error_builder_ecies_service_is_required',
+  Error_Builder_TypeNameAndEmailAreRequired = 'error_builder_type_name_and_email_are_required',
+
+  // Streaming errors
+  Error_Stream_InvalidPublicKeyLength = 'error_stream_invalid_public_key_length',
+  Error_Stream_EncryptionCancelled = 'error_stream_encryption_cancelled',
+  Error_Stream_BufferOverflow = 'error_stream_buffer_overflow',
+  Error_Stream_AtLeastOneRecipientRequired = 'error_stream_at_least_one_recipient_required',
+  Error_Stream_MaxRecipientsExceeded = 'error_stream_max_recipients_exceeded',
+  Error_Stream_InvalidRecipientPublicKeyLength = 'error_stream_invalid_recipient_public_key_length',
+  Error_Stream_InvalidRecipientIdLength = 'error_stream_invalid_recipient_id_length',
+  Error_Stream_InvalidPrivateKeyLength = 'error_stream_invalid_private_key_length',
+  Error_Stream_DecryptionCancelled = 'error_stream_decryption_cancelled',
+  Error_Stream_ChunkSequenceError = 'error_stream_chunk_sequence_error',
+
+  // Invariant errors
+  Error_Invariant_ConfigurationValidationFailedTemplate = 'error_invariant_configuration_validation_failed_template',
+  Error_Invariant_NodeRecipientIdConsistency_FailedTemplate = 'error_invariant_node_recipient_id_consistency_failed_template',
+  Error_Invariant_MemberIdLengthMismatchTemplate = 'error_invariant_member_id_length_mismatch_template',
+  Error_Invariant_EciesMultipleRecipientIdSizeMismatchTemplate = 'error_invariant_ecies_multiple_recipient_id_size_mismatch_template',
+  Error_Invariant_EncryptionRecipientIdSizeMismatchTemplate = 'error_invariant_encryption_recipient_id_size_mismatch_template',
+}
+
+export const NodeEciesComponentId = 'node-ecies';

package/src/i18n/translations/de.ts

@@ -0,0 +1,54 @@
+import { NodeEciesStringKey } from '../node-keys';
+
+export const germanTranslations: Record<NodeEciesStringKey, string> = {
+  [NodeEciesStringKey.Error_LengthError_LengthIsInvalidType]: 'Längencodierungstyp ist ungültig',
+  [NodeEciesStringKey.Error_Member_MissingMemberName]: 'Mitgliedsname ist erforderlich',
+  [NodeEciesStringKey.Error_Member_InvalidMemberNameWhitespace]: 'Mitgliedsname darf keine führenden oder nachfolgenden Leerzeichen haben',
+  [NodeEciesStringKey.Error_Member_NoWallet]: 'Keine Wallet verfügbar',
+  [NodeEciesStringKey.Error_Member_WalletAlreadyLoaded]: 'Wallet ist bereits geladen',
+  [NodeEciesStringKey.Error_Member_InvalidMnemonic]: 'Ungültige mnemonische Phrase',
+  [NodeEciesStringKey.Error_Member_MissingPrivateKey]: 'Privater Schlüssel fehlt',
+  [NodeEciesStringKey.Error_Member_MissingEncryptionData]: 'Verschlüsselungsdaten fehlen',
+  [NodeEciesStringKey.Error_Member_EncryptionDataTooLarge]: 'Verschlüsselungsdaten sind zu groß',
+  [NodeEciesStringKey.Error_Member_MissingEmail]: 'E-Mail-Adresse ist erforderlich',
+  [NodeEciesStringKey.Error_Member_InvalidEmailWhitespace]: 'E-Mail-Adresse darf keine führenden oder nachfolgenden Leerzeichen haben',
+  [NodeEciesStringKey.Error_InvalidPublicKey]: 'Null oder undefinierter öffentlicher Schlüssel empfangen',
+  [NodeEciesStringKey.Error_InvalidPublicKeyFormat]: 'Ungültiges Format oder Länge des öffentlichen Schlüssels',
+  [NodeEciesStringKey.Error_MessageLengthExceedsMaximumAllowedSize]: 'Die Nachricht überschreitet die maximal erlaubte Länge',
+  [NodeEciesStringKey.Error_InvalidEncryptionTypeOrNumberOfRecipients]: 'Ungültiger Verschlüsselungstyp oder Anzahl der Empfänger',
+  [NodeEciesStringKey.Error_EncryptedDataLengthMismatch]: 'Verschlüsselte Datenlänge stimmt nicht überein',
+  [NodeEciesStringKey.Error_EphemeralPublicKeyLengthMismatch]: 'Ephemerer öffentlicher Schlüssel hat nach der Normalisierung eine falsche Länge',
+  [NodeEciesStringKey.Error_EncryptedDataIsEmpty]: 'Verschlüsselte Daten sind leer',
+  [NodeEciesStringKey.Error_CombinedDataTooShort]: 'Die kombinierten Daten sind zu kurz, um die erforderlichen Komponenten zu enthalten',
+  [NodeEciesStringKey.Error_BufferIsTooShort]: 'Der Puffer ist zu kurz, um den Längentyp zu lesen',
+  [NodeEciesStringKey.Error_BufferIsTooShortToReadFullLengthValue]: 'Der Puffer ist zu kurz, um die vollständige Längenangabe zu lesen',
+  [NodeEciesStringKey.Error_LengthExceedsMaximumSafeInteger]: 'Die Länge überschreitet den maximalen sicheren Ganzzahlwert',
+  [NodeEciesStringKey.Error_BufferIsTooShortForDeclaredDataLength]: 'Der Puffer ist zu kurz für die deklarierte Datenlänge',
+  [NodeEciesStringKey.Error_InvalidChecksumConstants]: 'Ungültige Prüfziffernkonstanten',
+  [NodeEciesStringKey.Error_InvalidAESKeyLength]: 'AES-Schlüssel muss 16, 24 oder 32 Bytes sein',
+  [NodeEciesStringKey.Error_CannotEncryptEmptyData]: 'Null- oder undefinierte Daten können nicht verschlüsselt werden',
+  [NodeEciesStringKey.Error_CannotDecryptEmptyData]: 'Null- oder undefinierte Daten können nicht entschlüsselt werden',
+  [NodeEciesStringKey.Error_InvalidIVLength]: 'IV muss 16 Bytes sein',
+  [NodeEciesStringKey.Error_MessageTooLarge]: 'Nachricht überschreitet maximale Größe von 2GB',
+  [NodeEciesStringKey.Error_EncryptedSizeExceedsExpected]: 'Verschlüsselte Datengröße überschreitet erwartetes Maximum',
+  [NodeEciesStringKey.Error_Pbkdf2_InvalidSaltLength]: 'Ungültige Salt-Länge',
+  [NodeEciesStringKey.Error_Pbkdf2_InvalidHashLength]: 'Ungültige Hash-Länge',
+  [NodeEciesStringKey.Error_Builder_ECIESServiceMustBeSetBeforeGeneratingMnemonic]: 'ECIESService muss vor der Generierung eines Mnemonics festgelegt werden',
+  [NodeEciesStringKey.Error_Builder_ECIESServiceIsRequired]: 'ECIESService ist erforderlich',
+  [NodeEciesStringKey.Error_Builder_TypeNameAndEmailAreRequired]: 'Typ, Name und E-Mail sind erforderlich',
+  [NodeEciesStringKey.Error_Stream_InvalidPublicKeyLength]: 'Ungültiger öffentlicher Schlüssel: muss 33 (komprimiert) oder 65 (unkomprimiert) Bytes sein',
+  [NodeEciesStringKey.Error_Stream_EncryptionCancelled]: 'Verschlüsselung abgebrochen',
+  [NodeEciesStringKey.Error_Stream_BufferOverflow]: 'Pufferüberlauf: Quellblock überschreitet maximale Größe',
+  [NodeEciesStringKey.Error_Stream_AtLeastOneRecipientRequired]: 'Mindestens ein Empfänger erforderlich',
+  [NodeEciesStringKey.Error_Stream_MaxRecipientsExceeded]: 'Maximal 65535 Empfänger unterstützt',
+  [NodeEciesStringKey.Error_Stream_InvalidRecipientPublicKeyLength]: 'Ungültiger öffentlicher Empfängerschlüssel: muss 33 (komprimiert) oder 65 (unkomprimiert) Bytes sein',
+  [NodeEciesStringKey.Error_Stream_InvalidRecipientIdLength]: 'Ungültige Empfänger-ID: muss 32 Bytes sein',
+  [NodeEciesStringKey.Error_Stream_InvalidPrivateKeyLength]: 'Ungültiger privater Schlüssel: muss 32 Bytes sein',
+  [NodeEciesStringKey.Error_Stream_DecryptionCancelled]: 'Entschlüsselung abgebrochen',
+  [NodeEciesStringKey.Error_Stream_ChunkSequenceError]: 'Blocksequenzfehler',
+  [NodeEciesStringKey.Error_Invariant_ConfigurationValidationFailedTemplate]: 'Node.js configuration validation failed:\n{failures}',
+  [NodeEciesStringKey.Error_Invariant_NodeRecipientIdConsistency_FailedTemplate]: "Invariant 'NodeRecipientIdConsistency' failed:\n  {issues}",
+  [NodeEciesStringKey.Error_Invariant_MemberIdLengthMismatchTemplate]: 'MEMBER_ID_LENGTH ({actual}) !== idProvider.byteLength ({expected})',
+  [NodeEciesStringKey.Error_Invariant_EciesMultipleRecipientIdSizeMismatchTemplate]: 'ECIES.MULTIPLE.RECIPIENT_ID_SIZE ({actual}) !== idProvider.byteLength ({expected})',
+  [NodeEciesStringKey.Error_Invariant_EncryptionRecipientIdSizeMismatchTemplate]: 'ENCRYPTION.RECIPIENT_ID_SIZE ({actual}) !== idProvider.byteLength ({expected})',
+};

package/src/i18n/translations/en-GB.ts

@@ -0,0 +1,83 @@
+import { NodeEciesStringKey } from '../node-keys';
+
+export const britishEnglishTranslations: Record<NodeEciesStringKey, string> = {
+    [NodeEciesStringKey.Error_LengthError_LengthIsInvalidType]:
+      'Length encoding type is invalid',
+
+    // Member errors
+    [NodeEciesStringKey.Error_Member_MissingMemberName]:
+      'Member name is required',
+    [NodeEciesStringKey.Error_Member_InvalidMemberNameWhitespace]:
+      'Member name cannot have leading or trailing whitespace',
+    [NodeEciesStringKey.Error_Member_NoWallet]: 'No wallet available',
+    [NodeEciesStringKey.Error_Member_WalletAlreadyLoaded]:
+      'Wallet is already loaded',
+    [NodeEciesStringKey.Error_Member_InvalidMnemonic]:
+      'Invalid mnemonic phrase',
+    [NodeEciesStringKey.Error_Member_MissingPrivateKey]:
+      'Private key is missing',
+    [NodeEciesStringKey.Error_Member_MissingEncryptionData]:
+      'Encryption data is missing',
+    [NodeEciesStringKey.Error_Member_EncryptionDataTooLarge]:
+      'Encryption data is too large',
+    [NodeEciesStringKey.Error_Member_MissingEmail]: 'Email address is required',
+    [NodeEciesStringKey.Error_Member_InvalidEmailWhitespace]:
+      'Email address cannot have leading or trailing whitespace',
+    [NodeEciesStringKey.Error_InvalidPublicKey]:
+      'Received null or undefined public key',
+    [NodeEciesStringKey.Error_InvalidPublicKeyFormat]:
+      'Invalid public key format or length',
+    [NodeEciesStringKey.Error_MessageLengthExceedsMaximumAllowedSize]:
+      'Message length exceeds maximum allowed size',
+    [NodeEciesStringKey.Error_InvalidEncryptionTypeOrNumberOfRecipients]:
+      'Invalid encryption type or number of recipients',
+    [NodeEciesStringKey.Error_EncryptedDataLengthMismatch]:
+      'Encrypted data length mismatch',
+    [NodeEciesStringKey.Error_EphemeralPublicKeyLengthMismatch]:
+      'Ephemeral public key has incorrect length after normalization',
+    [NodeEciesStringKey.Error_CombinedDataTooShort]:
+      'Combined data is too short to contain required components',
+    [NodeEciesStringKey.Error_EncryptedDataIsEmpty]: 'Encrypted data is empty',
+    [NodeEciesStringKey.Error_BufferIsTooShort]:
+      'Buffer is too short to read length type.',
+    [NodeEciesStringKey.Error_BufferIsTooShortToReadFullLengthValue]:
+      'Buffer is too short to read the full length value.',
+    [NodeEciesStringKey.Error_LengthExceedsMaximumSafeInteger]:
+      'Length exceeds maximum safe integer value',
+    [NodeEciesStringKey.Error_BufferIsTooShortForDeclaredDataLength]:
+      'Buffer is too short for declared data length',
+        [NodeEciesStringKey.Error_InvalidChecksumConstants]:
+      'Constantes de somme de contrôle invalides.',
+
+    // AES-GCM security errors
+    [NodeEciesStringKey.Error_InvalidAESKeyLength]: 'La clé AES doit faire 16, 24 ou 32 octets',
+    [NodeEciesStringKey.Error_CannotEncryptEmptyData]: 'Impossible de chiffrer des données nulles ou indéfinies',
+    [NodeEciesStringKey.Error_CannotDecryptEmptyData]: 'Impossible de déchiffrer des données nulles ou indéfinies',
+    [NodeEciesStringKey.Error_InvalidIVLength]: 'Le vecteur d\'initialisation doit faire 16 octets',
+    [NodeEciesStringKey.Error_MessageTooLarge]: 'Le message dépasse la taille maximale de 2 Go',
+    [NodeEciesStringKey.Error_EncryptedSizeExceedsExpected]: 'La taille des données chiffrées dépasse le maximum attendu',
+
+    // PBKDF2 errors
+    [NodeEciesStringKey.Error_Pbkdf2_InvalidSaltLength]: 'Invalid salt length',
+    [NodeEciesStringKey.Error_Pbkdf2_InvalidHashLength]: 'Invalid hash length',
+
+    // Builder errors
+    [NodeEciesStringKey.Error_Builder_ECIESServiceMustBeSetBeforeGeneratingMnemonic]: 'ECIESService must be set before generating mnemonic',
+    [NodeEciesStringKey.Error_Builder_ECIESServiceIsRequired]: 'ECIESService is required',
+    [NodeEciesStringKey.Error_Builder_TypeNameAndEmailAreRequired]: 'Type, name, and email are required',
+    [NodeEciesStringKey.Error_Stream_InvalidPublicKeyLength]: 'Invalid public key: must be 33 (compressed) or 65 (uncompressed) bytes',
+    [NodeEciesStringKey.Error_Stream_EncryptionCancelled]: 'Encryption cancelled',
+    [NodeEciesStringKey.Error_Stream_BufferOverflow]: 'Buffer overflow: source chunk exceeds maximum size',
+    [NodeEciesStringKey.Error_Stream_AtLeastOneRecipientRequired]: 'At least one recipient required',
+    [NodeEciesStringKey.Error_Stream_MaxRecipientsExceeded]: 'Maximum 65535 recipients supported',
+    [NodeEciesStringKey.Error_Stream_InvalidRecipientPublicKeyLength]: 'Invalid recipient public key: must be 33 (compressed) or 65 (uncompressed) bytes',
+    [NodeEciesStringKey.Error_Stream_InvalidRecipientIdLength]: 'Invalid recipient ID: must be 32 bytes',
+    [NodeEciesStringKey.Error_Stream_InvalidPrivateKeyLength]: 'Invalid private key: must be 32 bytes',
+    [NodeEciesStringKey.Error_Stream_DecryptionCancelled]: 'Decryption cancelled',
+    [NodeEciesStringKey.Error_Stream_ChunkSequenceError]: 'Chunk sequence error',
+    [NodeEciesStringKey.Error_Invariant_ConfigurationValidationFailedTemplate]: 'Node.js configuration validation failed:\n{failures}',
+    [NodeEciesStringKey.Error_Invariant_NodeRecipientIdConsistency_FailedTemplate]: "Invariant 'NodeRecipientIdConsistency' failed:\n  {issues}",
+    [NodeEciesStringKey.Error_Invariant_MemberIdLengthMismatchTemplate]: 'MEMBER_ID_LENGTH ({actual}) !== idProvider.byteLength ({expected})',
+    [NodeEciesStringKey.Error_Invariant_EciesMultipleRecipientIdSizeMismatchTemplate]: 'ECIES.MULTIPLE.RECIPIENT_ID_SIZE ({actual}) !== idProvider.byteLength ({expected})',
+    [NodeEciesStringKey.Error_Invariant_EncryptionRecipientIdSizeMismatchTemplate]: 'ENCRYPTION.RECIPIENT_ID_SIZE ({actual}) !== idProvider.byteLength ({expected})',
+  };

package/src/i18n/translations/en-US.ts

@@ -0,0 +1,88 @@
+import { NodeEciesStringKey } from '../node-keys';
+
+/**
+   * Node ECIES string translations
+   */
+  export const englishTranslations: Record<NodeEciesStringKey, string> = {
+    [NodeEciesStringKey.Error_LengthError_LengthIsInvalidType]:
+      'Length encoding type is invalid',
+
+    // Member errors
+    [NodeEciesStringKey.Error_Member_MissingMemberName]:
+      'Member name is required',
+    [NodeEciesStringKey.Error_Member_InvalidMemberNameWhitespace]:
+      'Member name cannot have leading or trailing whitespace',
+    [NodeEciesStringKey.Error_Member_NoWallet]: 'No wallet available',
+    [NodeEciesStringKey.Error_Member_WalletAlreadyLoaded]:
+      'Wallet is already loaded',
+    [NodeEciesStringKey.Error_Member_InvalidMnemonic]:
+      'Invalid mnemonic phrase',
+    [NodeEciesStringKey.Error_Member_MissingPrivateKey]:
+      'Private key is missing',
+    [NodeEciesStringKey.Error_Member_MissingEncryptionData]:
+      'Encryption data is missing',
+    [NodeEciesStringKey.Error_Member_EncryptionDataTooLarge]:
+      'Encryption data is too large',
+    [NodeEciesStringKey.Error_Member_MissingEmail]: 'Email address is required',
+    [NodeEciesStringKey.Error_Member_InvalidEmailWhitespace]:
+      'Email address cannot have leading or trailing whitespace',
+    [NodeEciesStringKey.Error_InvalidPublicKey]:
+      'Received null or undefined public key',
+    [NodeEciesStringKey.Error_InvalidPublicKeyFormat]:
+      'Invalid public key format or length',
+    [NodeEciesStringKey.Error_MessageLengthExceedsMaximumAllowedSize]:
+      'Message length exceeds maximum allowed size',
+    [NodeEciesStringKey.Error_InvalidEncryptionTypeOrNumberOfRecipients]:
+      'Invalid encryption type or number of recipients',
+    [NodeEciesStringKey.Error_EncryptedDataLengthMismatch]:
+      'Encrypted data length mismatch',
+    [NodeEciesStringKey.Error_EphemeralPublicKeyLengthMismatch]:
+      'Ephemeral public key has incorrect length after normalization',
+    [NodeEciesStringKey.Error_EncryptedDataIsEmpty]: 'Encrypted data is empty',
+    [NodeEciesStringKey.Error_CombinedDataTooShort]:
+      'Combined data is too short to contain required components',
+    [NodeEciesStringKey.Error_BufferIsTooShort]:
+      'Buffer is too short to read length type.',
+    [NodeEciesStringKey.Error_BufferIsTooShortToReadFullLengthValue]:
+      'Buffer is too short to read the full length value.',
+    [NodeEciesStringKey.Error_LengthExceedsMaximumSafeInteger]:
+      'Length exceeds maximum safe integer value',
+    [NodeEciesStringKey.Error_BufferIsTooShortForDeclaredDataLength]:
+      'Buffer is too short for declared data length',
+        [NodeEciesStringKey.Error_InvalidChecksumConstants]:
+      'Invalid checksum constants',
+
+    // AES-GCM security errors
+    [NodeEciesStringKey.Error_InvalidAESKeyLength]: 'AES key must be 16, 24, or 32 bytes',
+    [NodeEciesStringKey.Error_CannotEncryptEmptyData]: 'Cannot encrypt null or undefined data',
+    [NodeEciesStringKey.Error_CannotDecryptEmptyData]: 'Cannot decrypt null or undefined data',
+    [NodeEciesStringKey.Error_InvalidIVLength]: 'IV must be 16 bytes',
+    [NodeEciesStringKey.Error_MessageTooLarge]: 'Message exceeds maximum size of 2GB',
+    [NodeEciesStringKey.Error_EncryptedSizeExceedsExpected]: 'Encrypted data size exceeds expected maximum',
+
+    // PBKDF2 errors
+    [NodeEciesStringKey.Error_Pbkdf2_InvalidSaltLength]: 'Invalid salt length',
+    [NodeEciesStringKey.Error_Pbkdf2_InvalidHashLength]: 'Invalid hash length',
+
+    // Builder errors
+    [NodeEciesStringKey.Error_Builder_ECIESServiceMustBeSetBeforeGeneratingMnemonic]: 'ECIESService must be set before generating mnemonic',
+    [NodeEciesStringKey.Error_Builder_ECIESServiceIsRequired]: 'ECIESService is required',
+    [NodeEciesStringKey.Error_Builder_TypeNameAndEmailAreRequired]: 'Type, name, and email are required',
+    [NodeEciesStringKey.Error_Stream_InvalidPublicKeyLength]: 'Invalid public key: must be 33 (compressed) or 65 (uncompressed) bytes',
+    [NodeEciesStringKey.Error_Stream_EncryptionCancelled]: 'Encryption cancelled',
+    [NodeEciesStringKey.Error_Stream_BufferOverflow]: 'Buffer overflow: source chunk exceeds maximum size',
+    [NodeEciesStringKey.Error_Stream_AtLeastOneRecipientRequired]: 'At least one recipient required',
+    [NodeEciesStringKey.Error_Stream_MaxRecipientsExceeded]: 'Maximum 65535 recipients supported',
+    [NodeEciesStringKey.Error_Stream_InvalidRecipientPublicKeyLength]: 'Invalid recipient public key: must be 33 (compressed) or 65 (uncompressed) bytes',
+    [NodeEciesStringKey.Error_Stream_InvalidRecipientIdLength]: 'Invalid recipient ID: must be 32 bytes',
+    [NodeEciesStringKey.Error_Stream_InvalidPrivateKeyLength]: 'Invalid private key: must be 32 bytes',
+    [NodeEciesStringKey.Error_Stream_DecryptionCancelled]: 'Decryption cancelled',
+    [NodeEciesStringKey.Error_Stream_ChunkSequenceError]: 'Chunk sequence error',
+
+    // Invariant errors
+    [NodeEciesStringKey.Error_Invariant_ConfigurationValidationFailedTemplate]: 'Node.js configuration validation failed:\n{failures}',
+    [NodeEciesStringKey.Error_Invariant_NodeRecipientIdConsistency_FailedTemplate]: "Invariant 'NodeRecipientIdConsistency' failed:\n  {issues}",
+    [NodeEciesStringKey.Error_Invariant_MemberIdLengthMismatchTemplate]: 'MEMBER_ID_LENGTH ({actual}) !== idProvider.byteLength ({expected})',
+    [NodeEciesStringKey.Error_Invariant_EciesMultipleRecipientIdSizeMismatchTemplate]: 'ECIES.MULTIPLE.RECIPIENT_ID_SIZE ({actual}) !== idProvider.byteLength ({expected})',
+    [NodeEciesStringKey.Error_Invariant_EncryptionRecipientIdSizeMismatchTemplate]: 'ENCRYPTION.RECIPIENT_ID_SIZE ({actual}) !== idProvider.byteLength ({expected})',
+  };

package/src/i18n/translations/es.ts

@@ -0,0 +1,54 @@
+import { NodeEciesStringKey } from '../node-keys';
+
+export const spanishTranslations: Record<NodeEciesStringKey, string> = {
+  [NodeEciesStringKey.Error_LengthError_LengthIsInvalidType]: 'El tipo de codificación de longitud es inválido',
+  [NodeEciesStringKey.Error_Member_MissingMemberName]: 'Se requiere el nombre del miembro',
+  [NodeEciesStringKey.Error_Member_InvalidMemberNameWhitespace]: 'El nombre del miembro no puede tener espacios al principio o al final',
+  [NodeEciesStringKey.Error_Member_NoWallet]: 'No hay billetera disponible',
+  [NodeEciesStringKey.Error_Member_WalletAlreadyLoaded]: 'La billetera ya está cargada',
+  [NodeEciesStringKey.Error_Member_InvalidMnemonic]: 'Frase mnemotécnica inválida',
+  [NodeEciesStringKey.Error_Member_MissingPrivateKey]: 'Falta la clave privada',
+  [NodeEciesStringKey.Error_Member_MissingEncryptionData]: 'Faltan los datos de cifrado',
+  [NodeEciesStringKey.Error_Member_EncryptionDataTooLarge]: 'Los datos de cifrado son demasiado grandes',
+  [NodeEciesStringKey.Error_Member_MissingEmail]: 'Se requiere la dirección de correo electrónico',
+  [NodeEciesStringKey.Error_Member_InvalidEmailWhitespace]: 'La dirección de correo electrónico no puede tener espacios al principio o al final',
+  [NodeEciesStringKey.Error_InvalidPublicKey]: 'Se recibió clave pública nula o indefinida',
+  [NodeEciesStringKey.Error_InvalidPublicKeyFormat]: 'Formato o longitud de clave pública inválido',
+  [NodeEciesStringKey.Error_MessageLengthExceedsMaximumAllowedSize]: 'La longitud del mensaje supera el tamaño máximo permitido',
+  [NodeEciesStringKey.Error_InvalidEncryptionTypeOrNumberOfRecipients]: 'Tipo de cifrado o número de destinatarios inválido',
+  [NodeEciesStringKey.Error_EncryptedDataLengthMismatch]: 'Desajuste de longitud de datos cifrados',
+  [NodeEciesStringKey.Error_EphemeralPublicKeyLengthMismatch]: 'La clave pública efímera tiene una longitud incorrecta después de la normalización',
+  [NodeEciesStringKey.Error_EncryptedDataIsEmpty]: 'Los datos cifrados están vacíos',
+  [NodeEciesStringKey.Error_CombinedDataTooShort]: 'Los datos combinados son demasiado cortos para contener los componentes requeridos',
+  [NodeEciesStringKey.Error_BufferIsTooShort]: 'El búfer es demasiado corto para leer el tipo de longitud',
+  [NodeEciesStringKey.Error_BufferIsTooShortToReadFullLengthValue]: 'El búfer es demasiado corto para leer la longitud completa',
+  [NodeEciesStringKey.Error_LengthExceedsMaximumSafeInteger]: 'La longitud excede el valor máximo seguro para enteros',
+  [NodeEciesStringKey.Error_BufferIsTooShortForDeclaredDataLength]: 'El búfer es demasiado corto para la longitud de datos declarada',
+  [NodeEciesStringKey.Error_InvalidChecksumConstants]: 'Constantes de suma de comprobación no válidas',
+  [NodeEciesStringKey.Error_InvalidAESKeyLength]: 'La clave AES debe ser de 16, 24 o 32 bytes',
+  [NodeEciesStringKey.Error_CannotEncryptEmptyData]: 'No se pueden cifrar datos nulos o indefinidos',
+  [NodeEciesStringKey.Error_CannotDecryptEmptyData]: 'No se pueden descifrar datos nulos o indefinidos',
+  [NodeEciesStringKey.Error_InvalidIVLength]: 'El IV debe ser de 16 bytes',
+  [NodeEciesStringKey.Error_MessageTooLarge]: 'El mensaje excede el tamaño máximo de 2GB',
+  [NodeEciesStringKey.Error_EncryptedSizeExceedsExpected]: 'El tamaño de los datos cifrados excede el máximo esperado',
+  [NodeEciesStringKey.Error_Pbkdf2_InvalidSaltLength]: 'Longitud de sal inválida',
+  [NodeEciesStringKey.Error_Pbkdf2_InvalidHashLength]: 'Longitud de hash inválida',
+  [NodeEciesStringKey.Error_Builder_ECIESServiceMustBeSetBeforeGeneratingMnemonic]: 'ECIESService debe configurarse antes de generar un mnemónico',
+  [NodeEciesStringKey.Error_Builder_ECIESServiceIsRequired]: 'ECIESService es requerido',
+  [NodeEciesStringKey.Error_Builder_TypeNameAndEmailAreRequired]: 'El tipo, nombre y correo electrónico son requeridos',
+  [NodeEciesStringKey.Error_Stream_InvalidPublicKeyLength]: 'Clave pública inválida: debe ser de 33 (comprimida) o 65 (sin comprimir) bytes',
+  [NodeEciesStringKey.Error_Stream_EncryptionCancelled]: 'Cifrado cancelado',
+  [NodeEciesStringKey.Error_Stream_BufferOverflow]: 'Desbordamiento de búfer: el fragmento de origen excede el tamaño máximo',
+  [NodeEciesStringKey.Error_Stream_AtLeastOneRecipientRequired]: 'Se requiere al menos un destinatario',
+  [NodeEciesStringKey.Error_Stream_MaxRecipientsExceeded]: 'Máximo de 65535 destinatarios admitidos',
+  [NodeEciesStringKey.Error_Stream_InvalidRecipientPublicKeyLength]: 'Clave pública del destinatario inválida: debe ser de 33 (comprimida) o 65 (sin comprimir) bytes',
+  [NodeEciesStringKey.Error_Stream_InvalidRecipientIdLength]: 'ID de destinatario inválido: debe ser de 32 bytes',
+  [NodeEciesStringKey.Error_Stream_InvalidPrivateKeyLength]: 'Clave privada inválida: debe ser de 32 bytes',
+  [NodeEciesStringKey.Error_Stream_DecryptionCancelled]: 'Descifrado cancelado',
+  [NodeEciesStringKey.Error_Stream_ChunkSequenceError]: 'Error de secuencia de fragmentos',
+  [NodeEciesStringKey.Error_Invariant_ConfigurationValidationFailedTemplate]: 'Node.js configuration validation failed:\n{failures}',
+  [NodeEciesStringKey.Error_Invariant_NodeRecipientIdConsistency_FailedTemplate]: "Invariant 'NodeRecipientIdConsistency' failed:\n  {issues}",
+  [NodeEciesStringKey.Error_Invariant_MemberIdLengthMismatchTemplate]: 'MEMBER_ID_LENGTH ({actual}) !== idProvider.byteLength ({expected})',
+  [NodeEciesStringKey.Error_Invariant_EciesMultipleRecipientIdSizeMismatchTemplate]: 'ECIES.MULTIPLE.RECIPIENT_ID_SIZE ({actual}) !== idProvider.byteLength ({expected})',
+  [NodeEciesStringKey.Error_Invariant_EncryptionRecipientIdSizeMismatchTemplate]: 'ENCRYPTION.RECIPIENT_ID_SIZE ({actual}) !== idProvider.byteLength ({expected})',
+};

package/src/i18n/translations/fr.ts

@@ -0,0 +1,54 @@
+import { NodeEciesStringKey } from '../node-keys';
+
+export const frenchTranslations: Record<NodeEciesStringKey, string> = {
+  [NodeEciesStringKey.Error_LengthError_LengthIsInvalidType]: "Le type d'encodage de longueur est invalide",
+  [NodeEciesStringKey.Error_Member_MissingMemberName]: 'Le nom du membre est requis',
+  [NodeEciesStringKey.Error_Member_InvalidMemberNameWhitespace]: "Le nom du membre ne peut pas avoir d'espaces au début ou à la fin",
+  [NodeEciesStringKey.Error_Member_NoWallet]: 'Aucun portefeuille disponible',
+  [NodeEciesStringKey.Error_Member_WalletAlreadyLoaded]: 'Le portefeuille est déjà chargé',
+  [NodeEciesStringKey.Error_Member_InvalidMnemonic]: 'Phrase mnémotechnique invalide',
+  [NodeEciesStringKey.Error_Member_MissingPrivateKey]: 'Clé privée manquante',
+  [NodeEciesStringKey.Error_Member_MissingEncryptionData]: 'Données de chiffrement manquantes',
+  [NodeEciesStringKey.Error_Member_EncryptionDataTooLarge]: 'Données de chiffrement trop volumineuses',
+  [NodeEciesStringKey.Error_Member_MissingEmail]: 'Adresse e-mail requise',
+  [NodeEciesStringKey.Error_Member_InvalidEmailWhitespace]: "L'adresse e-mail ne peut pas avoir d'espaces au début ou à la fin",
+  [NodeEciesStringKey.Error_InvalidPublicKey]: 'Clé publique reçue nulle ou indéfinie',
+  [NodeEciesStringKey.Error_InvalidPublicKeyFormat]: 'Format ou longueur de clé publique invalide',
+  [NodeEciesStringKey.Error_MessageLengthExceedsMaximumAllowedSize]: 'La longueur du message dépasse la taille maximale autorisée',
+  [NodeEciesStringKey.Error_InvalidEncryptionTypeOrNumberOfRecipients]: 'Type de chiffrement ou nombre de destinataires invalide',
+  [NodeEciesStringKey.Error_EncryptedDataLengthMismatch]: 'Incohérence de longueur des données chiffrées',
+  [NodeEciesStringKey.Error_EphemeralPublicKeyLengthMismatch]: 'La clé publique éphémère a une longueur incorrecte après normalisation',
+  [NodeEciesStringKey.Error_EncryptedDataIsEmpty]: 'Les données chiffrées sont vides',
+  [NodeEciesStringKey.Error_CombinedDataTooShort]: 'Les données combinées sont trop courtes pour contenir les composants requis',
+  [NodeEciesStringKey.Error_BufferIsTooShort]: 'Le tampon est trop court pour lire le type de longueur',
+  [NodeEciesStringKey.Error_BufferIsTooShortToReadFullLengthValue]: 'Le tampon est trop court pour lire la valeur de longueur complète',
+  [NodeEciesStringKey.Error_LengthExceedsMaximumSafeInteger]: 'La longueur dépasse la valeur entière sécurisée maximale',
+  [NodeEciesStringKey.Error_BufferIsTooShortForDeclaredDataLength]: 'Le tampon est trop court pour la longueur de données déclarée',
+  [NodeEciesStringKey.Error_InvalidChecksumConstants]: 'Constantes de somme de contrôle invalides',
+  [NodeEciesStringKey.Error_InvalidAESKeyLength]: 'La clé AES doit faire 16, 24 ou 32 octets',
+  [NodeEciesStringKey.Error_CannotEncryptEmptyData]: 'Impossible de chiffrer des données nulles ou indéfinies',
+  [NodeEciesStringKey.Error_CannotDecryptEmptyData]: 'Impossible de déchiffrer des données nulles ou indéfinies',
+  [NodeEciesStringKey.Error_InvalidIVLength]: 'Le vecteur d\'initialisation doit faire 16 octets',
+  [NodeEciesStringKey.Error_MessageTooLarge]: 'Le message dépasse la taille maximale de 2 Go',
+  [NodeEciesStringKey.Error_EncryptedSizeExceedsExpected]: 'La taille des données chiffrées dépasse le maximum attendu',
+  [NodeEciesStringKey.Error_Pbkdf2_InvalidSaltLength]: 'Longueur de sel invalide',
+  [NodeEciesStringKey.Error_Pbkdf2_InvalidHashLength]: 'Longueur de hachage invalide',
+  [NodeEciesStringKey.Error_Builder_ECIESServiceMustBeSetBeforeGeneratingMnemonic]: 'ECIESService doit être défini avant de générer un mnémonique',
+  [NodeEciesStringKey.Error_Builder_ECIESServiceIsRequired]: 'ECIESService est requis',
+  [NodeEciesStringKey.Error_Builder_TypeNameAndEmailAreRequired]: 'Le type, le nom et l\'e-mail sont requis',
+  [NodeEciesStringKey.Error_Stream_InvalidPublicKeyLength]: 'Clé publique invalide : doit faire 33 (compressée) ou 65 (non compressée) octets',
+  [NodeEciesStringKey.Error_Stream_EncryptionCancelled]: 'Chiffrement annulé',
+  [NodeEciesStringKey.Error_Stream_BufferOverflow]: 'Débordement de tampon : le bloc source dépasse la taille maximale',
+  [NodeEciesStringKey.Error_Stream_AtLeastOneRecipientRequired]: 'Au moins un destinataire requis',
+  [NodeEciesStringKey.Error_Stream_MaxRecipientsExceeded]: 'Maximum de 65535 destinataires pris en charge',
+  [NodeEciesStringKey.Error_Stream_InvalidRecipientPublicKeyLength]: 'Clé publique du destinataire invalide : doit faire 33 (compressée) ou 65 (non compressée) octets',
+  [NodeEciesStringKey.Error_Stream_InvalidRecipientIdLength]: 'ID de destinataire invalide : doit faire 32 octets',
+  [NodeEciesStringKey.Error_Stream_InvalidPrivateKeyLength]: 'Clé privée invalide : doit faire 32 octets',
+  [NodeEciesStringKey.Error_Stream_DecryptionCancelled]: 'Déchiffrement annulé',
+  [NodeEciesStringKey.Error_Stream_ChunkSequenceError]: 'Erreur de séquence de morceaux',
+  [NodeEciesStringKey.Error_Invariant_ConfigurationValidationFailedTemplate]: 'Node.js configuration validation failed:\n{failures}',
+  [NodeEciesStringKey.Error_Invariant_NodeRecipientIdConsistency_FailedTemplate]: "Invariant 'NodeRecipientIdConsistency' failed:\n  {issues}",
+  [NodeEciesStringKey.Error_Invariant_MemberIdLengthMismatchTemplate]: 'MEMBER_ID_LENGTH ({actual}) !== idProvider.byteLength ({expected})',
+  [NodeEciesStringKey.Error_Invariant_EciesMultipleRecipientIdSizeMismatchTemplate]: 'ECIES.MULTIPLE.RECIPIENT_ID_SIZE ({actual}) !== idProvider.byteLength ({expected})',
+  [NodeEciesStringKey.Error_Invariant_EncryptionRecipientIdSizeMismatchTemplate]: 'ENCRYPTION.RECIPIENT_ID_SIZE ({actual}) !== idProvider.byteLength ({expected})',
+};

package/src/i18n/translations/{index.d.ts → index.ts}

@@ -6,4 +6,3 @@ export { japaneseTranslations } from './ja';
 export { ukrainianTranslations } from './uk';
 export { englishTranslations } from './en-US';
 export { britishEnglishTranslations } from './en-GB';
-//# sourceMappingURL=index.d.ts.map

package/src/i18n/translations/ja.ts

@@ -0,0 +1,54 @@
+import { NodeEciesStringKey } from '../node-keys';
+
+export const japaneseTranslations: Record<NodeEciesStringKey, string> = {
+  [NodeEciesStringKey.Error_LengthError_LengthIsInvalidType]: '長さエンコーディングタイプが無効です',
+  [NodeEciesStringKey.Error_Member_MissingMemberName]: 'メンバー名は必須です',
+  [NodeEciesStringKey.Error_Member_InvalidMemberNameWhitespace]: 'メンバー名は前後に空白を含めることはできません',
+  [NodeEciesStringKey.Error_Member_NoWallet]: '利用可能なウォレットがありません',
+  [NodeEciesStringKey.Error_Member_WalletAlreadyLoaded]: 'ウォレットはすでに読み込まれています',
+  [NodeEciesStringKey.Error_Member_InvalidMnemonic]: '無効な助記詞フレーズ',
+  [NodeEciesStringKey.Error_Member_MissingPrivateKey]: 'プライベートキーが見つかりません',
+  [NodeEciesStringKey.Error_Member_MissingEncryptionData]: '暗号化データが見つかりません',
+  [NodeEciesStringKey.Error_Member_EncryptionDataTooLarge]: '暗号化データが大きすぎます',
+  [NodeEciesStringKey.Error_Member_MissingEmail]: 'メールアドレスは必須です',
+  [NodeEciesStringKey.Error_Member_InvalidEmailWhitespace]: 'メールアドレスは前後に空白を含めることはできません',
+  [NodeEciesStringKey.Error_InvalidPublicKey]: '受信した公開鍵はnullまたは未定義です',
+  [NodeEciesStringKey.Error_InvalidPublicKeyFormat]: '無効な公開鍵の形式または長さ',
+  [NodeEciesStringKey.Error_MessageLengthExceedsMaximumAllowedSize]: 'メッセージの長さが最大許可サイズを超えています',
+  [NodeEciesStringKey.Error_InvalidEncryptionTypeOrNumberOfRecipients]: '無効な暗号化タイプまたは受信者の数',
+  [NodeEciesStringKey.Error_EncryptedDataLengthMismatch]: '暗号化データの長さが一致しません',
+  [NodeEciesStringKey.Error_EphemeralPublicKeyLengthMismatch]: '正規化後のエフェメラル公開鍵の長さが正しくありません',
+  [NodeEciesStringKey.Error_EncryptedDataIsEmpty]: '暗号化データが空です',
+  [NodeEciesStringKey.Error_CombinedDataTooShort]: '組み合わせデータが短すぎて、必要なコンポーネントを含めることができません',
+  [NodeEciesStringKey.Error_BufferIsTooShort]: 'バッファが短すぎて長さタイプを読み取れません',
+  [NodeEciesStringKey.Error_BufferIsTooShortToReadFullLengthValue]: 'バッファが短すぎて完全な長さの値を読み取れません',
+  [NodeEciesStringKey.Error_LengthExceedsMaximumSafeInteger]: '長さが最大安全整数値を超えています',
+  [NodeEciesStringKey.Error_BufferIsTooShortForDeclaredDataLength]: 'バッファが短すぎて宣言されたデータ長を読み取れません',
+  [NodeEciesStringKey.Error_InvalidChecksumConstants]: '無効なチェックサム定数',
+  [NodeEciesStringKey.Error_InvalidAESKeyLength]: 'AES鍵は16、24、または32バイトである必要があります',
+  [NodeEciesStringKey.Error_CannotEncryptEmptyData]: 'nullまたは未定義のデータを暗号化できません',
+  [NodeEciesStringKey.Error_CannotDecryptEmptyData]: 'nullまたは未定義のデータを復号化できません',
+  [NodeEciesStringKey.Error_InvalidIVLength]: 'IVは16バイトである必要があります',
+  [NodeEciesStringKey.Error_MessageTooLarge]: 'メッセージが最大サイズ2GBを超えています',
+  [NodeEciesStringKey.Error_EncryptedSizeExceedsExpected]: '暗号化データサイズが予想される最大値を超えています',
+  [NodeEciesStringKey.Error_Pbkdf2_InvalidSaltLength]: '無効なソルト長',
+  [NodeEciesStringKey.Error_Pbkdf2_InvalidHashLength]: '無効なハッシュ長',
+  [NodeEciesStringKey.Error_Builder_ECIESServiceMustBeSetBeforeGeneratingMnemonic]: 'ニーモニックを生成する前にECIESServiceを設定する必要があります',
+  [NodeEciesStringKey.Error_Builder_ECIESServiceIsRequired]: 'ECIESServiceが必要です',
+  [NodeEciesStringKey.Error_Builder_TypeNameAndEmailAreRequired]: 'タイプ、名前、メールが必要です',
+  [NodeEciesStringKey.Error_Stream_InvalidPublicKeyLength]: '無効な公開鍵：33（圧縮）または65（非圧縮）バイトである必要があります',
+  [NodeEciesStringKey.Error_Stream_EncryptionCancelled]: '暗号化がキャンセルされました',
+  [NodeEciesStringKey.Error_Stream_BufferOverflow]: 'バッファオーバーフロー：ソースチャンクが最大サイズを超えています',
+  [NodeEciesStringKey.Error_Stream_AtLeastOneRecipientRequired]: '少なくとも1人の受信者が必要です',
+  [NodeEciesStringKey.Error_Stream_MaxRecipientsExceeded]: '最大65535人の受信者がサポートされています',
+  [NodeEciesStringKey.Error_Stream_InvalidRecipientPublicKeyLength]: '無効な受信者公開鍵：33（圧縮）または65（非圧縮）バイトである必要があります',
+  [NodeEciesStringKey.Error_Stream_InvalidRecipientIdLength]: '無効な受信者ID：32バイトである必要があります',
+  [NodeEciesStringKey.Error_Stream_InvalidPrivateKeyLength]: '無効な秘密鍵：32バイトである必要があります',
+  [NodeEciesStringKey.Error_Stream_DecryptionCancelled]: '復号化がキャンセルされました',
+  [NodeEciesStringKey.Error_Stream_ChunkSequenceError]: 'チャンクシーケンスエラー',
+  [NodeEciesStringKey.Error_Invariant_ConfigurationValidationFailedTemplate]: 'Node.js configuration validation failed:\n{failures}',
+  [NodeEciesStringKey.Error_Invariant_NodeRecipientIdConsistency_FailedTemplate]: "Invariant 'NodeRecipientIdConsistency' failed:\n  {issues}",
+  [NodeEciesStringKey.Error_Invariant_MemberIdLengthMismatchTemplate]: 'MEMBER_ID_LENGTH ({actual}) !== idProvider.byteLength ({expected})',
+  [NodeEciesStringKey.Error_Invariant_EciesMultipleRecipientIdSizeMismatchTemplate]: 'ECIES.MULTIPLE.RECIPIENT_ID_SIZE ({actual}) !== idProvider.byteLength ({expected})',
+  [NodeEciesStringKey.Error_Invariant_EncryptionRecipientIdSizeMismatchTemplate]: 'ENCRYPTION.RECIPIENT_ID_SIZE ({actual}) !== idProvider.byteLength ({expected})',
+};

package/src/i18n/translations/uk.ts

@@ -0,0 +1,54 @@
+import { NodeEciesStringKey } from '../node-keys';
+
+export const ukrainianTranslations: Record<NodeEciesStringKey, string> = {
+  [NodeEciesStringKey.Error_LengthError_LengthIsInvalidType]: 'Тип кодування довжини недійсний',
+  [NodeEciesStringKey.Error_Member_MissingMemberName]: "Обов'язкове поле: ім'я учасника",
+  [NodeEciesStringKey.Error_Member_InvalidMemberNameWhitespace]: "Ім'я учасника не може містити провідні або кінцеві пробіли",
+  [NodeEciesStringKey.Error_Member_NoWallet]: 'Немає доступного гаманця',
+  [NodeEciesStringKey.Error_Member_WalletAlreadyLoaded]: 'Гаманець вже завантажено',
+  [NodeEciesStringKey.Error_Member_InvalidMnemonic]: 'Неправильна мнемонічна фраза',
+  [NodeEciesStringKey.Error_Member_MissingPrivateKey]: 'Відсутній приватний ключ',
+  [NodeEciesStringKey.Error_Member_MissingEncryptionData]: 'Відсутні дані шифрування',
+  [NodeEciesStringKey.Error_Member_EncryptionDataTooLarge]: 'Дані шифрування занадто великі',
+  [NodeEciesStringKey.Error_Member_MissingEmail]: "Обов'язкове поле: адреса електронної пошти",
+  [NodeEciesStringKey.Error_Member_InvalidEmailWhitespace]: 'Адреса електронної пошти не може містити провідні або кінцеві пробіли',
+  [NodeEciesStringKey.Error_InvalidPublicKey]: 'Отримано нульовий або невизначений публічний ключ',
+  [NodeEciesStringKey.Error_InvalidPublicKeyFormat]: 'Неправильний формат або довжина публічного ключа',
+  [NodeEciesStringKey.Error_MessageLengthExceedsMaximumAllowedSize]: 'Довжина повідомлення перевищує максимально допустимий розмір',
+  [NodeEciesStringKey.Error_InvalidEncryptionTypeOrNumberOfRecipients]: 'Неправильний тип шифрування або кількість отримувачів',
+  [NodeEciesStringKey.Error_EncryptedDataLengthMismatch]: 'Довжина зашифрованих даних не збігається',
+  [NodeEciesStringKey.Error_EphemeralPublicKeyLengthMismatch]: 'Тимчасовий публічний ключ має неправильну довжину після нормалізації',
+  [NodeEciesStringKey.Error_EncryptedDataIsEmpty]: 'Зашифровані дані порожні',
+  [NodeEciesStringKey.Error_CombinedDataTooShort]: "Об'єднані дані занадто короткі, щоб містити необхідні компоненти",
+  [NodeEciesStringKey.Error_BufferIsTooShort]: 'Буфер занадто короткий, щоб прочитати тип довжини',
+  [NodeEciesStringKey.Error_BufferIsTooShortToReadFullLengthValue]: 'Буфер занадто короткий, щоб прочитати повну довжину значення',
+  [NodeEciesStringKey.Error_LengthExceedsMaximumSafeInteger]: 'Довжина перевищує максимальне безпечне ціле значення',
+  [NodeEciesStringKey.Error_BufferIsTooShortForDeclaredDataLength]: 'Буфер занадто короткий для заявленої довжини даних',
+  [NodeEciesStringKey.Error_InvalidChecksumConstants]: 'Неправильні константи контрольної суми',
+  [NodeEciesStringKey.Error_InvalidAESKeyLength]: 'Ключ AES повинен бути 16, 24 або 32 байти',
+  [NodeEciesStringKey.Error_CannotEncryptEmptyData]: 'Неможливо зашифрувати null або невизначені дані',
+  [NodeEciesStringKey.Error_CannotDecryptEmptyData]: 'Неможливо розшифрувати null або невизначені дані',
+  [NodeEciesStringKey.Error_InvalidIVLength]: 'IV повинен бути 16 байтів',
+  [NodeEciesStringKey.Error_MessageTooLarge]: 'Повідомлення перевищує максимальний розмір 2ГБ',
+  [NodeEciesStringKey.Error_EncryptedSizeExceedsExpected]: 'Розмір зашифрованих даних перевищує очікуваний максимум',
+  [NodeEciesStringKey.Error_Pbkdf2_InvalidSaltLength]: 'Недійсна довжина солі',
+  [NodeEciesStringKey.Error_Pbkdf2_InvalidHashLength]: 'Недійсна довжина хешу',
+  [NodeEciesStringKey.Error_Builder_ECIESServiceMustBeSetBeforeGeneratingMnemonic]: 'ECIESService повинен бути встановлений перед генерацією мнемоніки',
+  [NodeEciesStringKey.Error_Builder_ECIESServiceIsRequired]: "ECIESService є обов'язковим",
+  [NodeEciesStringKey.Error_Builder_TypeNameAndEmailAreRequired]: "Тип, ім'я та електронна пошта є обов'язковими",
+  [NodeEciesStringKey.Error_Stream_InvalidPublicKeyLength]: 'Недійсний публічний ключ: повинен бути 33 (стиснутий) або 65 (нестиснутий) байтів',
+  [NodeEciesStringKey.Error_Stream_EncryptionCancelled]: 'Шифрування скасовано',
+  [NodeEciesStringKey.Error_Stream_BufferOverflow]: 'Переповнення буфера: блок джерела перевищує максимальний розмір',
+  [NodeEciesStringKey.Error_Stream_AtLeastOneRecipientRequired]: "Потрібен щонайменше один отримувач",
+  [NodeEciesStringKey.Error_Stream_MaxRecipientsExceeded]: 'Підтримується максимум 65535 отримувачів',
+  [NodeEciesStringKey.Error_Stream_InvalidRecipientPublicKeyLength]: 'Недійсний публічний ключ отримувача: повинен бути 33 (стиснутий) або 65 (нестиснутий) байтів',
+  [NodeEciesStringKey.Error_Stream_InvalidRecipientIdLength]: 'Недійсний ID отримувача: повинен бути 32 байти',
+  [NodeEciesStringKey.Error_Stream_InvalidPrivateKeyLength]: 'Недійсний приватний ключ: повинен бути 32 байти',
+  [NodeEciesStringKey.Error_Stream_DecryptionCancelled]: 'Розшифрування скасовано',
+  [NodeEciesStringKey.Error_Stream_ChunkSequenceError]: 'Помилка послідовності фрагментів',
+  [NodeEciesStringKey.Error_Invariant_ConfigurationValidationFailedTemplate]: 'Node.js configuration validation failed:\n{failures}',
+  [NodeEciesStringKey.Error_Invariant_NodeRecipientIdConsistency_FailedTemplate]: "Invariant 'NodeRecipientIdConsistency' failed:\n  {issues}",
+  [NodeEciesStringKey.Error_Invariant_MemberIdLengthMismatchTemplate]: 'MEMBER_ID_LENGTH ({actual}) !== idProvider.byteLength ({expected})',
+  [NodeEciesStringKey.Error_Invariant_EciesMultipleRecipientIdSizeMismatchTemplate]: 'ECIES.MULTIPLE.RECIPIENT_ID_SIZE ({actual}) !== idProvider.byteLength ({expected})',
+  [NodeEciesStringKey.Error_Invariant_EncryptionRecipientIdSizeMismatchTemplate]: 'ENCRYPTION.RECIPIENT_ID_SIZE ({actual}) !== idProvider.byteLength ({expected})',
+};