@digitaldefiance/ecies-lib 4.4.1 → 4.4.3

package/src/email-string.ts

@@ -0,0 +1,82 @@
+import validator from 'validator';
+import { InvalidEmailErrorType } from './enumerations/invalid-email-type';
+import { InvalidEmailError } from './errors/invalid-email';
+import { getEciesI18nEngine } from './i18n-setup';
+
+/**
+ * EmailString represents a validated email address.
+ * It ensures that the email is not empty, does not have leading or trailing spaces,
+ * and is a valid email format.
+ */
+export class EmailString {
+  public readonly email: string;
+
+  /**
+   * Creates an instance of EmailString.
+   * @param email - The email address to validate and store.
+   * @throws Will throw an error if the email is invalid.
+   */
+  constructor(email: string) {
+    const trimmedEmail = email.trim();
+    if (trimmedEmail.length === 0) {
+      throw new InvalidEmailError(
+        InvalidEmailErrorType.Missing,
+      );
+    }
+    if (trimmedEmail.length != email.length) {
+      throw new InvalidEmailError(
+        InvalidEmailErrorType.Whitespace,
+        email,
+      );
+    }
+    if (!validator.isEmail(trimmedEmail)) {
+      throw new InvalidEmailError(
+        InvalidEmailErrorType.Invalid,
+        email,
+      );
+    }
+    this.email = trimmedEmail;
+  }
+
+  /**
+   * Returns the email address as a string.
+   * @returns The email address.
+   */
+  public toString(): string {
+    return this.email;
+  }
+
+  /**
+   * Checks if this email address is equal to another email address.
+   * @param other - The other email address to compare.
+   * @returns True if the email addresses are equal, false otherwise.
+   */
+  public equals(other: EmailString): boolean {
+    return this.email === other.email;
+  }
+
+  /**
+   * Converts the email address to a JSON string.
+   * @returns The email address as a JSON string.
+   */
+  public toJson(): string {
+    return JSON.stringify(this.email);
+  }
+
+  /**
+   * Creates an EmailString instance from a JSON string.
+   * @param email - The JSON string representing the email address.
+   * @returns The EmailString instance.
+   */
+  public static fromJson(email: string): EmailString {
+    return new EmailString(JSON.parse(email));
+  }
+
+  /**
+   * Gets the length of the email address.
+   * @returns The length of the email address.
+   */
+  public get length(): number {
+    return this.email.length;
+  }
+}

package/src/enumerations/disposed-error-type.ts

@@ -0,0 +1,11 @@
+/**
+ * Enumeration of disposed object error types.
+ * These errors occur when attempting to use an object that has been disposed.
+ */
+export enum DisposedErrorType {
+  /**
+   * Generic disposed object error.
+   * Occurs when an operation is attempted on a disposed object.
+   */
+  ObjectDisposed = 'ObjectDisposed',
+}

package/src/enumerations/ecies-cipher-suite.ts

@@ -0,0 +1,4 @@
+export enum EciesCipherSuiteEnum {
+  // Curve: secp256k1, KDF: PBKDF2/HKDF?, Sym: AES-256-GCM, Hash: SHA-256
+  Secp256k1_Aes256Gcm_Sha256 = 1,
+}

package/src/enumerations/ecies-encryption-type.ts

@@ -0,0 +1,41 @@
+export type EciesEncryptionType = 'simple' | 'single' | 'multiple';
+
+export enum EciesEncryptionTypeEnum {
+  Simple = 33,
+  Single = 66,
+  Multiple = 99,
+}
+
+export const EciesEncryptionTypeMap: Record<
+  EciesEncryptionType,
+  EciesEncryptionTypeEnum
+> = {
+  simple: EciesEncryptionTypeEnum.Simple,
+  single: EciesEncryptionTypeEnum.Single,
+  multiple: EciesEncryptionTypeEnum.Multiple,
+};
+
+export const EciesEncryptionTypeStringMap: Record<EciesEncryptionType, string> =
+  {
+    simple: 'simple',
+    single: 'single',
+    multiple: 'multiple',
+  };
+
+export const EciesEncryptionTypeEnumTypeMap: Record<
+  EciesEncryptionTypeEnum,
+  EciesEncryptionType
+> = {
+  33: 'simple',
+  66: 'single',
+  99: 'multiple',
+};
+
+export const EciesEncryptionTypeEnumStringMap: Record<
+  EciesEncryptionTypeEnum,
+  string
+> = {
+  33: 'simple',
+  66: 'single',
+  99: 'multiple',
+};

package/src/enumerations/ecies-error-type.ts

@@ -0,0 +1,43 @@
+export enum ECIESErrorTypeEnum {
+  InvalidECIESMultipleEncryptedKeySize = 'InvalidECIESMultipleEncryptedKeySize',
+  InvalidECIESPublicKeyLength = 'InvalidECIESPublicKeyLength',
+  InvalidECIESMultipleRecipientCountSize = 'InvalidECIESMultipleRecipientCountSize',
+  InvalidECIESMultipleDataLengthSize = 'InvalidECIESMultipleDataLengthSize',
+  InvalidECIESMultipleRecipientIdSize = 'InvalidECIESMultipleRecipientIdSize',
+  CRCError = 'CRCError',
+  InvalidEncryptionType = 'InvalidEncryptionType',
+  InvalidIVLength = 'InvalidIVLength',
+  InvalidAuthTagLength = 'InvalidAuthTagLength',
+  InvalidHeaderLength = 'InvalidHeaderLength',
+  InvalidDataLength = 'InvalidDataLength',
+  InvalidEncryptedDataLength = 'InvalidEncryptedDataLength',
+  InvalidMessageCrc = 'InvalidMessageCrc',
+  InvalidMnemonic = 'InvalidMnemonic',
+  InvalidOperation = 'InvalidOperation',
+  MessageLengthMismatch = 'MessageLengthMismatch',
+  InvalidEncryptedKeyLength = 'InvalidEncryptedKeyLength',
+  InvalidEphemeralPublicKey = 'InvalidEphemeralPublicKey',
+  RecipientNotFound = 'RecipientNotFound',
+  InvalidSignature = 'InvalidSignature',
+  InvalidSenderPublicKey = 'InvalidSenderPublicKey',
+  TooManyRecipients = 'TooManyRecipients',
+  PrivateKeyNotLoaded = 'PrivateKeyNotLoaded',
+  RecipientKeyCountMismatch = 'RecipientKeyCountMismatch',
+  InvalidRecipientCount = 'InvalidRecipientCount',
+  FileSizeTooLarge = 'FileSizeTooLarge',
+  DecryptionFailed = 'DecryptionFailed', // Added for MAC/Padding errors
+  InvalidRecipientPublicKey = 'InvalidRecipientPublicKey', // Added for specific key errors
+  SecretComputationFailed = 'SecretComputationFailed', // Added for ECDH failures
+  AuthenticationTagIsRequiredForKeyEncryption = 'AuthenticationTagIsRequiredForKeyEncryption',
+  FailedToDecryptKey = 'FailedToDecryptKey',
+  MessageTooLarge = 'MessageTooLarge',
+  AuthenticationTagIsRequiredForMultiRecipientECIESEncryption = 'AuthenticationTagIsRequiredForMultiRecipientECIESEncryption',
+  CannotEncryptEmptyData = 'CannotEncryptEmptyData',
+  CannotDecryptEmptyData = 'CannotDecryptEmptyData',
+  EncryptedSizeExceedsExpected = 'EncryptedSizeExceedsExpected',
+  DecryptedDataLengthMismatch = 'DecryptedDataLengthMismatch',
+  RecipientCountMismatch = 'RecipientCountMismatch',
+  DataTooShortForMultiRecipientHeader = 'DataTooShortForMultiRecipientHeader',
+  InvalidVersion = 'InvalidVersion',
+  InvalidCipherSuite = 'InvalidCipherSuite',
+}

package/src/enumerations/ecies-string-key.ts

@@ -0,0 +1,205 @@
+export enum EciesStringKey {
+  Error_ECIESError_InvalidECIESMultipleEncryptedKeySize = 'Error_ECIESError_InvalidECIESMultipleEncryptedKeySize',
+  Error_ECIESError_InvalidECIESPublicKeyLength = 'Error_ECIESError_InvalidECIESPublicKeyLength',
+  Error_ECIESError_InvalidECIESMultipleRecipientCountSize = 'Error_ECIESError_InvalidECIESMultipleRecipientCountSize',
+  Error_ECIESError_InvalidECIESMultipleDataLengthSize = 'Error_ECIESError_InvalidECIESMultipleDataLengthSize',
+  Error_ECIESError_InvalidECIESMultipleRecipientIdSize = 'Error_ECIESError_InvalidECIESMultipleRecipientIdSize',
+  Error_ECIESError_CRCError = 'Error_ECIESError_CRCError',
+  Error_ECIESError_InvalidEncryptionType = 'Error_ECIESError_InvalidEncryptionType',
+  Error_ECIESError_InvalidEncryptionTypeTemplate = 'Error_ECIESError_InvalidEncryptionTypeTemplate',
+  Error_ECIESError_InvalidIVLength = 'Error_ECIESError_InvalidIVLength',
+  Error_ECIESError_InvalidAuthTagLength = 'Error_ECIESError_InvalidAuthTagLength',
+  Error_ECIESError_InvalidHeaderLength = 'Error_ECIESError_InvalidHeaderLength',
+  Error_ECIESError_InvalidDataLength = 'Error_ECIESError_InvalidDataLength',
+  Error_ECIESError_InvalidPrivateKey = 'Error_ECIESError_InvalidPrivateKey',
+  Error_ECIESError_InvalidIV = 'Error_ECIESError_InvalidIV',
+  Error_ECIESError_InvalidAuthTag = 'Error_ECIESError_InvalidAuthTag',
+  Error_ECIESError_InvalidSharedSecret = 'Error_ECIESError_InvalidSharedSecret',
+  Error_ECIESError_InvalidPublicKeyNotOnCurve = 'Error_ECIESError_InvalidPublicKeyNotOnCurve',
+  Error_ECIESError_InvalidEncryptedDataLength = 'Error_ECIESError_InvalidEncryptedDataLength',
+  Error_ECIESError_InvalidMessageCrc = 'Error_ECIESError_InvalidMessageCrc',
+  Error_ECIESError_InvalidMnemonic = 'Error_ECIESError_InvalidMnemonic',
+  Error_ECIESError_InvalidOperation = 'Error_ECIESError_InvalidOperation',
+  Error_ECIESError_MessageLengthMismatch = 'Error_ECIESError_MessageLengthMismatch',
+  Error_ECIESError_InvalidEncryptedKeyLength = 'Error_ECIESError_InvalidEncryptedKeyLength',
+  Error_ECIESError_InvalidEphemeralPublicKey = 'Error_ECIESError_InvalidEphemeralPublicKey',
+  Error_ECIESError_MissingEphemeralPublicKey = 'Error_ECIESError_MissingEphemeralPublicKey',
+  Error_ECIESError_RecipientNotFound = 'Error_ECIESError_RecipientNotFound',
+  Error_ECIESError_InvalidSignature = 'Error_ECIESError_InvalidSignature',
+  Error_ECIESError_InvalidSenderPublicKey = 'Error_ECIESError_InvalidSenderPublicKey',
+  Error_ECIESError_TooManyRecipients = 'Error_ECIESError_TooManyRecipients',
+  Error_ECIESError_PrivateKeyNotLoaded = 'Error_ECIESError_PrivateKeyNotLoaded',
+  Error_ECIESError_RecipientKeyCountMismatch = 'Error_ECIESError_RecipientKeyCountMismatch',
+  Error_ECIESError_InvalidRecipientCount = 'Error_ECIESError_InvalidRecipientCount',
+  Error_ECIESError_FileSizeTooLarge = 'Error_ECIESError_FileSizeTooLarge',
+  Error_ECIESError_DecryptionFailed = 'Error_ECIESError_DecryptionFailed',
+  Error_ECIESError_InvalidRecipientPublicKey = 'Error_ECIESError_InvalidRecipientPublicKey',
+  Error_ECIESError_SecretComputationFailed = 'Error_ECIESError_SecretComputationFailed',
+  Error_ECIESError_AuthenticationTagIsRequiredForKeyEncryption = 'Error_ECIESError_AuthenticationTagIsRequiredForKeyEncryption',
+  Error_ECIESError_AuthenticationTagIsRequiredForECIESEncryption = 'Error_ECIESError_AuthenticationTagIsRequiredForECIESEncryption',
+  Error_ECIESError_AuthenticationTagIsRequiredForMultiRecipientECIESEncryption = 'Error_ECIESError_AuthenticationTagIsRequiredForMultiRecipientECIESEncryption',
+  Error_ECIESError_InvalidEncryptedKeyLengthTemplate = 'Error_ECIESError_InvalidEncryptedKeyLengthTemplate',
+  Error_ECIESError_FailedToDecryptKey = 'Error_ECIESError_FailedToDecryptKey',
+  Error_ECIESError_TooManyRecipientsTemplate = 'Error_ECIESError_TooManyRecipientsTemplate',
+  Error_ECIESError_MessageTooLarge = 'Error_ECIESError_MessageTooLarge',
+  Error_ECIESError_MessageTooLargeTemplate = 'Error_ECIESError_MessageTooLargeTemplate',
+  Error_ECIESError_DecryptedDataLengthMismatch = 'Error_ECIESError_DecryptedDataLengthMismatch',
+  Error_ECIESError_RecipientCountMismatch = 'Error_ECIESError_RecipientCountMismatch',
+  Error_ECIESError_DataTooShortForMultiRecipientHeader = 'Error_ECIESError_DataTooShortForMultiRecipientHeader',
+  Error_ECIESError_FailedToDecryptChallengeTemplate = 'Error_ECIESError_FailedToDecryptChallengeTemplate',
+  Error_ECIESError_InvalidChallengeSignature = 'Error_ECIESError_InvalidChallengeSignature',
+  Error_ECIESError_FailedToDervivePrivateKey = 'Error_ECIESError_FailedToDervivePrivateKey',
+  Error_ECIESError_InvalidPublicKeyFormatOrLengthTemplate = 'Error_ECIESError_InvalidPublicKeyFormatOrLengthTemplate',
+  Error_ECIESError_ReceivedNullOrUndefinedPublicKey = 'Error_ECIESError_ReceivedNullOrUndefinedPublicKey',
+  Error_ECIESError_MessageLengthExceedsMaximumAllowedSizeTemplate = 'Error_ECIESError_MessageLengthExceedsMaximumAllowedSizeTemplate',
+  Error_ECIESError_MultipleEncryptionTypeNotSupportedInSingleRecipientMode = 'Error_ECIESError_MultipleEncryptionTypeNotSupportedInSingleRecipientMode',
+  Error_ECIESError_EncryptionTypeMismatchTemplate = 'Error_ECIESError_EncryptionTypeMismatchTemplate',
+  Error_ECIESError_DataTooShortTemplate = 'Error_ECIESError_DataTooShortTemplate',
+  Error_ECIESError_DataLengthMismatchTemplate = 'Error_ECIESError_DataLengthMismatchTemplate',
+  Error_ECIESError_CombinedDataTooShortForComponents = 'Error_ECIESError_CombinedDataTooShortForComponents',
+  Error_ECIESError_InvalidChecksumConstants = 'Error_ECIESError_InvalidChecksumConstants',
+  Error_ECIESError_CannotOverwriteDefaultConfiguration = 'Error_ECIESError_CannotOverwriteDefaultConfiguration',
+  Error_ECIESError_InvalidAESKeyLength = 'Error_ECIESError_InvalidAESKeyLength',
+  Error_ECIESError_CannotEncryptEmptyData = 'Error_ECIESError_CannotEncryptEmptyData',
+  Error_ECIESError_CannotDecryptEmptyData = 'Error_ECIESError_CannotDecryptEmptyData',
+  Error_ECIESError_EncryptedSizeExceedsExpected = 'Error_ECIESError_EncryptedSizeExceedsExpected',
+
+  // Member Error Types - buildReasonMap(MemberErrorType, 'Error', 'MemberError')
+  Error_MemberError_MissingMemberName = 'Error_MemberError_MissingMemberName',
+  Error_MemberError_InvalidMemberNameWhitespace = 'Error_MemberError_InvalidMemberNameWhitespace',
+  Error_MemberError_InvalidEmail = 'Error_MemberError_InvalidEmail',
+  Error_MemberError_InvalidMemberName = 'Error_MemberError_InvalidMemberName',
+  Error_MemberError_MissingEmail = 'Error_MemberError_MissingEmail',
+  Error_MemberError_InvalidEmailWhitespace = 'Error_MemberError_InvalidEmailWhitespace',
+  Error_MemberError_MissingPrivateKey = 'Error_MemberError_MissingPrivateKey',
+  Error_MemberError_NoWallet = 'Error_MemberError_NoWallet',
+  Error_MemberError_WalletAlreadyLoaded = 'Error_MemberError_WalletAlreadyLoaded',
+  Error_MemberError_InvalidMnemonic = 'Error_MemberError_InvalidMnemonic',
+  Error_MemberError_IncorrectOrInvalidPrivateKey = 'Error_MemberError_IncorrectOrInvalidPrivateKey',
+  Error_MemberError_MemberNotFound = 'Error_MemberError_MemberNotFound',
+  Error_MemberError_MemberAlreadyExists = 'Error_MemberError_MemberAlreadyExists',
+  Error_MemberError_InvalidMemberStatus = 'Error_MemberError_InvalidMemberStatus',
+  Error_MemberError_FailedToHydrateMember = 'Error_MemberError_FailedToHydrateMember',
+  Error_MemberError_InvalidMemberData = 'Error_MemberError_InvalidMemberData',
+  Error_MemberError_FailedToConvertMemberData = 'Error_MemberError_FailedToConvertMemberData',
+  Error_MemberError_MissingEncryptionData = 'Error_MemberError_MissingEncryptionData',
+  Error_MemberError_EncryptionDataTooLarge = 'Error_MemberError_EncryptionDataTooLarge',
+  Error_MemberError_InvalidEncryptionData = 'Error_MemberError_InvalidEncryptionData',
+
+  // Length Error Types - buildReasonMap(LengthErrorType, 'Error', 'LengthError')
+  Error_LengthError_LengthIsTooShort = 'Error_LengthError_LengthIsTooShort',
+  Error_LengthError_LengthIsTooLong = 'Error_LengthError_LengthIsTooLong',
+  Error_LengthError_LengthIsInvalidType = 'Error_LengthError_LengthIsInvalidType',
+
+  // PBKDF2 Error Types - buildReasonMap(Pbkdf2ErrorType, 'Error', 'Pbkdf2Error')
+  Error_Pbkdf2Error_InvalidProfile = 'Error_Pbkdf2Error_InvalidProfile',
+  Error_Pbkdf2Error_InvalidSaltLength = 'Error_Pbkdf2Error_InvalidSaltLength',
+  Error_Pbkdf2Error_InvalidHashLength = 'Error_Pbkdf2Error_InvalidHashLength',
+
+  // Secure Storage Error Types - buildReasonMap(SecureStorageErrorType, 'Error', 'SecureStorageError')
+  Error_SecureStorageError_DecryptedValueLengthMismatch = 'Error_SecureStorageError_DecryptedValueLengthMismatch',
+  Error_SecureStorageError_DecryptedValueChecksumMismatch = 'Error_SecureStorageError_DecryptedValueChecksumMismatch',
+  Error_SecureStorageError_ValueIsNull = 'Error_SecureStorageError_ValueIsNull',
+
+  Error_InvalidEmailError_Invalid = 'Error_InvalidEmailError_Invalid',
+  Error_InvalidEmailError_Missing = 'Error_InvalidEmailError_Missing',
+  Error_InvalidEmailError_Whitespace = 'Error_InvalidEmailError_Whitespace',
+  Error_Utils_EncryptionFailedNoAuthTag = 'Error_Utils_EncryptionFailedNoAuthTag',
+  Error_PasswordLoginError_FailedToStoreLoginData = 'Error_PasswordLoginError_FailedToStoreLoginData',
+  Error_PasswordLoginError_PasswordLoginNotSetUp = 'Error_PasswordLoginError_PasswordLoginNotSetUp',
+
+  Error_PhoneNumber_InvalidTemplate = 'Error_PhoneNumber_InvalidTemplate',
+
+  // Multi-recipient and Streaming Error Types
+  Error_MultiRecipient_InvalidRecipientCountTemplate = 'Error_MultiRecipient_InvalidRecipientCountTemplate',
+  Error_MultiRecipient_SymmetricKeyMust32Bytes = 'Error_MultiRecipient_SymmetricKeyMust32Bytes',
+  Error_MultiRecipient_InvalidChunkIndexTemplate = 'Error_MultiRecipient_InvalidChunkIndexTemplate',
+  Error_MultiRecipient_DataSizeExceedsMaximumTemplate = 'Error_MultiRecipient_DataSizeExceedsMaximumTemplate',
+  Error_MultiRecipient_DuplicateRecipientId = 'Error_MultiRecipient_DuplicateRecipientId',
+  Error_MultiRecipient_RecipientIdMust32Bytes = 'Error_MultiRecipient_RecipientIdMust32Bytes',
+  Error_MultiRecipient_RecipientHeadersSizeOverflow = 'Error_MultiRecipient_RecipientHeadersSizeOverflow',
+  Error_MultiRecipient_ChunkSizeOverflow = 'Error_MultiRecipient_ChunkSizeOverflow',
+  Error_MultiRecipient_ChunkTooSmall = 'Error_MultiRecipient_ChunkTooSmall',
+  Error_MultiRecipient_InvalidChunkMagic = 'Error_MultiRecipient_InvalidChunkMagic',
+  Error_MultiRecipient_UnsupportedVersionTemplate = 'Error_MultiRecipient_UnsupportedVersionTemplate',
+  Error_MultiRecipient_ChunkTooSmallForEncryptedSize = 'Error_MultiRecipient_ChunkTooSmallForEncryptedSize',
+  Error_MultiRecipient_ChunkTruncatedRecipientId = 'Error_MultiRecipient_ChunkTruncatedRecipientId',
+  Error_MultiRecipient_ChunkTruncatedKeySize = 'Error_MultiRecipient_ChunkTruncatedKeySize',
+  Error_MultiRecipient_InvalidKeySizeTemplate = 'Error_MultiRecipient_InvalidKeySizeTemplate',
+  Error_MultiRecipient_ChunkTruncatedEncryptedKey = 'Error_MultiRecipient_ChunkTruncatedEncryptedKey',
+  Error_MultiRecipient_RecipientNotFoundInChunk = 'Error_MultiRecipient_RecipientNotFoundInChunk',
+  Error_Stream_DataTooShortForHeader = 'Error_Stream_DataTooShortForHeader',
+  Error_Stream_InvalidMagicBytes = 'Error_Stream_InvalidMagicBytes',
+  Error_Stream_UnsupportedVersion = 'Error_Stream_UnsupportedVersion',
+  Error_Stream_InvalidPublicKeyLength = 'Error_Stream_InvalidPublicKeyLength',
+  Error_Stream_BufferOverflowTemplate = 'Error_Stream_BufferOverflowTemplate',
+  Error_Stream_EncryptionCancelled = 'Error_Stream_EncryptionCancelled',
+  Error_Stream_AtLeastOneRecipientRequired = 'Error_Stream_AtLeastOneRecipientRequired',
+  Error_Stream_MaxRecipientsExceeded = 'Error_Stream_MaxRecipientsExceeded',
+  Error_Stream_InvalidRecipientPublicKeyLength = 'Error_Stream_InvalidRecipientPublicKeyLength',
+  Error_Stream_InvalidRecipientIdLength = 'Error_Stream_InvalidRecipientIdLength',
+  Error_Stream_InvalidRecipientIdLengthTemplate = 'Error_Stream_InvalidRecipientIdLengthTemplate',
+  Error_Stream_InvalidRecipientIdMust32Bytes = 'Error_Stream_InvalidRecipientIdMust32Bytes',
+  Error_Stream_InvalidPrivateKeyMust32Bytes = 'Error_Stream_InvalidPrivateKeyMust32Bytes',
+  Error_Stream_ChunkSequenceErrorTemplate = 'Error_Stream_ChunkSequenceErrorTemplate',
+  Error_Stream_DecryptionCancelled = 'Error_Stream_DecryptionCancelled',
+  Error_Chunk_DataTooShortForHeader = 'Error_Chunk_DataTooShortForHeader',
+  Error_Chunk_InvalidMagicBytes = 'Error_Chunk_InvalidMagicBytes',
+  Error_Chunk_UnsupportedVersion = 'Error_Chunk_UnsupportedVersion',
+  Error_Chunk_EncryptedSizeMismatchTemplate = 'Error_Chunk_EncryptedSizeMismatchTemplate',
+  Error_Chunk_ChecksumMismatch = 'Error_Chunk_ChecksumMismatch',
+  Error_Chunk_DecryptedSizeMismatch = 'Error_Chunk_DecryptedSizeMismatch',
+  Error_Progress_ChunkBytesCannotBeNegative = 'Error_Progress_ChunkBytesCannotBeNegative',
+  Error_Resumable_AutoSaveIntervalMustBePositive = 'Error_Resumable_AutoSaveIntervalMustBePositive',
+  Error_Resumable_PublicKeyMismatch = 'Error_Resumable_PublicKeyMismatch',
+  Error_Resumable_ChunkSizeMismatch = 'Error_Resumable_ChunkSizeMismatch',
+  Error_Resumable_IncludeChecksumsMismatch = 'Error_Resumable_IncludeChecksumsMismatch',
+  Error_Resumable_NoStateToSave = 'Error_Resumable_NoStateToSave',
+  Error_Resumable_UnsupportedStateVersionTemplate = 'Error_Resumable_UnsupportedStateVersionTemplate',
+  Error_Resumable_InvalidChunkIndex = 'Error_Resumable_InvalidChunkIndex',
+  Error_Resumable_StateTooOld = 'Error_Resumable_StateTooOld',
+  Error_Resumable_InvalidPublicKeyInState = 'Error_Resumable_InvalidPublicKeyInState',
+  Error_Resumable_StateIntegrityCheckFailed = 'Error_Resumable_StateIntegrityCheckFailed',
+  Error_Builder_MnemonicGenerationNotImplemented = 'Error_Builder_MnemonicGenerationNotImplemented',
+  Error_Builder_MemberNotMigrated = 'Error_Builder_MemberNotMigrated',
+  Error_Builder_ECIESServiceNotMigrated = 'Error_Builder_ECIESServiceNotMigrated',
+  Error_Service_InvalidDataLength = 'Error_Service_InvalidDataLength',
+  Error_Service_InvalidEncryptionType = 'Error_Service_InvalidEncryptionType',
+  Error_Service_InvalidEncryptedDataLength = 'Error_Service_InvalidEncryptedDataLength',
+  Error_Service_ComputedDecryptedLengthNegative = 'Error_Service_ComputedDecryptedLengthNegative',
+  Error_Service_MultiRecipientNotImplemented = 'Error_Service_MultiRecipientNotImplemented',
+  Error_Service_InvalidEncryptionTypeOrRecipientCountTemplate = 'Error_Service_InvalidEncryptionTypeOrRecipientCountTemplate',
+  Error_Container_ServiceNotFoundTemplate = 'Error_Container_ServiceNotFoundTemplate',
+  Error_Utils_InvalidHexString = 'Error_Utils_InvalidHexString',
+  Error_Utils_HexStringMustHaveEvenLength = 'Error_Utils_HexStringMustHaveEvenLength',
+  Error_Utils_HexStringContainsInvalidCharacters = 'Error_Utils_HexStringContainsInvalidCharacters',
+  Error_Utils_ValueExceedsSafeIntegerRange = 'Error_Utils_ValueExceedsSafeIntegerRange',
+  Error_Utils_ValueBelowSafeIntegerRange = 'Error_Utils_ValueBelowSafeIntegerRange',
+  Error_Builder_ECIESServiceMustBeSetBeforeGeneratingMnemonic = 'Error_Builder_ECIESServiceMustBeSetBeforeGeneratingMnemonic',
+  Error_Builder_ECIESServiceIsRequired = 'Error_Builder_ECIESServiceIsRequired',
+  Error_Builder_TypeNameAndEmailAreRequired = 'Error_Builder_TypeNameAndEmailAreRequired',
+  Error_DisposedError_ObjectDisposed = 'Error_DisposedError_ObjectDisposed',
+  Error_GuidError_InvalidGuid = 'Error_GuidError_InvalidGuid',
+  Error_GuidError_InvalidGuidWithDetailsTemplate = 'Error_GuidError_InvalidGuidWithDetailsTemplate',
+  Error_GuidError_InvalidGuidUnknownBrandTemplate = 'Error_GuidError_InvalidGuidUnknownBrandTemplate',
+  Error_GuidError_InvalidGuidUnknownLengthTemplate = 'Error_GuidError_InvalidGuidUnknownLengthTemplate',
+  Error_IdProviderError_InvalidLength = 'Error_IdProviderError_InvalidLength',
+  Error_IdProviderError_InputMustBeString = 'Error_IdProviderError_InputMustBeString',
+  Error_IdProviderError_InvalidStringLength = 'Error_IdProviderError_InvalidStringLength',
+  Error_IdProviderError_InvalidCharacters = 'Error_IdProviderError_InvalidCharacters',
+  Error_IdProviderError_InvalidDeserializedId = 'Error_IdProviderError_InvalidDeserializedId',
+  Error_IdProviderError_InvalidByteLengthParameter = 'Error_IdProviderError_InvalidByteLengthParameter',
+  Error_IdProviderError_ParseFailed = 'Error_IdProviderError_ParseFailed',
+  Error_IdProviderError_InvalidGuidBuffer = 'Error_IdProviderError_InvalidGuidBuffer',
+  Error_IdProviderError_InvalidUuidFormat = 'Error_IdProviderError_InvalidUuidFormat',
+
+  // Invariant Validation Errors
+  Error_Invariant_ValidationFailedTemplate = 'Error_Invariant_ValidationFailedTemplate',
+  Error_Invariant_UnknownInvariantTemplate = 'Error_Invariant_UnknownInvariantTemplate',
+  Error_Invariant_ConfigurationValidationFailedMultipleTemplate = 'Error_Invariant_ConfigurationValidationFailedMultipleTemplate',
+  Error_ECIESError_RecipientIdSizeTooLargeTemplate = 'Error_ECIESError_RecipientIdSizeTooLargeTemplate',
+  Error_ECIESError_InvalidVersion = 'Error_ECIESError_InvalidVersion',
+  Error_ECIESError_InvalidVersionTemplate = 'Error_ECIESError_InvalidVersionTemplate',
+  Error_ECIESError_InvalidCipherSuite = 'Error_ECIESError_InvalidCipherSuite',
+  Error_ECIESError_InvalidCipherSuiteTemplate = 'Error_ECIESError_InvalidCipherSuiteTemplate',
+}

package/src/enumerations/ecies-version.ts

@@ -0,0 +1,3 @@
+export enum EciesVersionEnum {
+  V1 = 1,
+}

package/src/enumerations/guid-brand-type.ts

@@ -0,0 +1,26 @@
+export enum GuidBrandType {
+  Unknown = 'Unknown',
+  /**
+   * Full hex guid, 36 characters
+   * 00000000-0000-0000-0000-000000000000
+   */
+  FullHexGuid = 'FullHexGuid',
+  /**
+   * Short hex guid, 32 characters
+   * 0000000000000000000000000000000
+   */
+  ShortHexGuid = 'ShortHexGuid',
+  /**
+   * Base64 guid, 24 characters
+   * AAAA/AAAAAA==
+   */
+  Base64Guid = 'Base64Guid',
+  /**
+   * BigInt, variable width
+   */
+  BigIntGuid = 'BigIntGuid',
+  /**
+   * Raw Guid, in a buffer, 16 bytes
+   */
+  RawGuidBuffer = 'RawGuidBuffer',
+}

package/src/enumerations/guid-error-type.ts

@@ -0,0 +1,6 @@
+export enum GuidErrorType {
+  InvalidGuid = 'InvalidGuid',
+  InvalidGuidWithDetails = 'InvalidGuidWithDetails',
+  InvalidGuidUnknownBrand = 'InvalidGuidUnknownBrand',
+  InvalidGuidUnknownLength = 'InvalidGuidUnknownLength',
+}

package/src/enumerations/id-provider-error-type.ts

@@ -0,0 +1,50 @@
+/**
+ * Enumeration of ID provider error types.
+ * These errors occur during ID generation, validation, serialization, or deserialization.
+ */
+export enum IdProviderErrorType {
+  /**
+   * ID buffer length does not match expected byte length.
+   */
+  InvalidLength = 'InvalidLength',
+  
+  /**
+   * Input is not a string when string is required.
+   */
+  InputMustBeString = 'InputMustBeString',
+  
+  /**
+   * String length is incorrect for deserialization.
+   */
+  InvalidStringLength = 'InvalidStringLength',
+  
+  /**
+   * String contains invalid characters for the format.
+   */
+  InvalidCharacters = 'InvalidCharacters',
+  
+  /**
+   * Deserialized ID failed validation.
+   */
+  InvalidDeserializedId = 'InvalidDeserializedId',
+  
+  /**
+   * Invalid byte length parameter (CustomIdProvider).
+   */
+  InvalidByteLengthParameter = 'InvalidByteLengthParameter',
+  
+  /**
+   * Failed to parse or convert ID format.
+   */
+  ParseFailed = 'ParseFailed',
+  
+  /**
+   * GUID buffer is invalid.
+   */
+  InvalidGuidBuffer = 'InvalidGuidBuffer',
+  
+  /**
+   * Invalid UUID format.
+   */
+  InvalidUuidFormat = 'InvalidUuidFormat',
+}

package/src/enumerations/{index.js → index.ts}

@@ -15,4 +15,3 @@ export * from './password-login-error-type';
 export * from './pbkdf2-error-type';
 export * from './pbkdf2-profile';
 export * from './secure-storage-error-type';
-//# sourceMappingURL=index.js.map

package/src/enumerations/invalid-email-type.ts

@@ -0,0 +1,5 @@
+export enum InvalidEmailErrorType {
+  Invalid = 'Invalid',
+  Missing = 'Missing',
+  Whitespace = 'Whitespace',
+}

package/src/enumerations/length-encoding-type.ts

@@ -0,0 +1,6 @@
+export enum LengthEncodingType {
+  UInt8 = 0,
+  UInt16 = 1,
+  UInt32 = 2,
+  UInt64 = 3,
+}

package/src/enumerations/length-error-type.ts

@@ -0,0 +1,5 @@
+export enum LengthErrorType {
+  LengthIsTooShort = 'LengthIsTooShort',
+  LengthIsTooLong = 'LengthIsTooLong',
+  LengthIsInvalidType = 'LengthIsInvalidType',
+}

package/src/enumerations/member-error-type.ts

@@ -0,0 +1,106 @@
+/**
+ * Error types specific to member operations
+ */
+export enum MemberErrorType {
+  /**
+   * Member name is missing
+   */
+  MissingMemberName = 'MissingMemberName',
+
+  /**
+   * Member name contains invalid whitespace
+   */
+  InvalidMemberNameWhitespace = 'InvalidMemberNameWhitespace',
+
+  /**
+   * Invalid email for member
+   */
+  InvalidEmail = 'InvalidEmail',
+
+  /**
+   * Invalid name for member
+   */
+  InvalidMemberName = 'InvalidMemberName',
+
+  /**
+   * Member email is missing
+   */
+  MissingEmail = 'MissingEmail',
+
+  /**
+   * Member email contains invalid whitespace
+   */
+  InvalidEmailWhitespace = 'InvalidEmailWhitespace',
+
+  /**
+   * Member private key is missing
+   */
+  MissingPrivateKey = 'MissingPrivateKey',
+
+  /**
+   * Member wallet is not loaded
+   */
+  NoWallet = 'NoWallet',
+
+  /**
+   * Member wallet is already loaded
+   */
+  WalletAlreadyLoaded = 'WalletAlreadyLoaded',
+
+  /**
+   * Invalid mnemonic for member
+   */
+  InvalidMnemonic = 'InvalidMnemonic',
+
+  /**
+   * Incorrect or invalid private key
+   */
+  IncorrectOrInvalidPrivateKey = 'IncorrectOrInvalidPrivateKey',
+
+  /**
+   * Member not found
+   */
+  MemberNotFound = 'MemberNotFound',
+
+  /**
+   * Member already exists
+   */
+  MemberAlreadyExists = 'MemberAlreadyExists',
+
+  /**
+   * Invalid member status
+   */
+  InvalidMemberStatus = 'InvalidMemberStatus',
+
+  /**
+   * Failed to hydrate member
+   */
+  FailedToHydrateMember = 'FailedToHydrateMember',
+
+  /**
+   * Invalid member data
+   */
+  InvalidMemberData = 'InvalidMemberData',
+
+  /**
+   * Failed to convert member data
+   */
+  FailedToConvertMemberData = 'FailedToConvertMemberData',
+
+  /**
+   * Data to encrypt is missing or null
+   */
+  MissingEncryptionData = 'MissingEncryptionData',
+
+  /**
+   * Data to encrypt exceeds maximum size limit
+   */
+  EncryptionDataTooLarge = 'EncryptionDataTooLarge',
+
+  /**
+   * Data to encrypt contains invalid characters
+   */
+  InvalidEncryptionData = 'InvalidEncryptionData',
+}
+
+export default MemberErrorType;

package/src/enumerations/{member-type.d.ts → member-type.ts}

@@ -5,17 +5,18 @@
  * 3. User - Regular users
  * 4. Anonymous - Users who aren't logged in and un-owned data
  */
-export declare enum MemberType {
-    Admin = "Admin",
-    System = "System",
-    User = "User",
-    Anonymous = "Anonymous"
+export enum MemberType {
+  Admin = 'Admin',
+  System = 'System',
+  User = 'User',
+  Anonymous = 'Anonymous',
 }
+
 /**
  * String union type for MemberType values.
  * Use this type when you need to extend with custom member types:
  * type CustomMemberType = MemberTypeValue | 'CustomType';
  */
 export type MemberTypeValue = `${MemberType}`;
+
 export default MemberType;
-//# sourceMappingURL=member-type.d.ts.map

package/src/enumerations/password-login-error-type.ts

@@ -0,0 +1,4 @@
+export enum PasswordLoginErrorTypeEnum {
+  FailedToStoreLoginData = 'FailedToStoreLoginData',
+  PasswordLoginNotSetUp = 'PasswordLoginNotSetUp',
+}

package/src/enumerations/pbkdf2-error-type.ts

@@ -0,0 +1,5 @@
+export enum Pbkdf2ErrorType {
+  InvalidProfile = 'InvalidProfile',
+  InvalidSaltLength = 'InvalidSaltLength',
+  InvalidHashLength = 'InvalidHashLength',
+}