@icure/api 7.1.16 → 8.0.0-RC.2

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

@@ -1,90 +1,77 @@
-import { AESUtils } from './crypto/AES';
-import { KeyPair, RSAUtils } from './crypto/RSA';
-import { ShamirClass } from './crypto/shamir';
-import { Delegation, Device, Document, EncryptedEntity, EncryptedParentEntity, HealthcareParty, Patient, User } from '../icc-api/model/models';
 import { StorageFacade } from './storage/StorageFacade';
 import { KeyStorageFacade } from './storage/KeyStorageFacade';
 import { ExchangeKeysManager } from './crypto/ExchangeKeysManager';
 import { CryptoPrimitives } from './crypto/CryptoPrimitives';
-import { KeyManager } from './crypto/KeyManager';
-import { DataOwner, IccDataOwnerXApi } from './icc-data-owner-x-api';
-import { EntitiesEncryption } from './crypto/EntitiesEncryption';
-import { IcureStorageFacade } from './storage/IcureStorageFacade';
+import { UserEncryptionKeysManager } from './crypto/UserEncryptionKeysManager';
+import { IccDataOwnerXApi } from './icc-data-owner-x-api';
+import { ExtendedApisUtils } from './crypto/ExtendedApisUtils';
 import { ShamirKeysManager } from './crypto/ShamirKeysManager';
-import { IccHcpartyApi, IccPatientApi } from '../icc-api';
 import { ConfidentialEntities } from './crypto/ConfidentialEntities';
-interface DelegatorAndKeys {
-    delegatorId: string;
-    key: CryptoKey;
-    rawKey: string;
-}
+import { ExchangeDataManager } from './crypto/ExchangeDataManager';
+import { AccessControlKeysHeadersProvider } from './crypto/AccessControlKeysHeadersProvider';
+import { KeyPair } from './crypto/RSA';
+import { DelegationsDeAnonymization } from './crypto/DelegationsDeAnonymization';
 export declare class IccCryptoXApi {
-    private readonly basePatientApi;
-    keychainLocalStoreIdPrefix: string;
-    keychainValidityDateLocalStoreIdPrefix: string;
-    hcpPreferenceKeyEhealthCert: string;
-    hcpPreferenceKeyEhealthCertDate: string;
-    rsaLocalStoreIdPrefix: string;
-    private readonly exchangeKeysManager;
-    private readonly cryptoPrimitives;
-    private readonly keyManager;
-    private readonly dataOwnerApi;
-    private readonly entitiesEncrypiton;
-    private readonly confidentialEntities;
-    private readonly icureStorage;
-    private readonly shamirManager;
+    private readonly _exchangeKeysManager;
+    private readonly _cryptoPrimitives;
+    private readonly _keyManager;
+    private readonly _dataOwnerApi;
+    private readonly xapiUtils;
+    private readonly _shamirManager;
     private readonly _storage;
     private readonly _keyStorage;
-    private readonly hcpartyBaseApi;
+    private readonly _confidentialEntities;
+    private readonly _exchangeDataManager;
+    private readonly _accessControlKeysHeaders;
+    private readonly _delegationsDeAnonymisation;
+    /**
+     * The instance of {@link CryptoPrimitives} used by this instance of the iCure SDK.
+     */
     get primitives(): CryptoPrimitives;
     /**
      * @internal this method is for internal use only and may be changed without notice.
      */
     get exchangeKeys(): ExchangeKeysManager;
     /**
-     * @deprecated replace with {@link CryptoPrimitives.crypto} at {@link primitives}.
-     */
-    get crypto(): Crypto;
-    /**
-     * @deprecated replace with {@link CryptoPrimitives.shamir} at {@link primitives}.
+     * @internal this is for internal use only and may be changed without notice.
      */
-    get shamir(): ShamirClass;
+    get keyStorage(): KeyStorageFacade;
     /**
-     * @deprecated replace with {@link CryptoPrimitives.RSA} at {@link primitives}.
+     * @internal this is for internal use only and may be changed without notice.
      */
-    get RSA(): RSAUtils;
+    get storage(): StorageFacade<string>;
     /**
-     * @deprecated replace with {@link CryptoPrimitives.AES} at {@link primitives}.
+     * @internal this is for internal use only and may be changed without notice.
      */
-    get AES(): AESUtils;
+    get xapi(): ExtendedApisUtils;
     /**
      * @internal this is for internal use only and may be changed without notice.
      */
-    get keyStorage(): KeyStorageFacade;
+    get exchangeData(): ExchangeDataManager;
     /**
      * @internal this is for internal use only and may be changed without notice.
      */
-    get storage(): StorageFacade<string>;
+    get confidential(): ConfidentialEntities;
     /**
      * @internal this is for internal use only and may be changed without notice.
      */
-    get entities(): EntitiesEncryption;
+    get accessControlKeysHeaders(): AccessControlKeysHeadersProvider;
     /**
      * @internal this is for internal use only and may be changed without notice.
      */
-    get confidential(): ConfidentialEntities;
+    get userKeysManager(): UserEncryptionKeysManager;
     /**
      * @internal this is for internal use only and may be changed without notice.
      */
-    get userKeysManager(): KeyManager;
+    get shamirKeysManager(): ShamirKeysManager;
     /**
      * @internal this is for internal use only and may be changed without notice.
      */
-    get shamirKeysManager(): ShamirKeysManager;
+    get delegationsDeAnonymization(): DelegationsDeAnonymization;
     /**
      * @internal
      */
-    constructor(exchangeKeysManager: ExchangeKeysManager, cryptoPrimitives: CryptoPrimitives, keyManager: KeyManager, dataOwnerApi: IccDataOwnerXApi, entitiesEncrypiton: EntitiesEncryption, shamirManager: ShamirKeysManager, storage: StorageFacade<string>, keyStorage: KeyStorageFacade, icureStorageFacade: IcureStorageFacade, hcPartyBaseApi: IccHcpartyApi, confidentialEntities: ConfidentialEntities, basePatientApi: IccPatientApi);
+    constructor(_exchangeKeysManager: ExchangeKeysManager, _cryptoPrimitives: CryptoPrimitives, _keyManager: UserEncryptionKeysManager, _dataOwnerApi: IccDataOwnerXApi, xapiUtils: ExtendedApisUtils, _shamirManager: ShamirKeysManager, _storage: StorageFacade<string>, _keyStorage: KeyStorageFacade, _confidentialEntities: ConfidentialEntities, _exchangeDataManager: ExchangeDataManager, _accessControlKeysHeaders: AccessControlKeysHeadersProvider, _delegationsDeAnonymisation: DelegationsDeAnonymization);
     /**
      * Deletes values cached by the crypto api, to allow to detect changes in stored key pairs, exchange keys and/or current data owner details.
      * This method may be useful in cases where a user is logged in from multiple devices or in cases where other users have just shared some data with
@@ -139,291 +126,4 @@ export declare class IccCryptoXApi {
      * @return the spki representation of public keys of available keypairs for the current user.
      */
     getCurrentUserAvailablePublicKeysHex(verifiedOnly: boolean): Promise<string[]>;
-    /**
-     * @deprecated depending on your use case you should delete the calls to this method or call {@link forceReload}:
-     * - Replace with `forceReload()` if one of the following parts of the current data owner may have been modified from a different api instance:
-     *   - Hcp hierarchy
-     *   - Key recovery data (transfer keys or shamir)
-     *   - Exchange keys (formerly hcp keys)
-     * - Remove the call if the main goal was to force reload the data owner: data owner are not cached anymore.
-     */
-    emptyHcpCache(hcpartyId: string): void;
-    /**
-     * @deprecated you should not need this method anymore to deal with the encryption of iCure entities because everything related to entities
-     * encryption should be done either through the entity-specific extended api or through the extended apis.
-     * Note that keys returned by the current implementation of this method may not be safe for encryption/sharing.
-     * If instead you are using this method to retrieve key pairs for other purposes, for example because you want to reuse the user keys in iCure for
-     * other services consider the following alternatives:
-     * - If you want to use all iCure facilities including key recovery and key verification you can use {@link getKeyPairForFingerprint}.
-     *   Note that this solution can only give access to keys for the data owner of the instantiated api and his parents.
-     * - Alternatively you can use directly your choice of {@link KeyStorageFacade} and {@link StorageEntryKeysFactory}: if these are the same you use
-     *   for the iCure API client the keys will be shared with it. Note however that the iCure api client uses
-     *   {@link StorageEntryKeysFactory.cachedRecoveredKeypairOfDataOwner} to cache recovered keys of a data owner which may not have originated from
-     *   this device, so you should only use {@link StorageEntryKeysFactory.deviceKeypairOfDataOwner} if you want to make sure the keys you use are safe
-     *   for encryption.
-     */
-    getCachedRsaKeyPairForFingerprint(dataOwnerId: string, pubKeyOrFingerprint: string): Promise<{
-        publicKey: CryptoKey;
-        privateKey: CryptoKey;
-    }>;
-    /**
-     * @deprecated You do not need this method to encrypt/decrypt data of iCure, but if you want to reuse the iCure keys for the user for other purposes
-     * you have different options to replace this method, depending on what you actually need. All options return the hex-encoded spki representation of
-     * the public keys.
-     * - If you want only the public keys for which we have a private key available
-     *   - you can replicate the current behaviour using {@link getCurrentUserHierarchyAvailablePublicKeysHex}. This includes keys for the current user
-     *   and his parents.
-     *   - use {@link getCurrentUserAvailablePublicKeysHex} to get public keys only for the current data owner, ignoring any keys of the
-     *     parent hierarchy. In this case you can also apply a filter to only get verified keys (safe for encryption).
-     * - If you need all public keys for the data owner, including those for which there is no corresponding private key available on the device use
-     *   {@link IccDataOwnerXApi.getHexPublicKeysOf} with the current data owner. If you don't have it available you may get it from
-     *   {@link IccDataOwnerXApi.getCurrentDataOwner}, but this will require to do a request to the iCure server (other options use only cached data).
-     */
-    getPublicKeys(): Promise<string[]>;
-    /**
-     * @deprecated replace with {@link CryptoPrimitives.randomUuid} at {@link primitives}.
-     */
-    randomUuid(): string;
-    /**
-     * @deprecated replace with {@link CryptoPrimitives.sha256} at {@link primitives}.
-     */
-    sha256(data: ArrayBuffer | Uint8Array): Promise<ArrayBuffer>;
-    /**
-     * @deprecated Use {@link ShamirKeysManager.updateSelfSplits} from {@link shamirKeysManager} instead. Note that the new method completely replaces
-     * all current values if a split for the provided key already exists.
-     */
-    encryptShamirRSAKey(hcp: HealthcareParty, notaries: Array<HealthcareParty>, threshold?: number): Promise<HealthcareParty>;
-    /**
-     * @deprecated You should not need this method anymore because the api will automatically try to recover the available shamir keys on startup.
-     */
-    decryptShamirRSAKey(hcp: HealthcareParty, notaries: Array<HealthcareParty>): Promise<void>;
-    /**
-     * @deprecated you should not need this method anymore because everything related to entities encryption should be done either through the
-     * entity-specific extended api.
-     * Note that currently this method does not cache results anymore (but the updated methods do).
-     */
-    decryptHcPartyKey(loggedHcPartyId: string, delegatorId: string, delegateHcPartyId: string, publicKey: string, encryptedHcPartyKeys: {
-        [key: string]: string;
-    }, publicKeys: string[]): Promise<DelegatorAndKeys>;
-    /**
-     * @deprecated you should not need this method anymore. The new API will automatically load on startup all keys available through the key storage
-     * facade and/or recoverable through transfer keys or shamir split. If no verified key (safe for encryption) can be found during the instantiation
-     * of the API, depending on the parameters passed to the factory one of two scenarios will happen:
-     * - A new key will be automatically created on the device and stored using the key storage facade.
-     * - The api instantiation fails with an exception. This is ideal if you want to try to recover an existing key pair before creating a new one.
-     *
-     * If you were using this method to allow the user to recover an existing key that is not available in the storage facade nor recoverable through
-     * transfer keys or shamir split (for example by scanning a qr code, or by loading a file from the computer to the web browser's local storage)
-     * you will have to move that logic in your implementation of CryptoStrategies.
-     * It is currently not allowed to create new key pairs if a verified key pair is already available on the device, as this would be wasteful.
-     * If you want to convert a `JsonWebKey` pair to a `CryptoKey` pair you should use directly the method in `primitives.RSA`.
-     */
-    cacheKeyPair(keyPairInJwk: KeyPair<JsonWebKey>): Promise<KeyPair<CryptoKey>>;
-    /**
-     * @deprecated Usually you should not need this method, since the preferred sfk is automatically chosen by the extended entity apis when creating a
-     * new instance of the entity.
-     */
-    extractPreferredSfk(parent: EncryptedParentEntity, hcpartyId: string, confidential: boolean): Promise<string | undefined>;
-    /**
-     * @deprecated you should not need this method anymore because everything related to entities encryption should be done either through the
-     * entity-specific extended api.
-     */
-    decryptAndImportAesHcPartyKeysForDelegators(delegatorsHcPartyIdsSet: Array<string>, delegateHcPartyId: string, minCacheDurationInSeconds?: number): Promise<Array<DelegatorAndKeys>>;
-    /**
-     * @deprecated you should not need this method anymore because everything related to entities encryption should be done either through the
-     * entity-specific extended api.
-     * Note that currently this method does not cache results anymore (but the updated methods do).
-     */
-    getEncryptedAesExchangeKeys(owner: DataOwner, delegateId: string): Promise<{
-        [pubKeyIdentifier: string]: {
-            [pubKeyFingerprint: string]: string;
-        };
-    }>;
-    /**
-     * @deprecated you should not use this method because initialisation of encrypted entities keys is done automatically by the entity-specific
-     * extended api. Also note that it is now forbidden to initialise an entity as a data owner which is not the current data owner: you should instead
-     * create the entity as the current data owner then create a delegation to the other data owner.
-     */
-    initEncryptionKeys(createdObject: any, ownerId: string): Promise<{
-        encryptionKeys: any;
-        secretId: string;
-    }>;
-    /**
-     * @deprecated You should use:
-     * - {@link IccPatientXApi.decryptSecretIdsOf} or {@link IccMessageXApi.decryptSecretIdsOf} to get the delegation sfks (now called secret ids).
-     * - {@link IccDataOwnerXApi.getCurrentDataOwnerHierarchyIds} to get the full hierarchy for the current data owner (cached). The first element is
-     *   the id of the topmost parent, while the last is the current data owner.
-     * Note that the behaviour of this method has some subtle changes compared to the past:
-     * - throws an error if the provided hcpartyId is not part of the current data owner hierarchy.
-     * - does not provide any guarantees on the ordering of the extracted keys
-     * - deduplicates extracted keys
-     */
-    extractDelegationsSFKs(document: EncryptedEntity | null, hcpartyId?: string): Promise<{
-        extractedKeys: Array<string>;
-        hcpartyId?: string;
-    }>;
-    /**
-     * @deprecated (light) You should use:
-     * - {@link IccHelementXApi.decryptPatientIdOf}, {@link IccDocumentXApi.decryptMessageIdOf}, ... to get the crypted foreign keys.
-     * - {@link IccDataOwnerXApi.getCurrentDataOwnerHierarchyIds} to get the full hierarchy for the current data owner (cached). The first element is
-     *   the id of the topmost parent, while the last is the current data owner.
-     * Note that the behaviour of this method has some subtle changes compared to the past:
-     * - throws an error if the provided hcpartyId is not part of the current data owner hierarchy.
-     * - does not provide any guarantees on the ordering of the extracted keys
-     * - deduplicates extracted keys
-     */
-    extractCryptedFKs(document: EncryptedEntity | null, hcpartyId: string): Promise<{
-        extractedKeys: Array<string>;
-        hcpartyId: string;
-    }>;
-    /**
-     * @deprecated You should use the extended apis methods to encrypt/decrypt entities or their attachments
-     * Note that the behaviour of this method has some subtle changes compared to the past:
-     * - throws an error if the provided hcpartyId is not part of the current data owner hierarchy.
-     * - does not provide any guarantees on the ordering of the extracted keys
-     * - deduplicates extracted keys
-     */
-    extractEncryptionsSKs(document: EncryptedEntity, hcpartyId: string): Promise<{
-        extractedKeys: Array<string>;
-        hcpartyId: string;
-    }>;
-    /**
-     * @deprecated You should not use this method anymore, depending on what you were passing as {@link delegations} you should replace this method as
-     * explained in {@link extractEncryptionsSKs} (if you were passing encryptionKeys), {@link extractCryptedFKs} (cryptedForeignKeys), or
-     * {@link extractDelegationsSFKs} (delegations).
-     */
-    extractKeysFromDelegationsForHcpHierarchy(dataOwnerId: string, objectId: string, delegations: {
-        [key: string]: Array<Delegation>;
-    }): Promise<{
-        extractedKeys: Array<string>;
-        hcpartyId: string;
-    }>;
-    /**
-     * @deprecated you should not need this method anymore: the new API will automatically load on startup all keys available through the key storage
-     * facade and/or recoverable through transfer keys or shamir split. If you were using this method to load a key recovered through other means you
-     * will have to do so in your implementation of CryptoStrategies.
-     * You can convert the private key pkcs8 array to a jwk key using {@link pkcs8ToJwk} then you can extract the full key pair using
-     * {@link keyPairFromPrivateKeyJwk}.
-     */
-    loadKeyPairsAsTextInBrowserLocalStorage(healthcarePartyId: string, privateKey: Uint8Array): Promise<void>;
-    /**
-     * @deprecated you should not need this method anymore: the new API will automatically load on startup all keys available through the key storage
-     * facade and/or recoverable through transfer keys or shamir split. If you were using this method to load a key recovered through other means you
-     * will have to do so in your implementation of CryptoStrategies.
-     * You can extract the full key pair using {@link keyPairFromPrivateKeyJwk}.
-     */
-    loadKeyPairsAsJwkInBrowserLocalStorage(healthcarePartyId: string, privateKey: JsonWebKey): Promise<void>;
-    /**
-     * @deprecated you should not need this method anymore: the new API will automatically load on startup all keys available through the key storage
-     * facade and/or recoverable through transfer keys or shamir split. If you were using this method to load a key recovered through other means you
-     * will have to do so in your implementation of CryptoStrategies.
-     */
-    loadKeyPairsInBrowserLocalStorage(healthcarePartyId: string, file: Blob): Promise<void>;
-    /**
-     * @deprecated keychains are not part of iCure's api: this method will be removed.
-     */
-    saveKeychainInBrowserLocalStorage(id: string, keychain: number): void;
-    /**
-     * @deprecated keychains are not part of iCure's api: this method will be removed.
-     */
-    saveKeychainInBrowserLocalStorageAsBase64(id: string, keyChainB64: string): void;
-    /**
-     * @deprecated keychains are not part of iCure's api: this method will be removed.
-     */
-    saveKeychainValidityDateInBrowserLocalStorage(id: string, date: string): Promise<void>;
-    /**
-     * @deprecated keychains are not part of iCure's api: this method will be removed.
-     *
-     * Populate the HCP.options dict with an encrypted eHealth certificate and unencryped expiry date.
-     * Any potentially unencrypted certificates will be pruned from the HCP.
-     * @param hcpId Id of the hcp to modify
-     * @returns modified HCP
-     */
-    saveKeyChainInHCPFromLocalStorage(hcpId: string): Promise<HealthcareParty>;
-    /**
-     * @deprecated keychains are not part of iCure's api: this method will be removed.
-     */
-    importKeychainInBrowserFromHCP(hcpId: string): Promise<void>;
-    /**
-     * @deprecated e-health certificates and keychains are not part of iCure's api: this method will be removed.
-     *
-     * Synchronizes the eHealth certificate from the database into the LocalStorage, returning information on the presence
-     * of certificate data in either place.
-     *
-     * @param hcpId The healthcare party id
-     * @returns A Promise for an object that represents the existence of a certificate in local storage and in the DB,
-     * through the two boolean properties "local" and "remote".
-     */
-    syncEhealthCertificateFromDatabase(hcpId: string): Promise<{
-        remote: boolean;
-        local: boolean;
-    }>;
-    /**
-     * @deprecated keychains are not part of iCure's api: this method will be removed.
-     */
-    getKeychainInBrowserLocalStorageAsBase64(id: string): Promise<string | undefined>;
-    /**
-     * @deprecated keychains are not part of iCure's api: this method will be removed.
-     */
-    getKeychainValidityDateInBrowserLocalStorage(id: string): Promise<string | undefined>;
-    /**
-     * @deprecated keychains are not part of iCure's api: this method will be removed.
-     */
-    loadKeychainFromBrowserLocalStorage(id: string): Promise<Uint8Array[] | null>;
-    /**
-     * @deprecated you should not need this method anymore to deal with the encryption of iCure entities because everything related to entities
-     * encryption should be done through the entity-specific extended api.
-     * If instead you were using the method for other reasons check {@link getCachedRsaKeyPairForFingerprint} to get an idea of possible replacements.
-     */
-    loadKeyPairNotImported(id: string, publicKeyFingerPrint?: string): Promise<{
-        publicKey: JsonWebKey;
-        privateKey: JsonWebKey;
-    } | undefined>;
-    /**
-     * @deprecated use {@link IccIcureMaintenanceXApi.applyKeyPairUpdate} instead.
-     */
-    giveAccessBackTo(delegateUser: User, ownerId: string, ownerNewPublicKey: string): Promise<DataOwner>;
-    /**
-     * @deprecated You don't need to manually generate exchange keys as they will be automatically created by the api when needed.
-     * Note that this method has some changes compared to previous version:
-     * - The method may return any data owner (including devices)
-     * - The method will throw an exception if the provided ownerId does not match the current data owner
-     */
-    generateKeyForDelegate(ownerId: string, delegateId: string): Promise<DataOwner>;
-    /**
-     * @deprecated replace with {@link IccDataOwnerXApi.getDataOwner}. Note that data owners are not cached anymore.
-     */
-    getDataOwner(ownerId: string, loadIfMissingFromCache?: boolean): Promise<import("../icc-api/model/DataOwnerWithType").DataOwnerWithType>;
-    /**
-     * @deprecated the crypto api will automatically verify on startup the validity of private keys, but in some cases you may want to verify the
-     * validity of keys recovered in your implementation of {@link CryptoStrategies}: in this case the method has been replaced with
-     * {@link RSA.checkKeyPairValidity}
-     */
-    checkPrivateKeyValidity(dataOwner: DataOwner): Promise<boolean>;
-    /**
-     * @deprecated (See {@link extractEncryptionsSKs} for a detailed explanation).
-     */
-    getEncryptionDecryptionKeys(dataOwnerId: string, document: EncryptedEntity): Promise<Array<string> | undefined>;
-    /**
-     * @deprecated For the encryption/decryption of iCure entities and attachments you should rely solely on the extended apis methods.
-     */
-    encryptDecrypt(method: 'encrypt' | 'decrypt', content: Uint8Array | ArrayBuffer, edKey?: string, user?: User, documentObject?: Document): Promise<Uint8Array | Array<any> | any>;
-    /**
-     * @deprecated you should not need to interact directly with the storage instance used by the iCure sdk.
-     */
-    storeKeyPair(id: string, keyPair: {
-        publicKey: any;
-        privateKey: any;
-    }): void;
-    /**
-     * @deprecated This method is not safe as it allows any data owner to add a public key to other data owners. The method will be removed in future,
-     * additionally the user calling this method will require a special permission when calling it for another data owner.
-     * @param ownerId the id of the data owner which will have a new key.
-     */
-    generateAndAddNewKeyPairForOwner(ownerId: string): Promise<{
-        dataOwner: HealthcareParty | Patient | Device;
-        publicKey: string;
-        privateKey: string;
-    }>;
 }
-export {};