@digitaldefiance/ecies-lib 1.1.24 → 1.1.26

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

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

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

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

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

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

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

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

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

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

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

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

@@ -1,106 +0,0 @@
-/**
- * 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/password-login-error-type.ts

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

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

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

package/src/enumerations/pbkdf2-profile.ts

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

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

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

package/src/errors/disposed.ts

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

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

@@ -1,34 +0,0 @@
-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/src/errors/invalid-email.ts

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

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

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

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

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

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

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