@icure/cardinal-sdk 2.1.1 → 2.1.2

package/api/HealthElementInGroupApi.d.mts

@@ -14,6 +14,10 @@ import { HealthElementFlavouredInGroupApi } from './HealthElementFlavouredInGrou
 export interface HealthElementInGroupApi {
     encrypted: HealthElementFlavouredInGroupApi<EncryptedHealthElement>;
     tryAndRecover: HealthElementFlavouredInGroupApi<HealthElement>;
+    /**
+     *
+     *  In-group version of [HealthElementApi.withEncryptionMetadata]
+     */
     withEncryptionMetadata(entityGroupId: string, base: DecryptedHealthElement | undefined, patient: GroupScoped<Patient>, options?: {
         user?: User | undefined;
         delegates?: ArrayWithUniqueKeys<{
@@ -23,40 +27,164 @@ export interface HealthElementInGroupApi {
         secretId?: SecretIdUseOption;
         alternateRootDelegateReference?: EntityReferenceInGroup | undefined;
     }): Promise<GroupScoped<DecryptedHealthElement>>;
+    /**
+     *
+     *  In-group version of [HealthElementApi.getEncryptionKeysOf]
+     */
     getEncryptionKeysOf(healthElement: GroupScoped<HealthElement>): Promise<Array<HexString>>;
+    /**
+     *
+     *  In-group version of [HealthElementApi.hasWriteAccess]
+     */
     hasWriteAccess(healthElement: GroupScoped<HealthElement>): Promise<boolean>;
+    /**
+     *
+     *  In-group version of [HealthElementApi.decryptPatientIdOf]
+     */
     decryptPatientIdOf(healthElement: GroupScoped<HealthElement>): Promise<Array<EntityReferenceInGroup>>;
+    /**
+     *
+     *  In-group version of [HealthElementApi.createDelegationDeAnonymizationMetadata]
+     */
     createDelegationDeAnonymizationMetadata(entity: GroupScoped<HealthElement>, delegates: Array<EntityReferenceInGroup>): Promise<void>;
+    /**
+     *
+     *  In-group version of [HealthElementApi.decrypt]
+     */
     decrypt(healthElements: Array<GroupScoped<EncryptedHealthElement>>): Promise<Array<GroupScoped<DecryptedHealthElement>>>;
+    /**
+     *
+     *  In-group version of [HealthElementApi.tryDecrypt]
+     */
     tryDecrypt(healthElements: Array<GroupScoped<EncryptedHealthElement>>): Promise<Array<GroupScoped<HealthElement>>>;
+    /**
+     *
+     *  In-group version of [HealthElementApi.encryptOrValidate]
+     */
     encryptOrValidate(healthElements: Array<GroupScoped<HealthElement>>): Promise<Array<GroupScoped<EncryptedHealthElement>>>;
+    /**
+     *
+     *  In-group version of [HealthElementApi.matchHealthElementsBy]
+     */
     matchHealthElementsBy(groupId: string, filter: FilterOptions<HealthElement>): Promise<Array<string>>;
+    /**
+     *
+     *  In-group version of [HealthElementApi.matchHealthElementsBySorted]
+     */
     matchHealthElementsBySorted(groupId: string, filter: SortableFilterOptions<HealthElement>): Promise<Array<string>>;
+    /**
+     *
+     *  In-group version of [HealthElementBasicFlavourlessApi.deleteHealthElementById]
+     */
     deleteHealthElementById(entityId: GroupScoped<StoredDocumentIdentifier>): Promise<GroupScoped<StoredDocumentIdentifier>>;
+    /**
+     *
+     *  In-group version of [HealthElementBasicFlavourlessApi.deleteHealthElementsByIds]
+     */
     deleteHealthElementsByIds(entityIds: Array<GroupScoped<StoredDocumentIdentifier>>): Promise<Array<GroupScoped<StoredDocumentIdentifier>>>;
+    /**
+     *
+     *  In-group version of [HealthElementBasicFlavourlessApi.purgeHealthElementById]
+     */
     purgeHealthElementById(entityId: GroupScoped<StoredDocumentIdentifier>): Promise<void>;
+    /**
+     *
+     *  In-group version of [HealthElementBasicFlavourlessApi.purgeHealthElementsByIds]
+     */
     purgeHealthElementsByIds(entityIds: Array<GroupScoped<StoredDocumentIdentifier>>): Promise<Array<GroupScoped<StoredDocumentIdentifier>>>;
+    /**
+     *
+     *  In-group version of [HealthElementBasicFlavourlessApi.deleteHealthElement]
+     */
     deleteHealthElement(healthElement: GroupScoped<HealthElement>): Promise<GroupScoped<StoredDocumentIdentifier>>;
+    /**
+     *
+     *  In-group version of [HealthElementBasicFlavourlessApi.deleteHealthElements]
+     */
     deleteHealthElements(healthElements: Array<GroupScoped<HealthElement>>): Promise<Array<GroupScoped<StoredDocumentIdentifier>>>;
+    /**
+     *
+     *  In-group version of [HealthElementBasicFlavourlessApi.purgeHealthElement]
+     */
     purgeHealthElement(healthElement: GroupScoped<HealthElement>): Promise<void>;
+    /**
+     *
+     *  In-group version of [HealthElementBasicFlavourlessApi.purgeHealthElements]
+     */
     purgeHealthElements(healthElements: Array<GroupScoped<HealthElement>>): Promise<Array<GroupScoped<StoredDocumentIdentifier>>>;
+    /**
+     *
+     *  In-group version of [HealthElementFlavouredApi.shareWith]
+     */
     shareWith(delegate: EntityReferenceInGroup, healthElement: GroupScoped<DecryptedHealthElement>, options?: {
         options?: HealthElementShareOptions | undefined;
     }): Promise<GroupScoped<DecryptedHealthElement>>;
+    /**
+     *
+     *  In-group version of [HealthElementFlavouredApi.shareWithMany]
+     */
     shareWithMany(healthElement: GroupScoped<DecryptedHealthElement>, delegates: ArrayWithUniqueKeys<{
         delegate: EntityReferenceInGroup;
         shareOptions: HealthElementShareOptions;
     }, 'delegate'>): Promise<GroupScoped<DecryptedHealthElement>>;
+    /**
+     *
+     *  In-group version of [HealthElementFlavouredApi.filterHealthElementsBy]
+     */
     filterHealthElementsBy(groupId: string, filter: FilterOptions<HealthElement>): Promise<PaginatedListIterator<GroupScoped<DecryptedHealthElement>>>;
+    /**
+     *
+     *  In-group version of [HealthElementFlavouredApi.filterHealthElementsBySorted]
+     */
     filterHealthElementsBySorted(groupId: string, filter: SortableFilterOptions<HealthElement>): Promise<PaginatedListIterator<GroupScoped<DecryptedHealthElement>>>;
+    /**
+     *
+     *  In-group version of [HealthElementApi.createHealthElement]
+     */
     createHealthElement(entity: GroupScoped<DecryptedHealthElement>): Promise<GroupScoped<DecryptedHealthElement>>;
+    /**
+     *
+     *  In-group version of [HealthElementApi.createHealthElements]
+     */
     createHealthElements(entities: Array<GroupScoped<DecryptedHealthElement>>): Promise<Array<GroupScoped<DecryptedHealthElement>>>;
+    /**
+     *
+     *  In-group version of [HealthElementBasicFlavouredApi.undeleteHealthElementById]
+     */
     undeleteHealthElementById(entityId: GroupScoped<StoredDocumentIdentifier>): Promise<GroupScoped<DecryptedHealthElement>>;
+    /**
+     *
+     *  In-group version of [HealthElementBasicFlavouredApi.undeleteHealthElementsByIds]
+     */
     undeleteHealthElementsByIds(entityIds: Array<GroupScoped<StoredDocumentIdentifier>>): Promise<Array<GroupScoped<DecryptedHealthElement>>>;
+    /**
+     *
+     *  In-group version of [HealthElementBasicFlavouredApi.undeleteHealthElement]
+     */
     undeleteHealthElement(healthElement: GroupScoped<HealthElement>): Promise<GroupScoped<DecryptedHealthElement>>;
+    /**
+     *
+     *  In-group version of [HealthElementBasicFlavouredApi.undeleteHealthElements]
+     */
     undeleteHealthElements(healthElements: Array<GroupScoped<DecryptedHealthElement>>): Promise<Array<GroupScoped<DecryptedHealthElement>>>;
+    /**
+     *
+     *  In-group version of [HealthElementBasicFlavouredApi.modifyHealthElement]
+     */
     modifyHealthElement(entity: GroupScoped<DecryptedHealthElement>): Promise<GroupScoped<DecryptedHealthElement>>;
+    /**
+     *
+     *  In-group version of [HealthElementBasicFlavouredApi.modifyHealthElements]
+     */
     modifyHealthElements(entities: Array<GroupScoped<DecryptedHealthElement>>): Promise<Array<GroupScoped<DecryptedHealthElement>>>;
+    /**
+     *
+     *  In-group version of [HealthElementBasicFlavouredApi.getHealthElement]
+     */
     getHealthElement(groupId: string, entityId: string): Promise<GroupScoped<DecryptedHealthElement> | undefined>;
+    /**
+     *
+     *  In-group version of [HealthElementBasicFlavouredApi.getHealthElements]
+     */
     getHealthElements(groupId: string, entityIds: Array<string>): Promise<Array<GroupScoped<DecryptedHealthElement>>>;
 }

package/api/HealthcarePartyApi.d.mts

@@ -26,18 +26,113 @@ export interface HealthcarePartyApi {
         token?: string | undefined;
         useShortToken?: boolean | undefined;
     }): Promise<DataOwnerRegistrationSuccess>;
+    /**
+     *
+     *  Deletes a healthcareParty. If you don't have write access to the healthcareParty the method will fail.
+     *  @param entityId id of the healthcareParty.
+     *  @param rev the latest known rev of the healthcareParty to delete
+     *  @return the id and revision of the deleted healthcareParty.
+     *  @throws RevisionConflictException if the provided revision doesn't match the latest known revision
+     */
     deleteHealthcarePartyById(entityId: string, rev: string): Promise<StoredDocumentIdentifier>;
+    /**
+     *
+     *  Deletes many healthcareParties. Ids that do not correspond to an entity, or that correspond to an entity for which
+     *  you don't have write access will be ignored.
+     *  @param entityIds ids and revisions of the healthcareParties to delete.
+     *  @return the id and revision of the deleted healthcareParties. If some entities could not be deleted (for example
+     *  because you had no write access to them) they will not be included in this list.
+     */
     deleteHealthcarePartiesByIds(entityIds: Array<StoredDocumentIdentifier>): Promise<Array<StoredDocumentIdentifier>>;
+    /**
+     *
+     *  Permanently deletes a healthcareParty.
+     *  @param id id of the healthcareParty to purge
+     *  @param rev latest revision of the healthcareParty
+     *  @throws RevisionConflictException if the provided revision doesn't match the latest known revision
+     */
     purgeHealthcarePartyById(id: string, rev: string): Promise<void>;
+    /**
+     *
+     *  Permanently deletes many healthcareParties.
+     *  @param entityIds ids and revisions of the healthcareParties to delete
+     *  @return the id and revision of the deleted healthcareParties. If some entities couldn't be deleted (for example
+     *  because you had no write access to them) they will not be included in this list.
+     */
     purgeHealthcarePartiesByIds(entityIds: Array<StoredDocumentIdentifier>): Promise<Array<StoredDocumentIdentifier>>;
+    /**
+     *
+     *  Restores a healthcareParty that was marked as deleted.
+     *  @param id the id of the entity
+     *  @param rev the latest revision of the entity.
+     *  @return the restored entity.
+     *  @throws RevisionConflictException if the provided revision doesn't match the latest known revision
+     */
     undeleteHealthcarePartyById(id: string, rev: string): Promise<HealthcareParty>;
+    /**
+     *
+     *  Restores a batch of healthcareParties that were marked as deleted.
+     *  @param entityIds the ids and the revisions of the healthcareParties to restore.
+     *  @return the restored healthcareParties. If some entities couldn't be restored (because the user does not have access or the revision is not
+     *  up-to-date), then those entities will not be restored and will not appear in this list.
+     */
     undeleteHealthcarePartiesByIds(entityIds: Array<StoredDocumentIdentifier>): Promise<Array<HealthcareParty>>;
+    /**
+     *
+     *  Deletes a healthcareParty. If you don't have write access to the healthcareParty the method will fail.
+     *  @param healthcareParty the healthcareParty to delete
+     *  @return the id and revision of the deleted healthcareParty.
+     *  @throws RevisionConflictException if the provided healthcareParty doesn't match the latest known revision
+     */
     deleteHealthcareParty(healthcareParty: HealthcareParty): Promise<StoredDocumentIdentifier>;
+    /**
+     *
+     *  Deletes many healthcareParties. Ignores healthcareParty for which you don't have write access or that don't match the latest revision.
+     *  @param healthcareParties the healthcareParties to delete
+     *  @return the id and revision of the deleted healthcareParties. If some entities couldn't be deleted they will not be
+     *  included in this list.
+     */
     deleteHealthcareParties(healthcareParties: Array<HealthcareParty>): Promise<Array<StoredDocumentIdentifier>>;
+    /**
+     *
+     *  Permanently deletes a healthcareParty.
+     *  @param healthcareParty the healthcareParty to purge.
+     *  @throws RevisionConflictException if the provided healthcareParty doesn't match the latest known revision
+     */
     purgeHealthcareParty(healthcareParty: HealthcareParty): Promise<void>;
+    /**
+     *
+     *  Permanently deletes many healthcareParties.
+     *  @param healthcareParties the healthcareParties to delete
+     *  @return the id and revision of the deleted healthcareParties. If some entities couldn't be deleted (for example
+     *  because you had no write access to them) they will not be included in this list.
+     */
     purgeHealthcareParties(healthcareParties: Array<HealthcareParty>): Promise<Array<StoredDocumentIdentifier>>;
+    /**
+     *
+     *  Restores a healthcareParty that was marked as deleted.
+     *  @param healthcareParty the healthcareParty to undelete
+     *  @return the restored healthcareParty.
+     *  @throws RevisionConflictException if the provided healthcareParty doesn't match the latest known revision
+     */
     undeleteHealthcareParty(healthcareParty: HealthcareParty): Promise<HealthcareParty>;
+    /**
+     *
+     *  Restores a batch of healthcareParties that were marked as deleted.
+     *  @param healthcareParties the healthcareParties to restore.
+     *  @return the restored healthcareParties. If some entities couldn't be restored (because the user does not have access or the revision is not
+     *  up-to-date), then those entities will not be restored and will not appear in this list.
+     */
     undeleteHealthcareParties(healthcareParties: Array<HealthcareParty>): Promise<Array<HealthcareParty>>;
+    /**
+     *
+     *  Subscribe to receive real-time notifications when an entity is updated.
+     *  @param events the type of events that will be notified to the subscription
+     *  @param filter the subscription will receive notifications only for entities matching this filter, you should
+     *  make the filter as restrictive as possible.
+     *  @param subscriptionConfig customize the configuration for the subscription
+     *  @return a subscription that receives notifications for the configured events.
+     */
     subscribeToEvents(events: Array<SubscriptionEventType>, filter: FilterOptions<HealthcareParty>, options?: {
         subscriptionConfig?: EntitySubscriptionConfiguration | undefined;
     }): Promise<EntitySubscription<HealthcareParty>>;

package/api/InvoiceApi.d.mts

@@ -19,6 +19,19 @@ export interface InvoiceApi {
     encrypted: InvoiceFlavouredApi<EncryptedInvoice>;
     tryAndRecover: InvoiceFlavouredApi<Invoice>;
     inGroup: InvoiceInGroupApi;
+    /**
+     *
+     *  Creates a new invoice with initialized encryption metadata
+     *  @param base an invoice with initialized content and uninitialized encryption metadata. The result of this
+     *  method takes the content from [base] if provided.
+     *  @param patient the patient linked to the invoice.
+     *  @param user the current user, will be used for the auto-delegations if provided.
+     *  @param delegates additional data owners that will have access to the newly created entity. You may choose the
+     *  permissions that the delegates will have on the entity, but they will have access to all encryption metadata.
+     *  @param secretId specifies which secret id of [patient] to use for the new invoice
+     *  @return an invoice with initialized encryption metadata.
+     *  @throws IllegalArgumentException if base is not null and has a revision or has encryption metadata.
+     */
     withEncryptionMetadata(base: DecryptedInvoice | undefined, patient: Patient | undefined, options?: {
         user?: User | undefined;
         delegates?: {
@@ -27,24 +40,189 @@ export interface InvoiceApi {
         secretId?: SecretIdUseOption;
         alternateRootDelegateId?: string | undefined;
     }): Promise<DecryptedInvoice>;
+    /**
+     *
+     *  Attempts to extract the encryption keys of an invoice. If the user does not have access to any encryption key
+     *  of the access log the method will return an empty set.
+     *  Note: entities now have only one encryption key, but this method returns a set for compatibility with older
+     *  versions of iCure where this was not a guarantee.
+     *  @param invoice an invoice
+     *  @return the encryption keys extracted from the provided invoice.
+     */
     getEncryptionKeysOf(invoice: Invoice): Promise<Array<HexString>>;
+    /**
+     *
+     *  Specifies if the current user has write access to an invoice through delegations.
+     *  Doesn't consider actual permissions on the server side: for example, if the data owner has access to all entities
+     *  thanks to extended permission but has no delegation on the provided entity this method returns false. Similarly,
+     *  if the SDK was initialized in hierarchical mode but the user is lacking the hierarchical permission on the server
+     *  side this method will still return true if there is a delegation to the parent.
+     *  @param invoice an invoice
+     *  @return if the current user has write access to the provided invoice
+     */
     hasWriteAccess(invoice: Invoice): Promise<boolean>;
+    /**
+     *
+     *  Attempts to extract the patient id linked to an invoice.
+     *  Note: invoices usually should be linked with only one patient, but this method returns a set for compatibility
+     *  with older versions of iCure
+     *  @param invoice an invoice
+     *  @return the id of the patient linked to the invoice, or empty if the current user can't access any patient id
+     *  of the invoice.
+     */
     decryptPatientIdOf(invoice: Invoice): Promise<Array<EntityReferenceInGroup>>;
+    /**
+     *
+     *  Create metadata to allow other users to identify the anonymous delegates of an invoice.
+     *
+     *  When calling this method the SDK will use all the information available to the current user to try to identify
+     *  any anonymous data-owners in the delegations of the provided invoice. The SDK will be able to identify the
+     *  anonymous data owners of the delegations only under the following conditions:
+     *  - The other participant of the delegation is the current data owner
+     *  - The SDK is using hierarchical data owners and the other participant of the delegation is a parent of the
+     *  current data owner
+     *  - There is de-anonymization metadata for the delegation shared with the current data owner.
+     *
+     *  After identifying the anonymous delegates in the invoice the sdk will create the corresponding de-anonymization
+     *  metadata if it does not yet exist, and then share it with the provided delegates.
+     *
+     *  Note that this delegation metadata may be used to de-anonymize the corresponding delegation in any Invoice,
+     *  not only in the provided instance.
+     *
+     *  ## Example
+     *
+     *  If you have an invoice E, and you have shared it with patient P and healthcare party H, H will not
+     *  be able to know that P has access to E until you create delegations de anonymization metadata and share that with
+     *  H. From now on, for any invoice that you have shared with P, H will be able to know that the invoice was
+     *  shared with P, regardless of whether it was created before or after the corresponding de-anonymization metadata.
+     *
+     *  At the same time since the de-anonymization metadata applies to a specific delegation and therefore to a specific
+     *  delegator-delegate pair, you will not be able to see if P has access to an invoice that was created by H and
+     *  shared with you and P unless also H creates delegations de-anonymization metadata.
+     *
+     *  @param entity an invoice
+     *  @param delegates a set of data owner ids
+     */
     createDelegationDeAnonymizationMetadata(entity: Invoice, delegates: Array<string>): Promise<void>;
+    /**
+     *
+     *  Decrypts an invoice, throwing an exception if it is not possible.
+     *  @param invoice an invoice
+     *  @return the decrypted invoice
+     *  @throws EntityEncryptionException if the invoice could not be decrypted
+     */
     decrypt(invoice: EncryptedInvoice): Promise<DecryptedInvoice>;
+    /**
+     *
+     *  Tries to decrypt an invoice, returns the input if it is not possible.
+     *  @param invoice an encrypted invoice
+     *  @return the decrypted invoice if the decryption was successful or the input if it was not.
+     */
     tryDecrypt(invoice: EncryptedInvoice): Promise<Invoice>;
+    /**
+     *
+     *  Deletes an invoice. If you don't have write access to the invoice the method will fail.
+     *  @param entityId id of the invoice.
+     *  @param rev the latest known rev of the invoice to delete
+     *  @return the id and revision of the deleted invoice.
+     *  @throws RevisionConflictException if the provided revision doesn't match the latest known revision
+     */
     deleteInvoiceById(entityId: string, rev: string): Promise<StoredDocumentIdentifier>;
+    /**
+     *
+     *  Deletes many invoices. Ids that do not correspond to an entity, or that correspond to an entity for which
+     *  you don't have write access will be ignored.
+     *  @param entityIds ids and revisions of the invoices to delete.
+     *  @return the id and revision of the deleted invoices. If some entities could not be deleted (for example
+     *  because you had no write access to them) they will not be included in this list.
+     */
     deleteInvoicesByIds(entityIds: Array<StoredDocumentIdentifier>): Promise<Array<StoredDocumentIdentifier>>;
+    /**
+     *
+     *  Permanently deletes an invoice.
+     *  @param id id of the invoice to purge
+     *  @param rev latest revision of the invoice
+     *  @throws RevisionConflictException if the provided revision doesn't match the latest known revision
+     */
     purgeInvoiceById(id: string, rev: string): Promise<void>;
+    /**
+     *
+     *  Permanently deletes many invoices.
+     *  @param entityIds ids and revisions of the invoices to delete
+     *  @return the id and revision of the deleted invoices. If some entities couldn't be deleted (for example
+     *  because you had no write access to them) they will not be included in this list.
+     */
     purgeInvoicesByIds(entityIds: Array<StoredDocumentIdentifier>): Promise<Array<StoredDocumentIdentifier>>;
+    /**
+     *
+     *  Deletes an invoice. If you don't have write access to the invoice the method will fail.
+     *  @param invoice the invoice to delete
+     *  @return the id and revision of the deleted invoice.
+     *  @throws RevisionConflictException if the provided invoice doesn't match the latest known revision
+     */
     deleteInvoice(invoice: Invoice): Promise<StoredDocumentIdentifier>;
+    /**
+     *
+     *  Deletes many invoices. Ignores invoice for which you don't have write access or that don't match the latest revision.
+     *  @param invoices the invoices to delete
+     *  @return the id and revision of the deleted invoices. If some entities couldn't be deleted they will not be
+     *  included in this list.
+     */
     deleteInvoices(invoices: Array<Invoice>): Promise<Array<StoredDocumentIdentifier>>;
+    /**
+     *
+     *  Permanently deletes an invoice.
+     *  @param invoice the invoice to purge.
+     *  @throws RevisionConflictException if the provided invoice doesn't match the latest known revision
+     */
     purgeInvoice(invoice: Invoice): Promise<void>;
+    /**
+     *
+     *  Permanently deletes many invoices.
+     *  @param invoices the invoices to purge.
+     *  @return the id and revision of the deleted invoices. If some entities couldn't be deleted (for example
+     *  because you had no write access to them) they will not be included in this list.
+     */
     purgeInvoices(invoices: Array<Invoice>): Promise<Array<StoredDocumentIdentifier>>;
+    /**
+     *
+     *  Gives an approximation of the amount of times each tarification code ([Invoice.invoicingCodes] ->
+     *  [InvoicingCode.tarificationId]) is used in invoices where the current data owner is a direct delegate (does not
+     *  count situations where the data owner has access to the service through delegations to a parent data owner).
+     *  This number is not exact, and may be cached, so you should not use this method if you need precise values, but
+     *  it can be useful if you want to give suggestions.
+     *  Only codes that occur at least [minOccurrence] times will be used.
+     *  @return the occurrences for each invoicing code that is used at least [minOccurrence] times.
+     */
     getTarificationsCodesOccurrences(minOccurrence: number): Promise<Array<LabelledOccurence>>;
+    /**
+     *
+     *  Share an invoice with another data owner. The invoice must already exist in the database for this method to
+     *  succeed. If you want to share the invoice before creation you should instead pass provide the delegates in
+     *  the initialize encryption metadata method.
+     *  Note: this method only updates the security metadata. If the input entity has unsaved changes they may be lost.
+     *  @param delegateId the owner that will gain access to the invoice
+     *  @param invoice the invoice to share with [delegateId]
+     *  @param options specifies how the invoice will be shared. By default, all data available to the current user
+     *  will be shared, and the delegate will have the same permissions as the current user on the invoice. Refer
+     *  to the documentation of [InvoiceShareOptions] for more information.
+     *  @return the updated invoice if the sharing was successful, or details on the errors if the sharing failed.
+     */
     shareWith(delegateId: string, invoice: DecryptedInvoice, options?: {
         options?: InvoiceShareOptions | undefined;
     }): Promise<DecryptedInvoice>;
+    /**
+     *
+     *  Share an invoice with multiple data owners. The invoice must already exist in the database for this method to
+     *  succeed. If you want to share the invoice before creation you should instead pass provide the delegates in
+     *  the initialize encryption metadata method.
+     *  Note: this method only updates the security metadata. If the input entity has unsaved changes they may be lost.
+     *  Throws an exception if the operation fails.
+     *  @param invoice the invoice to share
+     *  @param delegates specify the data owners which will gain access to the entity and the options for sharing with
+     *  each of them.
+     *  @return the updated invoice.
+     */
     shareWithMany(invoice: DecryptedInvoice, delegates: {
         [key: string]: InvoiceShareOptions;
     }): Promise<DecryptedInvoice>;
@@ -53,15 +231,90 @@ export interface InvoiceApi {
         endDate?: number | undefined;
         descending?: boolean | undefined;
     }): Promise<PaginatedListIterator<DecryptedInvoice>>;
+    /**
+     *
+     *  Create a new invoice. The provided invoice must have the encryption metadata initialized.
+     *  @param entity an invoice with initialized encryption metadata
+     *  @return the created invoice with updated revision.
+     *  @throws IllegalArgumentException if the encryption metadata of the input was not initialized.
+     */
     createInvoice(entity: DecryptedInvoice): Promise<DecryptedInvoice>;
+    /**
+     *
+     *  Create multiple invoices. All the provided invoices must have the encryption metadata initialized, otherwise
+     *  this method fails without doing anything.
+     *  @param entities invoices with initialized encryption metadata
+     *  @return the created invoices with updated revision.
+     *  @throws IllegalArgumentException if the encryption metadata of any invoice in the input was not initialized.
+     */
     createInvoices(entities: Array<DecryptedInvoice>): Promise<Array<DecryptedInvoice>>;
+    /**
+     *
+     *  Restores an invoice that was marked as deleted.
+     *  @param id the id of the entity
+     *  @param rev the latest revision of the entity.
+     *  @return the restored entity.
+     *  @throws RevisionConflictException if the provided revision doesn't match the latest known revision
+     */
     undeleteInvoiceById(id: string, rev: string): Promise<DecryptedInvoice>;
+    /**
+     *
+     *  Restores a batch of invoiceIds that were marked as deleted.
+     *  @param entityIds the ids and the revisions of the invoiceIds to restore.
+     *  @return the restored invoiceIds. If some entities couldn't be restored (because the user does not have access or the revision is not
+     *  up-to-date), then those entities will not be restored and will not appear in this list.
+     */
     undeleteInvoicesByIds(entityIds: Array<StoredDocumentIdentifier>): Promise<Array<DecryptedInvoice>>;
+    /**
+     *
+     *  Restores an invoice that was marked as deleted.
+     *  @param invoice the invoice to undelete
+     *  @return the restored invoice.
+     *  @throws RevisionConflictException if the provided invoice doesn't match the latest known revision
+     */
     undeleteInvoice(invoice: Invoice): Promise<DecryptedInvoice>;
+    /**
+     *
+     *  Restores a batch of invoices that were marked as deleted.
+     *  @param invoices the invoices to restore.
+     *  @return the restored invoices. If some entities couldn't be restored (because the user does not have access or the revision is not
+     *  up-to-date), then those entities will not be restored and will not appear in this list.
+     */
     undeleteInvoices(invoices: Array<Invoice>): Promise<Array<DecryptedInvoice>>;
+    /**
+     *
+     *  Modifies an invoice. You need to have write access to the entity.
+     *  Flavoured method.
+     *  @param entity an invoice with update content
+     *  @return the invoice updated with the provided content and a new revision.
+     */
     modifyInvoice(entity: DecryptedInvoice): Promise<DecryptedInvoice>;
+    /**
+     *
+     *  Modifies multiple invoices. Ignores all invoices for which you don't have write access.
+     *  Flavoured method.
+     *  @param entities invoices with update content
+     *  @return the updated invoices with a new revision.
+     */
     modifyInvoices(entities: Array<DecryptedInvoice>): Promise<Array<DecryptedInvoice>>;
+    /**
+     *
+     *  Get an invoice by its id. You must have read access to the entity. Fails if the id does not correspond to any
+     *  entity, corresponds to an entity that is not an invoice, or corresponds to an entity for which you don't have
+     *  read access.
+     *  Flavoured method.
+     *  @param entityId an invoice id.
+     *  @return the invoice with id [entityId].
+     */
     getInvoice(entityId: string): Promise<DecryptedInvoice | undefined>;
+    /**
+     *
+     *  Get multiple invoices by their ids. Ignores all ids that do not correspond to an entity, correspond to
+     *  an entity that is not an invoice, or correspond to an entity for which you don't have read access.
+     *  Flavoured method.
+     *  @param entityIds a list of invoices ids
+     *  @return all invoices that you can access with one of the provided ids.
+     */
     getInvoices(entityIds: Array<string>): Promise<Array<DecryptedInvoice>>;
     reassignInvoice(invoice: DecryptedInvoice): Promise<DecryptedInvoice>;
     mergeTo(invoiceId: string, ids: Array<string>): Promise<DecryptedInvoice>;