@icure/cardinal-sdk 2.1.1 → 2.1.3

package/api/InvoiceBasicApi.d.mts

@@ -8,24 +8,166 @@ import { MediumType } from '../model/embed/MediumType.mjs';
 import { InvoiceBasicInGroupApi } from './InvoiceBasicInGroupApi.mjs';
 export interface InvoiceBasicApi {
     inGroup: InvoiceBasicInGroupApi;
+    /**
+     *
+     *  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>>;
+    /**
+     *
+     *  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: EncryptedInvoice): Promise<EncryptedInvoice>;
+    /**
+     *
+     *  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<EncryptedInvoice>): Promise<Array<EncryptedInvoice>>;
+    /**
+     *
+     *  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<EncryptedInvoice>;
+    /**
+     *
+     *  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<EncryptedInvoice>>;
+    /**
+     *
+     *  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<EncryptedInvoice>;
+    /**
+     *
+     *  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<EncryptedInvoice>>;
+    /**
+     *
+     *  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: EncryptedInvoice): Promise<EncryptedInvoice>;
+    /**
+     *
+     *  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<EncryptedInvoice>): Promise<Array<EncryptedInvoice>>;
+    /**
+     *
+     *  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<EncryptedInvoice | 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<EncryptedInvoice>>;
     reassignInvoice(invoice: EncryptedInvoice): Promise<EncryptedInvoice>;
     mergeTo(invoiceId: string, ids: Array<string>): Promise<EncryptedInvoice>;

package/api/InvoiceBasicInGroupApi.d.mts

@@ -2,22 +2,94 @@ import { GroupScoped } from '../model/GroupScoped.mjs';
 import { EncryptedInvoice, Invoice } from '../model/Invoice.mjs';
 import { StoredDocumentIdentifier } from '../model/StoredDocumentIdentifier.mjs';
 export interface InvoiceBasicInGroupApi {
+    /**
+     *
+     *  In-group version of [InvoiceBasicFlavourlessApi.deleteInvoiceById]
+     */
     deleteInvoiceById(entityId: GroupScoped<StoredDocumentIdentifier>): Promise<GroupScoped<StoredDocumentIdentifier>>;
+    /**
+     *
+     *  In-group version of [InvoiceBasicFlavourlessApi.deleteInvoicesByIds]
+     */
     deleteInvoicesByIds(entityIds: Array<GroupScoped<StoredDocumentIdentifier>>): Promise<Array<GroupScoped<StoredDocumentIdentifier>>>;
+    /**
+     *
+     *  In-group version of [InvoiceBasicFlavourlessApi.purgeInvoiceById]
+     */
     purgeInvoiceById(entityId: GroupScoped<StoredDocumentIdentifier>): Promise<void>;
+    /**
+     *
+     *  In-group version of [InvoiceBasicFlavourlessApi.purgeInvoicesByIds]
+     */
     purgeInvoicesByIds(entityIds: Array<GroupScoped<StoredDocumentIdentifier>>): Promise<Array<GroupScoped<StoredDocumentIdentifier>>>;
+    /**
+     *
+     *  In-group version of [InvoiceBasicFlavourlessApi.deleteInvoice]
+     */
     deleteInvoice(invoice: GroupScoped<Invoice>): Promise<GroupScoped<StoredDocumentIdentifier>>;
+    /**
+     *
+     *  In-group version of [InvoiceBasicFlavourlessApi.deleteInvoices]
+     */
     deleteInvoices(invoices: Array<GroupScoped<Invoice>>): Promise<Array<GroupScoped<StoredDocumentIdentifier>>>;
+    /**
+     *
+     *  In-group version of [InvoiceBasicFlavourlessApi.purgeInvoice]
+     */
     purgeInvoice(invoice: GroupScoped<Invoice>): Promise<void>;
+    /**
+     *
+     *  In-group version of [InvoiceBasicFlavourlessApi.purgeInvoices]
+     */
     purgeInvoices(invoices: Array<GroupScoped<Invoice>>): Promise<Array<GroupScoped<StoredDocumentIdentifier>>>;
+    /**
+     *
+     *  In-group version of [InvoiceApi.createInvoice]
+     */
     createInvoice(entity: GroupScoped<EncryptedInvoice>): Promise<GroupScoped<EncryptedInvoice>>;
+    /**
+     *
+     *  In-group version of [InvoiceApi.createInvoices]
+     */
     createInvoices(entities: Array<GroupScoped<EncryptedInvoice>>): Promise<Array<GroupScoped<EncryptedInvoice>>>;
+    /**
+     *
+     *  In-group version of [InvoiceBasicFlavouredApi.undeleteInvoiceById]
+     */
     undeleteInvoiceById(entityId: GroupScoped<StoredDocumentIdentifier>): Promise<GroupScoped<EncryptedInvoice>>;
+    /**
+     *
+     *  In-group version of [InvoiceBasicFlavouredApi.undeleteInvoicesByIds]
+     */
     undeleteInvoicesByIds(entityIds: Array<GroupScoped<StoredDocumentIdentifier>>): Promise<Array<GroupScoped<EncryptedInvoice>>>;
+    /**
+     *
+     *  In-group version of [InvoiceBasicFlavouredApi.undeleteInvoice]
+     */
     undeleteInvoice(invoice: GroupScoped<Invoice>): Promise<GroupScoped<EncryptedInvoice>>;
+    /**
+     *
+     *  In-group version of [InvoiceBasicFlavouredApi.undeleteInvoices]
+     */
     undeleteInvoices(invoices: Array<GroupScoped<EncryptedInvoice>>): Promise<Array<GroupScoped<EncryptedInvoice>>>;
+    /**
+     *
+     *  In-group version of [InvoiceBasicFlavouredApi.modifyInvoice]
+     */
     modifyInvoice(entity: GroupScoped<EncryptedInvoice>): Promise<GroupScoped<EncryptedInvoice>>;
+    /**
+     *
+     *  In-group version of [InvoiceBasicFlavouredApi.modifyInvoices]
+     */
     modifyInvoices(entities: Array<GroupScoped<EncryptedInvoice>>): Promise<Array<GroupScoped<EncryptedInvoice>>>;
+    /**
+     *
+     *  In-group version of [InvoiceBasicFlavouredApi.getInvoice]
+     */
     getInvoice(groupId: string, entityId: string): Promise<GroupScoped<EncryptedInvoice> | undefined>;
+    /**
+     *
+     *  In-group version of [InvoiceBasicFlavouredApi.getInvoices]
+     */
     getInvoices(groupId: string, entityIds: Array<string>): Promise<Array<GroupScoped<EncryptedInvoice>>>;
 }

package/api/InvoiceFlavouredApi.d.mts

@@ -8,9 +8,34 @@ import { InvoiceType } from '../model/embed/InvoiceType.mjs';
 import { EncryptedInvoicingCode } from '../model/embed/InvoicingCode.mjs';
 import { MediumType } from '../model/embed/MediumType.mjs';
 export interface InvoiceFlavouredApi<E extends Invoice> {
+    /**
+     *
+     *  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: E, options?: {
         options?: InvoiceShareOptions | undefined;
     }): Promise<E>;
+    /**
+     *
+     *  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: E, delegates: {
         [key: string]: InvoiceShareOptions;
     }): Promise<E>;
@@ -19,15 +44,90 @@ export interface InvoiceFlavouredApi<E extends Invoice> {
         endDate?: number | undefined;
         descending?: boolean | undefined;
     }): Promise<PaginatedListIterator<E>>;
+    /**
+     *
+     *  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: E): Promise<E>;
+    /**
+     *
+     *  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<E>): Promise<Array<E>>;
+    /**
+     *
+     *  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<E>;
+    /**
+     *
+     *  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<E>>;
+    /**
+     *
+     *  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<E>;
+    /**
+     *
+     *  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<E>>;
+    /**
+     *
+     *  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: E): Promise<E>;
+    /**
+     *
+     *  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<E>): Promise<Array<E>>;
+    /**
+     *
+     *  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<E | 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<E>>;
     reassignInvoice(invoice: E): Promise<E>;
     mergeTo(invoiceId: string, ids: Array<string>): Promise<E>;

package/api/InvoiceFlavouredInGroupApi.d.mts

@@ -5,21 +5,69 @@ import { Invoice } from '../model/Invoice.mjs';
 import { StoredDocumentIdentifier } from '../model/StoredDocumentIdentifier.mjs';
 import { ArrayWithUniqueKeys } from '../utils/ArrayWithUniqueKeys.mjs';
 export interface InvoiceFlavouredInGroupApi<E extends Invoice> {
+    /**
+     *
+     *  In-group version of [InvoiceFlavouredApi.shareWith]
+     */
     shareWith(delegate: EntityReferenceInGroup, invoice: GroupScoped<E>, options?: {
         options?: InvoiceShareOptions | undefined;
     }): Promise<GroupScoped<E>>;
+    /**
+     *
+     *  In-group version of [InvoiceFlavouredApi.shareWithMany]
+     */
     shareWithMany(invoice: GroupScoped<E>, delegates: ArrayWithUniqueKeys<{
         delegate: EntityReferenceInGroup;
         shareOptions: InvoiceShareOptions;
     }, 'delegate'>): Promise<GroupScoped<E>>;
+    /**
+     *
+     *  In-group version of [InvoiceApi.createInvoice]
+     */
     createInvoice(entity: GroupScoped<E>): Promise<GroupScoped<E>>;
+    /**
+     *
+     *  In-group version of [InvoiceApi.createInvoices]
+     */
     createInvoices(entities: Array<GroupScoped<E>>): Promise<Array<GroupScoped<E>>>;
+    /**
+     *
+     *  In-group version of [InvoiceBasicFlavouredApi.undeleteInvoiceById]
+     */
     undeleteInvoiceById(entityId: GroupScoped<StoredDocumentIdentifier>): Promise<GroupScoped<E>>;
+    /**
+     *
+     *  In-group version of [InvoiceBasicFlavouredApi.undeleteInvoicesByIds]
+     */
     undeleteInvoicesByIds(entityIds: Array<GroupScoped<StoredDocumentIdentifier>>): Promise<Array<GroupScoped<E>>>;
+    /**
+     *
+     *  In-group version of [InvoiceBasicFlavouredApi.undeleteInvoice]
+     */
     undeleteInvoice(invoice: GroupScoped<Invoice>): Promise<GroupScoped<E>>;
+    /**
+     *
+     *  In-group version of [InvoiceBasicFlavouredApi.undeleteInvoices]
+     */
     undeleteInvoices(invoices: Array<GroupScoped<E>>): Promise<Array<GroupScoped<E>>>;
+    /**
+     *
+     *  In-group version of [InvoiceBasicFlavouredApi.modifyInvoice]
+     */
     modifyInvoice(entity: GroupScoped<E>): Promise<GroupScoped<E>>;
+    /**
+     *
+     *  In-group version of [InvoiceBasicFlavouredApi.modifyInvoices]
+     */
     modifyInvoices(entities: Array<GroupScoped<E>>): Promise<Array<GroupScoped<E>>>;
+    /**
+     *
+     *  In-group version of [InvoiceBasicFlavouredApi.getInvoice]
+     */
     getInvoice(groupId: string, entityId: string): Promise<GroupScoped<E> | undefined>;
+    /**
+     *
+     *  In-group version of [InvoiceBasicFlavouredApi.getInvoices]
+     */
     getInvoices(groupId: string, entityIds: Array<string>): Promise<Array<GroupScoped<E>>>;
 }

package/api/InvoiceInGroupApi.d.mts

@@ -13,6 +13,10 @@ import { InvoiceFlavouredInGroupApi } from './InvoiceFlavouredInGroupApi.mjs';
 export interface InvoiceInGroupApi {
     encrypted: InvoiceFlavouredInGroupApi<EncryptedInvoice>;
     tryAndRecover: InvoiceFlavouredInGroupApi<Invoice>;
+    /**
+     *
+     *  In-group version of [InvoiceApi.withEncryptionMetadata]
+     */
     withEncryptionMetadata(entityGroupId: string, base: DecryptedInvoice | undefined, patient: GroupScoped<Patient> | undefined, options?: {
         user?: User | undefined;
         delegates?: ArrayWithUniqueKeys<{
@@ -22,35 +26,139 @@ export interface InvoiceInGroupApi {
         secretId?: SecretIdUseOption;
         alternateRootDelegateReference?: EntityReferenceInGroup | undefined;
     }): Promise<GroupScoped<DecryptedInvoice>>;
+    /**
+     *
+     *  In-group version of [InvoiceApi.getEncryptionKeysOf]
+     */
     getEncryptionKeysOf(invoice: GroupScoped<Invoice>): Promise<Array<HexString>>;
+    /**
+     *
+     *  In-group version of [InvoiceApi.hasWriteAccess]
+     */
     hasWriteAccess(invoice: GroupScoped<Invoice>): Promise<boolean>;
+    /**
+     *
+     *  In-group version of [InvoiceApi.decryptPatientIdOf]
+     */
     decryptPatientIdOf(invoice: GroupScoped<Invoice>): Promise<Array<EntityReferenceInGroup>>;
+    /**
+     *
+     *  In-group version of [InvoiceApi.createDelegationDeAnonymizationMetadata]
+     */
     createDelegationDeAnonymizationMetadata(entity: GroupScoped<Invoice>, delegates: Array<EntityReferenceInGroup>): Promise<void>;
+    /**
+     *
+     *  In-group version of [InvoiceApi.decrypt]
+     */
     decrypt(invoices: Array<GroupScoped<EncryptedInvoice>>): Promise<Array<GroupScoped<DecryptedInvoice>>>;
+    /**
+     *
+     *  In-group version of [InvoiceApi.tryDecrypt]
+     */
     tryDecrypt(invoices: Array<GroupScoped<EncryptedInvoice>>): Promise<Array<GroupScoped<Invoice>>>;
+    /**
+     *
+     *  In-group version of [InvoiceBasicFlavourlessApi.deleteInvoiceById]
+     */
     deleteInvoiceById(entityId: GroupScoped<StoredDocumentIdentifier>): Promise<GroupScoped<StoredDocumentIdentifier>>;
+    /**
+     *
+     *  In-group version of [InvoiceBasicFlavourlessApi.deleteInvoicesByIds]
+     */
     deleteInvoicesByIds(entityIds: Array<GroupScoped<StoredDocumentIdentifier>>): Promise<Array<GroupScoped<StoredDocumentIdentifier>>>;
+    /**
+     *
+     *  In-group version of [InvoiceBasicFlavourlessApi.purgeInvoiceById]
+     */
     purgeInvoiceById(entityId: GroupScoped<StoredDocumentIdentifier>): Promise<void>;
+    /**
+     *
+     *  In-group version of [InvoiceBasicFlavourlessApi.purgeInvoicesByIds]
+     */
     purgeInvoicesByIds(entityIds: Array<GroupScoped<StoredDocumentIdentifier>>): Promise<Array<GroupScoped<StoredDocumentIdentifier>>>;
+    /**
+     *
+     *  In-group version of [InvoiceBasicFlavourlessApi.deleteInvoice]
+     */
     deleteInvoice(invoice: GroupScoped<Invoice>): Promise<GroupScoped<StoredDocumentIdentifier>>;
+    /**
+     *
+     *  In-group version of [InvoiceBasicFlavourlessApi.deleteInvoices]
+     */
     deleteInvoices(invoices: Array<GroupScoped<Invoice>>): Promise<Array<GroupScoped<StoredDocumentIdentifier>>>;
+    /**
+     *
+     *  In-group version of [InvoiceBasicFlavourlessApi.purgeInvoice]
+     */
     purgeInvoice(invoice: GroupScoped<Invoice>): Promise<void>;
+    /**
+     *
+     *  In-group version of [InvoiceBasicFlavourlessApi.purgeInvoices]
+     */
     purgeInvoices(invoices: Array<GroupScoped<Invoice>>): Promise<Array<GroupScoped<StoredDocumentIdentifier>>>;
+    /**
+     *
+     *  In-group version of [InvoiceFlavouredApi.shareWith]
+     */
     shareWith(delegate: EntityReferenceInGroup, invoice: GroupScoped<DecryptedInvoice>, options?: {
         options?: InvoiceShareOptions | undefined;
     }): Promise<GroupScoped<DecryptedInvoice>>;
+    /**
+     *
+     *  In-group version of [InvoiceFlavouredApi.shareWithMany]
+     */
     shareWithMany(invoice: GroupScoped<DecryptedInvoice>, delegates: ArrayWithUniqueKeys<{
         delegate: EntityReferenceInGroup;
         shareOptions: InvoiceShareOptions;
     }, 'delegate'>): Promise<GroupScoped<DecryptedInvoice>>;
+    /**
+     *
+     *  In-group version of [InvoiceApi.createInvoice]
+     */
     createInvoice(entity: GroupScoped<DecryptedInvoice>): Promise<GroupScoped<DecryptedInvoice>>;
+    /**
+     *
+     *  In-group version of [InvoiceApi.createInvoices]
+     */
     createInvoices(entities: Array<GroupScoped<DecryptedInvoice>>): Promise<Array<GroupScoped<DecryptedInvoice>>>;
+    /**
+     *
+     *  In-group version of [InvoiceBasicFlavouredApi.undeleteInvoiceById]
+     */
     undeleteInvoiceById(entityId: GroupScoped<StoredDocumentIdentifier>): Promise<GroupScoped<DecryptedInvoice>>;
+    /**
+     *
+     *  In-group version of [InvoiceBasicFlavouredApi.undeleteInvoicesByIds]
+     */
     undeleteInvoicesByIds(entityIds: Array<GroupScoped<StoredDocumentIdentifier>>): Promise<Array<GroupScoped<DecryptedInvoice>>>;
+    /**
+     *
+     *  In-group version of [InvoiceBasicFlavouredApi.undeleteInvoice]
+     */
     undeleteInvoice(invoice: GroupScoped<Invoice>): Promise<GroupScoped<DecryptedInvoice>>;
+    /**
+     *
+     *  In-group version of [InvoiceBasicFlavouredApi.undeleteInvoices]
+     */
     undeleteInvoices(invoices: Array<GroupScoped<DecryptedInvoice>>): Promise<Array<GroupScoped<DecryptedInvoice>>>;
+    /**
+     *
+     *  In-group version of [InvoiceBasicFlavouredApi.modifyInvoice]
+     */
     modifyInvoice(entity: GroupScoped<DecryptedInvoice>): Promise<GroupScoped<DecryptedInvoice>>;
+    /**
+     *
+     *  In-group version of [InvoiceBasicFlavouredApi.modifyInvoices]
+     */
     modifyInvoices(entities: Array<GroupScoped<DecryptedInvoice>>): Promise<Array<GroupScoped<DecryptedInvoice>>>;
+    /**
+     *
+     *  In-group version of [InvoiceBasicFlavouredApi.getInvoice]
+     */
     getInvoice(groupId: string, entityId: string): Promise<GroupScoped<DecryptedInvoice> | undefined>;
+    /**
+     *
+     *  In-group version of [InvoiceBasicFlavouredApi.getInvoices]
+     */
     getInvoices(groupId: string, entityIds: Array<string>): Promise<Array<GroupScoped<DecryptedInvoice>>>;
 }