@digitaldefiance/ecies-lib 1.1.23 → 1.1.24

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

@@ -0,0 +1,102 @@
+import { ECIESError } from '../errors/ecies';
+import { getEciesI18nEngine } from '../i18n-setup';
+import { ECIESErrorTypeEnum } from './ecies-error-type';
+
+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
+> = {
+  [EciesEncryptionTypeEnum.Simple]: 'simple',
+  [EciesEncryptionTypeEnum.Single]: 'single',
+  [EciesEncryptionTypeEnum.Multiple]: 'multiple',
+};
+
+export const EciesEncryptionTypeEnumStringMap: Record<
+  EciesEncryptionTypeEnum,
+  string
+> = {
+  [EciesEncryptionTypeEnum.Simple]: 'simple',
+  [EciesEncryptionTypeEnum.Single]: 'single',
+  [EciesEncryptionTypeEnum.Multiple]: 'multiple',
+};
+
+export function encryptionTypeToString(
+  type: EciesEncryptionType | EciesEncryptionTypeEnum,
+): string {
+  // if enum
+  let resultType: EciesEncryptionType;
+  if (typeof type === 'number') {
+    resultType = EciesEncryptionTypeEnumTypeMap[type];
+    if (resultType === undefined) {
+      throw new ECIESError(
+        ECIESErrorTypeEnum.InvalidEncryptionType,
+        getEciesI18nEngine() as any,
+      );
+    }
+  } else {
+    resultType = type;
+  }
+  const result = EciesEncryptionTypeStringMap[resultType];
+  if (result === undefined) {
+    throw new ECIESError(
+      ECIESErrorTypeEnum.InvalidEncryptionType,
+      getEciesI18nEngine() as any,
+    );
+  }
+  return result;
+}
+
+export function encryptionTypeEnumToType(
+  type: EciesEncryptionTypeEnum,
+): EciesEncryptionType {
+  const result = EciesEncryptionTypeEnumTypeMap[type];
+  if (result === undefined) {
+    throw new ECIESError(
+      ECIESErrorTypeEnum.InvalidEncryptionType,
+      getEciesI18nEngine() as any,
+    );
+  }
+  return result;
+}
+
+export function validateEciesEncryptionTypeEnum(
+  type: EciesEncryptionTypeEnum,
+): boolean {
+  return Object.values(EciesEncryptionTypeEnum).includes(type);
+}
+
+export function ensureEciesEncryptionTypeEnum(
+  type: EciesEncryptionTypeEnum,
+): EciesEncryptionTypeEnum {
+  if (!validateEciesEncryptionTypeEnum(type)) {
+    throw new ECIESError(
+      ECIESErrorTypeEnum.InvalidEncryptionType,
+      getEciesI18nEngine() as any,
+    );
+  }
+  return type;
+}

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

@@ -0,0 +1,31 @@
+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
+}

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

@@ -0,0 +1,108 @@
+
+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_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_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_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',
+
+  // 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',
+
+  // GUID Error Types - buildReasonMap(GuidErrorType, 'Error', 'GuidError')
+  Error_GuidError_Invalid = 'Error_GuidError_Invalid',
+  Error_GuidError_InvalidWithGuidTemplate = 'Error_GuidError_InvalidWithGuidTemplate',
+  Error_GuidError_UnknownBrandTemplate = 'Error_GuidError_UnknownBrandTemplate',
+  Error_GuidError_UnknownLengthTemplate = 'Error_GuidError_UnknownLengthTemplate',
+
+  // 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',
+}

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 Uint8Array, 16 bytes
+   */
+  RawGuidUint8Array = 'RawGuidUint8Array',
+}

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

@@ -0,0 +1,6 @@
+export enum GuidErrorType {
+  Invalid = 'Invalid',
+  InvalidWithGuid = 'InvalidWithGuid',
+  UnknownBrand = 'UnknownBrand',
+  UnknownLength = 'UnknownLength',
+}

package/{dist/enumerations/index.d.ts → src/enumerations/index.ts}

@@ -12,4 +12,3 @@ export * from './password-login-error-type';
 export * from './pbkdf2-error-type';
 export * from './pbkdf2-profile';
 export * from './secure-storage-error-type';
-//# sourceMappingURL=index.d.ts.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/{dist/enumerations/member-type.d.ts → src/enumerations/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',
+}

package/src/enumerations/pbkdf2-profile.ts

@@ -0,0 +1,5 @@
+export enum Pbkdf2ProfileEnum {
+  BROWSER_PASSWORD = 'BROWSER_PASSWORD',
+  HIGH_SECURITY = 'HIGH_SECURITY',
+  TEST_FAST = 'TEST_FAST',
+}

package/src/enumerations/secure-storage-error-type.ts

@@ -0,0 +1,5 @@
+export enum SecureStorageErrorType {
+  DecryptedValueLengthMismatch = 'DecryptedValueLengthMismatch',
+  DecryptedValueChecksumMismatch = 'DecryptedValueChecksumMismatch',
+  ValueIsNull = 'ValueIsNull',
+}

package/src/errors/disposed.ts

@@ -0,0 +1,15 @@
+import { CoreStringKey, I18nEngine, Language } from '@digitaldefiance/i18n-lib';
+
+export class DisposedError extends Error {
+  constructor() {
+    let message = 'Object has been disposed';
+    try {
+      const engine = I18nEngine.getInstance();
+      message = engine.translate(CoreStringKey.Common_Disposed);
+    } catch {
+      // I18n engine not initialized, use fallback message
+    }
+    super(message);
+    this.name = 'DisposedError';
+  }
+}

package/src/errors/ecies.ts

@@ -0,0 +1,34 @@
+import { buildReasonMap, HandleableErrorOptions, CoreLanguageCode, PluginI18nEngine, PluginTypedHandleableError } from '@digitaldefiance/i18n-lib';
+import { ECIESErrorTypeEnum } from '../enumerations/ecies-error-type';
+import { EciesStringKey } from '../enumerations/ecies-string-key';
+import { EciesComponentId, getEciesI18nEngine } from '../i18n-setup';
+
+export class ECIESError<TLanguage extends CoreLanguageCode = CoreLanguageCode> extends PluginTypedHandleableError<
+  typeof ECIESErrorTypeEnum,
+  EciesStringKey,
+  TLanguage
+> {
+  constructor(
+    type: ECIESErrorTypeEnum,
+    engine?: PluginI18nEngine<TLanguage>,
+    options?: HandleableErrorOptions,
+    language?: TLanguage,
+    otherVars?: Record<string, string | number>,
+  ) {
+    const pluginEngine = (engine || getEciesI18nEngine()) as PluginI18nEngine<TLanguage>;
+    super(
+      pluginEngine,
+      EciesComponentId,
+      type,
+      buildReasonMap<typeof ECIESErrorTypeEnum, EciesStringKey>(
+        ECIESErrorTypeEnum,
+        ['Error', 'ECIESError'],
+      ),
+      new Error(),
+      options,
+      language,
+      otherVars,
+    );
+    this.name = 'ECIESError';
+  }
+}

package/src/errors/guid.ts

@@ -0,0 +1,34 @@
+import { GuidBrandType } from '../enumerations/guid-brand-type';
+import { GuidErrorType } from '../enumerations/guid-error-type';
+import { RawGuidUint8Array } from '../types';
+import { buildReasonMap, HandleableErrorOptions, CoreLanguageCode, PluginI18nEngine, PluginTypedHandleableError } from '@digitaldefiance/i18n-lib';
+import { EciesStringKey } from '../enumerations/ecies-string-key';
+import { EciesComponentId } from '../i18n-setup';
+
+/**
+ * Error class for handling GUID-related errors.
+ */
+export class GuidError<TLanguage extends CoreLanguageCode = CoreLanguageCode> extends PluginTypedHandleableError<typeof GuidErrorType, EciesStringKey, TLanguage> {
+  public readonly brand?: GuidBrandType;
+  public readonly length?: number;
+  public readonly guid?: Uint8Array;
+  
+  constructor(
+    type: GuidErrorType,
+    engine: PluginI18nEngine<TLanguage>,
+    brand?: GuidBrandType,
+    length?: number,
+    guid?: RawGuidUint8Array | Uint8Array,
+    options?: HandleableErrorOptions,
+    language?: TLanguage,
+  ) {
+    super(engine, EciesComponentId, type, buildReasonMap<typeof GuidErrorType, EciesStringKey>(GuidErrorType, ['Error', 'GuidError'], new Set([GuidErrorType.InvalidWithGuid, GuidErrorType.UnknownBrand, GuidErrorType.UnknownLength])), new Error(), options, language, {
+      GUID: guid ? Array.from(guid).map(b => b.toString(16).padStart(2, '0')).join(' ') : '',
+      BRAND: String(brand) ?? '',
+      LENGTH: String(length) ?? '',
+    });
+    this.brand = brand;
+    this.length = length;
+    this.guid = guid;
+  }
+}

package/{dist/errors/index.d.ts → src/errors/index.ts}

@@ -6,4 +6,3 @@ export * from './length';
 export * from './member';
 export * from './pbkdf2';
 export * from './secure-storage';
-//# sourceMappingURL=index.d.ts.map

package/src/errors/invalid-email.ts

@@ -0,0 +1,11 @@
+import { InvalidEmailErrorType } from '../enumerations/invalid-email-type';
+import { buildReasonMap, HandleableErrorOptions, CoreLanguageCode, PluginI18nEngine, PluginTypedHandleableError } from '@digitaldefiance/i18n-lib';
+import { EciesStringKey } from '../enumerations/ecies-string-key';
+import { EciesComponentId } from '../i18n-setup';
+
+export class InvalidEmailError<TLanguage extends CoreLanguageCode = CoreLanguageCode> extends PluginTypedHandleableError<typeof InvalidEmailErrorType, EciesStringKey, TLanguage> {
+  constructor(type: InvalidEmailErrorType, engine: PluginI18nEngine<TLanguage>, options?: HandleableErrorOptions, language?: TLanguage) {
+    super(engine, EciesComponentId, type, buildReasonMap<typeof InvalidEmailErrorType, EciesStringKey>(InvalidEmailErrorType, ['Error', 'InvalidEmailError']), new Error(), options, language);
+    this.name = 'InvalidEmailError';
+  }
+}

package/src/errors/length.ts

@@ -0,0 +1,11 @@
+import { LengthErrorType } from '../enumerations/length-error-type';
+import { buildReasonMap, HandleableErrorOptions, CoreLanguageCode, PluginI18nEngine, PluginTypedHandleableError } from '@digitaldefiance/i18n-lib';
+import { EciesStringKey } from '../enumerations/ecies-string-key';
+import { EciesComponentId } from '../i18n-setup';
+
+export class LengthError<TLanguage extends CoreLanguageCode = CoreLanguageCode> extends PluginTypedHandleableError<typeof LengthErrorType, EciesStringKey, TLanguage> {
+  constructor(type: LengthErrorType, engine: PluginI18nEngine<TLanguage>, options?: HandleableErrorOptions, language?: TLanguage) {
+    super(engine, EciesComponentId, type, buildReasonMap<typeof LengthErrorType, EciesStringKey>(LengthErrorType, ['Error', 'LengthError']), new Error(), options, language);
+    this.name = 'LengthError';
+  }
+}

package/src/errors/member.ts

@@ -0,0 +1,12 @@
+import { MemberErrorType } from '../enumerations/member-error-type';
+import { buildReasonMap, HandleableErrorOptions, CoreLanguageCode, PluginI18nEngine, PluginTypedHandleableError } from '@digitaldefiance/i18n-lib';
+import { EciesStringKey } from '../enumerations/ecies-string-key';
+import { EciesComponentId } from '../i18n-setup';
+
+export class MemberError<TLanguage extends CoreLanguageCode = CoreLanguageCode> extends PluginTypedHandleableError<typeof MemberErrorType, EciesStringKey, TLanguage> {
+
+  constructor(type: MemberErrorType, engine: PluginI18nEngine<TLanguage>, options?: HandleableErrorOptions, language?: TLanguage) {
+    super(engine, EciesComponentId, type, buildReasonMap<typeof MemberErrorType, EciesStringKey>(MemberErrorType, ['Error', 'MemberError']), new Error(), options, language);
+    this.name = 'MemberError';
+  }
+}

package/src/errors/pbkdf2.ts

@@ -0,0 +1,12 @@
+import { Pbkdf2ErrorType } from '../enumerations/pbkdf2-error-type';
+import { buildReasonMap, HandleableErrorOptions, PluginTypedHandleableError, PluginI18nEngine, CoreLanguageCode } from '@digitaldefiance/i18n-lib';
+import { EciesStringKey } from '../enumerations/ecies-string-key';
+import { EciesComponentId } from '../i18n-setup';
+
+export class Pbkdf2Error<TLanguage extends CoreLanguageCode = CoreLanguageCode> extends PluginTypedHandleableError<typeof Pbkdf2ErrorType, EciesStringKey, TLanguage> {
+
+  constructor(type: Pbkdf2ErrorType, engine: PluginI18nEngine<TLanguage>, options?: HandleableErrorOptions, language?: TLanguage) {
+    super(engine, EciesComponentId, type, buildReasonMap<typeof Pbkdf2ErrorType, EciesStringKey>(Pbkdf2ErrorType, ['Error', 'Pbkdf2Error']), new Error(), options, language);
+    this.name = 'Pbkdf2Error';
+  }
+}

package/src/errors/secure-storage.ts

@@ -0,0 +1,13 @@
+import { SecureStorageErrorType } from '../enumerations/secure-storage-error-type';
+import { buildReasonMap, HandleableErrorOptions, CoreLanguageCode, PluginI18nEngine, PluginTypedHandleableError } from '@digitaldefiance/i18n-lib';
+import { EciesStringKey } from '../enumerations/ecies-string-key';
+import { EciesComponentId } from '../i18n-setup';
+
+export class SecureStorageError<TLanguage extends CoreLanguageCode = CoreLanguageCode> extends PluginTypedHandleableError<typeof SecureStorageErrorType, EciesStringKey, TLanguage> {
+  constructor(type: SecureStorageErrorType, engine: PluginI18nEngine<TLanguage>, options?: HandleableErrorOptions, language?: TLanguage) {
+    const reasonMap = buildReasonMap<typeof SecureStorageErrorType, EciesStringKey>(SecureStorageErrorType, ['Error', 'SecureStorageError']);
+    
+    super(engine, EciesComponentId, type, reasonMap, new Error(), options, language);
+    this.name = 'SecureStorageError';
+  }
+}

package/src/errors/simple-ecies.ts

@@ -0,0 +1,18 @@
+import { buildReasonMap, HandleableErrorOptions, CoreLanguageCode, PluginI18nEngine, PluginTypedHandleableError } from '@digitaldefiance/i18n-lib';
+import { ECIESErrorTypeEnum, EciesStringKey } from '../enumerations';
+import { EciesComponentId } from '../i18n-setup';
+
+export class SimpleECIESError<TLanguage extends CoreLanguageCode = CoreLanguageCode> extends PluginTypedHandleableError<typeof ECIESErrorTypeEnum, EciesStringKey, TLanguage> {
+  constructor(
+    type: ECIESErrorTypeEnum,
+    engine: PluginI18nEngine<TLanguage>,
+    options?: HandleableErrorOptions,
+    language?: TLanguage,
+    otherVars?: Record<string, string | number>
+  ) {
+    const reasonMap = buildReasonMap<typeof ECIESErrorTypeEnum, EciesStringKey>(ECIESErrorTypeEnum, ['Error', 'ECIESError']);
+
+    super(engine, EciesComponentId, type, reasonMap, new Error(), options, language, otherVars);
+    this.name = 'SimpleECIESError';
+  }
+}

package/src/errors/simple-test-error.ts

@@ -0,0 +1,6 @@
+export class SimpleTestError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = 'SimpleTestError';
+  }
+}