@icure/api 8.6.5 → 8.6.7

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

@@ -75,7 +75,7 @@ export declare class IccContactXApi extends IccContactApi implements EncryptedEn
      */
     findBy(hcpartyId: string, patient: models.Patient, usingPost?: boolean): Promise<any[]>;
     /**
-     * Same as {@link findIdsBy} but it will only return the ids of the contacts. It can also filter the contacts where Contact.openingDate is between
+     * Same as {@link findBy} but it will only return the ids of the contacts. It can also filter the contacts where Contact.openingDate is between
      * startDate and endDate in ascending or descending order by that field. (default: ascending).
      */
     findIdsBy(hcpartyId: string, patient: models.Patient, startDate?: number, endDate?: number, descending?: boolean): Promise<string[]>;
@@ -102,34 +102,206 @@ export declare class IccContactXApi extends IccContactApi implements EncryptedEn
      * @deprecated use {@link findContactIdsByDataOwnerPatientOpeningDate} instead.
      */
     findByHCPartyPatientSecretFKeysArray(hcPartyId: string, secretFKeys: string[], planOfActionIds?: string, skipClosedContacts?: boolean): Promise<Array<models.Contact> | any>;
+    /**
+     * Filters contacts using a filter chain and decrypts the results for the given user.
+     * @param user the user for decryption
+     * @param startDocumentId optional document id to start pagination from
+     * @param limit maximum number of results to return
+     * @param body the filter chain to apply
+     * @return a paginated list of decrypted contacts
+     */
     filterByWithUser(user: models.User, startDocumentId?: string, limit?: number, body?: models.FilterChainContact): Promise<PaginatedListContact | any>;
+    /**
+     * Lists contacts by opening date within a date range and decrypts the results for the given user.
+     * @param user the user for decryption
+     * @param startDate start of the date range (format: YYYYMMDDHHmmss)
+     * @param endDate end of the date range (format: YYYYMMDDHHmmss)
+     * @param hcpartyid the healthcare party id
+     * @param startKey optional start key for pagination
+     * @param startDocumentId optional document id to start pagination from
+     * @param limit maximum number of results to return
+     * @return a paginated list of decrypted contacts
+     */
     listContactsByOpeningDateWithUser(user: models.User, startDate: number, endDate: number, hcpartyid: string, startKey?: string, startDocumentId?: string, limit?: number): Promise<PaginatedListContact | any>;
+    /**
+     * Gets a service by id and decrypts it for the given user.
+     * @param user the user for decryption
+     * @param serviceId the service id
+     * @return the decrypted service
+     */
     getServiceWithUser(user: models.User, serviceId: string): Promise<Service>;
+    /**
+     * Lists services by their ids and decrypts them for the given user.
+     * @param user the user for decryption
+     * @param serviceIds the list of service ids to retrieve
+     * @return an array of decrypted services
+     */
     listServicesWithUser(user: models.User, serviceIds: ListOfIds): Promise<Array<Service> | any>;
+    /**
+     * Finds contacts by healthcare party and form id and decrypts them for the given user.
+     * @param user the user for decryption
+     * @param hcPartyId the healthcare party id
+     * @param formId the form id
+     * @return an array of decrypted contacts
+     */
     findByHCPartyFormIdWithUser(user: models.User, hcPartyId: string, formId: string): Promise<Array<models.Contact> | any>;
+    /**
+     * Finds contacts by healthcare party and multiple form ids and decrypts them for the given user.
+     * @param user the user for decryption
+     * @param hcPartyId the healthcare party id
+     * @param body the list of form ids
+     * @return an array of decrypted contacts
+     */
     findByHCPartyFormIdsWithUser(user: models.User, hcPartyId: string, body: models.ListOfIds): Promise<Array<models.Contact> | any>;
+    /**
+     * Gets a contact by id and decrypts it for the given user.
+     * @param user the user for decryption
+     * @param contactId the contact id
+     * @return the decrypted contact
+     */
     getContactWithUser(user: models.User, contactId: string): Promise<models.Contact>;
+    /**
+     * Gets multiple contacts by their ids and decrypts them for the given user.
+     * @param user the user for decryption
+     * @param body the list of contact ids
+     * @return an array of decrypted contacts
+     */
     getContactsWithUser(user: models.User, body?: models.ListOfIds): Promise<Array<models.Contact> | any>;
+    /**
+     * Modifies an existing contact by encrypting it and saving it to the database.
+     * @param user the user for encryption
+     * @param body the contact to modify
+     * @return the modified and decrypted contact
+     */
     modifyContactWithUser(user: models.User, body?: models.Contact): Promise<models.Contact | any>;
     private modifyContactAs;
+    /**
+     * Modifies multiple existing contacts by encrypting them and saving them to the database.
+     * @param user the user for encryption
+     * @param bodies the array of contacts to modify
+     * @return an array of modified and decrypted contacts
+     */
     modifyContactsWithUser(user: models.User, bodies?: Array<models.Contact>): Promise<models.Contact[] | any>;
+    /**
+     * Creates a new contact by encrypting it and saving it to the database.
+     * @param user the user for encryption
+     * @param body the contact to create
+     * @return the created and decrypted contact
+     */
     createContactWithUser(user: models.User, body?: models.Contact): Promise<models.Contact | null>;
+    /**
+     * Creates multiple new contacts by encrypting them and saving them to the database.
+     * @param user the user for encryption
+     * @param bodies the array of contacts to create
+     * @return an array of created and decrypted contacts
+     */
     createContactsWithUser(user: models.User, bodies?: Array<models.Contact>): Promise<models.Contact[] | null>;
+    /**
+     * Encrypts the content and custom encrypted fields of services.
+     * Services with compound values are recursively encrypted.
+     * @param key the encryption key
+     * @param rawKey the raw encryption key as a string
+     * @param services the array of services to encrypt
+     * @return a promise containing the encrypted services
+     */
     encryptServices(key: CryptoKey, rawKey: string, services: Service[]): PromiseLike<Service[]>;
+    /**
+     * Encrypts contacts for the given user including all services within the contacts.
+     * @param user the user for encryption
+     * @param ctcs the array of contacts to encrypt
+     * @return a promise containing the encrypted contacts
+     */
     encrypt(user: models.User, ctcs: Array<models.Contact>): Promise<models.Contact[]>;
     private encryptAs;
+    /**
+     * Decrypts contacts and all their encrypted content.
+     * @param hcpartyId the healthcare party id (deprecated parameter, kept for compatibility)
+     * @param ctcs the array of encrypted contacts
+     * @return a promise containing the decrypted contacts
+     */
     decrypt(hcpartyId: string, ctcs: Array<models.Contact>): Promise<Array<models.Contact>>;
+    /**
+     * Decrypts services and all their encrypted content.
+     * @param hcpartyId the healthcare party id (deprecated parameter, kept for compatibility)
+     * @param svcs the array of encrypted services
+     * @return a promise containing the decrypted services
+     */
     decryptServices(hcpartyId: string, svcs: Array<models.Service>): Promise<Array<models.Service>>;
+    /**
+     * Finds the contact containing the given service id, prioritizing the latest version by valueDate.
+     * @param ctcs the array of contacts to search
+     * @param svcId the service id to find
+     * @return the contact containing the service or undefined if not found
+     */
     contactOfService(ctcs: Array<models.Contact>, svcId: string): models.Contact | undefined;
+    /**
+     * Extracts and filters services from contacts, keeping only the latest version of each service and excluding deleted services.
+     * @param ctcs the array of contacts containing services
+     * @param filter a predicate function to filter services: (service, contact) => boolean
+     * @return an array of filtered services with contactId set
+     */
     filteredServices(ctcs: Array<models.Contact>, filter: any): Array<models.Service>;
+    /**
+     * Extracts and filters services from contacts, returning a promise. Same as filteredServices but wrapped in a promise.
+     * @param ctcs the array of contacts containing services
+     * @param filter a predicate function to filter services: (service, contact) => boolean
+     * @return a promise containing an array of filtered services
+     */
     filterServices(ctcs: Array<models.Contact>, filter: any): Promise<Array<models.Service>>;
+    /**
+     * Gets all services from a contact that have the specified label.
+     * @param ctc the contact
+     * @param label the service label to filter by
+     * @return an array of services with the given label
+     */
     services(ctc: models.Contact, label: string): models.Service[];
+    /**
+     * Gets the preferred content for a service based on language preference, falling back to French then first available language.
+     * @param svc the service
+     * @param lng the preferred language code
+     * @return the content in the preferred language or null if no content exists
+     */
     preferredContent(svc: models.Service, lng: string): models.Content | undefined;
+    /**
+     * Extracts the value from content, prioritizing string, number, measure, medication, and boolean values in that order.
+     * @param c the content
+     * @return the extracted value or undefined if no value is present
+     */
     contentValue(c: models.Content): string | number | boolean | models.Measure | models.Medication | undefined;
+    /**
+     * Gets a short human-readable description of a service in the preferred language.
+     * @param svc the service
+     * @param lng the preferred language code
+     * @return a short description of the service content or empty string
+     */
     shortServiceDescription(svc: models.Service, lng: string): string | number;
+    /**
+     * Gets a short human-readable description of content, formatted appropriately for the content type.
+     * @param c the content
+     * @param lng the language code for medication formatting
+     * @param label optional label used for boolean content display
+     * @return a short description of the content
+     */
     shortContentDescription(c: models.Content, lng: string, label?: string): string | number;
+    /**
+     * Extracts the medication value from a service's content in the preferred language.
+     * @param svc the service
+     * @param lng the preferred language code
+     * @return the medication value or undefined if not present
+     */
     medicationValue(svc: models.Service, lng: string): models.Medication | undefined;
+    /**
+     * Checks if content has any data value set (string, number, measure, boolean, medication, or document).
+     * @param c the content to check
+     * @return true if content has data, false otherwise
+     */
     contentHasData(c: any): boolean;
+    /**
+     * Localizes a value by selecting the appropriate language from an object, falling back through FR, EN, and NL.
+     * @param e the object with language-keyed values or a simple value
+     * @param lng the preferred language code
+     * @return the localized value or null if e is null/undefined
+     */
     localize(e: any, lng: string): any;
     /**
      * Modifies the subcontacts this svc belongs to while minimizing the number of references to the svcs inside the subcontacts
@@ -157,10 +329,24 @@ export declare class IccContactXApi extends IccContactApi implements EncryptedEn
     promoteServiceInContact(ctc: models.Contact, user: models.User, ctcs: Array<models.Contact>, svc: models.Service, formId: string, poaIds?: {
         [key: string]: string[];
     }, heIds?: Array<string>, init?: any): any;
+    /**
+     * Checks if a service has numeric content (measure or number value) in the preferred language.
+     * @param svc the service
+     * @param lng the preferred language code
+     * @return true if the service has numeric content, false otherwise
+     */
     isNumeric(svc: models.Service, lng: string): number | boolean | models.Measure | undefined;
+    /**
+     * Returns utility functions for working with services.
+     * @return an object with helper methods for creating and manipulating services
+     */
     service(): {
         newInstance: (user: models.User, s: any) => any;
     };
+    /**
+     * Returns utility functions for working with medication content.
+     * @return an object with helper methods for formatting and displaying medication information
+     */
     medication(): {
         regimenScores: () => any;
         medicationNameToString: (m: any) => string;
@@ -250,14 +436,46 @@ export declare class IccContactXApi extends IccContactApi implements EncryptedEn
             sharePatientId?: ShareMetadataBehaviour;
         };
     }): Promise<ShareResult<models.Contact>>;
+    /**
+     * Gets the data owners that have access to the contact and their permission levels.
+     * @param entity the contact
+     * @return a promise containing the permissions by data owner id and whether there are unknown anonymous data owners
+     */
     getDataOwnersWithAccessTo(entity: models.Contact): Promise<{
         permissionsByDataOwnerId: {
             [p: string]: AccessLevelEnum;
         };
         hasUnknownAnonymousDataOwners: boolean;
     }>;
+    /**
+     * Gets all encryption keys available for the contact.
+     * @param entity the contact
+     * @return a promise containing an array of encryption key hex strings
+     */
     getEncryptionKeysOf(entity: models.Contact): Promise<string[]>;
+    /**
+     * Subscribes to service events (create, update, delete) and receives decrypted services.
+     * @param eventTypes the types of events to subscribe to
+     * @param filter optional filter to apply to services
+     * @param eventFired callback function invoked when an event occurs, receives the decrypted service
+     * @param options optional subscription options
+     * @return a connection that can be closed to unsubscribe
+     */
     subscribeToServiceEvents(eventTypes: ('CREATE' | 'UPDATE' | 'DELETE')[], filter: AbstractFilter<Service> | undefined, eventFired: (dataSample: Service) => Promise<void>, options?: SubscriptionOptions): Promise<Connection>;
+    /**
+     * Subscribes to contact events (create, update, delete) and receives decrypted contacts.
+     * @param eventTypes the types of events to subscribe to
+     * @param filter optional filter to apply to contacts
+     * @param eventFired callback function invoked when an event occurs, receives the decrypted contact
+     * @param options optional subscription options
+     * @return a connection that can be closed to unsubscribe
+     */
     subscribeToContactEvents(eventTypes: ('CREATE' | 'UPDATE' | 'DELETE')[], filter: AbstractFilter<Contact> | undefined, eventFired: (dataSample: Contact) => Promise<void>, options?: SubscriptionOptions): Promise<Connection>;
+    /**
+     * Creates or updates de-anonymization metadata for delegations in a contact.
+     * @param entity the contact
+     * @param delegates the array of delegate ids to create de-anonymization metadata for
+     * @return a promise that completes when the metadata is created/updated
+     */
     createDelegationDeAnonymizationMetadata(entity: Contact, delegates: string[]): Promise<void>;
 }