@icure/api 6.4.0 → 7.0.0-beta.1

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

@@ -11,6 +11,7 @@ import * as models from '../icc-api/model/models';
 import { IccCalendarItemXApi } from './icc-calendar-item-x-api';
 import { IccDataOwnerXApi } from './icc-data-owner-x-api';
 import { AuthenticationProvider } from './auth/AuthenticationProvider';
+import { ShareMetadataBehaviour } from './crypto/ShareMetadataBehaviour';
 export declare class IccPatientXApi extends IccPatientApi {
     crypto: IccCryptoXApi;
     contactApi: IccContactXApi;
@@ -26,10 +27,36 @@ export declare class IccPatientXApi extends IccPatientApi {
     constructor(host: string, headers: {
         [key: string]: string;
     }, crypto: IccCryptoXApi, contactApi: IccContactXApi, formApi: IccFormXApi, helementApi: IccHelementXApi, invoiceApi: IccInvoiceXApi, documentApi: IccDocumentXApi, hcpartyApi: IccHcpartyXApi, classificationApi: IccClassificationXApi, dataOwnerApi: IccDataOwnerXApi, calendarItemaApi: IccCalendarItemXApi, encryptedKeys?: Array<string>, authenticationProvider?: AuthenticationProvider, fetchImpl?: (input: RequestInfo, init?: RequestInit) => Promise<Response>);
-    newInstance(user: models.User, p?: any, delegates?: string[]): Promise<models.Patient>;
+    /**
+     * Creates a new instance of patient with initialised encryption metadata (not in the database).
+     * @param user the current user.
+     * @param p initialised data for the patient. Metadata such as id, creation data, etc. will be automatically initialised, but you can specify
+     * other kinds of data or overwrite generated metadata with this. You can't specify encryption metadata.
+     * @param options optional parameters:
+     * - additionalDelegates: delegates which will have access to the entity in addition to the current data owner and delegates from the
+     * auto-delegations. Must be an object which associates each data owner id with the access level to give to that data owner. May overlap with
+     * auto-delegations, in such case the access level specified here will be used. Currently only WRITE access is supported, but in future also read
+     * access will be possible.
+     * @return a new instance of patient.
+     */
+    newInstance(user: models.User, p?: any, options?: {
+        additionalDelegates?: {
+            [dataOwnerId: string]: 'WRITE';
+        };
+    }): Promise<models.Patient>;
     completeNames(patient: models.Patient): models.Patient;
-    initDelegationsAndEncryptionKeys(patient: models.Patient, user: models.User, secretForeignKey?: string | undefined, delegates?: string[]): Promise<models.Patient>;
-    initConfidentialDelegation(patient: models.Patient, user: models.User): Promise<models.Patient | null>;
+    /**
+     * @deprecated replace with {@link initConfidentialSecretId}
+     */
+    initConfidentialDelegation(patient: models.Patient, user: models.User): Promise<models.Patient>;
+    /**
+     * Ensures that the current data owner has some confidential secret ids for the provided patient. If not creates them and updates the patient in the
+     * database.
+     * @param patient the patient for which you want to initialise the confidential secret id.
+     * @param user the current user.
+     * @return the updated patient or the original patient if no change was necessary.
+     */
+    initConfidentialSecretId(patient: models.Patient, user: models.User): Promise<models.Patient>;
     createPatient(body?: models.Patient): never;
     createPatientWithUser(user: models.User, body?: models.Patient): Promise<models.Patient | any>;
     filterBy(startKey?: string, startDocumentId?: string, limit?: number, skip?: number, sort?: string, desc?: boolean, body?: models.FilterChainPatient): never;
@@ -70,15 +97,13 @@ export declare class IccPatientXApi extends IccPatientApi {
     modifyPatient(body?: models.Patient): never;
     modifyPatientRaw(body?: models.Patient): Promise<models.Patient | any>;
     modifyPatientWithUser(user: models.User, body?: models.Patient): Promise<models.Patient | null>;
+    modifyAs(dataOwner: string, body: models.Patient): Promise<models.Patient>;
     modifyPatientReferral(patientId: string, referralId: string, start?: number, end?: number): never;
     modifyPatientReferralWithUser(user: models.User, patientId: string, referralId: string, start?: number, end?: number): Promise<models.Patient | any>;
     encrypt(user: models.User, pats: Array<models.Patient>): Promise<Array<models.Patient>>;
-    private tryEncrypt;
+    private encryptAs;
     decrypt(user: models.User, patients: Array<models.Patient>, fillDelegations?: boolean): Promise<Array<models.Patient>>;
     private tryDecryptOrReturnOriginal;
-    /** By default, an encryptionKey will be added for every hcp in the autoDelegations of the provided user.
-     * In optional field additionalDelegateIds, you can ask the method to create encryptionKeys for additional hcps */
-    initEncryptionKeys(user: models.User, pat: models.Patient, additionalDelegateIds?: string[]): Promise<models.Patient>;
     share(user: models.User, patId: string, ownerId: string, delegateIds: Array<string>, delegationTags: {
         [key: string]: Array<string>;
     }, usingPost?: boolean): Promise<{
@@ -96,4 +121,39 @@ export declare class IccPatientXApi extends IccPatientApi {
     checkInami(inami: string): boolean;
     isValidSsin(ssin: string): boolean;
     getPatientIdOfChildDocumentForHcpAndHcpParents(childDocument: models.Invoice | models.CalendarItem | models.Contact | models.AccessLog, hcpId: string): Promise<string>;
+    /**
+     * Share an existing patient with other data owners, allowing them to access the non-encrypted data of the patient and optionally also
+     * the encrypted content.
+     * @param delegateId the id of the data owner which will be granted access to the patient.
+     * @param patient the patient to share.
+     * @param shareSecretIds the secret ids of the Patient that the delegate will be given access to. Allows the delegate to search for data where the
+     * shared Patient is the owning entity id.
+     * @param options optional parameters to customize the sharing behaviour:
+     * - shareEncryptionKey: specifies if the encryption key of the access log should be shared with the delegate, giving access to all encrypted
+     * content of the entity, excluding other encrypted metadata (defaults to {@link ShareMetadataBehaviour.IF_AVAILABLE}). Note that by default a
+     * patient does not have encrypted content.
+     * {@link ShareMetadataBehaviour.IF_AVAILABLE}).
+     * @return a promise which will contain the updated patient.
+     */
+    shareWith(delegateId: string, patient: models.Patient, shareSecretIds: string[], options?: {
+        shareEncryptionKey?: ShareMetadataBehaviour;
+    }): Promise<models.Patient>;
+    /**
+     * @param patient a patient
+     * @return all the decryptable secret ids of the patient, retrieved from the encrypted metadata. The result may be used to find entities where the
+     * patient is the 'owning entity', or in the {@link shareWith} method in order to share it with other data owners.
+     */
+    decryptSecretIdsOf(patient: models.Patient): Promise<string[]>;
+    /**
+     * @param patient a patient
+     * @return the confidential secret ids of the patient, retrieved from the encrypted metadata. The result may be used to find entities where the
+     * patient is the 'owning entity', or in the {@link shareWith} method in order to share it with other data owners.
+     */
+    decryptConfidentialSecretIdsOf(patient: models.Patient): Promise<string[]>;
+    /**
+     * @param patient a patient
+     * @return the non-confidential secret ids of the patient, retrieved from the encrypted metadata. The result may be used to find entities where the
+     * patient is the 'owning entity', or in the {@link shareWith} method in order to share it with other data owners.
+     */
+    decryptNonConfidentialSecretIdsOf(patient: models.Patient): Promise<string[]>;
 }