@digitaldefiance/ecies-lib 4.4.1 → 4.4.3

package/src/test-mocks/mock-frontend-member.ts

@@ -0,0 +1,276 @@
+import {
+  EmailString,
+  MemberType,
+  SecureBuffer,
+  SecureString,
+} from '@digitaldefiance/ecies-lib';
+import { Wallet } from '@ethereumjs/wallet';
+import { faker } from '@faker-js/faker';
+
+import { ObjectId } from 'bson';
+import type { IFrontendMemberOperational } from '../interfaces/frontend-member-operational';
+import { SignatureUint8Array } from '../types';
+
+const hexToUint8Array = (hex: string): Uint8Array => {
+  const clean = hex.replace(/^0x/, '');
+  const bytes = new Uint8Array(clean.length / 2);
+  for (let i = 0; i < clean.length; i += 2) {
+    bytes[i / 2] = parseInt(clean.slice(i, i + 2), 16);
+  }
+  return bytes;
+};
+
+const createMockWallet = (): Wallet =>
+  ({
+    getPrivateKey: () =>
+      hexToUint8Array(faker.string.hexadecimal({ length: 64 })),
+    getPublicKey: () =>
+      hexToUint8Array(faker.string.hexadecimal({ length: 128 })),
+    getAddress: () => hexToUint8Array(faker.string.hexadecimal({ length: 40 })),
+    sign: () => hexToUint8Array(faker.string.hexadecimal({ length: 128 })),
+  } as any);
+
+export class MockFrontendMember
+  implements IFrontendMemberOperational<ObjectId>
+{
+  private _id: ObjectId;
+  private _type: MemberType;
+  private _name: string;
+  private _email: EmailString;
+  private _publicKey: Uint8Array;
+  private _creatorId: ObjectId;
+  private _dateCreated: Date;
+  private _dateUpdated: Date;
+  private _privateKey?: SecureBuffer;
+  private _wallet?: Wallet;
+  private _hasPrivateKey: boolean;
+
+  constructor(
+    data: Partial<{
+      id: ObjectId;
+      type: MemberType;
+      name: string;
+      email: EmailString;
+      publicKey: Uint8Array;
+      privateKey: SecureBuffer;
+      wallet: Wallet;
+      creatorId: ObjectId;
+      dateCreated: Date;
+      dateUpdated: Date;
+      hasPrivateKey: boolean;
+    }> = {},
+  ) {
+    this._id = data.id || new ObjectId();
+    this._type = data.type || faker.helpers.enumValue(MemberType);
+    this._name = data.name || faker.person.fullName();
+    this._email = data.email || new EmailString(faker.internet.email());
+    this._publicKey =
+      data.publicKey ||
+      hexToUint8Array(faker.string.hexadecimal({ length: 130 }));
+    this._creatorId = data.creatorId || this._id;
+    this._dateCreated = data.dateCreated || faker.date.past();
+    this._dateUpdated =
+      data.dateUpdated ||
+      faker.date.between({ from: this._dateCreated, to: new Date() });
+    this._privateKey = data.privateKey;
+    this._wallet =
+      data.wallet ||
+      (data.hasPrivateKey !== false ? createMockWallet() : undefined);
+    this._hasPrivateKey = data.hasPrivateKey ?? !!this._privateKey;
+  }
+
+  get id(): ObjectId {
+    return this._id;
+  }
+  get type(): MemberType {
+    return this._type;
+  }
+  get name(): string {
+    return this._name;
+  }
+  get email(): EmailString {
+    return this._email;
+  }
+  get publicKey(): Uint8Array {
+    return this._publicKey;
+  }
+  get creatorId(): ObjectId {
+    return this._creatorId;
+  }
+  get dateCreated(): Date {
+    return this._dateCreated;
+  }
+  get dateUpdated(): Date {
+    return this._dateUpdated;
+  }
+  get privateKey(): SecureBuffer | undefined {
+    return this._privateKey;
+  }
+  get wallet(): Wallet | undefined {
+    return this._wallet;
+  }
+  get hasPrivateKey(): boolean {
+    return this._hasPrivateKey;
+  }
+
+  unloadPrivateKey(): void {}
+
+  unloadWallet(): void {}
+
+  unloadWalletAndPrivateKey(): void {}
+
+  loadWallet(mnemonic: SecureString): void {}
+
+  loadPrivateKey(privateKey: SecureBuffer): void {}
+
+  sign(data: Uint8Array): SignatureUint8Array {
+    return hexToUint8Array(
+      faker.string.hexadecimal({ length: 128 }),
+    ) as SignatureUint8Array;
+  }
+
+  verify(signature: SignatureUint8Array, data: Uint8Array): boolean {
+    return true;
+  }
+
+  async encryptData(data: string | Uint8Array): Promise<Uint8Array> {
+    return hexToUint8Array(faker.string.hexadecimal({ length: 256 }));
+  }
+
+  async decryptData(encryptedData: Uint8Array): Promise<Uint8Array> {
+    const text = faker.lorem.paragraph();
+    return new TextEncoder().encode(text);
+  }
+
+  async *encryptDataStream(
+    source: AsyncIterable<Uint8Array> | ReadableStream<Uint8Array>,
+    options?: {
+      recipientPublicKey?: Uint8Array;
+      onProgress?: (progress: {
+        bytesProcessed: number;
+        chunksProcessed: number;
+      }) => void;
+      signal?: AbortSignal;
+    },
+  ): AsyncGenerator<
+    import('../interfaces/encrypted-chunk').IEncryptedChunk,
+    void,
+    unknown
+  > {
+    // Mock implementation
+    const chunks = [];
+    if ('getReader' in source) {
+      const reader = (source as ReadableStream<Uint8Array>).getReader();
+      try {
+        while (true) {
+          const { done, value } = await reader.read();
+          if (done) break;
+          chunks.push(value);
+        }
+      } finally {
+        reader.releaseLock();
+      }
+    } else {
+      for await (const chunk of source as AsyncIterable<Uint8Array>) {
+        chunks.push(chunk);
+      }
+    }
+    let index = 0;
+    for (const chunk of chunks) {
+      yield {
+        index: index++,
+        data: hexToUint8Array(
+          faker.string.hexadecimal({ length: chunk.length * 2 }),
+        ),
+        isLast: index === chunks.length,
+        metadata: {
+          originalSize: chunk.length,
+          encryptedSize: chunk.length * 2,
+          timestamp: Date.now(),
+        },
+      };
+    }
+  }
+
+  async *decryptDataStream(
+    source: AsyncIterable<Uint8Array> | ReadableStream<Uint8Array>,
+    options?: {
+      onProgress?: (progress: {
+        bytesProcessed: number;
+        chunksProcessed: number;
+      }) => void;
+      signal?: AbortSignal;
+    },
+  ): AsyncGenerator<Uint8Array, void, unknown> {
+    // Mock implementation
+    if ('getReader' in source) {
+      const reader = (source as ReadableStream<Uint8Array>).getReader();
+      try {
+        while (true) {
+          const { done, value } = await reader.read();
+          if (done) break;
+          yield value;
+        }
+      } finally {
+        reader.releaseLock();
+      }
+    } else {
+      for await (const chunk of source as AsyncIterable<Uint8Array>) {
+        yield chunk;
+      }
+    }
+  }
+
+  toJson(): string {
+    return JSON.stringify({
+      id: this._id.toString(),
+      type: this._type,
+      name: this._name,
+      email: this._email.toString(),
+      publicKey: btoa(String.fromCharCode(...this._publicKey)),
+      creatorId: this._creatorId.toString(),
+      dateCreated: this._dateCreated.toISOString(),
+      dateUpdated: this._dateUpdated.toISOString(),
+    });
+  }
+
+  dispose(): void {}
+
+  static create(
+    overrides: Partial<{
+      id: ObjectId;
+      type: MemberType;
+      name: string;
+      email: EmailString;
+      publicKey: Uint8Array;
+      privateKey: SecureBuffer;
+      wallet: Wallet;
+      creatorId: ObjectId;
+      dateCreated: Date;
+      dateUpdated: Date;
+      hasPrivateKey: boolean;
+    }> = {},
+  ): MockFrontendMember {
+    return new MockFrontendMember(overrides);
+  }
+
+  static createMultiple(count: number): MockFrontendMember[] {
+    return Array.from({ length: count }, () => this.create());
+  }
+
+  static createWithPrivateKey(): MockFrontendMember {
+    return new MockFrontendMember({
+      privateKey: new SecureBuffer(
+        hexToUint8Array(faker.string.hexadecimal({ length: 64 })),
+      ),
+      hasPrivateKey: true,
+    });
+  }
+
+  static createWithoutPrivateKey(): MockFrontendMember {
+    return new MockFrontendMember({
+      privateKey: undefined,
+      hasPrivateKey: false,
+    });
+  }
+}

package/src/{testing.js → testing.ts}

@@ -1,3 +1,2 @@
 // Test utilities entry point - import from '@digitaldefiance/ecies-lib/testing'
 export * from './test-mocks';
-//# sourceMappingURL=testing.js.map

package/src/translations/{de.js → de.ts}

@@ -1,18 +1,27 @@
 import { EciesStringKey } from '../enumerations';
-import { createPluralString } from '@digitaldefiance/i18n-lib';
-export const germanTranslations = {
+import { createPluralString, PluralString } from '@digitaldefiance/i18n-lib';
+
+export const germanTranslations: Record<EciesStringKey, string | PluralString> = {
     // ECIES Error Types - buildReasonMap(ECIESErrorTypeEnum, 'Error', 'ECIESError')
-    [EciesStringKey.Error_ECIESError_InvalidECIESMultipleEncryptedKeySize]: 'Ungültige ECIES mehrfache verschlüsselte Schlüssellänge',
-    [EciesStringKey.Error_ECIESError_InvalidECIESPublicKeyLength]: 'Ungültige ECIES öffentliche Schlüssellänge',
-    [EciesStringKey.Error_ECIESError_InvalidECIESMultipleRecipientCountSize]: 'Ungültige ECIES mehrere Empfängeranzahlgröße',
-    [EciesStringKey.Error_ECIESError_InvalidECIESMultipleDataLengthSize]: 'Ungültige ECIES mehrere Datenlängen',
-    [EciesStringKey.Error_ECIESError_InvalidECIESMultipleRecipientIdSize]: 'Ungültige ECIES mehrere Empfänger-ID-Größe',
+    [EciesStringKey.Error_ECIESError_InvalidECIESMultipleEncryptedKeySize]:
+      'Ungültige ECIES mehrfache verschlüsselte Schlüssellänge',
+    [EciesStringKey.Error_ECIESError_InvalidECIESPublicKeyLength]:
+      'Ungültige ECIES öffentliche Schlüssellänge',
+    [EciesStringKey.Error_ECIESError_InvalidECIESMultipleRecipientCountSize]:
+      'Ungültige ECIES mehrere Empfängeranzahlgröße',
+    [EciesStringKey.Error_ECIESError_InvalidECIESMultipleDataLengthSize]:
+      'Ungültige ECIES mehrere Datenlängen',
+    [EciesStringKey.Error_ECIESError_InvalidECIESMultipleRecipientIdSize]:
+      'Ungültige ECIES mehrere Empfänger-ID-Größe',
     [EciesStringKey.Error_ECIESError_CRCError]: 'CRC-Fehler',
-    [EciesStringKey.Error_ECIESError_InvalidEncryptionType]: 'Ungültiger Verschlüsselungstyp',
+    [EciesStringKey.Error_ECIESError_InvalidEncryptionType]:
+      'Ungültiger Verschlüsselungstyp',
     [EciesStringKey.Error_ECIESError_InvalidEncryptionTypeTemplate]: 'Ungültiger Verschlüsselungstyp: {encryptionType}',
     [EciesStringKey.Error_ECIESError_InvalidIVLength]: 'Ungültige IV-Länge',
-    [EciesStringKey.Error_ECIESError_InvalidAuthTagLength]: 'Ungültige Auth-Tag-Länge',
-    [EciesStringKey.Error_ECIESError_InvalidHeaderLength]: 'Ungültige Header-Länge',
+    [EciesStringKey.Error_ECIESError_InvalidAuthTagLength]:
+      'Ungültige Auth-Tag-Länge',
+    [EciesStringKey.Error_ECIESError_InvalidHeaderLength]:
+      'Ungültige Header-Länge',
     [EciesStringKey.Error_ECIESError_InvalidDataLength]: 'Ungültige Datenlänge',
     [EciesStringKey.Error_ECIESError_InvalidPrivateKey]: 'Ungültiger privater Schlüssel',
     [EciesStringKey.Error_ECIESError_InvalidIV]: 'Ungültiger Initialisierungsvektor (IV)',
@@ -23,27 +32,43 @@ export const germanTranslations = {
     [EciesStringKey.Error_ECIESError_CannotEncryptEmptyData]: 'Leere Daten können nicht verschlüsselt werden',
     [EciesStringKey.Error_ECIESError_CannotDecryptEmptyData]: 'Leere Daten können nicht entschlüsselt werden',
     [EciesStringKey.Error_ECIESError_EncryptedSizeExceedsExpected]: 'Verschlüsselte Größe überschreitet das erwartete Maximum',
-    [EciesStringKey.Error_ECIESError_InvalidEncryptedDataLength]: 'Ungültige verschlüsselte Datenlänge',
+    [EciesStringKey.Error_ECIESError_InvalidEncryptedDataLength]:
+      'Ungültige verschlüsselte Datenlänge',
     [EciesStringKey.Error_ECIESError_InvalidMessageCrc]: 'Ungültige Nachrichten-CRC',
     [EciesStringKey.Error_ECIESError_InvalidMnemonic]: 'Ungültige Mnemonik',
     [EciesStringKey.Error_ECIESError_InvalidOperation]: 'Ungültige Operation',
-    [EciesStringKey.Error_ECIESError_MessageLengthMismatch]: 'Längenabweichung der Nachricht',
-    [EciesStringKey.Error_ECIESError_InvalidEncryptedKeyLength]: 'Ungültige verschlüsselte Schlüssellänge',
-    [EciesStringKey.Error_ECIESError_InvalidEphemeralPublicKey]: 'Ungültiger ephemerer öffentlicher Schlüssel',
-    [EciesStringKey.Error_ECIESError_MissingEphemeralPublicKey]: 'Fehlender ephemerer öffentlicher Schlüssel',
-    [EciesStringKey.Error_ECIESError_RecipientNotFound]: 'Empfänger nicht in den Empfänger-IDs gefunden',
+    [EciesStringKey.Error_ECIESError_MessageLengthMismatch]:
+      'Längenabweichung der Nachricht',
+    [EciesStringKey.Error_ECIESError_InvalidEncryptedKeyLength]:
+      'Ungültige verschlüsselte Schlüssellänge',
+    [EciesStringKey.Error_ECIESError_InvalidEphemeralPublicKey]:
+      'Ungültiger ephemerer öffentlicher Schlüssel',
+    [EciesStringKey.Error_ECIESError_MissingEphemeralPublicKey]:
+      'Fehlender ephemerer öffentlicher Schlüssel',
+    [EciesStringKey.Error_ECIESError_RecipientNotFound]:
+      'Empfänger nicht in den Empfänger-IDs gefunden',
     [EciesStringKey.Error_ECIESError_InvalidSignature]: 'Ungültige Signatur',
-    [EciesStringKey.Error_ECIESError_InvalidSenderPublicKey]: 'Ungültiger Sender-öffentlicher Schlüssel',
-    [EciesStringKey.Error_ECIESError_TooManyRecipients]: 'Zu viele Empfänger: Überschreitung der maximalen Anzahl',
-    [EciesStringKey.Error_ECIESError_PrivateKeyNotLoaded]: 'Privater Schlüssel nicht geladen',
-    [EciesStringKey.Error_ECIESError_RecipientKeyCountMismatch]: 'Anzahl der Empfänger stimmt nicht mit der Anzahl der Schlüssel überein',
-    [EciesStringKey.Error_ECIESError_InvalidRecipientCount]: 'Ungültige Empfängeranzahl',
+    [EciesStringKey.Error_ECIESError_InvalidSenderPublicKey]:
+      'Ungültiger Sender-öffentlicher Schlüssel',
+    [EciesStringKey.Error_ECIESError_TooManyRecipients]:
+      'Zu viele Empfänger: Überschreitung der maximalen Anzahl',
+    [EciesStringKey.Error_ECIESError_PrivateKeyNotLoaded]:
+      'Privater Schlüssel nicht geladen',
+    [EciesStringKey.Error_ECIESError_RecipientKeyCountMismatch]:
+      'Anzahl der Empfänger stimmt nicht mit der Anzahl der Schlüssel überein',
+    [EciesStringKey.Error_ECIESError_InvalidRecipientCount]:
+      'Ungültige Empfängeranzahl',
     [EciesStringKey.Error_ECIESError_FileSizeTooLarge]: 'Dateigröße zu groß',
-    [EciesStringKey.Error_ECIESError_DecryptionFailed]: 'Entschlüsselungsoperation fehlgeschlagen',
-    [EciesStringKey.Error_ECIESError_InvalidRecipientPublicKey]: 'Ungültiger Empfänger-öffentlicher Schlüssel für die Verschlüsselung bereitgestellt',
-    [EciesStringKey.Error_ECIESError_SecretComputationFailed]: 'Fehler bei der Berechnung des gemeinsamen Schlüssels während der ECIES-Operation',
-    [EciesStringKey.Error_ECIESError_AuthenticationTagIsRequiredForKeyEncryption]: 'Authentifizierungstag ist für die Schlüsselverschlüsselung erforderlich',
-    [EciesStringKey.Error_ECIESError_InvalidEncryptedKeyLengthTemplate]: 'Ungültige verschlüsselte Schlüssellänge: erwartet {keySize}, erhalten {encryptedKeyLength}',
+    [EciesStringKey.Error_ECIESError_DecryptionFailed]:
+      'Entschlüsselungsoperation fehlgeschlagen',
+    [EciesStringKey.Error_ECIESError_InvalidRecipientPublicKey]:
+      'Ungültiger Empfänger-öffentlicher Schlüssel für die Verschlüsselung bereitgestellt',
+    [EciesStringKey.Error_ECIESError_SecretComputationFailed]:
+      'Fehler bei der Berechnung des gemeinsamen Schlüssels während der ECIES-Operation',
+    [EciesStringKey.Error_ECIESError_AuthenticationTagIsRequiredForKeyEncryption]:
+      'Authentifizierungstag ist für die Schlüsselverschlüsselung erforderlich',
+    [EciesStringKey.Error_ECIESError_InvalidEncryptedKeyLengthTemplate]:
+      'Ungültige verschlüsselte Schlüssellänge: erwartet {keySize}, erhalten {encryptedKeyLength}',
     [EciesStringKey.Error_ECIESError_FailedToDecryptKey]: 'Fehler beim Entschlüsseln des Schlüssels',
     [EciesStringKey.Error_ECIESError_TooManyRecipientsTemplate]: 'Zu viele Empfänger: {recipientsCount}',
     [EciesStringKey.Error_ECIESError_MessageTooLarge]: 'Nachricht zu groß',
@@ -71,46 +96,77 @@ export const germanTranslations = {
     [EciesStringKey.Error_ECIESError_InvalidVersionTemplate]: 'Ungültige ECIES-Version: {version}',
     [EciesStringKey.Error_ECIESError_InvalidCipherSuite]: 'Ungültige ECIES-Verschlüsselungssuite',
     [EciesStringKey.Error_ECIESError_InvalidCipherSuiteTemplate]: 'Ungültige ECIES-Verschlüsselungssuite: {cipherSuite}',
+
     // Member Error Types - buildReasonMap(MemberErrorType, 'Error', 'MemberError')
-    [EciesStringKey.Error_MemberError_MissingMemberName]: 'Mitgliedsname ist erforderlich',
-    [EciesStringKey.Error_MemberError_InvalidMemberNameWhitespace]: 'Mitgliedsname enthält führende oder nachfolgende Leerzeichen.',
+    [EciesStringKey.Error_MemberError_MissingMemberName]:
+      'Mitgliedsname ist erforderlich',
+    [EciesStringKey.Error_MemberError_InvalidMemberNameWhitespace]:
+      'Mitgliedsname enthält führende oder nachfolgende Leerzeichen.',
     [EciesStringKey.Error_MemberError_InvalidEmail]: 'Ungültige E-Mail.',
-    [EciesStringKey.Error_MemberError_InvalidMemberName]: 'Ungültiger Mitgliedsname.',
-    [EciesStringKey.Error_MemberError_InvalidMemberStatus]: 'Ungültiger Mitgliedsstatus.',
+    [EciesStringKey.Error_MemberError_InvalidMemberName]:
+      'Ungültiger Mitgliedsname.',
+    [EciesStringKey.Error_MemberError_InvalidMemberStatus]:
+      'Ungültiger Mitgliedsstatus.',
     [EciesStringKey.Error_MemberError_MissingEmail]: 'Fehlende E-Mail.',
-    [EciesStringKey.Error_MemberError_InvalidEmailWhitespace]: 'E-Mail enthält führende oder nachfolgende Leerzeichen.',
-    [EciesStringKey.Error_MemberError_MissingPrivateKey]: 'Fehlender privater Schlüssel.',
+    [EciesStringKey.Error_MemberError_InvalidEmailWhitespace]:
+      'E-Mail enthält führende oder nachfolgende Leerzeichen.',
+    [EciesStringKey.Error_MemberError_MissingPrivateKey]:
+      'Fehlender privater Schlüssel.',
     [EciesStringKey.Error_MemberError_NoWallet]: 'Keine Wallet geladen.',
-    [EciesStringKey.Error_MemberError_WalletAlreadyLoaded]: 'Wallet bereits geladen.',
-    [EciesStringKey.Error_MemberError_InvalidMnemonic]: 'Ungültige Wallet-Mnemonik.',
-    [EciesStringKey.Error_MemberError_IncorrectOrInvalidPrivateKey]: 'Falscher oder ungültiger privater Schlüssel für öffentlichen Schlüssel',
+    [EciesStringKey.Error_MemberError_WalletAlreadyLoaded]:
+      'Wallet bereits geladen.',
+    [EciesStringKey.Error_MemberError_InvalidMnemonic]:
+      'Ungültige Wallet-Mnemonik.',
+    [EciesStringKey.Error_MemberError_IncorrectOrInvalidPrivateKey]:
+      'Falscher oder ungültiger privater Schlüssel für öffentlichen Schlüssel',
     [EciesStringKey.Error_MemberError_MemberNotFound]: 'Mitglied nicht gefunden.',
-    [EciesStringKey.Error_MemberError_MemberAlreadyExists]: 'Mitglied existiert bereits.',
-    [EciesStringKey.Error_MemberError_FailedToHydrateMember]: 'Fehler beim Hydratisieren des Mitglieds.',
-    [EciesStringKey.Error_MemberError_InvalidMemberData]: 'Ungültige Mitgliedsdaten.',
-    [EciesStringKey.Error_MemberError_FailedToConvertMemberData]: 'Fehler beim Konvertieren der Mitgliedsdaten.',
-    [EciesStringKey.Error_MemberError_MissingEncryptionData]: 'Fehlende Verschlüsselungsdaten.',
-    [EciesStringKey.Error_MemberError_EncryptionDataTooLarge]: 'Verschlüsselungsdaten zu groß.',
-    [EciesStringKey.Error_MemberError_InvalidEncryptionData]: 'Ungültige Verschlüsselungsdaten.',
+    [EciesStringKey.Error_MemberError_MemberAlreadyExists]:
+      'Mitglied existiert bereits.',
+    [EciesStringKey.Error_MemberError_FailedToHydrateMember]:
+      'Fehler beim Hydratisieren des Mitglieds.',
+    [EciesStringKey.Error_MemberError_InvalidMemberData]:
+      'Ungültige Mitgliedsdaten.',
+    [EciesStringKey.Error_MemberError_FailedToConvertMemberData]:
+      'Fehler beim Konvertieren der Mitgliedsdaten.',
+    [EciesStringKey.Error_MemberError_MissingEncryptionData]:
+      'Fehlende Verschlüsselungsdaten.',
+    [EciesStringKey.Error_MemberError_EncryptionDataTooLarge]:
+      'Verschlüsselungsdaten zu groß.',
+    [EciesStringKey.Error_MemberError_InvalidEncryptionData]:
+      'Ungültige Verschlüsselungsdaten.',
+
     // Length Error Types - buildReasonMap(LengthErrorType, 'Error', 'LengthError')
     [EciesStringKey.Error_LengthError_LengthIsTooShort]: 'Länge ist zu kurz.',
     [EciesStringKey.Error_LengthError_LengthIsTooLong]: 'Länge ist zu lang.',
-    [EciesStringKey.Error_LengthError_LengthIsInvalidType]: 'Länge hat einen ungültigen Typ.',
+    [EciesStringKey.Error_LengthError_LengthIsInvalidType]:
+      'Länge hat einen ungültigen Typ.',
+
     // PBKDF2 Error Types - buildReasonMap(Pbkdf2ErrorType, 'Error', 'Pbkdf2Error')
-    [EciesStringKey.Error_Pbkdf2Error_InvalidProfile]: 'Ungültiges PBKDF2-Profil angegeben',
-    [EciesStringKey.Error_Pbkdf2Error_InvalidSaltLength]: 'Salt-Länge entspricht nicht der erwarteten Länge',
-    [EciesStringKey.Error_Pbkdf2Error_InvalidHashLength]: 'Hash-Länge entspricht nicht der erwarteten Länge',
+    [EciesStringKey.Error_Pbkdf2Error_InvalidProfile]:
+      'Ungültiges PBKDF2-Profil angegeben',
+    [EciesStringKey.Error_Pbkdf2Error_InvalidSaltLength]:
+      'Salt-Länge entspricht nicht der erwarteten Länge',
+    [EciesStringKey.Error_Pbkdf2Error_InvalidHashLength]:
+      'Hash-Länge entspricht nicht der erwarteten Länge',
+
     // Secure Storage Error Types - buildReasonMap(SecureStorageErrorType, 'Error', 'SecureStorageError')
-    [EciesStringKey.Error_SecureStorageError_DecryptedValueLengthMismatch]: 'Länge des entschlüsselten Werts entspricht nicht der erwarteten Länge',
-    [EciesStringKey.Error_SecureStorageError_DecryptedValueChecksumMismatch]: 'Prüfsumme des entschlüsselten Werts stimmt nicht überein',
-    [EciesStringKey.Error_SecureStorageError_ValueIsNull]: 'Sicherer Speicherwert ist null',
+    [EciesStringKey.Error_SecureStorageError_DecryptedValueLengthMismatch]:
+      'Länge des entschlüsselten Werts entspricht nicht der erwarteten Länge',
+    [EciesStringKey.Error_SecureStorageError_DecryptedValueChecksumMismatch]:
+      'Prüfsumme des entschlüsselten Werts stimmt nicht überein',
+    [EciesStringKey.Error_SecureStorageError_ValueIsNull]:
+      'Sicherer Speicherwert ist null',
     [EciesStringKey.Error_InvalidEmailError_Invalid]: 'Ungültige E-Mail-Adresse.',
     [EciesStringKey.Error_InvalidEmailError_Missing]: 'E-Mail-Adresse ist erforderlich.',
     [EciesStringKey.Error_InvalidEmailError_Whitespace]: 'E-Mail-Adresse enthält führende oder nachfolgende Leerzeichen.',
-    [EciesStringKey.Error_Utils_EncryptionFailedNoAuthTag]: 'Verschlüsselung fehlgeschlagen: kein Authentifizierungstag generiert',
-    [EciesStringKey.Error_PasswordLoginError_FailedToStoreLoginData]: 'Fehler beim Speichern der Passwort-Anmeldedaten',
-    [EciesStringKey.Error_PasswordLoginError_PasswordLoginNotSetUp]: 'Passwort-Anmeldung ist nicht eingerichtet',
+    [EciesStringKey.Error_Utils_EncryptionFailedNoAuthTag]:
+      'Verschlüsselung fehlgeschlagen: kein Authentifizierungstag generiert',
+    [EciesStringKey.Error_PasswordLoginError_FailedToStoreLoginData]:
+      'Fehler beim Speichern der Passwort-Anmeldedaten',
+    [EciesStringKey.Error_PasswordLoginError_PasswordLoginNotSetUp]:
+      'Passwort-Anmeldung ist nicht eingerichtet',
     [EciesStringKey.Error_PhoneNumber_InvalidTemplate]: 'Ungültige Telefonnummer: {phoneNumber}',
+
     // Multi-recipient and Streaming Error Types
     [EciesStringKey.Error_MultiRecipient_InvalidRecipientCountTemplate]: 'Ungültige Empfängeranzahl: {count}',
     [EciesStringKey.Error_MultiRecipient_SymmetricKeyMust32Bytes]: 'Symmetrischer Schlüssel muss 32 Bytes sein',
@@ -193,12 +249,12 @@ export const germanTranslations = {
     [EciesStringKey.Error_IdProviderError_ParseFailed]: 'ID konnte nicht geparst werden: {message}',
     [EciesStringKey.Error_IdProviderError_InvalidGuidBuffer]: 'Ungültiger GUID-Puffer: {message}',
     [EciesStringKey.Error_IdProviderError_InvalidUuidFormat]: 'Ungültiges UUID-Format: {input}',
+
     // Invariant Validation Errors
     [EciesStringKey.Error_Invariant_ValidationFailedTemplate]: 'Invariantenvalidierung fehlgeschlagen: {message}',
     [EciesStringKey.Error_Invariant_UnknownInvariantTemplate]: 'Unbekannte Invariante: {name}',
     [EciesStringKey.Error_Invariant_ConfigurationValidationFailedMultipleTemplate]: createPluralString({
-        one: 'Konfigurationsvalidierung fehlgeschlagen ({count} Invariante):\n\n{failures}',
-        other: 'Konfigurationsvalidierung fehlgeschlagen ({count} Invarianten):\n\n{failures}'
+      one: 'Konfigurationsvalidierung fehlgeschlagen ({count} Invariante):\n\n{failures}',
+      other: 'Konfigurationsvalidierung fehlgeschlagen ({count} Invarianten):\n\n{failures}'
     }),
-};
-//# sourceMappingURL=de.js.map
+  };