@icure/cardinal-sdk 2.1.1 → 2.1.3

package/api/ContactBasicApi.d.mts

@@ -9,38 +9,306 @@ import { SubscriptionEventType } from '../subscription/SubscriptionEventType.mjs
 import { ContactBasicInGroupApi } from './ContactBasicInGroupApi.mjs';
 export interface ContactBasicApi {
     inGroup: ContactBasicInGroupApi;
+    /**
+     *
+     *  Get the ids of all contacts matching the provided filter.
+     *
+     *  This method does not guarantee that the returned data will be ordered when using sortable filter options.
+     *  Even if the data obtained from an invocation of the method appears to be ordered, any changes to the stored data,
+     *  or to the internal iCure implementations, may cause future invocations to return unordered data.
+     *  If you need ordered data use [matchContactsBySorted] instead.
+     *
+     *  @param filter a contact filter
+     *  @return a list of contact ids
+     */
     matchContactsBy(filter: BaseFilterOptions<Contact>): Promise<Array<string>>;
+    /**
+     *
+     *  Get the ids of all services matching the provided filter.
+     *
+     *  This method does not guarantee that the returned data will be ordered when using sortable filter options.
+     *  Even if the data obtained from an invocation of the method appears to be ordered, any changes to the stored data,
+     *  or to the internal iCure implementations, may cause future invocations to return unordered data.
+     *  If you need ordered data use [matchServicesBySorted] instead.
+     *
+     *  @param filter a service filter
+     *  @return a list of service ids
+     */
     matchServicesBy(filter: BaseFilterOptions<Service>): Promise<Array<string>>;
+    /**
+     *
+     *  Get the ids of all contacts matching the provided filter.
+     *
+     *  This method guarantees that the returned data will be ordered using the rules specified by the provided filter,
+     *  but the operation may take longer than [matchContactsBy].
+     *
+     *  @param filter a contact filter
+     *  @return a list of contact ids
+     */
     matchContactsBySorted(filter: BaseSortableFilterOptions<Contact>): Promise<Array<string>>;
+    /**
+     *
+     *  Get the ids of all services matching the provided filter.
+     *
+     *  This method guarantees that the returned data will be ordered using the rules specified by the provided filter,
+     *  but the operation may take longer than [matchServicesBy].
+     *
+     *  @param filter a service filter
+     *  @return a list of service ids
+     */
     matchServicesBySorted(filter: BaseSortableFilterOptions<Service>): Promise<Array<string>>;
+    /**
+     *
+     *  Get an iterator that iterates through all contacts matching the provided filter, executing multiple requests to
+     *  the api if needed.
+     *
+     *  This method does not guarantee that the returned data will be ordered when using sortable filter options.
+     *  Even if the data obtained from an invocation of the method appears to be ordered, any changes to the stored data,
+     *  or to the internal iCure implementations, may cause future invocations to return unordered data.
+     *  If you need ordered data use [filterContactsBySorted] instead.
+     *
+     *  @param filter a contact filter
+     *  @return an iterator that iterates over all contacts matching the provided filter.
+     */
     filterContactsBy(filter: BaseFilterOptions<Contact>): Promise<PaginatedListIterator<EncryptedContact>>;
+    /**
+     *
+     *  Get an iterator that iterates through all services matching the provided filter, executing multiple requests to
+     *  the api if needed.
+     *
+     *  This method does not guarantee that the returned data will be ordered when using sortable filter options.
+     *  Even if the data obtained from an invocation of the method appears to be ordered, any changes to the stored data,
+     *  or to the internal iCure implementations, may cause future invocations to return unordered data.
+     *  If you need ordered data use [filterServicesBySorted] instead.
+     *
+     *  @param filter a service filter
+     *  @return an iterator that iterates over all services matching the provided filter.
+     */
     filterServicesBy(filter: BaseFilterOptions<Service>): Promise<PaginatedListIterator<EncryptedService>>;
+    /**
+     *
+     *  Get an iterator that iterates through all contacts matching the provided filter, executing multiple requests to
+     *  the api if needed.
+     *
+     *  This method guarantees that the returned data will be ordered using the rules specified by the provided filter,
+     *  but the operation may take longer than [filterContactsBy].
+     *
+     *  @param filter a contact filter
+     *  @return an iterator that iterates over all contacts matching the provided filter.
+     */
     filterContactsBySorted(filter: BaseSortableFilterOptions<Contact>): Promise<PaginatedListIterator<EncryptedContact>>;
+    /**
+     *
+     *  Get an iterator that iterates through all services matching the provided filter, executing multiple requests to
+     *  the api if needed.
+     *
+     *  This method guarantees that the returned data will be ordered using the rules specified by the provided filter,
+     *  but the operation may take longer than [filterServicesBy].
+     *
+     *  @param filter a service filter
+     *  @return an iterator that iterates over all services matching the provided filter.
+     */
     filterServicesBySorted(filter: BaseSortableFilterOptions<Service>): Promise<PaginatedListIterator<EncryptedService>>;
+    /**
+     *
+     *  Subscribe to creation and update events on Services. Unlike other entity events subscription methods for services
+     *  you all subscription will be notified of both creation and update events.
+     *  @param filter only events for services matching this filter will be notified
+     *  @param subscriptionConfig customize the subscription configuration
+     *  @return a subscription that receives notifications for creation or update of services.
+     */
     subscribeToServiceCreateOrUpdateEvents(filter: BaseFilterOptions<Service>, options?: {
         subscriptionConfig?: EntitySubscriptionConfiguration | undefined;
     }): Promise<EntitySubscription<EncryptedService>>;
+    /**
+     *
+     *  Deletes a contact. If you don't have write access to the contact the method will fail.
+     *  @param entityId id of the contact.
+     *  @param rev the latest known rev of the contact to delete
+     *  @return the id and revision of the deleted contact.
+     *  @throws RevisionConflictException if the provided revision doesn't match the latest known revision
+     */
     deleteContactById(entityId: string, rev: string): Promise<StoredDocumentIdentifier>;
+    /**
+     *
+     *  Deletes many contacts. Ids that don't 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 contacts to delete.
+     *  @return the id and revision of the deleted contacts. 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.
+     */
     deleteContactsByIds(entityIds: Array<StoredDocumentIdentifier>): Promise<Array<StoredDocumentIdentifier>>;
+    /**
+     *
+     *  Permanently deletes a contact.
+     *  @param id id of the contact to purge
+     *  @param rev latest revision of the contact
+     *  @throws RevisionConflictException if the provided revision doesn't match the latest known revision
+     */
     purgeContactById(id: string, rev: string): Promise<void>;
+    /**
+     *
+     *  Permanently deletes many contacts.
+     *  @param entityIds ids and revisions of the contacts to delete
+     *  @return the id and revision of the deleted contacts. 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.
+     */
     purgeContactsByIds(entityIds: Array<StoredDocumentIdentifier>): Promise<Array<StoredDocumentIdentifier>>;
+    /**
+     *
+     *  Deletes a contact. If you don't have write access to the contact the method will fail.
+     *  @param contact the contact to delete
+     *  @return the id and revision of the deleted contact.
+     *  @throws RevisionConflictException if the provided contact doesn't match the latest known revision
+     */
     deleteContact(contact: Contact): Promise<StoredDocumentIdentifier>;
+    /**
+     *
+     *  Deletes many contacts. Ignores contact for which you don't have write access or that don't match the latest revision.
+     *  @param contacts the contacts to delete
+     *  @return the id and revision of the deleted contacts. If some entities couldn't be deleted they will not be
+     *  included in this list.
+     */
     deleteContacts(contacts: Array<Contact>): Promise<Array<StoredDocumentIdentifier>>;
+    /**
+     *
+     *  Permanently deletes a contact.
+     *  @param contact the contact to purge.
+     *  @throws RevisionConflictException if the provided contact doesn't match the latest known revision
+     */
     purgeContact(contact: Contact): Promise<void>;
+    /**
+     *
+     *  Permanently deletes many contacts.
+     *  @param contacts the contacts to delete
+     *  @return the id and revision of the deleted contacts. 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.
+     */
     purgeContacts(contacts: Array<Contact>): Promise<Array<StoredDocumentIdentifier>>;
+    /**
+     *
+     *  Gives an approximation of the amount of times each code of type [codeType] is used in services 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 [minOccurrences] times will be used.
+     *  @return the occurrences for codes of type [codeType] in services.
+     */
     getServiceCodesOccurrences(codeType: string, minOccurrences: number): Promise<Array<LabelledOccurence>>;
+    /**
+     *
+     *  Create a new contact. The provided contact must have the encryption metadata initialized.
+     *  @param entity a contact with initialized encryption metadata
+     *  @return the created contact with updated revision.
+     *  @throws IllegalArgumentException if the encryption metadata of the input was not initialized.
+     */
     createContact(entity: EncryptedContact): Promise<EncryptedContact>;
+    /**
+     *
+     *  Create multiple contacts. All the provided contacts must have the encryption metadata initialized, otherwise
+     *  this method fails without doing anything.
+     *  @param entities contacts with initialized encryption metadata
+     *  @return the created contacts with updated revision.
+     *  @throws IllegalArgumentException if the encryption metadata of any contact in the input was not initialized.
+     */
     createContacts(entities: Array<EncryptedContact>): Promise<Array<EncryptedContact>>;
+    /**
+     *
+     *  Restores a contact 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
+     */
     undeleteContactById(id: string, rev: string): Promise<EncryptedContact>;
+    /**
+     *
+     *  Restores a batch of contacts that were marked as deleted.
+     *  @param entityIds the ids and the revisions of the contacts to restore.
+     *  @return the restored contacts. 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.
+     */
     undeleteContactsByIds(entityIds: Array<StoredDocumentIdentifier>): Promise<Array<EncryptedContact>>;
+    /**
+     *
+     *  Restores a contact that was marked as deleted.
+     *  @param contact the contact to undelete
+     *  @return the restored contact.
+     *  @throws RevisionConflictException if the provided contact doesn't match the latest known revision
+     */
     undeleteContact(contact: Contact): Promise<EncryptedContact>;
+    /**
+     *
+     *  Restores a batch of contacts that were marked as deleted.
+     *  @param contacts the contacts to restore.
+     *  @return the restored contacts. 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.
+     */
     undeleteContacts(contacts: Array<Contact>): Promise<Array<EncryptedContact>>;
+    /**
+     *
+     *  Modifies a contact. You need to have write access to the entity.
+     *  Flavoured method.
+     *  @param entity a contact with update content
+     *  @return the contact updated with the provided content and a new revision.
+     */
     modifyContact(entity: EncryptedContact): Promise<EncryptedContact>;
+    /**
+     *
+     *  Modifies multiple contacts. Ignores all contacts for which you don't have write access.
+     *  Flavoured method.
+     *  @param entities contacts with update content
+     *  @return the updated contacts with a new revision.
+     */
     modifyContacts(entities: Array<EncryptedContact>): Promise<Array<EncryptedContact>>;
+    /**
+     *
+     *  Get a contact 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 a contact, or corresponds to an entity for which you don't have
+     *  read access.
+     *  Flavoured method.
+     *  @param entityId a contact id.
+     *  @return the contact with id [entityId].
+     */
     getContact(entityId: string): Promise<EncryptedContact | undefined>;
+    /**
+     *
+     *  Get multiple contacts by their ids. Ignores all ids that do not correspond to an entity, correspond to
+     *  an entity that is not a contact, or correspond to an entity for which you don't have read access.
+     *  Flavoured method.
+     *  @param entityIds a list of contacts ids
+     *  @return all contacts that you can access with one of the provided ids.
+     */
     getContacts(entityIds: Array<string>): Promise<Array<EncryptedContact>>;
+    /**
+     *
+     *  Get a service 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 a service, or corresponds to an entity for which you don't have
+     *  read access.
+     *  Flavoured method.
+     *  @param serviceId a service id
+     *  @return the service with id [serviceId].
+     */
     getService(serviceId: string): Promise<EncryptedService | undefined>;
+    /**
+     *
+     *  Get multiple services by their ids. Ignores all ids that do not correspond to an entity, correspond to
+     *  an entity that is not a services, or correspond to an entity for which you don't have read access.
+     *  Flavoured method.
+     *  @param entityIds a list of service ids
+     *  @return all services that you can access with one of the provided ids.
+     */
     getServices(entityIds: Array<string>): Promise<Array<EncryptedService>>;
+    /**
+     *
+     *  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: BaseFilterOptions<Contact>, options?: {
         subscriptionConfig?: EntitySubscriptionConfiguration | undefined;
     }): Promise<EntitySubscription<EncryptedContact>>;

package/api/ContactBasicInGroupApi.d.mts

@@ -4,32 +4,144 @@ import { GroupScoped } from '../model/GroupScoped.mjs';
 import { StoredDocumentIdentifier } from '../model/StoredDocumentIdentifier.mjs';
 import { EncryptedService, Service } from '../model/embed/Service.mjs';
 export interface ContactBasicInGroupApi {
+    /**
+     *
+     *  In-group version of [ContactBasicApi.matchContactsBy]
+     */
     matchContactsBy(groupId: string, filter: BaseFilterOptions<Contact>): Promise<Array<string>>;
+    /**
+     *
+     *  In-group version of [ContactBasicApi.matchContactsBySorted]
+     */
     matchContactsBySorted(groupId: string, filter: BaseSortableFilterOptions<Contact>): Promise<Array<string>>;
+    /**
+     *
+     *  In-group version of [ContactBasicApi.matchServicesBy]
+     */
     matchServicesBy(groupId: string, filter: BaseFilterOptions<Service>): Promise<Array<string>>;
+    /**
+     *
+     *  In-group version of [ContactBasicApi.matchServicesBySorted]
+     */
     matchServicesBySorted(groupId: string, filter: BaseSortableFilterOptions<Service>): Promise<Array<string>>;
+    /**
+     *
+     *  In-group version of [ContactBasicApi.filterContactsBy]
+     */
     filterContactsBy(groupId: string, filter: BaseFilterOptions<Contact>): Promise<PaginatedListIterator<GroupScoped<EncryptedContact>>>;
+    /**
+     *
+     *  In-group version of [ContactBasicApi.filterContactsBySorted]
+     */
     filterContactsBySorted(groupId: string, filter: BaseSortableFilterOptions<Contact>): Promise<PaginatedListIterator<GroupScoped<EncryptedContact>>>;
+    /**
+     *
+     *  In-group version of [ContactBasicApi.filterServicesBy]
+     */
     filterServicesBy(groupId: string, filter: BaseFilterOptions<Service>): Promise<PaginatedListIterator<GroupScoped<EncryptedService>>>;
+    /**
+     *
+     *  In-group version of [ContactBasicApi.filterServicesBySorted]
+     */
     filterServicesBySorted(groupId: string, filter: BaseSortableFilterOptions<Service>): Promise<PaginatedListIterator<GroupScoped<EncryptedService>>>;
+    /**
+     *
+     *  In-group version of [ContactBasicFlavourlessApi.deleteContactById]
+     */
     deleteContactById(entityId: GroupScoped<StoredDocumentIdentifier>): Promise<GroupScoped<StoredDocumentIdentifier>>;
+    /**
+     *
+     *  In-group version of [ContactBasicFlavourlessApi.deleteContactsByIds]
+     */
     deleteContactsByIds(entityIds: Array<GroupScoped<StoredDocumentIdentifier>>): Promise<Array<GroupScoped<StoredDocumentIdentifier>>>;
+    /**
+     *
+     *  In-group version of [ContactBasicFlavourlessApi.purgeContactById]
+     */
     purgeContactById(entityId: GroupScoped<StoredDocumentIdentifier>): Promise<void>;
+    /**
+     *
+     *  In-group version of [ContactBasicFlavourlessApi.purgeContactsByIds]
+     */
     purgeContactsByIds(entityIds: Array<GroupScoped<StoredDocumentIdentifier>>): Promise<Array<GroupScoped<StoredDocumentIdentifier>>>;
+    /**
+     *
+     *  In-group version of [ContactBasicFlavourlessApi.deleteContact]
+     */
     deleteContact(contact: GroupScoped<Contact>): Promise<GroupScoped<StoredDocumentIdentifier>>;
+    /**
+     *
+     *  In-group version of [ContactBasicFlavourlessApi.deleteContacts]
+     */
     deleteContacts(contacts: Array<GroupScoped<Contact>>): Promise<Array<GroupScoped<StoredDocumentIdentifier>>>;
+    /**
+     *
+     *  In-group version of [ContactBasicFlavourlessApi.purgeContact]
+     */
     purgeContact(contact: GroupScoped<Contact>): Promise<void>;
+    /**
+     *
+     *  In-group version of [ContactBasicFlavourlessApi.purgeContacts]
+     */
     purgeContacts(contacts: Array<GroupScoped<Contact>>): Promise<Array<GroupScoped<StoredDocumentIdentifier>>>;
+    /**
+     *
+     *  In-group version of [ContactBasicFlavouredApi.createContact].
+     */
     createContact(entity: GroupScoped<EncryptedContact>): Promise<GroupScoped<EncryptedContact>>;
+    /**
+     *
+     *  In-group version of [ContactBasicFlavouredApi.createContacts].
+     */
     createContacts(entities: Array<GroupScoped<EncryptedContact>>): Promise<Array<GroupScoped<EncryptedContact>>>;
+    /**
+     *
+     *  In-group version of [ContactBasicFlavouredApi.undeleteContactById]
+     */
     undeleteContactById(entityId: GroupScoped<StoredDocumentIdentifier>): Promise<GroupScoped<EncryptedContact>>;
+    /**
+     *
+     *  In-group version of [ContactBasicFlavouredApi.undeleteContactsByIds]
+     */
     undeleteContactsByIds(entityIds: Array<GroupScoped<StoredDocumentIdentifier>>): Promise<Array<GroupScoped<EncryptedContact>>>;
+    /**
+     *
+     *  In-group version of [ContactBasicFlavouredApi.undeleteContact]
+     */
     undeleteContact(contact: GroupScoped<Contact>): Promise<GroupScoped<EncryptedContact>>;
+    /**
+     *
+     *  In-group version of [ContactBasicFlavouredApi.undeleteContacts]
+     */
     undeleteContacts(contacts: Array<GroupScoped<EncryptedContact>>): Promise<Array<GroupScoped<EncryptedContact>>>;
+    /**
+     *
+     *  In-group version of [ContactBasicFlavouredApi.modifyContact]
+     */
     modifyContact(entity: GroupScoped<EncryptedContact>): Promise<GroupScoped<EncryptedContact>>;
+    /**
+     *
+     *  In-group version of [ContactBasicFlavouredApi.modifyContacts]
+     */
     modifyContacts(entities: Array<GroupScoped<EncryptedContact>>): Promise<Array<GroupScoped<EncryptedContact>>>;
+    /**
+     *
+     *  In-group version of [ContactBasicFlavouredApi.getContact]
+     */
     getContact(groupId: string, entityId: string): Promise<GroupScoped<EncryptedContact> | undefined>;
+    /**
+     *
+     *  In-group version of [ContactBasicFlavouredApi.getContacts]
+     */
     getContacts(groupId: string, entityIds: Array<string>): Promise<Array<GroupScoped<EncryptedContact>>>;
+    /**
+     *
+     *  In-group version of [ContactBasicFlavouredApi.getService]
+     */
     getService(groupId: string, serviceId: string): Promise<GroupScoped<EncryptedService> | undefined>;
+    /**
+     *
+     *  In-group version of [ContactBasicFlavouredApi.getServices]
+     */
     getServices(groupId: string, entityIds: Array<string>): Promise<Array<GroupScoped<EncryptedService>>>;
 }

package/api/ContactFlavouredApi.d.mts

@@ -4,26 +4,191 @@ import { Contact } from '../model/Contact.mjs';
 import { StoredDocumentIdentifier } from '../model/StoredDocumentIdentifier.mjs';
 import { Service } from '../model/embed/Service.mjs';
 export interface ContactFlavouredApi<E extends Contact, S extends Service> {
+    /**
+     *
+     *  Share a contact with another data owner. The contact must already exist in the database for this method to
+     *  succeed. If you want to share the contact 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 contact
+     *  @param contact the contact to share with [delegateId]
+     *  @param options specifies how the contact 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 contact. Refer
+     *  to the documentation of [ContactShareOptions] for more information.
+     *  @return the updated contact if the sharing was successful, or details on the errors if the sharing failed.
+     */
     shareWith(delegateId: string, contact: E, options?: {
         options?: ContactShareOptions | undefined;
     }): Promise<E>;
+    /**
+     *
+     *  Share a contact with multiple data owners. The contact must already exist in the database for this method to
+     *  succeed. If you want to share the contact 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 contact the contact 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 contact.
+     */
     shareWithMany(contact: E, delegates: {
         [key: string]: ContactShareOptions;
     }): Promise<E>;
+    /**
+     *
+     *  Get an iterator that iterates through all contacts matching the provided filter, executing multiple requests to
+     *  the api if needed.
+     *
+     *  This method does not guarantee that the returned data will be ordered when using sortable filter options.
+     *  Even if the data obtained from an invocation of the method appears to be ordered, any changes to the stored data,
+     *  or to the internal iCure implementations, may cause future invocations to return unordered data.
+     *  If you need ordered data use [filterContactsBySorted] instead.
+     *
+     *  @param filter a contact filter
+     *  @return an iterator that iterates over all contacts matching the provided filter.
+     */
     filterContactsBy(filter: FilterOptions<Contact>): Promise<PaginatedListIterator<E>>;
+    /**
+     *
+     *  Get an iterator that iterates through all services matching the provided filter, executing multiple requests to
+     *  the api if needed.
+     *
+     *  This method does not guarantee that the returned data will be ordered when using sortable filter options.
+     *  Even if the data obtained from an invocation of the method appears to be ordered, any changes to the stored data,
+     *  or to the internal iCure implementations, may cause future invocations to return unordered data.
+     *  If you need ordered data use [filterServicesBySorted] instead.
+     *
+     *  @param filter a service filter
+     *  @return an iterator that iterates over all services matching the provided filter.
+     */
     filterServicesBy(filter: FilterOptions<Service>): Promise<PaginatedListIterator<S>>;
+    /**
+     *
+     *  Get an iterator that iterates through all contacts matching the provided filter, executing multiple requests to
+     *  the api if needed.
+     *
+     *  This method guarantees that the returned data will be ordered using the rules specified by the provided filter,
+     *  but the operation may take longer than [filterContactsBy].
+     *
+     *  @param filter a contact filter
+     *  @return an iterator that iterates over all contacts matching the provided filter.
+     */
     filterContactsBySorted(filter: SortableFilterOptions<Contact>): Promise<PaginatedListIterator<E>>;
+    /**
+     *
+     *  Get an iterator that iterates through all services matching the provided filter, executing multiple requests to
+     *  the api if needed.
+     *
+     *  This method guarantees that the returned data will be ordered using the rules specified by the provided filter,
+     *  but the operation may take longer than [filterServicesBy].
+     *
+     *  @param filter a service filter
+     *  @return an iterator that iterates over all services matching the provided filter.
+     */
     filterServicesBySorted(filter: SortableFilterOptions<Service>): Promise<PaginatedListIterator<S>>;
+    /**
+     *
+     *  Create a new contact. The provided contact must have the encryption metadata initialized.
+     *  @param entity a contact with initialized encryption metadata
+     *  @return the created contact with updated revision.
+     *  @throws IllegalArgumentException if the encryption metadata of the input was not initialized.
+     */
     createContact(entity: E): Promise<E>;
+    /**
+     *
+     *  Create multiple contacts. All the provided contacts must have the encryption metadata initialized, otherwise
+     *  this method fails without doing anything.
+     *  @param entities contacts with initialized encryption metadata
+     *  @return the created contacts with updated revision.
+     *  @throws IllegalArgumentException if the encryption metadata of any contact in the input was not initialized.
+     */
     createContacts(entities: Array<E>): Promise<Array<E>>;
+    /**
+     *
+     *  Restores a contact 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
+     */
     undeleteContactById(id: string, rev: string): Promise<E>;
+    /**
+     *
+     *  Restores a batch of contacts that were marked as deleted.
+     *  @param entityIds the ids and the revisions of the contacts to restore.
+     *  @return the restored contacts. 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.
+     */
     undeleteContactsByIds(entityIds: Array<StoredDocumentIdentifier>): Promise<Array<E>>;
+    /**
+     *
+     *  Restores a contact that was marked as deleted.
+     *  @param contact the contact to undelete
+     *  @return the restored contact.
+     *  @throws RevisionConflictException if the provided contact doesn't match the latest known revision
+     */
     undeleteContact(contact: Contact): Promise<E>;
+    /**
+     *
+     *  Restores a batch of contacts that were marked as deleted.
+     *  @param contacts the contacts to restore.
+     *  @return the restored contacts. 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.
+     */
     undeleteContacts(contacts: Array<Contact>): Promise<Array<E>>;
+    /**
+     *
+     *  Modifies a contact. You need to have write access to the entity.
+     *  Flavoured method.
+     *  @param entity a contact with update content
+     *  @return the contact updated with the provided content and a new revision.
+     */
     modifyContact(entity: E): Promise<E>;
+    /**
+     *
+     *  Modifies multiple contacts. Ignores all contacts for which you don't have write access.
+     *  Flavoured method.
+     *  @param entities contacts with update content
+     *  @return the updated contacts with a new revision.
+     */
     modifyContacts(entities: Array<E>): Promise<Array<E>>;
+    /**
+     *
+     *  Get a contact 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 a contact, or corresponds to an entity for which you don't have
+     *  read access.
+     *  Flavoured method.
+     *  @param entityId a contact id.
+     *  @return the contact with id [entityId].
+     */
     getContact(entityId: string): Promise<E | undefined>;
+    /**
+     *
+     *  Get multiple contacts by their ids. Ignores all ids that do not correspond to an entity, correspond to
+     *  an entity that is not a contact, or correspond to an entity for which you don't have read access.
+     *  Flavoured method.
+     *  @param entityIds a list of contacts ids
+     *  @return all contacts that you can access with one of the provided ids.
+     */
     getContacts(entityIds: Array<string>): Promise<Array<E>>;
+    /**
+     *
+     *  Get a service 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 a service, or corresponds to an entity for which you don't have
+     *  read access.
+     *  Flavoured method.
+     *  @param serviceId a service id
+     *  @return the service with id [serviceId].
+     */
     getService(serviceId: string): Promise<S | undefined>;
+    /**
+     *
+     *  Get multiple services by their ids. Ignores all ids that do not correspond to an entity, correspond to
+     *  an entity that is not a services, or correspond to an entity for which you don't have read access.
+     *  Flavoured method.
+     *  @param entityIds a list of service ids
+     *  @return all services that you can access with one of the provided ids.
+     */
     getServices(entityIds: Array<string>): Promise<Array<S>>;
 }