@icure/api 4.0.72 → 4.0.76

package/icc-x-api/icc-crypto-x-api.d.ts

@@ -0,0 +1,313 @@
+import { IccHcpartyApi, IccPatientApi } from '../icc-api';
+import { AESUtils } from './crypto/AES';
+import { RSAUtils } from './crypto/RSA';
+import { UtilsClass } from './crypto/utils';
+import { ShamirClass } from './crypto/shamir';
+import * as models from '../icc-api/model/models';
+import { HealthcareParty } from '../icc-api/model/models';
+export declare class IccCryptoXApi {
+    get shamir(): ShamirClass;
+    get utils(): UtilsClass;
+    get RSA(): RSAUtils;
+    get AES(): AESUtils;
+    hcPartyKeysCache: {
+        [key: string]: {
+            delegatorId: string;
+            key: CryptoKey;
+            rawKey: string;
+        };
+    };
+    hcPartyKeysRequestsCache: {
+        [delegateId: string]: Promise<{
+            [delegatorId: string]: string;
+        }>;
+    };
+    emptyHcpCache(hcpartyId: string): void;
+    private getHcpOrPatient;
+    /**
+     * Gets all delegate encrypted HcParty keys of the delegate with the given `delegateHcPartyId`, and for each key the delegator id
+     * If the keys are not cached, they are retrieved from the backend.
+     *
+     * @param delegateHcPartyId The Health Care Party id
+     * @returns  \{delegatorId: delegateEncryptedHcPartyKey\}
+     */
+    private getHcPartyKeysForDelegate;
+    private forceGetHcPartyKeysForDelegate;
+    keychainLocalStoreIdPrefix: string;
+    hcpPreferenceKeyEhealthCert: string;
+    private hcpartyBaseApi;
+    private patientBaseApi;
+    private crypto;
+    private generateKeyConcurrencyMap;
+    private _AES;
+    private _RSA;
+    private _utils;
+    private _shamir;
+    constructor(host: string, headers: {
+        [key: string]: string;
+    }, hcpartyBaseApi: IccHcpartyApi, //Init with a hcparty x api for better performances
+    patientBaseApi: IccPatientApi, crypto?: Crypto);
+    randomUuid(): string;
+    encryptedShamirRSAKey(hcp: HealthcareParty, notaries: Array<HealthcareParty>, threshold?: number): Promise<HealthcareParty>;
+    decryptedShamirRSAKey(hcp: HealthcareParty, notaries: Array<HealthcareParty>): Promise<void>;
+    /**
+     * Gets the decryptedHcPartyKey for the given `encryptedHcPartyKey`
+     *
+     * If the decrypted key exists in the cache, retrieves it from there.
+     * Otherwise, decrypts it using the RSA key of the delegator or delegate (depending on the value of `encryptedForDelegator`)
+     * @param delegatorId : the id of the delegator HcP
+     * @param delegateHcPartyId : the id of the delegate HcP
+     * @param encryptedHcPartyKey : can be delegatorEncryptedHcPartyKey or delegateEncryptedHcPartyKey (depending on the value of `encryptedForDelegator`)
+     * @param encryptedForDelegator : default false - for the `encryptedHcPartyKey` RSA encrypted for delegate; true for the `encryptedHcPartyKey` RSA encrypted for delegator;
+     * @returns - **delegatorId** the input param  `delegatorId`
+     * - **key** the decrypted `encryptedHcPartyKey`
+     */
+    decryptHcPartyKey(delegatorId: string, delegateHcPartyId: string, encryptedHcPartyKey: string, encryptedForDelegator?: boolean): Promise<{
+        delegatorId: string;
+        key: CryptoKey;
+        rawKey: string;
+    }>;
+    /**
+     * Cache the RSA private/public key pair for the HcP with the given id `hcPartyKeyOwner`
+     */
+    cacheKeyPair(keyPairInJwk: {
+        publicKey: JsonWebKey | ArrayBuffer;
+        privateKey: JsonWebKey | ArrayBuffer;
+    }, hcPartyKeyOwner: string): Promise<{
+        publicKey: CryptoKey;
+        privateKey: CryptoKey;
+    }>;
+    /**
+     * Gets the secret ID (SFKs) that should be used in the prescribed context (condfidential or not) from decrypted SPKs of the given `parent`, decrypted by the HcP with the given `hcpartyId` AND by its HcP parents
+     * @param parent : the object of which delegations (SPKs) to decrypt
+     * @param hcpartyId : the id of the delegate HcP
+     * @param confidential : wether the key is going to be used for a confidential piece or data or not
+     * @returns - **extractedKeys** array containing secret IDs (SFKs) from decrypted SPKs, from both given HcP and its parents ; can contain duplicates
+     * - **hcpartyId** the given `hcpartyId` OR, if a parent exist, the HcP id of the top parent in the hierarchy  (even if that parent has no delegations)
+     */
+    extractPreferredSfk(parent: models.Patient | models.Message, hcpartyId: string, confidential: boolean): Promise<string | null>;
+    /**
+     * Gets an array of decrypted HcPartyKeys, shared between the delegate with ID `delegateHcPartyId` and the delegators in `delegatorsHcPartyIdsSet`
+     *
+     * 1. Get the keys for the delegateHealthCareParty (cache/backend).
+     * 2. For each key in the delegators, decrypt it with the delegate's private key
+     * 3. Filter out undefined keys and return them
+     *
+     * @param delegatorsHcPartyIdsSet array of delegator HcP IDs that could have delegated something to the HcP with ID `delegateHcPartyId`
+     * @param delegateHcPartyId the HcP for which the HcPs with IDs in `delegatorsHcPartyIdsSet` could have delegated something
+     * @returns - **delegatorId** : the id of the delegator HcP that shares the **key** with the `delegateHcPartyId`
+     *  - **key** the decrypted HcPartyKey, shared between **delegatorId** and `delegateHcPartyId`
+     */
+    decryptAndImportAesHcPartyKeysForDelegators(delegatorsHcPartyIdsSet: Array<string>, delegateHcPartyId: string): Promise<Array<{
+        delegatorId: string;
+        key: CryptoKey;
+        rawKey: string;
+    }>>;
+    /**
+     * Gets an array of decrypted HcPartyKeys from the given `delegations`, that are shared with / can be decrypted by the HcP with the given `healthcarePartyId` (or by its parents when `fallbackOnParent` is true)
+     *
+     * 1. Checks whether the delegations' object has a delegation for the
+     * given healthCarePartyId.
+     * 2. Enumerates all the delegators (delegation.owner) present in
+     * the delegations.
+     * 3. Decrypt's delegators' keys and returns them.
+     *
+     * @param healthcarePartyId : the id of the delegate HCP
+     * @param delegations : generic delegations (can be SPKs, CFKs, EKs) for all delegates
+     * @param fallbackOnParent  default true; use parent's healthCarePartyId in case there's no delegation for the `healthcarePartyId`
+     * @returns  - **delegatorId** : the id of the delegator HcP that shares the **key** with the `healthcarePartyId`
+     *  - **key** the decrypted HcPartyKey, shared between **delegatorId** and `healthcarePartyId`
+     */
+    decryptAndImportAesHcPartyKeysInDelegations(healthcarePartyId: string, delegations: {
+        [key: string]: Array<models.Delegation>;
+    }, fallbackOnParent?: boolean): Promise<Array<{
+        delegatorId: string;
+        key: CryptoKey;
+        rawKey: string;
+    }>>;
+    /**
+     * Retreive the owner HealthCareParty key and use it to encrypt
+     * both the delegations (createdObject.id) and the cryptedForeignKeys
+     * (parentObject.id), and returns them in an object.
+     */
+    initObjectDelegations(createdObject: any, parentObject: any, ownerId: string, secretForeignKeyOfParent: string | null): Promise<{
+        delegations: any;
+        cryptedForeignKeys: any;
+        secretForeignKeys: any[];
+        secretId: string;
+    }>;
+    /**
+     * Gets updated instances of SPKs and CKFs for the child object `modifiedObject`.
+     * These updated SPKs and CKFs contain new SPKs/CFKs to provide delegation from delegator HcP with id `ownerId` to delegate HcP with id `delegateId`
+     *
+     * 1. if `secretIdOfModifiedObject` is not provided, the method will throw an exception; this `secretIdOfModifiedObject` is used to generate a new delegation (SPK) in step 3;
+     *  the `secretIdOfModifiedObject` is returned, unmodified, as `secretId`
+     * 2. if the owner (delegator) did not perform a delegation to the delegate, then this HcP delegation (creation of a new HcPKey) is performed now
+     * 3. creates a new delegation (Secret Primary Keys) on the `modifiedObject` encrypted with the HcPKey from owner to the delegate;
+     * 4. if `parentObject` != null, creates a new CFK on the `modifiedObject` encrypted with the HcPKey from owner to the delegate;
+     * 5. this new delegation (from step 3) is added to the list of existing delegations (Secret Primary Keys) on the `modifiedObject` for the delegate given by `delegateId`
+     * 6. if the CFK (from step 4) can be created, this new CFK is added to the list of existing CFKs on the `modifiedObject` for the delegate given by `delegateId`
+     * 7. then some duplicates delegations (SPKs) and CKFs are removed
+     *
+     * @param modifiedObject : the object of which SPKs and CFKs will be cloned, the clones will be modified and then used as returned values ; it's a 'child' of `parentObject`; will NOT be mutated
+     * @param parentObject : will NOT be mutated
+     * @param ownerId : the HcP id of the delegator
+     * @param delegateId : the HcP id of the delegate
+     * @param secretIdOfModifiedObject : the secret id used in the child object to generate its SPK
+     * @returns - **delegations**  existing delegations (SPKs) of the `modifiedObject`, appended with results from step 5
+     * - **cryptedForeignKeys** existing CFKs of the `modifiedObject`, appended with results from steps 6
+     * - **secretId** which is the given input parameter `secretIdOfModifiedObject`
+     */
+    extendedDelegationsAndCryptedForeignKeys(modifiedObject: any | null, parentObject: any | null, ownerId: string, delegateId: string, secretIdOfModifiedObject: string | null): Promise<{
+        delegations: {
+            [key: string]: Array<models.Delegation>;
+        };
+        cryptedForeignKeys: {
+            [key: string]: Array<models.Delegation>;
+        };
+        secretId: string | null;
+    }>;
+    private getOrCreateHcPartyKey;
+    /**
+     * Retrieve the owners HealthCareParty key, decrypt it, and
+     * use it to encrypt & initialize the "encryptionKeys" object
+     * and return it.
+     * @param createdObject
+     * @param ownerId
+     */
+    initEncryptionKeys(createdObject: any, ownerId: string): Promise<{
+        encryptionKeys: any;
+        secretId: string;
+    }>;
+    /**
+     * Gets an updated instance of the EKs of `modifiedObject`.
+     * The updated EKs contain a new EK to provide delegation from delegator HcP with id `ownerId` to delegate HcP with id `delegateId`.
+     * @param modifiedObject : the object of which EKs will be cloned, the clone will be used to append the new EK, and then used as return value; will NOT be mutated
+     * @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`
+     */
+    appendEncryptionKeys(modifiedObject: any, ownerId: string, delegateId: string, secretEncryptionKeyOfObject: string): Promise<{
+        encryptionKeys: {
+            [key: string]: Array<models.Delegation>;
+        };
+        secretId: string | null;
+    }>;
+    /**
+     * Gets an updated `child` object that will have its SPKs, CFKs, KSs updated to include delegations from delegator HcP with id `ownerId` to delegate HcP with id `delegateId`
+     * The SFKs of `child` are not updated, so this method assumes this is not the initial delegation on the `child` object
+     * The method also performs some deduplication of all types of delegations.
+     * @param parent : the parent object of `child`; will NOT be mutated
+     * @param child : the object that will be mutated and returned
+     * @param ownerId delegator HcP id
+     * @param delegateId delegate HcP id
+     * @param secretDelegationKey  the secret Id used in the child object to generate the SPK
+     * @param secretEncryptionKey  the secret Id used in the child object to generate the EK (Content Encryption Key)
+     * @returns - an updated `child` object that will contain updated SPKs, CFKs, EKs
+     *  */
+    addDelegationsAndEncryptionKeys<T extends models.AccessLog | models.Patient | models.Form | models.Contact | models.Invoice | models.Document | models.HealthElement | models.CalendarItem | models.Classification | models.Receipt>(parent: models.Patient | models.Message | null, child: T, ownerId: string, delegateId: string, secretDelegationKey: string | null, secretEncryptionKey: string | null): Promise<T>;
+    /**
+     * Gets the secret IDs (SFKs) inside decrypted SPKs of the given `document`, decrypted by the HcP with the given `hcpartyId` AND by its HcP parents
+     * @param document : the object of which delegations (SPKs) to decrypt
+     * @param hcpartyId : the id of the delegate HcP
+     * @returns - **extractedKeys** array containing secret IDs (SFKs) from decrypted SPKs, from both given HcP and its parents ; can contain duplicates
+     * - **hcpartyId** the given `hcpartyId` OR, if a parent exist, the HcP id of the top parent in the hierarchy  (even if that parent has no delegations)
+     */
+    extractDelegationsSFKs(document: models.Patient | models.Message | models.Contact | models.Document | models.Invoice | models.HealthElement | models.Receipt | models.Classification | models.CalendarItem | null, hcpartyId?: string): Promise<{
+        extractedKeys: Array<string>;
+        hcpartyId?: string;
+    }>;
+    /**
+     * Gets the secret IDs (SFKs) inside decrypted SPKs of the given `document`, decrypted by the HcP with the given `hcpartyId` AND by its HcP parents
+     * @param document : the object of which delegations (SPKs) to decrypt
+     * @param hcpartyId : the id of the delegate HcP
+     * @returns - **extractedKeys** array containing secret IDs (SFKs) from decrypted SPKs, from both given HcP and its parents ; can contain duplicates
+     * - **hcpartyId** the given `hcpartyId` OR, if a parent exist, the HcP id of the top parent in the hierarchy  (even if that parent has no delegations)
+     */
+    extractSFKsHierarchyFromDelegations(document: models.Patient | models.Message | models.Contact | models.Document | models.Invoice | models.HealthElement | models.Receipt | models.Classification | models.CalendarItem | null, hcpartyId?: string): Promise<Array<{
+        hcpartyId: string;
+        extractedKeys: Array<string>;
+    }>>;
+    extractCryptedFKs(document: models.Patient | models.Message | models.Contact | models.Document | models.Invoice | models.HealthElement | models.Receipt | models.CalendarItem | models.Classification | null, hcpartyId: string): Promise<{
+        extractedKeys: Array<string>;
+        hcpartyId: string;
+    }>;
+    extractEncryptionsSKs(document: models.Patient | models.Message | models.Contact | models.Document | models.Invoice | models.Receipt | models.HealthElement | models.Classification, hcpartyId: string): Promise<{
+        extractedKeys: Array<string>;
+        hcpartyId: string;
+    }>;
+    extractDelegationsSFKsAndEncryptionSKs(ety: models.Patient | models.Contact | models.Invoice | models.Document | models.HealthElement, ownerId: string): Promise<[string[], string[]]>;
+    /**
+     * Get decrypted generic secret IDs (secretIdSPKs, parentIds, secretIdEKs) from generic delegations (SPKs, CFKs, EKs)
+     * 1. Get HealthCareParty from it's Id.
+     * 2. Decrypt the keys of the given HCP.
+     * 3. Decrypt the parent's key if it has parent.
+     * 4. Return the decrypted key corresponding to the Health Care Party.
+     * @param hcpartyId : the id of the delegate HcP (including its parents) for which to decrypt `extractedKeys`
+     * @param objectId : the id of the object/document of which delegations to decrypt ; used just to log to console a message (Cryptographic mistake) in case the object id inside SPK, CFK, EK is different from this one
+     * @param delegations : generic delegations (can be SPKs, CFKs, EKs) for all delegates from where to extract `extractedKeys`
+     * @returns - **extractedKeys** array containing secret IDs from decrypted generic delegations, from both HCP with given `hcpartyId` and its parents; can contain duplicates
+     * - **hcpartyId** the given `hcpartyId` OR, if a parent exist, the HCP id of the top parent in the hierarchy  (even if that parent has no delegations)
+     */
+    extractKeysHierarchyFromDelegationLikes(hcpartyId: string, objectId: string, delegations: {
+        [key: string]: Array<models.Delegation>;
+    }): Promise<Array<{
+        hcpartyId: string;
+        extractedKeys: Array<string>;
+    }>>;
+    /**
+     * Get decrypted generic secret IDs (secretIdSPKs, parentIds, secretIdEKs) from generic delegations (SPKs, CFKs, EKs)
+     * 1. Get HealthCareParty from it's Id.
+     * 2. Decrypt the keys of the given HCP.
+     * 3. Decrypt the parent's key if it has parent.
+     * 4. Return the decrypted key corresponding to the Health Care Party.
+     * @param hcpartyId : the id of the delegate HcP (including its parents) for which to decrypt `extractedKeys`
+     * @param objectId : the id of the object/document of which delegations to decrypt ; used just to log to console a message (Cryptographic mistake) in case the object id inside SPK, CFK, EK is different from this one
+     * @param delegations : generic delegations (can be SPKs, CFKs, EKs) for all delegates from where to extract `extractedKeys`
+     * @returns - **extractedKeys** array containing secret IDs from decrypted generic delegations, from both HCP with given `hcpartyId` and its parents; can contain duplicates
+     * - **hcpartyId** the given `hcpartyId` OR, if a parent exist, the HCP id of the top parent in the hierarchy  (even if that parent has no delegations)
+     */
+    extractKeysFromDelegationsForHcpHierarchy(hcpartyId: string, objectId: string, delegations: {
+        [key: string]: Array<models.Delegation>;
+    }): Promise<{
+        extractedKeys: Array<string>;
+        hcpartyId: string;
+    }>;
+    /**
+     * Gets an array of generic secret IDs decrypted from a list of generic delegations (SPKs, CFKs, EKs) `delegationsArray`
+     * If a particular generic delegation thows an exception when decrypted, the return value for it's secret ID will be 'false' and a message is logged to console
+     * For each one of the delegations in the `delegationsArray`, it tries to decrypt with the decryptedHcPartyKey of the owner of that delegation;
+     *
+     * @param delegationsArray : generic delegations array
+     * @param aesKeys : **key** HcP ids of delegators/owners in the `delegationsArray`, each with its own decryptedHcPartyKey
+     * @param masterId : is the object id to which the generic delegation belongs to
+     * - used only to check whether the object.id matches the one stored in the decrypted generic delegation item
+     * - even if there's no match, the secret ID is kept as a valid result (and a message logged to console)
+     * @returns array of generic secret IDs (secretIdSPK, parentId, secretIdEK)
+     */
+    decryptKeyInDelegationLikes(delegationsArray: Array<models.Delegation>, aesKeys: {
+        [key: string]: {
+            key: CryptoKey;
+            rawKey: string;
+        };
+    }, masterId: string): Promise<Array<string>>;
+    loadKeyPairsAsTextInBrowserLocalStorage(healthcarePartyId: string, privateKey: Uint8Array): Promise<void>;
+    loadKeyPairsAsJwkInBrowserLocalStorage(healthcarePartyId: string, privKey: JsonWebKey): Promise<void>;
+    loadKeyPairsInBrowserLocalStorage(healthcarePartyId: string, file: Blob): Promise<void>;
+    saveKeychainInBrowserLocalStorage(id: string, keychain: number): void;
+    saveKeychainInBrowserLocalStorageAsBase64(id: string, keyChainB64: string): void;
+    saveKeyChainInHCPFromLocalStorage(hcpId: string): Promise<HealthcareParty>;
+    importKeychainInBrowserFromHCP(hcpId: string): Promise<void>;
+    /**
+     * Returns true if a key has been set in the localstorage
+     * @param hcpId The healthcare party id
+     */
+    syncEhealthCertificate(hcpId: string): Promise<boolean>;
+    getKeychainInBrowserLocalStorageAsBase64(id: string): string | null;
+    loadKeychainFromBrowserLocalStorage(id: string): Uint8Array[] | null;
+    generateKeyForDelegate(ownerId: string, delegateId: string): PromiseLike<models.HealthcareParty | models.Patient>;
+    checkPrivateKeyValidity(hcp: models.HealthcareParty | models.Patient): Promise<boolean>;
+    private throwDetailedExceptionForInvalidParameter;
+}

package/icc-x-api/icc-doctemplate-x-api.d.ts

@@ -0,0 +1,15 @@
+import { IccDoctemplateApi } from '../icc-api';
+import { IccCryptoXApi } from './icc-crypto-x-api';
+import * as models from '../icc-api/model/models';
+import { DocumentTemplate } from '../icc-api/model/models';
+export declare class IccDoctemplateXApi extends IccDoctemplateApi {
+    crypto: IccCryptoXApi;
+    fetchImpl: (input: RequestInfo, init?: RequestInit) => Promise<Response>;
+    constructor(host: string, headers: {
+        [key: string]: string;
+    }, crypto: IccCryptoXApi, fetchImpl?: (input: RequestInfo, init?: RequestInit) => Promise<Response>);
+    newInstance(user: models.User, template: string, c: any): Promise<DocumentTemplate>;
+    findAllByOwnerId(ownerId: string): Promise<Array<models.DocumentTemplate>>;
+    getAttachmentUrl(documentId: string, attachmentId: string): string;
+    getAttachmentText(documentTemplateId: string, attachmentId: string): Promise<any | boolean>;
+}

package/icc-x-api/icc-document-x-api.d.ts

@@ -0,0 +1,40 @@
+import { IccAuthApi, IccDocumentApi } from '../icc-api';
+import { IccCryptoXApi } from './icc-crypto-x-api';
+import * as models from '../icc-api/model/models';
+export declare class IccDocumentXApi extends IccDocumentApi {
+    crypto: IccCryptoXApi;
+    fetchImpl: (input: RequestInfo, init?: RequestInit) => Promise<Response>;
+    authApi: IccAuthApi;
+    /** maps invalid UTI values to corresponding MIME type for backward-compatibility (pre-v1.0.117) */
+    compatUtiRevDefs: {
+        [key: string]: string;
+    };
+    utiRevDefs: {
+        [key: string]: string;
+    };
+    utiExts: {
+        [key: string]: string;
+    };
+    utiDefs: {
+        [key: string]: string;
+    };
+    constructor(host: string, headers: {
+        [key: string]: string;
+    }, crypto: IccCryptoXApi, authApi: IccAuthApi, fetchImpl?: (input: RequestInfo, init?: RequestInit) => Promise<Response>);
+    newInstance(user: models.User, message?: models.Message, c?: any): Promise<models.Document>;
+    private initDelegationsAndEncryptionKeys;
+    initEncryptionKeys(user: models.User, document: models.Document): Promise<models.Document & {
+        encryptionKeys: any;
+    }>;
+    findByMessage(hcpartyId: string, message: models.Message): Promise<models.Document[]>;
+    decrypt(hcpartyId: string, documents: Array<models.Document>): Promise<Array<models.Document>>;
+    getAttachmentAs(documentId: string, attachmentId: string, returnType: "application/octet-stream", enckeys?: string, fileName?: string): Promise<ArrayBuffer>;
+    getAttachmentAs(documentId: string, attachmentId: string, returnType: "text/plain", enckeys?: string, fileName?: string): Promise<string>;
+    getAttachmentAs(documentId: string, attachmentId: string, returnType: "application/json", enckeys?: string, fileName?: string): Promise<any>;
+    getAttachmentUrl(documentId: string, attachmentId: string, sfks: Array<{
+        delegatorId: string;
+        key: CryptoKey;
+    }>, fileName?: string): Promise<string>;
+    uti(mimeType: string, extension: string): string;
+    mimeType(uti: string): string;
+}

package/icc-x-api/icc-form-x-api.d.ts

@@ -0,0 +1,31 @@
+import { IccFormApi } from '../icc-api';
+import { IccCryptoXApi } from './icc-crypto-x-api';
+import * as models from '../icc-api/model/models';
+export declare class IccFormXApi extends IccFormApi {
+    crypto: IccCryptoXApi;
+    constructor(host: string, headers: {
+        [key: string]: string;
+    }, crypto: IccCryptoXApi, fetchImpl?: (input: RequestInfo, init?: RequestInit) => Promise<Response>);
+    newInstance(user: models.User, patient: models.Patient, c: any): Promise<models.Form>;
+    private initDelegationsAndEncryptionKeys;
+    initEncryptionKeys(user: models.User, form: models.Form): Promise<models.Form & {
+        encryptionKeys: any;
+    }>;
+    /**
+     * 1. Check whether there is a delegation with 'hcpartyId' or not.
+     * 2. 'fetchHcParty[hcpartyId][1]': is encrypted AES exchange key by RSA public key of him.
+     * 3. Obtain the AES exchange key, by decrypting the previous step value with hcparty private key
+     *      3.1.  KeyPair should be fetch from cache (in jwk)
+     *      3.2.  if it doesn't exist in the cache, it has to be loaded from Browser Local store, and then import it to WebCrypto
+     * 4. Obtain the array of delegations which are delegated to his ID (hcpartyId) in this patient
+     * 5. Decrypt and collect all keys (secretForeignKeys) within delegations of previous step (with obtained AES key of step 4)
+     * 6. Do the REST call to get all contacts with (allSecretForeignKeysDelimitedByComa, hcpartyId)
+     *
+     * After these painful steps, you have the contacts of the patient.
+     *
+     * @param hcpartyId
+     * @param patient (Promise)
+     */
+    findBy(hcpartyId: string, patient: models.Patient): Promise<void | (void | models.Form)[]>;
+    decrypt(hcpartyId: string, forms: Array<models.Form>): Promise<void | (void | models.Form)[]>;
+}

package/icc-x-api/icc-hcparty-x-api.d.ts

@@ -0,0 +1,26 @@
+import { IccHcpartyApi } from '../icc-api';
+import { HealthcareParty } from '../icc-api/model/HealthcareParty';
+export declare class IccHcpartyXApi extends IccHcpartyApi {
+    hcPartyKeysCache: {
+        [key: string]: {
+            [key: string]: string;
+        };
+    };
+    hcPartyCache: {
+        [key: string]: [number, Promise<HealthcareParty>];
+    };
+    private CACHE_RETENTION_IN_MS;
+    constructor(host: string, headers: {
+        [key: string]: string;
+    }, fetchImpl?: (input: RequestInfo, init?: RequestInit) => Promise<Response>);
+    private getHcPartyFromCache;
+    putHcPartyInCache(key: string, value?: Promise<HealthcareParty> | null): Promise<HealthcareParty>;
+    modifyHealthcareParty(body?: HealthcareParty): Promise<HealthcareParty | any>;
+    getHealthcareParty(healthcarePartyId: string, bypassCache?: boolean): Promise<HealthcareParty | any>;
+    getHealthcareParties(healthcarePartyIds: string): Promise<Array<HealthcareParty> | any>;
+    getCurrentHealthcareParty(): Promise<HealthcareParty | any>;
+    getHcPartyKeysForDelegate(healthcarePartyId: string, bypassCache?: boolean): Promise<{
+        [key: string]: string;
+    }>;
+    isValidCbe(cbe: string): boolean;
+}

package/icc-x-api/icc-helement-x-api.d.ts

@@ -0,0 +1,31 @@
+import { IccHelementApi } from '../icc-api';
+import { IccCryptoXApi } from './icc-crypto-x-api';
+import * as models from '../icc-api/model/models';
+export declare class IccHelementXApi extends IccHelementApi {
+    crypto: IccCryptoXApi;
+    constructor(host: string, headers: {
+        [key: string]: string;
+    }, crypto: IccCryptoXApi, fetchImpl?: (input: RequestInfo, init?: RequestInit) => Promise<Response>);
+    newInstance(user: models.User, patient: models.Patient, h: any, confidential?: boolean): Promise<any>;
+    /**
+     * 1. Check whether there is a delegation with 'hcpartyId' or not.
+     * 2. 'fetchHcParty[hcpartyId][1]': is encrypted AES exchange key by RSA public key of him.
+     * 3. Obtain the AES exchange key, by decrypting the previous step value with hcparty private key
+     *      3.1.  KeyPair should be fetch from cache (in jwk)
+     *      3.2.  if it doesn't exist in the cache, it has to be loaded from Browser Local store, and then import it to WebCrypto
+     * 4. Obtain the array of delegations which are delegated to his ID (hcpartyId) in this patient
+     * 5. Decrypt and collect all keys (secretForeignKeys) within delegations of previous step (with obtained AES key of step 4)
+     * 6. Do the REST call to get all helements with (allSecretForeignKeysDelimitedByComa, hcpartyId)
+     *
+     * After these painful steps, you have the helements of the patient.
+     *
+     * @param hcpartyId
+     * @param patient (Promise)
+     * @param keepObsoleteVersions
+     */
+    findBy(hcpartyId: string, patient: models.Patient, keepObsoleteVersions?: boolean): Promise<models.HealthElement[]>;
+    findByHCPartyPatientSecretFKeys(hcPartyId: string, secretFKeys: string): Promise<Array<models.Contact> | any>;
+    decrypt(hcpartyId: string, hes: Array<models.HealthElement>): Promise<Array<models.HealthElement>>;
+    serviceToHealthElement(user: models.User, patient: models.Patient, heSvc: models.Service, descr: string): Promise<models.HealthElement>;
+    stringToCode(code: string): models.Code;
+}

package/icc-x-api/icc-invoice-x-api.d.ts

@@ -0,0 +1,37 @@
+import { IccInvoiceApi, IccEntityrefApi } from '../icc-api';
+import { IccCryptoXApi } from './icc-crypto-x-api';
+import * as models from '../icc-api/model/models';
+import { Invoice } from '../icc-api/model/models';
+export declare class IccInvoiceXApi extends IccInvoiceApi {
+    crypto: IccCryptoXApi;
+    entityrefApi: IccEntityrefApi;
+    constructor(host: string, headers: {
+        [key: string]: string;
+    }, crypto: IccCryptoXApi, entityrefApi: IccEntityrefApi, fetchImpl?: (input: RequestInfo, init?: RequestInit) => Promise<Response>);
+    newInstance(user: models.User, patient: models.Patient, inv?: any): Promise<models.Invoice>;
+    private initDelegationsAndEncryptionKeys;
+    initEncryptionKeys(user: models.User, invoice: models.Invoice): Promise<models.Invoice & {
+        encryptionKeys: any;
+    }>;
+    createInvoice(invoice: Invoice, prefix?: string): Promise<Invoice>;
+    getNextInvoiceReference(prefix: string, entityrefApi: IccEntityrefApi): Promise<number>;
+    createInvoiceReference(nextReference: number, docId: string, prefix: string, entityrefApi: IccEntityrefApi): Promise<models.EntityReference>;
+    /**
+     * 1. Check whether there is a delegation with 'hcpartyId' or not.
+     * 2. 'fetchHcParty[hcpartyId][1]': is encrypted AES exchange key by RSA public key of him.
+     * 3. Obtain the AES exchange key, by decrypting the previous step value with hcparty private key
+     *      3.1.  KeyPair should be fetch from cache (in jwk)
+     *      3.2.  if it doesn't exist in the cache, it has to be loaded from Browser Local store, and then import it to WebCrypto
+     * 4. Obtain the array of delegations which are delegated to his ID (hcpartyId) in this patient
+     * 5. Decrypt and collect all keys (secretForeignKeys) within delegations of previous step (with obtained AES key of step 4)
+     * 6. Do the REST call to get all invoices with (allSecretForeignKeysDelimitedByComa, hcpartyId)
+     *
+     * After these painful steps, you have the invoices of the patient.
+     *
+     * @param hcpartyId
+     * @param patient (Promise)
+     */
+    findBy(hcpartyId: string, patient: models.Patient): Promise<Array<models.Invoice>>;
+    encrypt(user: models.User, invoices: Array<models.Invoice>): Promise<models.Invoice[]>;
+    decrypt(hcpartyId: string, invoices: Array<models.Invoice>): Promise<Array<models.Invoice>>;
+}

package/icc-x-api/icc-message-x-api.d.ts

@@ -0,0 +1,21 @@
+import { IccEntityrefApi, IccInsuranceApi, IccMessageApi } from '../icc-api';
+import { IccCryptoXApi } from './icc-crypto-x-api';
+import { IccDocumentXApi } from './icc-document-x-api';
+import { IccInvoiceXApi } from './icc-invoice-x-api';
+import { Patient, User } from '../icc-api/model/models';
+import { IccReceiptXApi } from './icc-receipt-x-api';
+import { IccPatientXApi } from './icc-patient-x-api';
+export declare class IccMessageXApi extends IccMessageApi {
+    private crypto;
+    private insuranceApi;
+    private entityReferenceApi;
+    private receiptXApi;
+    private invoiceXApi;
+    private documentXApi;
+    private patientApi;
+    constructor(host: string, headers: {
+        [key: string]: string;
+    }, crypto: IccCryptoXApi, insuranceApi: IccInsuranceApi, entityReferenceApi: IccEntityrefApi, invoiceXApi: IccInvoiceXApi, documentXApi: IccDocumentXApi, receiptXApi: IccReceiptXApi, patientApi: IccPatientXApi, fetchImpl?: (input: RequestInfo, init?: RequestInit) => Promise<Response>);
+    newInstance(user: User, m: any): Promise<any>;
+    newInstanceWithPatient(user: User, patient: Patient | null, m: any): Promise<any>;
+}