@icure/api 8.6.4 → 8.6.6

package/icc-x-api/icc-calendar-item-x-api.d.ts

@@ -24,6 +24,14 @@ export declare class IccCalendarItemXApi extends IccCalendarItemApi implements E
     constructor(host: string, headers: {
         [key: string]: string;
     }, crypto: IccCryptoXApi, dataOwnerApi: IccDataOwnerXApi, autofillAuthor: boolean, encryptedKeys?: Array<string>, authenticationProvider?: AuthenticationProvider, fetchImpl?: (input: RequestInfo, init?: RequestInit) => Promise<Response>);
+    /**
+     * Creates a new instance of calendar item with initialised encryption metadata (not in the database), without
+     * linking it to a patient. Use {@link newInstancePatient} to create a calendar item linked to a patient.
+     * @param user the current user.
+     * @param ci initialised data for the calendar item.
+     * @param options optional parameters for delegates and root delegation.
+     * @return a new instance of calendar item.
+     */
     newInstance(user: User, ci: any | CalendarItem, options?: {
         additionalDelegates?: {
             [dataOwnerId: string]: AccessLevelEnum;
@@ -70,30 +78,110 @@ export declare class IccCalendarItemXApi extends IccCalendarItemApi implements E
      * @deprecated use {@link findCalendarItemIdsByDataOwnerPatientStartTime} instead.
      */
     findByHCPartyPatientSecretFKeysArray(hcPartyId: string, secretFKeys: string[]): Promise<Array<models.CalendarItem> | any>;
+    /**
+     * @throws always. Use {@link createCalendarItemWithHcParty} instead.
+     */
     createCalendarItem(body?: CalendarItem): never;
+    /**
+     * Creates a calendar item after encrypting its content.
+     * @param user the current user, used for encryption.
+     * @param body the calendar item to create.
+     * @return the created and decrypted calendar item.
+     */
     createCalendarItemWithHcParty(user: models.User, body?: models.CalendarItem): Promise<models.CalendarItem | any>;
+    /**
+     * Retrieves a calendar item by id and decrypts it.
+     * @param user the current user, used for decryption.
+     * @param calendarItemId the id of the calendar item to retrieve.
+     * @return the decrypted calendar item.
+     */
     getCalendarItemWithUser(user: models.User, calendarItemId: string): Promise<CalendarItem | any>;
+    /**
+     * @throws always. Use {@link getCalendarItemWithUser} instead.
+     */
     getCalendarItem(calendarItemId: string): never;
     /**
      * @deprecated use {@link getCalendarItemsWithPaginationWithUser} instead.
      */
     getCalendarItemsWithUser(user: models.User): Promise<Array<CalendarItem> | any>;
+    /**
+     * @throws always. Use {@link getCalendarItemsWithPaginationWithUser} instead.
+     */
     getCalendarItems(): never;
+    /**
+     * Retrieves calendar items with pagination and decrypts them.
+     * @param user the current user, used for decryption.
+     * @param startDocumentId the pagination start document id.
+     * @param limit the maximum number of results to return.
+     * @return a paginated list of decrypted calendar items.
+     */
     getCalendarItemsWithPaginationWithUser(user: models.User, startDocumentId?: string, limit?: number): Promise<PaginatedListCalendarItem>;
+    /**
+     * @throws always. Use {@link getCalendarItemsWithPaginationWithUser} instead.
+     */
     getCalendarItemsWithPagination(startDocumentId?: string, limit?: number): never;
     /**
      * @deprecated use {@link findCalendarItemsByRecurrenceIdWithPaginationWithUser} instead.
      */
     findCalendarItemsByRecurrenceIdWithUser(user: models.User, recurrenceId: string): Promise<Array<CalendarItem> | any>;
+    /**
+     * @throws always. Use {@link findCalendarItemsByRecurrenceIdWithPaginationWithUser} instead.
+     */
     findCalendarItemsByRecurrenceId(recurrenceId: string): never;
+    /**
+     * Finds calendar items by recurrence id with pagination and decrypts them.
+     * @param user the current user, used for decryption.
+     * @param recurrenceId the recurrence id to search for.
+     * @param startKey the pagination start key.
+     * @param startDocumentId the pagination start document id.
+     * @param limit the maximum number of results to return.
+     * @return a paginated list of decrypted calendar items matching the recurrence id.
+     */
     findCalendarItemsByRecurrenceIdWithPaginationWithUser(user: models.User, recurrenceId: string, startKey?: string, startDocumentId?: string, limit?: number): Promise<PaginatedListCalendarItem>;
+    /**
+     * @throws always. Use {@link findCalendarItemsByRecurrenceIdWithPaginationWithUser} instead.
+     */
     findCalendarItemsByRecurrenceIdWithPagination(recurrenceId: string, startKey?: string, startDocumentId?: string, limit?: number): never;
+    /**
+     * Retrieves multiple calendar items by their ids and decrypts them.
+     * @param user the current user, used for decryption.
+     * @param body the list of calendar item ids to retrieve.
+     * @return the decrypted calendar items.
+     */
     getCalendarItemsWithIdsWithUser(user: models.User, body?: models.ListOfIds): Promise<Array<CalendarItem> | any>;
+    /**
+     * @throws always. Use {@link getCalendarItemsWithIdsWithUser} instead.
+     */
     getCalendarItemsWithIds(body?: models.ListOfIds): never;
+    /**
+     * Retrieves calendar items for a given healthcare party within a date range and decrypts them.
+     * @param user the current user, used for decryption.
+     * @param startDate the start of the date range.
+     * @param endDate the end of the date range.
+     * @param hcPartyId the id of the healthcare party.
+     * @return the decrypted calendar items.
+     */
     getCalendarItemsByPeriodAndHcPartyIdWithUser(user: models.User, startDate: number, endDate: number, hcPartyId: string): Promise<Array<CalendarItem> | any>;
+    /**
+     * @throws always. Use {@link getCalendarItemsByPeriodAndHcPartyIdWithUser} instead.
+     */
     getCalendarItemsByPeriodAndHcPartyId(startDate?: number, endDate?: number, hcPartyId?: string): never;
+    /**
+     * Retrieves calendar items for a given agenda within a date range and decrypts them.
+     * @param user the current user, used for decryption.
+     * @param startDate the start of the date range.
+     * @param endDate the end of the date range.
+     * @param agendaId the id of the agenda.
+     * @return the decrypted calendar items.
+     */
     getCalendarsByPeriodAndAgendaIdWithUser(user: models.User, startDate: number, endDate: number, agendaId: string): Promise<Array<CalendarItem> | any>;
+    /**
+     * @throws always. Use {@link getCalendarsByPeriodAndAgendaIdWithUser} instead.
+     */
     getCalendarsByPeriodAndAgendaId(startDate?: number, endDate?: number, agendaId?: string): never;
+    /**
+     * @throws always. Use {@link modifyCalendarItemWithHcParty} instead.
+     */
     modifyCalendarItem(body?: CalendarItem): never;
     /**
      * Remove the following delegation objects from the
@@ -107,10 +195,28 @@ export declare class IccCalendarItemXApi extends IccCalendarItemApi implements E
      * @param calendarItem The Calendar Item object
      */
     resetCalendarDelegationObjects(calendarItem: models.CalendarItem): models.CalendarItem;
+    /**
+     * Modifies a calendar item after encrypting its content.
+     * @param user the current user, used for encryption/decryption.
+     * @param body the calendar item with updated fields.
+     * @return the modified and decrypted calendar item, or null if body was not provided.
+     */
     modifyCalendarItemWithHcParty(user: models.User, body?: models.CalendarItem): Promise<models.CalendarItem | any>;
     private modifyAs;
+    /**
+     * Encrypts the encrypted fields of a list of calendar items.
+     * @param user the current user, used to determine the data owner for encryption.
+     * @param calendarItems the calendar items to encrypt.
+     * @return the encrypted calendar items.
+     */
     encrypt(user: models.User, calendarItems: Array<models.CalendarItem>): Promise<Array<models.CalendarItem>>;
     private encryptAs;
+    /**
+     * Decrypts a list of calendar items using the current data owner's keys.
+     * @param hcpId the id of the healthcare party performing the decryption.
+     * @param calendarItems the calendar items to decrypt.
+     * @return the decrypted calendar items.
+     */
     decrypt(hcpId: string, calendarItems: Array<models.CalendarItem>): Promise<Array<models.CalendarItem>>;
     /**
      * @param calendarItem a calendar item
@@ -188,12 +294,22 @@ export declare class IccCalendarItemXApi extends IccCalendarItemApi implements E
             sharePatientId?: ShareMetadataBehaviour;
         };
     }): Promise<ShareResult<models.CalendarItem>>;
+    /**
+     * Retrieves the data owners that have access to the given calendar item, along with their access levels.
+     * @param entity the calendar item.
+     * @return an object containing a map of data owner ids to their access levels, and a flag indicating if there are unknown anonymous data owners.
+     */
     getDataOwnersWithAccessTo(entity: CalendarItem): Promise<{
         permissionsByDataOwnerId: {
             [p: string]: AccessLevelEnum;
         };
         hasUnknownAnonymousDataOwners: boolean;
     }>;
+    /**
+     * Retrieves the encryption keys of the given calendar item.
+     * @param entity the calendar item.
+     * @return the encryption key ids.
+     */
     getEncryptionKeysOf(entity: CalendarItem): Promise<string[]>;
     /**
      * Adds a bidirectional link between a calendar item with a patient.
@@ -227,5 +343,11 @@ export declare class IccCalendarItemXApi extends IccCalendarItemApi implements E
      * @return the updated calendar item
      */
     addLinkFromPatient(calendarItem: CalendarItem, patient: models.Patient, sfkOption?: SecretIdUseOption): Promise<CalendarItem>;
+    /**
+     * Creates or updates de-anonymization metadata for the given calendar item, allowing the specified delegates to
+     * identify the data owners that have access to it.
+     * @param entity the calendar item.
+     * @param delegates the data owner ids for which to create de-anonymization metadata.
+     */
     createDelegationDeAnonymizationMetadata(entity: CalendarItem, delegates: string[]): Promise<void>;
 }

package/icc-x-api/icc-calendar-item-x-api.js

@@ -49,6 +49,14 @@ class IccCalendarItemXApi extends icc_api_1.IccCalendarItemApi {
         this.dataOwnerApi = dataOwnerApi;
         this.encryptedFields = (0, utils_1.parseEncryptedFields)(encryptedKeys, 'CalendarItem.');
     }
+    /**
+     * Creates a new instance of calendar item with initialised encryption metadata (not in the database), without
+     * linking it to a patient. Use {@link newInstancePatient} to create a calendar item linked to a patient.
+     * @param user the current user.
+     * @param ci initialised data for the calendar item.
+     * @param options optional parameters for delegates and root delegation.
+     * @return a new instance of calendar item.
+     */
     newInstance(user, ci, options = {}) {
         return this.newInstancePatient(user, null, ci, options);
     }
@@ -130,9 +138,18 @@ class IccCalendarItemXApi extends icc_api_1.IccCalendarItemApi {
             .findCalendarItemsByHCPartyPatientForeignKeysUsingPost(hcPartyId, secretFKeys)
             .then((calendarItems) => this.decrypt(hcPartyId, calendarItems));
     }
+    /**
+     * @throws always. Use {@link createCalendarItemWithHcParty} instead.
+     */
     createCalendarItem(body) {
         throw new Error('Cannot call a method that must encrypt a calendar item without providing a user for de/encryption');
     }
+    /**
+     * Creates a calendar item after encrypting its content.
+     * @param user the current user, used for encryption.
+     * @param body the calendar item to create.
+     * @return the created and decrypted calendar item.
+     */
     createCalendarItemWithHcParty(user, body) {
         const _super = Object.create(null, {
             createCalendarItem: { get: () => super.createCalendarItem }
@@ -146,12 +163,21 @@ class IccCalendarItemXApi extends icc_api_1.IccCalendarItemApi {
                 : null;
         });
     }
+    /**
+     * Retrieves a calendar item by id and decrypts it.
+     * @param user the current user, used for decryption.
+     * @param calendarItemId the id of the calendar item to retrieve.
+     * @return the decrypted calendar item.
+     */
     getCalendarItemWithUser(user, calendarItemId) {
         return super
             .getCalendarItem(calendarItemId)
             .then((calendarItem) => this.decrypt(this.dataOwnerApi.getDataOwnerIdOf(user), [calendarItem]))
             .then((cis) => cis[0]);
     }
+    /**
+     * @throws always. Use {@link getCalendarItemWithUser} instead.
+     */
     getCalendarItem(calendarItemId) {
         throw new Error('Cannot call a method that must en/decrypt a calendar item without providing a user for de/encryption');
     }
@@ -166,9 +192,19 @@ class IccCalendarItemXApi extends icc_api_1.IccCalendarItemApi {
             return _super.getCalendarItems.call(this).then((calendarItems) => this.decrypt(this.dataOwnerApi.getDataOwnerIdOf(user), calendarItems));
         });
     }
+    /**
+     * @throws always. Use {@link getCalendarItemsWithPaginationWithUser} instead.
+     */
     getCalendarItems() {
         throw new Error('Cannot call a method that must en/decrypt a calendar item without providing a user for de/encryption');
     }
+    /**
+     * Retrieves calendar items with pagination and decrypts them.
+     * @param user the current user, used for decryption.
+     * @param startDocumentId the pagination start document id.
+     * @param limit the maximum number of results to return.
+     * @return a paginated list of decrypted calendar items.
+     */
     getCalendarItemsWithPaginationWithUser(user, startDocumentId, limit) {
         const _super = Object.create(null, {
             getCalendarItemsWithPagination: { get: () => super.getCalendarItemsWithPagination }
@@ -183,6 +219,9 @@ class IccCalendarItemXApi extends icc_api_1.IccCalendarItemApi {
             });
         });
     }
+    /**
+     * @throws always. Use {@link getCalendarItemsWithPaginationWithUser} instead.
+     */
     getCalendarItemsWithPagination(startDocumentId, limit) {
         throw new Error('Cannot call a method that must en/decrypt a calendar item without providing a user for de/encryption');
     }
@@ -198,9 +237,21 @@ class IccCalendarItemXApi extends icc_api_1.IccCalendarItemApi {
                 .then((calendarItems) => this.decrypt(this.dataOwnerApi.getDataOwnerIdOf(user), calendarItems));
         });
     }
+    /**
+     * @throws always. Use {@link findCalendarItemsByRecurrenceIdWithPaginationWithUser} instead.
+     */
     findCalendarItemsByRecurrenceId(recurrenceId) {
         throw new Error('Cannot call a method that must en/decrypt a calendar item without providing a user for de/encryption');
     }
+    /**
+     * Finds calendar items by recurrence id with pagination and decrypts them.
+     * @param user the current user, used for decryption.
+     * @param recurrenceId the recurrence id to search for.
+     * @param startKey the pagination start key.
+     * @param startDocumentId the pagination start document id.
+     * @param limit the maximum number of results to return.
+     * @return a paginated list of decrypted calendar items matching the recurrence id.
+     */
     findCalendarItemsByRecurrenceIdWithPaginationWithUser(user, recurrenceId, startKey, startDocumentId, limit) {
         const _super = Object.create(null, {
             findCalendarItemsByRecurrenceIdWithPagination: { get: () => super.findCalendarItemsByRecurrenceIdWithPagination }
@@ -215,31 +266,68 @@ class IccCalendarItemXApi extends icc_api_1.IccCalendarItemApi {
             });
         });
     }
+    /**
+     * @throws always. Use {@link findCalendarItemsByRecurrenceIdWithPaginationWithUser} instead.
+     */
     findCalendarItemsByRecurrenceIdWithPagination(recurrenceId, startKey, startDocumentId, limit) {
         throw new Error('Cannot call a method that must en/decrypt a calendar item without providing a user for de/encryption');
     }
+    /**
+     * Retrieves multiple calendar items by their ids and decrypts them.
+     * @param user the current user, used for decryption.
+     * @param body the list of calendar item ids to retrieve.
+     * @return the decrypted calendar items.
+     */
     getCalendarItemsWithIdsWithUser(user, body) {
         return super.getCalendarItemsWithIds(body).then((calendarItems) => this.decrypt(this.dataOwnerApi.getDataOwnerIdOf(user), calendarItems));
     }
+    /**
+     * @throws always. Use {@link getCalendarItemsWithIdsWithUser} instead.
+     */
     getCalendarItemsWithIds(body) {
         throw new Error('Cannot call a method that must en/decrypt a calendar item without providing a user for de/encryption');
     }
+    /**
+     * Retrieves calendar items for a given healthcare party within a date range and decrypts them.
+     * @param user the current user, used for decryption.
+     * @param startDate the start of the date range.
+     * @param endDate the end of the date range.
+     * @param hcPartyId the id of the healthcare party.
+     * @return the decrypted calendar items.
+     */
     getCalendarItemsByPeriodAndHcPartyIdWithUser(user, startDate, endDate, hcPartyId) {
         return super
             .getCalendarItemsByPeriodAndHcPartyId(startDate, endDate, hcPartyId)
             .then((calendarItems) => this.decrypt(this.dataOwnerApi.getDataOwnerIdOf(user), calendarItems));
     }
+    /**
+     * @throws always. Use {@link getCalendarItemsByPeriodAndHcPartyIdWithUser} instead.
+     */
     getCalendarItemsByPeriodAndHcPartyId(startDate, endDate, hcPartyId) {
         throw new Error('Cannot call a method that must en/decrypt a calendar item without providing a user for de/encryption');
     }
+    /**
+     * Retrieves calendar items for a given agenda within a date range and decrypts them.
+     * @param user the current user, used for decryption.
+     * @param startDate the start of the date range.
+     * @param endDate the end of the date range.
+     * @param agendaId the id of the agenda.
+     * @return the decrypted calendar items.
+     */
     getCalendarsByPeriodAndAgendaIdWithUser(user, startDate, endDate, agendaId) {
         return super
             .getCalendarsByPeriodAndAgendaId(startDate, endDate, agendaId)
             .then((calendarItems) => this.decrypt(this.dataOwnerApi.getDataOwnerIdOf(user), calendarItems));
     }
+    /**
+     * @throws always. Use {@link getCalendarsByPeriodAndAgendaIdWithUser} instead.
+     */
     getCalendarsByPeriodAndAgendaId(startDate, endDate, agendaId) {
         throw new Error('Cannot call a method that must en/decrypt a calendar item without providing a user for de/encryption');
     }
+    /**
+     * @throws always. Use {@link modifyCalendarItemWithHcParty} instead.
+     */
     modifyCalendarItem(body) {
         throw new Error('Cannot call a method that must encrypt a calendar item without providing a user for de/encryption');
     }
@@ -258,6 +346,12 @@ class IccCalendarItemXApi extends icc_api_1.IccCalendarItemApi {
         const { cryptedForeignKeys, secretForeignKeys } = calendarItem, resetCalendarItem = __rest(calendarItem, ["cryptedForeignKeys", "secretForeignKeys"]);
         return resetCalendarItem;
     }
+    /**
+     * Modifies a calendar item after encrypting its content.
+     * @param user the current user, used for encryption/decryption.
+     * @param body the calendar item with updated fields.
+     * @return the modified and decrypted calendar item, or null if body was not provided.
+     */
     modifyCalendarItemWithHcParty(user, body) {
         return __awaiter(this, void 0, void 0, function* () {
             return body ? this.modifyAs(this.dataOwnerApi.getDataOwnerIdOf(user), _.cloneDeep(body)) : null;
@@ -269,12 +363,24 @@ class IccCalendarItemXApi extends icc_api_1.IccCalendarItemApi {
             .then((ci) => this.decrypt(dataOwner, [ci]))
             .then((cis) => cis[0]);
     }
+    /**
+     * Encrypts the encrypted fields of a list of calendar items.
+     * @param user the current user, used to determine the data owner for encryption.
+     * @param calendarItems the calendar items to encrypt.
+     * @return the encrypted calendar items.
+     */
     encrypt(user, calendarItems) {
         return this.encryptAs(this.dataOwnerApi.getDataOwnerIdOf(user), calendarItems);
     }
     encryptAs(dataOwner, calendarItems) {
         return this.crypto.xapi.tryEncryptEntities(calendarItems, utils_1.EntityWithDelegationTypeName.CalendarItem, this.encryptedFields, false, false, (json) => new models_1.CalendarItem(json));
     }
+    /**
+     * Decrypts a list of calendar items using the current data owner's keys.
+     * @param hcpId the id of the healthcare party performing the decryption.
+     * @param calendarItems the calendar items to decrypt.
+     * @return the decrypted calendar items.
+     */
     decrypt(hcpId, calendarItems) {
         return __awaiter(this, void 0, void 0, function* () {
             return (yield this.crypto.xapi.tryDecryptEntities(calendarItems, utils_1.EntityWithDelegationTypeName.CalendarItem, (json) => new models_1.CalendarItem(json))).map(({ entity }) => entity);
@@ -374,9 +480,19 @@ class IccCalendarItemXApi extends icc_api_1.IccCalendarItemApi {
                 .then((r) => r.mapSuccessAsync((e) => this.decrypt(self, [e]).then((es) => es[0])));
         });
     }
+    /**
+     * Retrieves the data owners that have access to the given calendar item, along with their access levels.
+     * @param entity the calendar item.
+     * @return an object containing a map of data owner ids to their access levels, and a flag indicating if there are unknown anonymous data owners.
+     */
     getDataOwnersWithAccessTo(entity) {
         return this.crypto.delegationsDeAnonymization.getDataOwnersWithAccessTo({ entity, type: utils_1.EntityWithDelegationTypeName.CalendarItem });
     }
+    /**
+     * Retrieves the encryption keys of the given calendar item.
+     * @param entity the calendar item.
+     * @return the encryption key ids.
+     */
     getEncryptionKeysOf(entity) {
         return this.crypto.xapi.encryptionKeysOf({ entity, type: utils_1.EntityWithDelegationTypeName.CalendarItem }, undefined);
     }
@@ -464,6 +580,12 @@ class IccCalendarItemXApi extends icc_api_1.IccCalendarItemApi {
             }
         });
     }
+    /**
+     * Creates or updates de-anonymization metadata for the given calendar item, allowing the specified delegates to
+     * identify the data owners that have access to it.
+     * @param entity the calendar item.
+     * @param delegates the data owner ids for which to create de-anonymization metadata.
+     */
     createDelegationDeAnonymizationMetadata(entity, delegates) {
         return this.crypto.delegationsDeAnonymization.createOrUpdateDeAnonymizationInfo({ entity, type: utils_1.EntityWithDelegationTypeName.CalendarItem }, delegates);
     }