@digitaldefiance/ecies-lib 1.1.24 → 1.1.25

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

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EciesEncryptionTypeEnumStringMap = exports.EciesEncryptionTypeEnumTypeMap = exports.EciesEncryptionTypeStringMap = exports.EciesEncryptionTypeMap = exports.EciesEncryptionTypeEnum = void 0;
+exports.encryptionTypeToString = encryptionTypeToString;
+exports.encryptionTypeEnumToType = encryptionTypeEnumToType;
+exports.validateEciesEncryptionTypeEnum = validateEciesEncryptionTypeEnum;
+exports.ensureEciesEncryptionTypeEnum = ensureEciesEncryptionTypeEnum;
+const ecies_1 = require("../errors/ecies");
+const i18n_setup_1 = require("../i18n-setup");
+const ecies_error_type_1 = require("./ecies-error-type");
+var EciesEncryptionTypeEnum;
+(function (EciesEncryptionTypeEnum) {
+    EciesEncryptionTypeEnum[EciesEncryptionTypeEnum["Simple"] = 33] = "Simple";
+    EciesEncryptionTypeEnum[EciesEncryptionTypeEnum["Single"] = 66] = "Single";
+    EciesEncryptionTypeEnum[EciesEncryptionTypeEnum["Multiple"] = 99] = "Multiple";
+})(EciesEncryptionTypeEnum || (exports.EciesEncryptionTypeEnum = EciesEncryptionTypeEnum = {}));
+exports.EciesEncryptionTypeMap = {
+    simple: EciesEncryptionTypeEnum.Simple,
+    single: EciesEncryptionTypeEnum.Single,
+    multiple: EciesEncryptionTypeEnum.Multiple,
+};
+exports.EciesEncryptionTypeStringMap = {
+    simple: 'simple',
+    single: 'single',
+    multiple: 'multiple',
+};
+exports.EciesEncryptionTypeEnumTypeMap = {
+    [EciesEncryptionTypeEnum.Simple]: 'simple',
+    [EciesEncryptionTypeEnum.Single]: 'single',
+    [EciesEncryptionTypeEnum.Multiple]: 'multiple',
+};
+exports.EciesEncryptionTypeEnumStringMap = {
+    [EciesEncryptionTypeEnum.Simple]: 'simple',
+    [EciesEncryptionTypeEnum.Single]: 'single',
+    [EciesEncryptionTypeEnum.Multiple]: 'multiple',
+};
+function encryptionTypeToString(type) {
+    // if enum
+    let resultType;
+    if (typeof type === 'number') {
+        resultType = exports.EciesEncryptionTypeEnumTypeMap[type];
+        if (resultType === undefined) {
+            throw new ecies_1.ECIESError(ecies_error_type_1.ECIESErrorTypeEnum.InvalidEncryptionType, (0, i18n_setup_1.getEciesI18nEngine)());
+        }
+    }
+    else {
+        resultType = type;
+    }
+    const result = exports.EciesEncryptionTypeStringMap[resultType];
+    if (result === undefined) {
+        throw new ecies_1.ECIESError(ecies_error_type_1.ECIESErrorTypeEnum.InvalidEncryptionType, (0, i18n_setup_1.getEciesI18nEngine)());
+    }
+    return result;
+}
+function encryptionTypeEnumToType(type) {
+    const result = exports.EciesEncryptionTypeEnumTypeMap[type];
+    if (result === undefined) {
+        throw new ecies_1.ECIESError(ecies_error_type_1.ECIESErrorTypeEnum.InvalidEncryptionType, (0, i18n_setup_1.getEciesI18nEngine)());
+    }
+    return result;
+}
+function validateEciesEncryptionTypeEnum(type) {
+    return Object.values(EciesEncryptionTypeEnum).includes(type);
+}
+function ensureEciesEncryptionTypeEnum(type) {
+    if (!validateEciesEncryptionTypeEnum(type)) {
+        throw new ecies_1.ECIESError(ecies_error_type_1.ECIESErrorTypeEnum.InvalidEncryptionType, (0, i18n_setup_1.getEciesI18nEngine)());
+    }
+    return type;
+}
+//# sourceMappingURL=ecies-encryption-type.js.map

package/src/enumerations/ecies-encryption-type.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ecies-encryption-type.js","sourceRoot":"","sources":["../../../../../packages/digitaldefiance-ecies-lib/src/enumerations/ecies-encryption-type.ts"],"names":[],"mappings":";;;AA8CA,wDAwBC;AAED,4DAWC;AAED,0EAIC;AAED,sEAUC;AArGD,2CAA6C;AAC7C,8CAAmD;AACnD,yDAAwD;AAIxD,IAAY,uBAIX;AAJD,WAAY,uBAAuB;IACjC,0EAAW,CAAA;IACX,0EAAW,CAAA;IACX,8EAAa,CAAA;AACf,CAAC,EAJW,uBAAuB,uCAAvB,uBAAuB,QAIlC;AAEY,QAAA,sBAAsB,GAG/B;IACF,MAAM,EAAE,uBAAuB,CAAC,MAAM;IACtC,MAAM,EAAE,uBAAuB,CAAC,MAAM;IACtC,QAAQ,EAAE,uBAAuB,CAAC,QAAQ;CAC3C,CAAC;AAEW,QAAA,4BAA4B,GACvC;IACE,MAAM,EAAE,QAAQ;IAChB,MAAM,EAAE,QAAQ;IAChB,QAAQ,EAAE,UAAU;CACrB,CAAC;AAES,QAAA,8BAA8B,GAGvC;IACF,CAAC,uBAAuB,CAAC,MAAM,CAAC,EAAE,QAAQ;IAC1C,CAAC,uBAAuB,CAAC,MAAM,CAAC,EAAE,QAAQ;IAC1C,CAAC,uBAAuB,CAAC,QAAQ,CAAC,EAAE,UAAU;CAC/C,CAAC;AAEW,QAAA,gCAAgC,GAGzC;IACF,CAAC,uBAAuB,CAAC,MAAM,CAAC,EAAE,QAAQ;IAC1C,CAAC,uBAAuB,CAAC,MAAM,CAAC,EAAE,QAAQ;IAC1C,CAAC,uBAAuB,CAAC,QAAQ,CAAC,EAAE,UAAU;CAC/C,CAAC;AAEF,SAAgB,sBAAsB,CACpC,IAAmD;IAEnD,UAAU;IACV,IAAI,UAA+B,CAAC;IACpC,IAAI,OAAO,IAAI,KAAK,QAAQ,EAAE,CAAC;QAC7B,UAAU,GAAG,sCAA8B,CAAC,IAAI,CAAC,CAAC;QAClD,IAAI,UAAU,KAAK,SAAS,EAAE,CAAC;YAC7B,MAAM,IAAI,kBAAU,CAClB,qCAAkB,CAAC,qBAAqB,EACxC,IAAA,+BAAkB,GAAS,CAC5B,CAAC;QACJ,CAAC;IACH,CAAC;SAAM,CAAC;QACN,UAAU,GAAG,IAAI,CAAC;IACpB,CAAC;IACD,MAAM,MAAM,GAAG,oCAA4B,CAAC,UAAU,CAAC,CAAC;IACxD,IAAI,MAAM,KAAK,SAAS,EAAE,CAAC;QACzB,MAAM,IAAI,kBAAU,CAClB,qCAAkB,CAAC,qBAAqB,EACxC,IAAA,+BAAkB,GAAS,CAC5B,CAAC;IACJ,CAAC;IACD,OAAO,MAAM,CAAC;AAChB,CAAC;AAED,SAAgB,wBAAwB,CACtC,IAA6B;IAE7B,MAAM,MAAM,GAAG,sCAA8B,CAAC,IAAI,CAAC,CAAC;IACpD,IAAI,MAAM,KAAK,SAAS,EAAE,CAAC;QACzB,MAAM,IAAI,kBAAU,CAClB,qCAAkB,CAAC,qBAAqB,EACxC,IAAA,+BAAkB,GAAS,CAC5B,CAAC;IACJ,CAAC;IACD,OAAO,MAAM,CAAC;AAChB,CAAC;AAED,SAAgB,+BAA+B,CAC7C,IAA6B;IAE7B,OAAO,MAAM,CAAC,MAAM,CAAC,uBAAuB,CAAC,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;AAC/D,CAAC;AAED,SAAgB,6BAA6B,CAC3C,IAA6B;IAE7B,IAAI,CAAC,+BAA+B,CAAC,IAAI,CAAC,EAAE,CAAC;QAC3C,MAAM,IAAI,kBAAU,CAClB,qCAAkB,CAAC,qBAAqB,EACxC,IAAA,+BAAkB,GAAS,CAC5B,CAAC;IACJ,CAAC;IACD,OAAO,IAAI,CAAC;AACd,CAAC"}

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

@@ -0,0 +1,32 @@
+export declare 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"
+}
+//# sourceMappingURL=ecies-error-type.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ecies-error-type.d.ts","sourceRoot":"","sources":["../../../../../packages/digitaldefiance-ecies-lib/src/enumerations/ecies-error-type.ts"],"names":[],"mappings":"AAAA,oBAAY,kBAAkB;IAC5B,oCAAoC,yCAAyC;IAC7E,2BAA2B,gCAAgC;IAC3D,sCAAsC,2CAA2C;IACjF,kCAAkC,uCAAuC;IACzE,mCAAmC,wCAAwC;IAC3E,QAAQ,aAAa;IACrB,qBAAqB,0BAA0B;IAC/C,eAAe,oBAAoB;IACnC,oBAAoB,yBAAyB;IAC7C,mBAAmB,wBAAwB;IAC3C,iBAAiB,sBAAsB;IACvC,0BAA0B,+BAA+B;IACzD,iBAAiB,sBAAsB;IACvC,eAAe,oBAAoB;IACnC,gBAAgB,qBAAqB;IACrC,qBAAqB,0BAA0B;IAC/C,yBAAyB,8BAA8B;IACvD,yBAAyB,8BAA8B;IACvD,iBAAiB,sBAAsB;IACvC,gBAAgB,qBAAqB;IACrC,sBAAsB,2BAA2B;IACjD,iBAAiB,sBAAsB;IACvC,mBAAmB,wBAAwB;IAC3C,yBAAyB,8BAA8B;IACvD,qBAAqB,0BAA0B;IAC/C,gBAAgB,qBAAqB;IACrC,gBAAgB,qBAAqB,CAAE,+BAA+B;IACtE,yBAAyB,8BAA8B,CAAE,gCAAgC;IACzF,uBAAuB,4BAA4B;CACpD"}

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

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ECIESErrorTypeEnum = void 0;
+var ECIESErrorTypeEnum;
+(function (ECIESErrorTypeEnum) {
+    ECIESErrorTypeEnum["InvalidECIESMultipleEncryptedKeySize"] = "InvalidECIESMultipleEncryptedKeySize";
+    ECIESErrorTypeEnum["InvalidECIESPublicKeyLength"] = "InvalidECIESPublicKeyLength";
+    ECIESErrorTypeEnum["InvalidECIESMultipleRecipientCountSize"] = "InvalidECIESMultipleRecipientCountSize";
+    ECIESErrorTypeEnum["InvalidECIESMultipleDataLengthSize"] = "InvalidECIESMultipleDataLengthSize";
+    ECIESErrorTypeEnum["InvalidECIESMultipleRecipientIdSize"] = "InvalidECIESMultipleRecipientIdSize";
+    ECIESErrorTypeEnum["CRCError"] = "CRCError";
+    ECIESErrorTypeEnum["InvalidEncryptionType"] = "InvalidEncryptionType";
+    ECIESErrorTypeEnum["InvalidIVLength"] = "InvalidIVLength";
+    ECIESErrorTypeEnum["InvalidAuthTagLength"] = "InvalidAuthTagLength";
+    ECIESErrorTypeEnum["InvalidHeaderLength"] = "InvalidHeaderLength";
+    ECIESErrorTypeEnum["InvalidDataLength"] = "InvalidDataLength";
+    ECIESErrorTypeEnum["InvalidEncryptedDataLength"] = "InvalidEncryptedDataLength";
+    ECIESErrorTypeEnum["InvalidMessageCrc"] = "InvalidMessageCrc";
+    ECIESErrorTypeEnum["InvalidMnemonic"] = "InvalidMnemonic";
+    ECIESErrorTypeEnum["InvalidOperation"] = "InvalidOperation";
+    ECIESErrorTypeEnum["MessageLengthMismatch"] = "MessageLengthMismatch";
+    ECIESErrorTypeEnum["InvalidEncryptedKeyLength"] = "InvalidEncryptedKeyLength";
+    ECIESErrorTypeEnum["InvalidEphemeralPublicKey"] = "InvalidEphemeralPublicKey";
+    ECIESErrorTypeEnum["RecipientNotFound"] = "RecipientNotFound";
+    ECIESErrorTypeEnum["InvalidSignature"] = "InvalidSignature";
+    ECIESErrorTypeEnum["InvalidSenderPublicKey"] = "InvalidSenderPublicKey";
+    ECIESErrorTypeEnum["TooManyRecipients"] = "TooManyRecipients";
+    ECIESErrorTypeEnum["PrivateKeyNotLoaded"] = "PrivateKeyNotLoaded";
+    ECIESErrorTypeEnum["RecipientKeyCountMismatch"] = "RecipientKeyCountMismatch";
+    ECIESErrorTypeEnum["InvalidRecipientCount"] = "InvalidRecipientCount";
+    ECIESErrorTypeEnum["FileSizeTooLarge"] = "FileSizeTooLarge";
+    ECIESErrorTypeEnum["DecryptionFailed"] = "DecryptionFailed";
+    ECIESErrorTypeEnum["InvalidRecipientPublicKey"] = "InvalidRecipientPublicKey";
+    ECIESErrorTypeEnum["SecretComputationFailed"] = "SecretComputationFailed";
+})(ECIESErrorTypeEnum || (exports.ECIESErrorTypeEnum = ECIESErrorTypeEnum = {}));
+//# sourceMappingURL=ecies-error-type.js.map

package/src/enumerations/ecies-error-type.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ecies-error-type.js","sourceRoot":"","sources":["../../../../../packages/digitaldefiance-ecies-lib/src/enumerations/ecies-error-type.ts"],"names":[],"mappings":";;;AAAA,IAAY,kBA8BX;AA9BD,WAAY,kBAAkB;IAC5B,mGAA6E,CAAA;IAC7E,iFAA2D,CAAA;IAC3D,uGAAiF,CAAA;IACjF,+FAAyE,CAAA;IACzE,iGAA2E,CAAA;IAC3E,2CAAqB,CAAA;IACrB,qEAA+C,CAAA;IAC/C,yDAAmC,CAAA;IACnC,mEAA6C,CAAA;IAC7C,iEAA2C,CAAA;IAC3C,6DAAuC,CAAA;IACvC,+EAAyD,CAAA;IACzD,6DAAuC,CAAA;IACvC,yDAAmC,CAAA;IACnC,2DAAqC,CAAA;IACrC,qEAA+C,CAAA;IAC/C,6EAAuD,CAAA;IACvD,6EAAuD,CAAA;IACvD,6DAAuC,CAAA;IACvC,2DAAqC,CAAA;IACrC,uEAAiD,CAAA;IACjD,6DAAuC,CAAA;IACvC,iEAA2C,CAAA;IAC3C,6EAAuD,CAAA;IACvD,qEAA+C,CAAA;IAC/C,2DAAqC,CAAA;IACrC,2DAAqC,CAAA;IACrC,6EAAuD,CAAA;IACvD,yEAAmD,CAAA;AACrD,CAAC,EA9BW,kBAAkB,kCAAlB,kBAAkB,QA8B7B"}

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

@@ -0,0 +1,96 @@
+export declare 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",
+    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",
+    Error_GuidError_Invalid = "Error_GuidError_Invalid",
+    Error_GuidError_InvalidWithGuidTemplate = "Error_GuidError_InvalidWithGuidTemplate",
+    Error_GuidError_UnknownBrandTemplate = "Error_GuidError_UnknownBrandTemplate",
+    Error_GuidError_UnknownLengthTemplate = "Error_GuidError_UnknownLengthTemplate",
+    Error_LengthError_LengthIsTooShort = "Error_LengthError_LengthIsTooShort",
+    Error_LengthError_LengthIsTooLong = "Error_LengthError_LengthIsTooLong",
+    Error_LengthError_LengthIsInvalidType = "Error_LengthError_LengthIsInvalidType",
+    Error_Pbkdf2Error_InvalidProfile = "Error_Pbkdf2Error_InvalidProfile",
+    Error_Pbkdf2Error_InvalidSaltLength = "Error_Pbkdf2Error_InvalidSaltLength",
+    Error_Pbkdf2Error_InvalidHashLength = "Error_Pbkdf2Error_InvalidHashLength",
+    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"
+}
+//# sourceMappingURL=ecies-string-key.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ecies-string-key.d.ts","sourceRoot":"","sources":["../../../../../packages/digitaldefiance-ecies-lib/src/enumerations/ecies-string-key.ts"],"names":[],"mappings":"AACA,oBAAY,cAAc;IACxB,qDAAqD,0DAA0D;IAC/G,4CAA4C,iDAAiD;IAC7F,uDAAuD,4DAA4D;IACnH,mDAAmD,wDAAwD;IAC3G,oDAAoD,yDAAyD;IAC7G,yBAAyB,8BAA8B;IACvD,sCAAsC,2CAA2C;IACjF,8CAA8C,mDAAmD;IACjG,gCAAgC,qCAAqC;IACrE,qCAAqC,0CAA0C;IAC/E,oCAAoC,yCAAyC;IAC7E,kCAAkC,uCAAuC;IACzE,2CAA2C,gDAAgD;IAC3F,kCAAkC,uCAAuC;IACzE,gCAAgC,qCAAqC;IACrE,iCAAiC,sCAAsC;IACvE,sCAAsC,2CAA2C;IACjF,0CAA0C,+CAA+C;IACzF,0CAA0C,+CAA+C;IACzF,kCAAkC,uCAAuC;IACzE,iCAAiC,sCAAsC;IACvE,uCAAuC,4CAA4C;IACnF,kCAAkC,uCAAuC;IACzE,oCAAoC,yCAAyC;IAC7E,0CAA0C,+CAA+C;IACzF,sCAAsC,2CAA2C;IACjF,iCAAiC,sCAAsC;IACvE,iCAAiC,sCAAsC;IACvE,0CAA0C,+CAA+C;IACzF,wCAAwC,6CAA6C;IACrF,4DAA4D,iEAAiE;IAC7H,8DAA8D,mEAAmE;IACjI,4EAA4E,iFAAiF;IAC7J,kDAAkD,uDAAuD;IACzG,mCAAmC,wCAAwC;IAC3E,0CAA0C,+CAA+C;IACzF,wCAAwC,6CAA6C;IACrF,4CAA4C,iDAAiD;IAC7F,uCAAuC,4CAA4C;IACnF,oDAAoD,yDAAyD;IAC7G,iDAAiD,sDAAsD;IACvG,0CAA0C,+CAA+C;IACzF,0CAA0C,+CAA+C;IACzF,uDAAuD,4DAA4D;IACnH,iDAAiD,sDAAsD;IACvG,+DAA+D,oEAAoE;IACnI,wEAAwE,6EAA6E;IACrJ,+CAA+C,oDAAoD;IACnG,qCAAqC,0CAA0C;IAC/E,2CAA2C,gDAAgD;IAC3F,kDAAkD,uDAAuD;IACzG,yCAAyC,8CAA8C;IACvF,oDAAoD,yDAAyD;IAG7G,mCAAmC,wCAAwC;IAC3E,6CAA6C,kDAAkD;IAC/F,8BAA8B,mCAAmC;IACjE,mCAAmC,wCAAwC;IAC3E,8BAA8B,mCAAmC;IACjE,wCAAwC,6CAA6C;IACrF,mCAAmC,wCAAwC;IAC3E,0BAA0B,+BAA+B;IACzD,qCAAqC,0CAA0C;IAC/E,iCAAiC,sCAAsC;IACvE,8CAA8C,mDAAmD;IACjG,gCAAgC,qCAAqC;IACrE,qCAAqC,0CAA0C;IAC/E,qCAAqC,0CAA0C;IAC/E,uCAAuC,4CAA4C;IACnF,mCAAmC,wCAAwC;IAC3E,2CAA2C,gDAAgD;IAC3F,uCAAuC,4CAA4C;IACnF,wCAAwC,6CAA6C;IACrF,uCAAuC,4CAA4C;IAGnF,uBAAuB,4BAA4B;IACnD,uCAAuC,4CAA4C;IACnF,oCAAoC,yCAAyC;IAC7E,qCAAqC,0CAA0C;IAG/E,kCAAkC,uCAAuC;IACzE,iCAAiC,sCAAsC;IACvE,qCAAqC,0CAA0C;IAG/E,gCAAgC,qCAAqC;IACrE,mCAAmC,wCAAwC;IAC3E,mCAAmC,wCAAwC;IAG3E,qDAAqD,0DAA0D;IAC/G,uDAAuD,4DAA4D;IACnH,oCAAoC,yCAAyC;IAE7E,+BAA+B,oCAAoC;IACnE,+BAA+B,oCAAoC;IACnE,kCAAkC,uCAAuC;IACzE,qCAAqC,0CAA0C;IAC/E,+CAA+C,oDAAoD;IACnG,8CAA8C,mDAAmD;IAEjG,iCAAiC,sCAAsC;CACxE"}

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

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EciesStringKey = void 0;
+var EciesStringKey;
+(function (EciesStringKey) {
+    EciesStringKey["Error_ECIESError_InvalidECIESMultipleEncryptedKeySize"] = "Error_ECIESError_InvalidECIESMultipleEncryptedKeySize";
+    EciesStringKey["Error_ECIESError_InvalidECIESPublicKeyLength"] = "Error_ECIESError_InvalidECIESPublicKeyLength";
+    EciesStringKey["Error_ECIESError_InvalidECIESMultipleRecipientCountSize"] = "Error_ECIESError_InvalidECIESMultipleRecipientCountSize";
+    EciesStringKey["Error_ECIESError_InvalidECIESMultipleDataLengthSize"] = "Error_ECIESError_InvalidECIESMultipleDataLengthSize";
+    EciesStringKey["Error_ECIESError_InvalidECIESMultipleRecipientIdSize"] = "Error_ECIESError_InvalidECIESMultipleRecipientIdSize";
+    EciesStringKey["Error_ECIESError_CRCError"] = "Error_ECIESError_CRCError";
+    EciesStringKey["Error_ECIESError_InvalidEncryptionType"] = "Error_ECIESError_InvalidEncryptionType";
+    EciesStringKey["Error_ECIESError_InvalidEncryptionTypeTemplate"] = "Error_ECIESError_InvalidEncryptionTypeTemplate";
+    EciesStringKey["Error_ECIESError_InvalidIVLength"] = "Error_ECIESError_InvalidIVLength";
+    EciesStringKey["Error_ECIESError_InvalidAuthTagLength"] = "Error_ECIESError_InvalidAuthTagLength";
+    EciesStringKey["Error_ECIESError_InvalidHeaderLength"] = "Error_ECIESError_InvalidHeaderLength";
+    EciesStringKey["Error_ECIESError_InvalidDataLength"] = "Error_ECIESError_InvalidDataLength";
+    EciesStringKey["Error_ECIESError_InvalidEncryptedDataLength"] = "Error_ECIESError_InvalidEncryptedDataLength";
+    EciesStringKey["Error_ECIESError_InvalidMessageCrc"] = "Error_ECIESError_InvalidMessageCrc";
+    EciesStringKey["Error_ECIESError_InvalidMnemonic"] = "Error_ECIESError_InvalidMnemonic";
+    EciesStringKey["Error_ECIESError_InvalidOperation"] = "Error_ECIESError_InvalidOperation";
+    EciesStringKey["Error_ECIESError_MessageLengthMismatch"] = "Error_ECIESError_MessageLengthMismatch";
+    EciesStringKey["Error_ECIESError_InvalidEncryptedKeyLength"] = "Error_ECIESError_InvalidEncryptedKeyLength";
+    EciesStringKey["Error_ECIESError_InvalidEphemeralPublicKey"] = "Error_ECIESError_InvalidEphemeralPublicKey";
+    EciesStringKey["Error_ECIESError_RecipientNotFound"] = "Error_ECIESError_RecipientNotFound";
+    EciesStringKey["Error_ECIESError_InvalidSignature"] = "Error_ECIESError_InvalidSignature";
+    EciesStringKey["Error_ECIESError_InvalidSenderPublicKey"] = "Error_ECIESError_InvalidSenderPublicKey";
+    EciesStringKey["Error_ECIESError_TooManyRecipients"] = "Error_ECIESError_TooManyRecipients";
+    EciesStringKey["Error_ECIESError_PrivateKeyNotLoaded"] = "Error_ECIESError_PrivateKeyNotLoaded";
+    EciesStringKey["Error_ECIESError_RecipientKeyCountMismatch"] = "Error_ECIESError_RecipientKeyCountMismatch";
+    EciesStringKey["Error_ECIESError_InvalidRecipientCount"] = "Error_ECIESError_InvalidRecipientCount";
+    EciesStringKey["Error_ECIESError_FileSizeTooLarge"] = "Error_ECIESError_FileSizeTooLarge";
+    EciesStringKey["Error_ECIESError_DecryptionFailed"] = "Error_ECIESError_DecryptionFailed";
+    EciesStringKey["Error_ECIESError_InvalidRecipientPublicKey"] = "Error_ECIESError_InvalidRecipientPublicKey";
+    EciesStringKey["Error_ECIESError_SecretComputationFailed"] = "Error_ECIESError_SecretComputationFailed";
+    EciesStringKey["Error_ECIESError_AuthenticationTagIsRequiredForKeyEncryption"] = "Error_ECIESError_AuthenticationTagIsRequiredForKeyEncryption";
+    EciesStringKey["Error_ECIESError_AuthenticationTagIsRequiredForECIESEncryption"] = "Error_ECIESError_AuthenticationTagIsRequiredForECIESEncryption";
+    EciesStringKey["Error_ECIESError_AuthenticationTagIsRequiredForMultiRecipientECIESEncryption"] = "Error_ECIESError_AuthenticationTagIsRequiredForMultiRecipientECIESEncryption";
+    EciesStringKey["Error_ECIESError_InvalidEncryptedKeyLengthTemplate"] = "Error_ECIESError_InvalidEncryptedKeyLengthTemplate";
+    EciesStringKey["Error_ECIESError_FailedToDecryptKey"] = "Error_ECIESError_FailedToDecryptKey";
+    EciesStringKey["Error_ECIESError_TooManyRecipientsTemplate"] = "Error_ECIESError_TooManyRecipientsTemplate";
+    EciesStringKey["Error_ECIESError_MessageTooLargeTemplate"] = "Error_ECIESError_MessageTooLargeTemplate";
+    EciesStringKey["Error_ECIESError_DecryptedDataLengthMismatch"] = "Error_ECIESError_DecryptedDataLengthMismatch";
+    EciesStringKey["Error_ECIESError_RecipientCountMismatch"] = "Error_ECIESError_RecipientCountMismatch";
+    EciesStringKey["Error_ECIESError_DataTooShortForMultiRecipientHeader"] = "Error_ECIESError_DataTooShortForMultiRecipientHeader";
+    EciesStringKey["Error_ECIESError_FailedToDecryptChallengeTemplate"] = "Error_ECIESError_FailedToDecryptChallengeTemplate";
+    EciesStringKey["Error_ECIESError_InvalidChallengeSignature"] = "Error_ECIESError_InvalidChallengeSignature";
+    EciesStringKey["Error_ECIESError_FailedToDervivePrivateKey"] = "Error_ECIESError_FailedToDervivePrivateKey";
+    EciesStringKey["Error_ECIESError_InvalidPublicKeyFormatOrLengthTemplate"] = "Error_ECIESError_InvalidPublicKeyFormatOrLengthTemplate";
+    EciesStringKey["Error_ECIESError_ReceivedNullOrUndefinedPublicKey"] = "Error_ECIESError_ReceivedNullOrUndefinedPublicKey";
+    EciesStringKey["Error_ECIESError_MessageLengthExceedsMaximumAllowedSizeTemplate"] = "Error_ECIESError_MessageLengthExceedsMaximumAllowedSizeTemplate";
+    EciesStringKey["Error_ECIESError_MultipleEncryptionTypeNotSupportedInSingleRecipientMode"] = "Error_ECIESError_MultipleEncryptionTypeNotSupportedInSingleRecipientMode";
+    EciesStringKey["Error_ECIESError_EncryptionTypeMismatchTemplate"] = "Error_ECIESError_EncryptionTypeMismatchTemplate";
+    EciesStringKey["Error_ECIESError_DataTooShortTemplate"] = "Error_ECIESError_DataTooShortTemplate";
+    EciesStringKey["Error_ECIESError_DataLengthMismatchTemplate"] = "Error_ECIESError_DataLengthMismatchTemplate";
+    EciesStringKey["Error_ECIESError_CombinedDataTooShortForComponents"] = "Error_ECIESError_CombinedDataTooShortForComponents";
+    EciesStringKey["Error_ECIESError_InvalidChecksumConstants"] = "Error_ECIESError_InvalidChecksumConstants";
+    EciesStringKey["Error_ECIESError_CannotOverwriteDefaultConfiguration"] = "Error_ECIESError_CannotOverwriteDefaultConfiguration";
+    // Member Error Types - buildReasonMap(MemberErrorType, 'Error', 'MemberError')
+    EciesStringKey["Error_MemberError_MissingMemberName"] = "Error_MemberError_MissingMemberName";
+    EciesStringKey["Error_MemberError_InvalidMemberNameWhitespace"] = "Error_MemberError_InvalidMemberNameWhitespace";
+    EciesStringKey["Error_MemberError_InvalidEmail"] = "Error_MemberError_InvalidEmail";
+    EciesStringKey["Error_MemberError_InvalidMemberName"] = "Error_MemberError_InvalidMemberName";
+    EciesStringKey["Error_MemberError_MissingEmail"] = "Error_MemberError_MissingEmail";
+    EciesStringKey["Error_MemberError_InvalidEmailWhitespace"] = "Error_MemberError_InvalidEmailWhitespace";
+    EciesStringKey["Error_MemberError_MissingPrivateKey"] = "Error_MemberError_MissingPrivateKey";
+    EciesStringKey["Error_MemberError_NoWallet"] = "Error_MemberError_NoWallet";
+    EciesStringKey["Error_MemberError_WalletAlreadyLoaded"] = "Error_MemberError_WalletAlreadyLoaded";
+    EciesStringKey["Error_MemberError_InvalidMnemonic"] = "Error_MemberError_InvalidMnemonic";
+    EciesStringKey["Error_MemberError_IncorrectOrInvalidPrivateKey"] = "Error_MemberError_IncorrectOrInvalidPrivateKey";
+    EciesStringKey["Error_MemberError_MemberNotFound"] = "Error_MemberError_MemberNotFound";
+    EciesStringKey["Error_MemberError_MemberAlreadyExists"] = "Error_MemberError_MemberAlreadyExists";
+    EciesStringKey["Error_MemberError_InvalidMemberStatus"] = "Error_MemberError_InvalidMemberStatus";
+    EciesStringKey["Error_MemberError_FailedToHydrateMember"] = "Error_MemberError_FailedToHydrateMember";
+    EciesStringKey["Error_MemberError_InvalidMemberData"] = "Error_MemberError_InvalidMemberData";
+    EciesStringKey["Error_MemberError_FailedToConvertMemberData"] = "Error_MemberError_FailedToConvertMemberData";
+    EciesStringKey["Error_MemberError_MissingEncryptionData"] = "Error_MemberError_MissingEncryptionData";
+    EciesStringKey["Error_MemberError_EncryptionDataTooLarge"] = "Error_MemberError_EncryptionDataTooLarge";
+    EciesStringKey["Error_MemberError_InvalidEncryptionData"] = "Error_MemberError_InvalidEncryptionData";
+    // GUID Error Types - buildReasonMap(GuidErrorType, 'Error', 'GuidError')
+    EciesStringKey["Error_GuidError_Invalid"] = "Error_GuidError_Invalid";
+    EciesStringKey["Error_GuidError_InvalidWithGuidTemplate"] = "Error_GuidError_InvalidWithGuidTemplate";
+    EciesStringKey["Error_GuidError_UnknownBrandTemplate"] = "Error_GuidError_UnknownBrandTemplate";
+    EciesStringKey["Error_GuidError_UnknownLengthTemplate"] = "Error_GuidError_UnknownLengthTemplate";
+    // Length Error Types - buildReasonMap(LengthErrorType, 'Error', 'LengthError')
+    EciesStringKey["Error_LengthError_LengthIsTooShort"] = "Error_LengthError_LengthIsTooShort";
+    EciesStringKey["Error_LengthError_LengthIsTooLong"] = "Error_LengthError_LengthIsTooLong";
+    EciesStringKey["Error_LengthError_LengthIsInvalidType"] = "Error_LengthError_LengthIsInvalidType";
+    // PBKDF2 Error Types - buildReasonMap(Pbkdf2ErrorType, 'Error', 'Pbkdf2Error')
+    EciesStringKey["Error_Pbkdf2Error_InvalidProfile"] = "Error_Pbkdf2Error_InvalidProfile";
+    EciesStringKey["Error_Pbkdf2Error_InvalidSaltLength"] = "Error_Pbkdf2Error_InvalidSaltLength";
+    EciesStringKey["Error_Pbkdf2Error_InvalidHashLength"] = "Error_Pbkdf2Error_InvalidHashLength";
+    // Secure Storage Error Types - buildReasonMap(SecureStorageErrorType, 'Error', 'SecureStorageError')
+    EciesStringKey["Error_SecureStorageError_DecryptedValueLengthMismatch"] = "Error_SecureStorageError_DecryptedValueLengthMismatch";
+    EciesStringKey["Error_SecureStorageError_DecryptedValueChecksumMismatch"] = "Error_SecureStorageError_DecryptedValueChecksumMismatch";
+    EciesStringKey["Error_SecureStorageError_ValueIsNull"] = "Error_SecureStorageError_ValueIsNull";
+    EciesStringKey["Error_InvalidEmailError_Invalid"] = "Error_InvalidEmailError_Invalid";
+    EciesStringKey["Error_InvalidEmailError_Missing"] = "Error_InvalidEmailError_Missing";
+    EciesStringKey["Error_InvalidEmailError_Whitespace"] = "Error_InvalidEmailError_Whitespace";
+    EciesStringKey["Error_Utils_EncryptionFailedNoAuthTag"] = "Error_Utils_EncryptionFailedNoAuthTag";
+    EciesStringKey["Error_PasswordLoginError_FailedToStoreLoginData"] = "Error_PasswordLoginError_FailedToStoreLoginData";
+    EciesStringKey["Error_PasswordLoginError_PasswordLoginNotSetUp"] = "Error_PasswordLoginError_PasswordLoginNotSetUp";
+    EciesStringKey["Error_PhoneNumber_InvalidTemplate"] = "Error_PhoneNumber_InvalidTemplate";
+})(EciesStringKey || (exports.EciesStringKey = EciesStringKey = {}));
+//# sourceMappingURL=ecies-string-key.js.map

package/src/enumerations/ecies-string-key.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ecies-string-key.js","sourceRoot":"","sources":["../../../../../packages/digitaldefiance-ecies-lib/src/enumerations/ecies-string-key.ts"],"names":[],"mappings":";;;AACA,IAAY,cA0GX;AA1GD,WAAY,cAAc;IACxB,iIAA+G,CAAA;IAC/G,+GAA6F,CAAA;IAC7F,qIAAmH,CAAA;IACnH,6HAA2G,CAAA;IAC3G,+HAA6G,CAAA;IAC7G,yEAAuD,CAAA;IACvD,mGAAiF,CAAA;IACjF,mHAAiG,CAAA;IACjG,uFAAqE,CAAA;IACrE,iGAA+E,CAAA;IAC/E,+FAA6E,CAAA;IAC7E,2FAAyE,CAAA;IACzE,6GAA2F,CAAA;IAC3F,2FAAyE,CAAA;IACzE,uFAAqE,CAAA;IACrE,yFAAuE,CAAA;IACvE,mGAAiF,CAAA;IACjF,2GAAyF,CAAA;IACzF,2GAAyF,CAAA;IACzF,2FAAyE,CAAA;IACzE,yFAAuE,CAAA;IACvE,qGAAmF,CAAA;IACnF,2FAAyE,CAAA;IACzE,+FAA6E,CAAA;IAC7E,2GAAyF,CAAA;IACzF,mGAAiF,CAAA;IACjF,yFAAuE,CAAA;IACvE,yFAAuE,CAAA;IACvE,2GAAyF,CAAA;IACzF,uGAAqF,CAAA;IACrF,+IAA6H,CAAA;IAC7H,mJAAiI,CAAA;IACjI,+KAA6J,CAAA;IAC7J,2HAAyG,CAAA;IACzG,6FAA2E,CAAA;IAC3E,2GAAyF,CAAA;IACzF,uGAAqF,CAAA;IACrF,+GAA6F,CAAA;IAC7F,qGAAmF,CAAA;IACnF,+HAA6G,CAAA;IAC7G,yHAAuG,CAAA;IACvG,2GAAyF,CAAA;IACzF,2GAAyF,CAAA;IACzF,qIAAmH,CAAA;IACnH,yHAAuG,CAAA;IACvG,qJAAmI,CAAA;IACnI,uKAAqJ,CAAA;IACrJ,qHAAmG,CAAA;IACnG,iGAA+E,CAAA;IAC/E,6GAA2F,CAAA;IAC3F,2HAAyG,CAAA;IACzG,yGAAuF,CAAA;IACvF,+HAA6G,CAAA;IAE7G,+EAA+E;IAC/E,6FAA2E,CAAA;IAC3E,iHAA+F,CAAA;IAC/F,mFAAiE,CAAA;IACjE,6FAA2E,CAAA;IAC3E,mFAAiE,CAAA;IACjE,uGAAqF,CAAA;IACrF,6FAA2E,CAAA;IAC3E,2EAAyD,CAAA;IACzD,iGAA+E,CAAA;IAC/E,yFAAuE,CAAA;IACvE,mHAAiG,CAAA;IACjG,uFAAqE,CAAA;IACrE,iGAA+E,CAAA;IAC/E,iGAA+E,CAAA;IAC/E,qGAAmF,CAAA;IACnF,6FAA2E,CAAA;IAC3E,6GAA2F,CAAA;IAC3F,qGAAmF,CAAA;IACnF,uGAAqF,CAAA;IACrF,qGAAmF,CAAA;IAEnF,yEAAyE;IACzE,qEAAmD,CAAA;IACnD,qGAAmF,CAAA;IACnF,+FAA6E,CAAA;IAC7E,iGAA+E,CAAA;IAE/E,+EAA+E;IAC/E,2FAAyE,CAAA;IACzE,yFAAuE,CAAA;IACvE,iGAA+E,CAAA;IAE/E,+EAA+E;IAC/E,uFAAqE,CAAA;IACrE,6FAA2E,CAAA;IAC3E,6FAA2E,CAAA;IAE3E,qGAAqG;IACrG,iIAA+G,CAAA;IAC/G,qIAAmH,CAAA;IACnH,+FAA6E,CAAA;IAE7E,qFAAmE,CAAA;IACnE,qFAAmE,CAAA;IACnE,2FAAyE,CAAA;IACzE,iGAA+E,CAAA;IAC/E,qHAAmG,CAAA;IACnG,mHAAiG,CAAA;IAEjG,yFAAuE,CAAA;AACzE,CAAC,EA1GW,cAAc,8BAAd,cAAc,QA0GzB"}

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

@@ -0,0 +1,27 @@
+export declare 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"
+}
+//# sourceMappingURL=guid-brand-type.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"guid-brand-type.d.ts","sourceRoot":"","sources":["../../../../../packages/digitaldefiance-ecies-lib/src/enumerations/guid-brand-type.ts"],"names":[],"mappings":"AAAA,oBAAY,aAAa;IACvB,OAAO,YAAY;IACnB;;;OAGG;IACH,WAAW,gBAAgB;IAC3B;;;OAGG;IACH,YAAY,iBAAiB;IAC7B;;;OAGG;IACH,UAAU,eAAe;IACzB;;OAEG;IACH,UAAU,eAAe;IACzB;;OAEG;IACH,iBAAiB,sBAAsB;CACxC"}

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

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GuidBrandType = void 0;
+var GuidBrandType;
+(function (GuidBrandType) {
+    GuidBrandType["Unknown"] = "Unknown";
+    /**
+     * Full hex guid, 36 characters
+     * 00000000-0000-0000-0000-000000000000
+     */
+    GuidBrandType["FullHexGuid"] = "FullHexGuid";
+    /**
+     * Short hex guid, 32 characters
+     * 0000000000000000000000000000000
+     */
+    GuidBrandType["ShortHexGuid"] = "ShortHexGuid";
+    /**
+     * Base64 guid, 24 characters
+     * AAAA/AAAAAA==
+     */
+    GuidBrandType["Base64Guid"] = "Base64Guid";
+    /**
+     * BigInt, variable width
+     */
+    GuidBrandType["BigIntGuid"] = "BigIntGuid";
+    /**
+     * Raw Guid, in a Uint8Array, 16 bytes
+     */
+    GuidBrandType["RawGuidUint8Array"] = "RawGuidUint8Array";
+})(GuidBrandType || (exports.GuidBrandType = GuidBrandType = {}));
+//# sourceMappingURL=guid-brand-type.js.map

package/src/enumerations/guid-brand-type.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"guid-brand-type.js","sourceRoot":"","sources":["../../../../../packages/digitaldefiance-ecies-lib/src/enumerations/guid-brand-type.ts"],"names":[],"mappings":";;;AAAA,IAAY,aAyBX;AAzBD,WAAY,aAAa;IACvB,oCAAmB,CAAA;IACnB;;;OAGG;IACH,4CAA2B,CAAA;IAC3B;;;OAGG;IACH,8CAA6B,CAAA;IAC7B;;;OAGG;IACH,0CAAyB,CAAA;IACzB;;OAEG;IACH,0CAAyB,CAAA;IACzB;;OAEG;IACH,wDAAuC,CAAA;AACzC,CAAC,EAzBW,aAAa,6BAAb,aAAa,QAyBxB"}

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

@@ -0,0 +1,7 @@
+export declare enum GuidErrorType {
+    Invalid = "Invalid",
+    InvalidWithGuid = "InvalidWithGuid",
+    UnknownBrand = "UnknownBrand",
+    UnknownLength = "UnknownLength"
+}
+//# sourceMappingURL=guid-error-type.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"guid-error-type.d.ts","sourceRoot":"","sources":["../../../../../packages/digitaldefiance-ecies-lib/src/enumerations/guid-error-type.ts"],"names":[],"mappings":"AAAA,oBAAY,aAAa;IACvB,OAAO,YAAY;IACnB,eAAe,oBAAoB;IACnC,YAAY,iBAAiB;IAC7B,aAAa,kBAAkB;CAChC"}

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

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GuidErrorType = void 0;
+var GuidErrorType;
+(function (GuidErrorType) {
+    GuidErrorType["Invalid"] = "Invalid";
+    GuidErrorType["InvalidWithGuid"] = "InvalidWithGuid";
+    GuidErrorType["UnknownBrand"] = "UnknownBrand";
+    GuidErrorType["UnknownLength"] = "UnknownLength";
+})(GuidErrorType || (exports.GuidErrorType = GuidErrorType = {}));
+//# sourceMappingURL=guid-error-type.js.map

package/src/enumerations/guid-error-type.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"guid-error-type.js","sourceRoot":"","sources":["../../../../../packages/digitaldefiance-ecies-lib/src/enumerations/guid-error-type.ts"],"names":[],"mappings":";;;AAAA,IAAY,aAKX;AALD,WAAY,aAAa;IACvB,oCAAmB,CAAA;IACnB,oDAAmC,CAAA;IACnC,8CAA6B,CAAA;IAC7B,gDAA+B,CAAA;AACjC,CAAC,EALW,aAAa,6BAAb,aAAa,QAKxB"}

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

@@ -12,3 +12,4 @@ 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/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../packages/digitaldefiance-ecies-lib/src/enumerations/index.ts"],"names":[],"mappings":"AAAA,cAAc,yBAAyB,CAAC;AACxC,cAAc,oBAAoB,CAAC;AACnC,cAAc,oBAAoB,CAAC;AACnC,cAAc,mBAAmB,CAAC;AAClC,cAAc,mBAAmB,CAAC;AAClC,cAAc,sBAAsB,CAAC;AACrC,cAAc,wBAAwB,CAAC;AACvC,cAAc,qBAAqB,CAAC;AACpC,cAAc,qBAAqB,CAAC;AACpC,cAAc,eAAe,CAAC;AAC9B,cAAc,6BAA6B,CAAC;AAC5C,cAAc,qBAAqB,CAAC;AACpC,cAAc,kBAAkB,CAAC;AACjC,cAAc,6BAA6B,CAAC"}

package/src/enumerations/index.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./ecies-encryption-type"), exports);
+tslib_1.__exportStar(require("./ecies-error-type"), exports);
+tslib_1.__exportStar(require("./ecies-string-key"), exports);
+tslib_1.__exportStar(require("./guid-brand-type"), exports);
+tslib_1.__exportStar(require("./guid-error-type"), exports);
+tslib_1.__exportStar(require("./invalid-email-type"), exports);
+tslib_1.__exportStar(require("./length-encoding-type"), exports);
+tslib_1.__exportStar(require("./length-error-type"), exports);
+tslib_1.__exportStar(require("./member-error-type"), exports);
+tslib_1.__exportStar(require("./member-type"), exports);
+tslib_1.__exportStar(require("./password-login-error-type"), exports);
+tslib_1.__exportStar(require("./pbkdf2-error-type"), exports);
+tslib_1.__exportStar(require("./pbkdf2-profile"), exports);
+tslib_1.__exportStar(require("./secure-storage-error-type"), exports);
+//# sourceMappingURL=index.js.map

package/src/enumerations/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../packages/digitaldefiance-ecies-lib/src/enumerations/index.ts"],"names":[],"mappings":";;;AAAA,kEAAwC;AACxC,6DAAmC;AACnC,6DAAmC;AACnC,4DAAkC;AAClC,4DAAkC;AAClC,+DAAqC;AACrC,iEAAuC;AACvC,8DAAoC;AACpC,8DAAoC;AACpC,wDAA8B;AAC9B,sEAA4C;AAC5C,8DAAoC;AACpC,2DAAiC;AACjC,sEAA4C"}

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

@@ -0,0 +1,6 @@
+export declare enum InvalidEmailErrorType {
+    Invalid = "Invalid",
+    Missing = "Missing",
+    Whitespace = "Whitespace"
+}
+//# sourceMappingURL=invalid-email-type.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"invalid-email-type.d.ts","sourceRoot":"","sources":["../../../../../packages/digitaldefiance-ecies-lib/src/enumerations/invalid-email-type.ts"],"names":[],"mappings":"AAAA,oBAAY,qBAAqB;IAC/B,OAAO,YAAY;IACnB,OAAO,YAAY;IACnB,UAAU,eAAe;CAC1B"}

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

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InvalidEmailErrorType = void 0;
+var InvalidEmailErrorType;
+(function (InvalidEmailErrorType) {
+    InvalidEmailErrorType["Invalid"] = "Invalid";
+    InvalidEmailErrorType["Missing"] = "Missing";
+    InvalidEmailErrorType["Whitespace"] = "Whitespace";
+})(InvalidEmailErrorType || (exports.InvalidEmailErrorType = InvalidEmailErrorType = {}));
+//# sourceMappingURL=invalid-email-type.js.map

package/src/enumerations/invalid-email-type.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"invalid-email-type.js","sourceRoot":"","sources":["../../../../../packages/digitaldefiance-ecies-lib/src/enumerations/invalid-email-type.ts"],"names":[],"mappings":";;;AAAA,IAAY,qBAIX;AAJD,WAAY,qBAAqB;IAC/B,4CAAmB,CAAA;IACnB,4CAAmB,CAAA;IACnB,kDAAyB,CAAA;AAC3B,CAAC,EAJW,qBAAqB,qCAArB,qBAAqB,QAIhC"}

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

@@ -0,0 +1,7 @@
+export declare enum LengthEncodingType {
+    UInt8 = 0,
+    UInt16 = 1,
+    UInt32 = 2,
+    UInt64 = 3
+}
+//# sourceMappingURL=length-encoding-type.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"length-encoding-type.d.ts","sourceRoot":"","sources":["../../../../../packages/digitaldefiance-ecies-lib/src/enumerations/length-encoding-type.ts"],"names":[],"mappings":"AAAA,oBAAY,kBAAkB;IAC5B,KAAK,IAAI;IACT,MAAM,IAAI;IACV,MAAM,IAAI;IACV,MAAM,IAAI;CACX"}

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

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LengthEncodingType = void 0;
+var LengthEncodingType;
+(function (LengthEncodingType) {
+    LengthEncodingType[LengthEncodingType["UInt8"] = 0] = "UInt8";
+    LengthEncodingType[LengthEncodingType["UInt16"] = 1] = "UInt16";
+    LengthEncodingType[LengthEncodingType["UInt32"] = 2] = "UInt32";
+    LengthEncodingType[LengthEncodingType["UInt64"] = 3] = "UInt64";
+})(LengthEncodingType || (exports.LengthEncodingType = LengthEncodingType = {}));
+//# sourceMappingURL=length-encoding-type.js.map

package/src/enumerations/length-encoding-type.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"length-encoding-type.js","sourceRoot":"","sources":["../../../../../packages/digitaldefiance-ecies-lib/src/enumerations/length-encoding-type.ts"],"names":[],"mappings":";;;AAAA,IAAY,kBAKX;AALD,WAAY,kBAAkB;IAC5B,6DAAS,CAAA;IACT,+DAAU,CAAA;IACV,+DAAU,CAAA;IACV,+DAAU,CAAA;AACZ,CAAC,EALW,kBAAkB,kCAAlB,kBAAkB,QAK7B"}

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

@@ -0,0 +1,6 @@
+export declare enum LengthErrorType {
+    LengthIsTooShort = "LengthIsTooShort",
+    LengthIsTooLong = "LengthIsTooLong",
+    LengthIsInvalidType = "LengthIsInvalidType"
+}
+//# sourceMappingURL=length-error-type.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"length-error-type.d.ts","sourceRoot":"","sources":["../../../../../packages/digitaldefiance-ecies-lib/src/enumerations/length-error-type.ts"],"names":[],"mappings":"AAAA,oBAAY,eAAe;IACzB,gBAAgB,qBAAqB;IACrC,eAAe,oBAAoB;IACnC,mBAAmB,wBAAwB;CAC5C"}

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

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LengthErrorType = void 0;
+var LengthErrorType;
+(function (LengthErrorType) {
+    LengthErrorType["LengthIsTooShort"] = "LengthIsTooShort";
+    LengthErrorType["LengthIsTooLong"] = "LengthIsTooLong";
+    LengthErrorType["LengthIsInvalidType"] = "LengthIsInvalidType";
+})(LengthErrorType || (exports.LengthErrorType = LengthErrorType = {}));
+//# sourceMappingURL=length-error-type.js.map

package/src/enumerations/length-error-type.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"length-error-type.js","sourceRoot":"","sources":["../../../../../packages/digitaldefiance-ecies-lib/src/enumerations/length-error-type.ts"],"names":[],"mappings":";;;AAAA,IAAY,eAIX;AAJD,WAAY,eAAe;IACzB,wDAAqC,CAAA;IACrC,sDAAmC,CAAA;IACnC,8DAA2C,CAAA;AAC7C,CAAC,EAJW,eAAe,+BAAf,eAAe,QAI1B"}