@icure/api 4.2.33 → 4.2.36

package/icc-x-api/icc-crypto-x-api.js

@@ -89,7 +89,7 @@ class IccCryptoXApi {
         return this._RSA.loadKeyPairImported(hcp.id).then((keyPair) => this._RSA.exportKey(keyPair.privateKey, 'pkcs8').then((exportedKey) => {
             const privateKey = exportedKey;
             const nLen = notaries.length;
-            const shares = nLen == 1 ? [privateKey] : this._shamir.share(binary_utils_1.ua2hex(privateKey), nLen, threshold || nLen).map((share) => binary_utils_1.hex2ua(share));
+            const shares = nLen == 1 ? [privateKey] : this._shamir.share((0, binary_utils_1.ua2hex)(privateKey), nLen, threshold || nLen).map((share) => (0, binary_utils_1.hex2ua)(share));
             return _.reduce(notaries, (queue, notary, idx) => {
                 return queue.then((hcp) => __awaiter(this, void 0, void 0, function* () {
                     const hcParty = hcp.hcPartyKeys[notary.id] ? hcp : (yield this.generateKeyForDelegate(hcp.id, notary.id));
@@ -97,7 +97,7 @@ class IccCryptoXApi {
                         const importedAESHcPartyKey = yield this.decryptHcPartyKey(hcParty.id, notary.id, hcParty.hcPartyKeys[notary.id][1], false);
                         const encryptedShamirPartition = yield this.AES.encrypt(importedAESHcPartyKey.key, shares[idx]);
                         hcParty.privateKeyShamirPartitions = hcParty.privateKeyShamirPartitions || {};
-                        hcParty.privateKeyShamirPartitions[notary.id] = binary_utils_1.ua2hex(encryptedShamirPartition);
+                        hcParty.privateKeyShamirPartitions[notary.id] = (0, binary_utils_1.ua2hex)(encryptedShamirPartition);
                     }
                     catch (e) {
                         console.log('Error during encryptedShamirRSAKey', notary.id, e);
@@ -121,7 +121,7 @@ class IccCryptoXApi {
                 if (nLen == 1) {
                     const importedAESHcPartyKey = yield this.decryptHcPartyKey(hcp.id, notaries[0].id, hcp.hcPartyKeys[notaries[0].id][1], false);
                     const cryptedPrivatedKey = hcp.privateKeyShamirPartitions[notaries[0].id];
-                    decryptedPrivatedKey = binary_utils_1.ua2hex(yield this.AES.decrypt(importedAESHcPartyKey.key, binary_utils_1.hex2ua(cryptedPrivatedKey)));
+                    decryptedPrivatedKey = (0, binary_utils_1.ua2hex)(yield this.AES.decrypt(importedAESHcPartyKey.key, (0, binary_utils_1.hex2ua)(cryptedPrivatedKey)));
                 }
                 else {
                     const decryptedShares = yield _.reduce(notaries, (queue, notary) => {
@@ -132,7 +132,7 @@ class IccCryptoXApi {
                                 // give hcp the decrypted shares without having to also share their private keys.
                                 const importedAESHcPartyKey = yield this.decryptHcPartyKey(hcp.id, notary.id, hcp.hcPartyKeys[notary.id][1], false);
                                 const encryptedShare = hcp.privateKeyShamirPartitions[notary.id];
-                                const decryptedShamirPartition = binary_utils_1.ua2hex(yield this.AES.decrypt(importedAESHcPartyKey.key, binary_utils_1.hex2ua(encryptedShare)));
+                                const decryptedShamirPartition = (0, binary_utils_1.ua2hex)(yield this.AES.decrypt(importedAESHcPartyKey.key, (0, binary_utils_1.hex2ua)(encryptedShare)));
                                 shares.push(decryptedShamirPartition);
                             }
                             catch (e) {
@@ -143,8 +143,8 @@ class IccCryptoXApi {
                     }, Promise.resolve([]));
                     decryptedPrivatedKey = this._shamir.combine(decryptedShares);
                 }
-                const importedPrivateKey = yield this.RSA.importKey('pkcs8', binary_utils_1.hex2ua(decryptedPrivatedKey), ['decrypt']);
-                const importedPublicKey = yield this.RSA.importKey('spki', binary_utils_1.hex2ua(hcp.publicKey), ['encrypt']);
+                const importedPrivateKey = yield this.RSA.importKey('pkcs8', (0, binary_utils_1.hex2ua)(decryptedPrivatedKey), ['decrypt']);
+                const importedPublicKey = yield this.RSA.importKey('spki', (0, binary_utils_1.hex2ua)(hcp.publicKey), ['encrypt']);
                 const exportedKeyPair = yield this.RSA.exportKeys({ publicKey: importedPublicKey, privateKey: importedPrivateKey }, 'jwk', 'jwk');
                 this.RSA.storeKeyPair(hcp.id, exportedKeyPair);
             }
@@ -178,7 +178,7 @@ class IccCryptoXApi {
             return (keyPair
                 ? Promise.resolve(keyPair)
                 : Promise.resolve(this._RSA.loadKeyPairNotImported(hcPartyKeyOwner)).then((keyPairInJwk) => this.cacheKeyPair(keyPairInJwk, hcPartyKeyOwner)))
-                .then((keyPair) => this._RSA.decrypt(keyPair.privateKey, binary_utils_1.hex2ua(encryptedHcPartyKey)))
+                .then((keyPair) => this._RSA.decrypt(keyPair.privateKey, (0, binary_utils_1.hex2ua)(encryptedHcPartyKey)))
                 .catch((e) => {
                 console.log(`Cannot decrypt RSA encrypted AES HcPartyKey from ${delegatorId} to ${delegateHcPartyId} as ${encryptedForDelegator ? 'delegator' : 'delegate'}`);
                 throw e;
@@ -190,7 +190,7 @@ class IccCryptoXApi {
                 .then(({ decryptedHcPartyKey, decryptedImportedHcPartyKey }) => (this.hcPartyKeysCache[cacheKey] = {
                 delegatorId: delegatorId,
                 key: decryptedImportedHcPartyKey,
-                rawKey: binary_utils_1.ua2hex(new Uint8Array(decryptedHcPartyKey)),
+                rawKey: (0, binary_utils_1.ua2hex)(new Uint8Array(decryptedHcPartyKey)),
             }));
         }
     }
@@ -314,9 +314,9 @@ class IccCryptoXApi {
         })
             .then((encryptedHcPartyKey) => this.decryptHcPartyKey(ownerId, ownerId, encryptedHcPartyKey, true))
             .then((importedAESHcPartyKey) => Promise.all([
-            this._AES.encrypt(importedAESHcPartyKey.key, binary_utils_1.string2ua(createdObject.id + ':' + secretId).buffer, importedAESHcPartyKey.rawKey),
+            this._AES.encrypt(importedAESHcPartyKey.key, (0, binary_utils_1.string2ua)(createdObject.id + ':' + secretId).buffer, importedAESHcPartyKey.rawKey),
             parentObject
-                ? this._AES.encrypt(importedAESHcPartyKey.key, binary_utils_1.string2ua(createdObject.id + ':' + parentObject.id).buffer, importedAESHcPartyKey.rawKey)
+                ? this._AES.encrypt(importedAESHcPartyKey.key, (0, binary_utils_1.string2ua)(createdObject.id + ':' + parentObject.id).buffer, importedAESHcPartyKey.rawKey)
                 : Promise.resolve(null),
         ]))
             .then((encryptedDelegationAndSecretForeignKey) => ({
@@ -327,7 +327,7 @@ class IccCryptoXApi {
                         {
                             owner: ownerId,
                             delegatedTo: ownerId,
-                            key: binary_utils_1.ua2hex(encryptedDelegationAndSecretForeignKey[0]),
+                            key: (0, binary_utils_1.ua2hex)(encryptedDelegationAndSecretForeignKey[0]),
                         },
                     ],
                 ],
@@ -340,7 +340,7 @@ class IccCryptoXApi {
                             {
                                 owner: ownerId,
                                 delegatedTo: ownerId,
-                                key: binary_utils_1.ua2hex(encryptedDelegationAndSecretForeignKey[1]),
+                                key: (0, binary_utils_1.ua2hex)(encryptedDelegationAndSecretForeignKey[1]),
                             },
                         ],
                     ],
@@ -385,21 +385,21 @@ class IccCryptoXApi {
             .then((importedAESHcPartyKey) => Promise.all([
             Promise.all(((modifiedObject.delegations || {})[delegateId] || []).map((d) => (d.key &&
                 d.owner === ownerId &&
-                this._AES.decrypt(importedAESHcPartyKey.key, binary_utils_1.hex2ua(d.key), importedAESHcPartyKey.rawKey).catch(() => {
+                this._AES.decrypt(importedAESHcPartyKey.key, (0, binary_utils_1.hex2ua)(d.key), importedAESHcPartyKey.rawKey).catch(() => {
                     console.log(`Cannot decrypt delegation from ${d.owner} to ${d.delegatedTo} for object with id ${modifiedObject.id}:`, modifiedObject);
                     return null;
                 })) ||
                 Promise.resolve(null))),
             Promise.all(((modifiedObject.cryptedForeignKeys || {})[delegateId] || []).map((d) => (d.key &&
                 d.owner === ownerId &&
-                this._AES.decrypt(importedAESHcPartyKey.key, binary_utils_1.hex2ua(d.key), importedAESHcPartyKey.rawKey).catch(() => {
+                this._AES.decrypt(importedAESHcPartyKey.key, (0, binary_utils_1.hex2ua)(d.key), importedAESHcPartyKey.rawKey).catch(() => {
                     console.log(`Cannot decrypt cryptedForeignKeys from ${d.owner} to ${d.delegatedTo} for object with id ${modifiedObject.id}:`, modifiedObject);
                     return null;
                 })) ||
                 Promise.resolve(null))),
-            this._AES.encrypt(importedAESHcPartyKey.key, binary_utils_1.string2ua(modifiedObject.id + ':' + secretIdOfModifiedObject).buffer, importedAESHcPartyKey.rawKey),
+            this._AES.encrypt(importedAESHcPartyKey.key, (0, binary_utils_1.string2ua)(modifiedObject.id + ':' + secretIdOfModifiedObject).buffer, importedAESHcPartyKey.rawKey),
             parentObject
-                ? this._AES.encrypt(importedAESHcPartyKey.key, binary_utils_1.string2ua(modifiedObject.id + ':' + parentObject.id).buffer, importedAESHcPartyKey.rawKey)
+                ? this._AES.encrypt(importedAESHcPartyKey.key, (0, binary_utils_1.string2ua)(modifiedObject.id + ':' + parentObject.id).buffer, importedAESHcPartyKey.rawKey)
                 : Promise.resolve(null),
         ]))
             .then(([previousDecryptedDelegations, previousDecryptedCryptedForeignKeys, cryptedDelegation, cryptedForeignKey]) => {
@@ -410,7 +410,7 @@ class IccCryptoXApi {
             // We merge them to get one array of objects: { d: {owner,delegatedTo,encrypted(key)}, k: decrypted(key)}
             const delegationCryptedDecrypted = _.merge(((modifiedObject.delegations || {})[delegateId] || []).map((d) => ({
                 d,
-            })), (previousDecryptedDelegations || []).map((dd) => (dd ? binary_utils_1.ua2string(dd) : null)).map((k) => ({ k })))
+            })), (previousDecryptedDelegations || []).map((dd) => (dd ? (0, binary_utils_1.ua2string)(dd) : null)).map((k) => ({ k })))
                 .filter(({ d, k }) => !!k || d.owner !== ownerId) //Only keep the ones created by us that can still be decrypted
                 .map(({ d, k }) => ({ d, k: k || this.randomUuid() })) // Use some unique id that ensures the delegation not created by us are going to be held
                 .concat([
@@ -418,7 +418,7 @@ class IccCryptoXApi {
                     d: {
                         owner: ownerId,
                         delegatedTo: delegateId,
-                        key: binary_utils_1.ua2hex(cryptedDelegation),
+                        key: (0, binary_utils_1.ua2hex)(cryptedDelegation),
                     },
                     k: modifiedObject.id + ':' + secretIdOfModifiedObject,
                 },
@@ -428,7 +428,7 @@ class IccCryptoXApi {
             allDelegations[delegateId] = _.uniqBy(delegationCryptedDecrypted, (x) => x.k).map((x) => x.d);
             const cryptedForeignKeysCryptedDecrypted = _.merge(((modifiedObject.cryptedForeignKeys || {})[delegateId] || []).map((d) => ({
                 d,
-            })), (previousDecryptedCryptedForeignKeys || []).map((dd) => (dd ? binary_utils_1.ua2string(dd) : null)).map((k) => ({ k })))
+            })), (previousDecryptedCryptedForeignKeys || []).map((dd) => (dd ? (0, binary_utils_1.ua2string)(dd) : null)).map((k) => ({ k })))
                 .filter(({ d, k }) => !!k || d.owner !== ownerId) //Only keep the ones created by us that can still be decrypted
                 .map(({ d, k }) => ({ d, k: k || this.randomUuid() })) // Use some unique id that ensures the delegation not created by us are going to be held
                 .concat(cryptedForeignKey
@@ -437,7 +437,7 @@ class IccCryptoXApi {
                         d: {
                             owner: ownerId,
                             delegatedTo: delegateId,
-                            key: binary_utils_1.ua2hex(cryptedForeignKey),
+                            key: (0, binary_utils_1.ua2hex)(cryptedForeignKey),
                         },
                         k: modifiedObject.id + ':' + parentObject.id,
                     },
@@ -472,7 +472,7 @@ class IccCryptoXApi {
         return this.getDataOwner(ownerId)
             .then(({ dataOwner: owner }) => this.getOrCreateHcPartyKey(owner, ownerId))
             .then((encryptedHcPartyKey) => this.decryptHcPartyKey(ownerId, ownerId, encryptedHcPartyKey, true))
-            .then((importedAESHcPartyKey) => this._AES.encrypt(importedAESHcPartyKey.key, binary_utils_1.string2ua(createdObject.id + ':' + secretId)))
+            .then((importedAESHcPartyKey) => this._AES.encrypt(importedAESHcPartyKey.key, (0, binary_utils_1.string2ua)(createdObject.id + ':' + secretId)))
             .then((encryptedEncryptionKeys) => ({
             encryptionKeys: _.fromPairs([
                 [
@@ -481,7 +481,7 @@ class IccCryptoXApi {
                         {
                             owner: ownerId,
                             delegatedTo: ownerId,
-                            key: binary_utils_1.ua2hex(encryptedEncryptionKeys),
+                            key: (0, binary_utils_1.ua2hex)(encryptedEncryptionKeys),
                         },
                     ],
                 ],
@@ -496,8 +496,10 @@ class IccCryptoXApi {
      * @param ownerId : delegator HcP id
      * @param delegateId : delegate HcP id
      * @param secretEncryptionKeyOfObject : secret Id for the EK (Content Encryption Key)
-     * @returns - **encryptionKeys** existing EKs of the `modifiedObject`, appended with a new EK item (owner: `ownerId`, delegatedTo: `delegateId`, encrypted key with secretId: `secretEncryptionKeyOfObject` )
-     * - **secretId** which is the given input parameter `secretEncryptionKeyOfObject`
+     * @returns
+     *   - **encryptionKeys** existing EKs of the `modifiedObject`, appended with a new EK item (owner: `ownerId`, delegatedTo: `delegateId`, encrypted key with secretId:
+     *     `secretEncryptionKeyOfObject` )
+     *   - **secretId** which is the given input parameter `secretEncryptionKeyOfObject`
      */
     appendEncryptionKeys(
     //TODO: suggested name: getExtendedEKwithDelegationFromDelegatorToDelegate
@@ -510,12 +512,12 @@ class IccCryptoXApi {
             .then((importedAESHcPartyKey) => Promise.all([
             Promise.all(((modifiedObject.encryptionKeys || {})[delegateId] || []).map((d) => (d.key &&
                 d.owner === ownerId &&
-                this._AES.decrypt(importedAESHcPartyKey.key, binary_utils_1.hex2ua(d.key), importedAESHcPartyKey.rawKey).catch(() => {
+                this._AES.decrypt(importedAESHcPartyKey.key, (0, binary_utils_1.hex2ua)(d.key), importedAESHcPartyKey.rawKey).catch(() => {
                     console.log(`Cannot decrypt encryption key from ${d.owner} to ${d.delegatedTo} for object with id ${modifiedObject.id}:`, modifiedObject);
                     return null;
                 })) ||
                 Promise.resolve(null))),
-            this._AES.encrypt(importedAESHcPartyKey.key, binary_utils_1.string2ua(modifiedObject.id + ':' + secretEncryptionKeyOfObject)),
+            this._AES.encrypt(importedAESHcPartyKey.key, (0, binary_utils_1.string2ua)(modifiedObject.id + ':' + secretEncryptionKeyOfObject)),
         ]))
             .then(([previousDecryptedEncryptionKeys, encryptedEncryptionKey]) => {
             //try to limit the extent of the modifications to the delegations by preserving the redundant encryption keys already present and removing duplicates
@@ -525,7 +527,7 @@ class IccCryptoXApi {
             // We merge them to get one array of objects: { d: {owner,delegatedTo,encrypted(key)}, k: decrypted(key)}
             const encryptionKeysCryptedDecrypted = _.merge(((modifiedObject.encryptionKeys || {})[delegateId] || []).map((d) => ({
                 d,
-            })), (previousDecryptedEncryptionKeys || []).map((dd) => (dd ? binary_utils_1.ua2string(dd) : null)).map((k) => ({ k })))
+            })), (previousDecryptedEncryptionKeys || []).map((dd) => (dd ? (0, binary_utils_1.ua2string)(dd) : null)).map((k) => ({ k })))
                 .filter(({ d, k }) => !!k || d.owner !== ownerId) //Only keep the ones created by us that can still be decrypted
                 .map(({ d, k }) => ({ d, k: k || this.randomUuid() }))
                 .concat([
@@ -533,7 +535,7 @@ class IccCryptoXApi {
                     d: {
                         owner: ownerId,
                         delegatedTo: delegateId,
-                        key: binary_utils_1.ua2hex(encryptedEncryptionKey),
+                        key: (0, binary_utils_1.ua2hex)(encryptedEncryptionKey),
                     },
                     k: modifiedObject.id + ':' + secretEncryptionKeyOfObject,
                 },
@@ -735,9 +737,9 @@ class IccCryptoXApi {
             const aesKey = aesKeys[genericDelegationItem.owner];
             if (aesKey) {
                 decryptPromises.push(this._AES
-                    .decrypt(aesKey.key, binary_utils_1.hex2ua(genericDelegationItem.key), aesKey.rawKey)
+                    .decrypt(aesKey.key, (0, binary_utils_1.hex2ua)(genericDelegationItem.key), aesKey.rawKey)
                     .then((decryptedGenericDelegationKey) => {
-                    const results = binary_utils_1.ua2string(decryptedGenericDelegationKey).split(':');
+                    const results = (0, binary_utils_1.ua2string)(decryptedGenericDelegationKey).split(':');
                     const objectId = results[0]; //must be the ID of the object, for checksum
                     const genericSecretId = results[1];
                     const details = 'object ID: ' + masterId + '; generic delegation from ' + genericDelegationItem.owner + ' to ' + genericDelegationItem.delegatedTo;
@@ -771,7 +773,7 @@ class IccCryptoXApi {
             if (!publicKey) {
                 throw new Error('No public key has been defined for hcp');
             }
-            return this._RSA.importKeyPair('jwk', this._utils.pkcs8ToJwk(privateKey), 'jwk', this._utils.spkiToJwk(binary_utils_1.hex2ua(publicKey)));
+            return this._RSA.importKeyPair('jwk', this._utils.pkcs8ToJwk(privateKey), 'jwk', this._utils.spkiToJwk((0, binary_utils_1.hex2ua)(publicKey)));
         })
             .then((keyPair) => {
             this._RSA.rsaKeyPairs[healthcarePartyId] = keyPair;
@@ -785,7 +787,7 @@ class IccCryptoXApi {
     loadKeyPairsAsJwkInBrowserLocalStorage(healthcarePartyId, privKey) {
         return this.getDataOwner(healthcarePartyId)
             .then(({ dataOwner }) => {
-            const pubKey = this._utils.spkiToJwk(binary_utils_1.hex2ua(dataOwner.publicKey));
+            const pubKey = this._utils.spkiToJwk((0, binary_utils_1.hex2ua)(dataOwner.publicKey));
             privKey.n = pubKey.n;
             privKey.e = pubKey.e;
             return this._RSA.importKeyPair('jwk', privKey, 'jwk', pubKey);
@@ -807,14 +809,14 @@ class IccCryptoXApi {
             fr.onload = (e) => {
                 //TODO remove any
                 const privateKey = e.target.result;
-                this.loadKeyPairsAsTextInBrowserLocalStorage(healthcarePartyId, binary_utils_1.hex2ua(privateKey)).then(resolve).catch(reject);
+                this.loadKeyPairsAsTextInBrowserLocalStorage(healthcarePartyId, (0, binary_utils_1.hex2ua)(privateKey)).then(resolve).catch(reject);
             };
             fr.readAsText(file);
         });
     }
     // noinspection JSUnusedGlobalSymbols
     saveKeychainInBrowserLocalStorage(id, keychain) {
-        localStorage.setItem(this.keychainLocalStoreIdPrefix + id, binary_utils_1.b2a(new Uint8Array(keychain).reduce((data, byte) => data + String.fromCharCode(byte), '')));
+        localStorage.setItem(this.keychainLocalStoreIdPrefix + id, (0, binary_utils_1.b2a)(new Uint8Array(keychain).reduce((data, byte) => data + String.fromCharCode(byte), '')));
     }
     saveKeychainInBrowserLocalStorageAsBase64(id, keyChainB64) {
         localStorage.setItem(this.keychainLocalStoreIdPrefix + id, keyChainB64);
@@ -854,13 +856,13 @@ class IccCryptoXApi {
                 if (!!aesKey && !!crt) {
                     let crtEncrypted = null;
                     try {
-                        crtEncrypted = yield this.AES.encrypt(aesKey, new Uint8Array(binary_utils_1.string2ua(atob(crt))));
+                        crtEncrypted = yield this.AES.encrypt(aesKey, new Uint8Array((0, binary_utils_1.string2ua)(atob(crt))));
                     }
                     catch (e) {
                         console.error('Error while encrypting the certificate', e);
                     }
                     // add the encrypted certificate to the options
-                    _.set(opts, this.hcpPreferenceKeyEhealthCert, binary_utils_1.ua2string(new Uint8Array(crtEncrypted)));
+                    _.set(opts, this.hcpPreferenceKeyEhealthCert, (0, binary_utils_1.ua2string)(new Uint8Array(crtEncrypted)));
                 }
                 const crtValidityDate = this.getKeychainValidityDateInBrowserLocalStorage(hcp.id);
                 if (!!crtValidityDate) {
@@ -875,7 +877,7 @@ class IccCryptoXApi {
         return this.hcpartyBaseApi.getHealthcareParty(hcpId).then((hcp) => __awaiter(this, void 0, void 0, function* () {
             let crtCryp = null;
             if (!!hcp.options && !!hcp.options[this.hcpPreferenceKeyEhealthCert]) {
-                crtCryp = binary_utils_1.string2ua(hcp.options[this.hcpPreferenceKeyEhealthCert]);
+                crtCryp = (0, binary_utils_1.string2ua)(hcp.options[this.hcpPreferenceKeyEhealthCert]);
             }
             const crtValidityDate = _.get(hcp.options, this.hcpPreferenceKeyEhealthCertDate);
             // store the validity date
@@ -941,7 +943,7 @@ class IccCryptoXApi {
     // noinspection JSUnusedGlobalSymbols
     loadKeychainFromBrowserLocalStorage(id) {
         const lsItem = localStorage.getItem('org.taktik.icure.ehealth.keychain.' + id);
-        return lsItem !== null ? binary_utils_1.b64_2uas(lsItem) : null;
+        return lsItem !== null ? (0, binary_utils_1.b64_2uas)(lsItem) : null;
     }
     generateKeyForDelegate(ownerId, delegateId) {
         //Preload hcp and patient because we need them and they are going to be invalidated from the caches
@@ -954,17 +956,17 @@ class IccCryptoXApi {
                     ? this._AES
                         .generateCryptoKey(true)
                         .then((AESKey) => {
-                        const ownerPubKey = this._utils.spkiToJwk(binary_utils_1.hex2ua(owner.publicKey));
-                        const delegatePubKey = this._utils.spkiToJwk(binary_utils_1.hex2ua(delegate.publicKey));
+                        const ownerPubKey = this._utils.spkiToJwk((0, binary_utils_1.hex2ua)(owner.publicKey));
+                        const delegatePubKey = this._utils.spkiToJwk((0, binary_utils_1.hex2ua)(delegate.publicKey));
                         return Promise.all([
                             this._RSA.importKey('jwk', ownerPubKey, ['encrypt']),
                             this._RSA.importKey('jwk', delegatePubKey, ['encrypt']),
                         ]).then(([ownerImportedKey, delegateImportedKey]) => Promise.all([
-                            this._RSA.encrypt(ownerImportedKey, binary_utils_1.hex2ua(AESKey)),
-                            this._RSA.encrypt(delegateImportedKey, binary_utils_1.hex2ua(AESKey)),
+                            this._RSA.encrypt(ownerImportedKey, (0, binary_utils_1.hex2ua)(AESKey)),
+                            this._RSA.encrypt(delegateImportedKey, (0, binary_utils_1.hex2ua)(AESKey)),
                         ]));
                     })
-                        .then(([ownerKey, delegateKey]) => (owner.hcPartyKeys[delegateId] = [binary_utils_1.ua2hex(ownerKey), binary_utils_1.ua2hex(delegateKey)]))
+                        .then(([ownerKey, delegateKey]) => (owner.hcPartyKeys[delegateId] = [(0, binary_utils_1.ua2hex)(ownerKey), (0, binary_utils_1.ua2hex)(delegateKey)]))
                         .then(() => {
                         return ownerType === 'hcp'
                             ? (this.dataOwnerCache[owner.id] = this.hcpartyBaseApi
@@ -1007,8 +1009,8 @@ class IccCryptoXApi {
     checkPrivateKeyValidity(dataOwner) {
         return new Promise((resolve) => {
             this._RSA
-                .importKey('jwk', this._utils.spkiToJwk(binary_utils_1.hex2ua(dataOwner.publicKey)), ['encrypt'])
-                .then((k) => this._RSA.encrypt(k, binary_utils_1.utf8_2ua('shibboleth')))
+                .importKey('jwk', this._utils.spkiToJwk((0, binary_utils_1.hex2ua)(dataOwner.publicKey)), ['encrypt'])
+                .then((k) => this._RSA.encrypt(k, (0, binary_utils_1.utf8_2ua)('shibboleth')))
                 .then((cipher) => {
                 const kp = this._RSA.loadKeyPairNotImported(dataOwner.id);
                 return this._RSA
@@ -1016,7 +1018,7 @@ class IccCryptoXApi {
                     .then((ikp) => this._RSA.decrypt(ikp.privateKey, new Uint8Array(cipher)));
             })
                 .then((plainText) => {
-                const pt = binary_utils_1.ua2utf8(plainText);
+                const pt = (0, binary_utils_1.ua2utf8)(plainText);
                 console.log(pt);
                 resolve(pt === 'shibboleth');
             })
@@ -1050,7 +1052,7 @@ class IccCryptoXApi {
             if (!content || !(edKey || ((user === null || user === void 0 ? void 0 : user.healthcarePartyId) && documentObject)))
                 return content;
             if (edKey) {
-                const importedEdKey = yield this._AES.importKey('raw', binary_utils_1.hex2ua(edKey.replace(/-/g, '')));
+                const importedEdKey = yield this._AES.importKey('raw', (0, binary_utils_1.hex2ua)(edKey.replace(/-/g, '')));
                 try {
                     return yield this._AES[method](importedEdKey, content);
                 }
@@ -1059,7 +1061,7 @@ class IccCryptoXApi {
                 }
             }
             const sfks = yield this.extractKeysFromDelegationsForHcpHierarchy(user === null || user === void 0 ? void 0 : user.healthcarePartyId, documentObject === null || documentObject === void 0 ? void 0 : documentObject.id, documentObject === null || documentObject === void 0 ? void 0 : documentObject.encryptionKeys);
-            const importedEdKey = yield this._AES.importKey('raw', binary_utils_1.hex2ua(sfks.extractedKeys[0].replace(/-/g, '')));
+            const importedEdKey = yield this._AES.importKey('raw', (0, binary_utils_1.hex2ua)(sfks.extractedKeys[0].replace(/-/g, '')));
             try {
                 return yield this._AES[method](importedEdKey, content);
             }