@icure/cardinal-sdk 2.1.1 → 2.1.3

package/api/ContactFlavouredInGroupApi.d.mts

@@ -7,25 +7,89 @@ import { StoredDocumentIdentifier } from '../model/StoredDocumentIdentifier.mjs'
 import { Service } from '../model/embed/Service.mjs';
 import { ArrayWithUniqueKeys } from '../utils/ArrayWithUniqueKeys.mjs';
 export interface ContactFlavouredInGroupApi<E extends Contact, S extends Service> {
+    /**
+     *
+     *  In-group version of [ContactFlavouredApi.shareWith]
+     */
     shareWith(delegate: EntityReferenceInGroup, contact: GroupScoped<E>, options?: {
         options?: ContactShareOptions | undefined;
     }): Promise<GroupScoped<E>>;
+    /**
+     *
+     *  In-group version of [ContactFlavouredApi.shareWithMany]
+     */
     shareWithMany(contact: GroupScoped<E>, delegates: ArrayWithUniqueKeys<{
         delegate: EntityReferenceInGroup;
         shareOptions: ContactShareOptions;
     }, 'delegate'>): Promise<GroupScoped<E>>;
+    /**
+     *
+     *  In-group version of [ContactFlavouredApi.filterContactsBy]
+     */
     filterContactsBy(groupId: string, filter: FilterOptions<Contact>): Promise<PaginatedListIterator<GroupScoped<E>>>;
+    /**
+     *
+     *  In-group version of [ContactFlavouredApi.filterContactsBySorted]
+     */
     filterContactsBySorted(groupId: string, filter: SortableFilterOptions<Contact>): Promise<PaginatedListIterator<GroupScoped<E>>>;
+    /**
+     *
+     *  In-group version of [ContactBasicFlavouredApi.createContact].
+     */
     createContact(entity: GroupScoped<E>): Promise<GroupScoped<E>>;
+    /**
+     *
+     *  In-group version of [ContactBasicFlavouredApi.createContacts].
+     */
     createContacts(entities: Array<GroupScoped<E>>): Promise<Array<GroupScoped<E>>>;
+    /**
+     *
+     *  In-group version of [ContactBasicFlavouredApi.undeleteContactById]
+     */
     undeleteContactById(entityId: GroupScoped<StoredDocumentIdentifier>): Promise<GroupScoped<E>>;
+    /**
+     *
+     *  In-group version of [ContactBasicFlavouredApi.undeleteContactsByIds]
+     */
     undeleteContactsByIds(entityIds: Array<GroupScoped<StoredDocumentIdentifier>>): Promise<Array<GroupScoped<E>>>;
+    /**
+     *
+     *  In-group version of [ContactBasicFlavouredApi.undeleteContact]
+     */
     undeleteContact(contact: GroupScoped<Contact>): Promise<GroupScoped<E>>;
+    /**
+     *
+     *  In-group version of [ContactBasicFlavouredApi.undeleteContacts]
+     */
     undeleteContacts(contacts: Array<GroupScoped<E>>): Promise<Array<GroupScoped<E>>>;
+    /**
+     *
+     *  In-group version of [ContactBasicFlavouredApi.modifyContact]
+     */
     modifyContact(entity: GroupScoped<E>): Promise<GroupScoped<E>>;
+    /**
+     *
+     *  In-group version of [ContactBasicFlavouredApi.modifyContacts]
+     */
     modifyContacts(entities: Array<GroupScoped<E>>): Promise<Array<GroupScoped<E>>>;
+    /**
+     *
+     *  In-group version of [ContactBasicFlavouredApi.getContact]
+     */
     getContact(groupId: string, entityId: string): Promise<GroupScoped<E> | undefined>;
+    /**
+     *
+     *  In-group version of [ContactBasicFlavouredApi.getContacts]
+     */
     getContacts(groupId: string, entityIds: Array<string>): Promise<Array<GroupScoped<E>>>;
+    /**
+     *
+     *  In-group version of [ContactBasicFlavouredApi.getService]
+     */
     getService(groupId: string, serviceId: string): Promise<GroupScoped<S> | undefined>;
+    /**
+     *
+     *  In-group version of [ContactBasicFlavouredApi.getServices]
+     */
     getServices(groupId: string, entityIds: Array<string>): Promise<Array<GroupScoped<S>>>;
 }

package/api/ContactInGroupApi.d.mts

@@ -15,6 +15,10 @@ import { ContactFlavouredInGroupApi } from './ContactFlavouredInGroupApi.mjs';
 export interface ContactInGroupApi {
     encrypted: ContactFlavouredInGroupApi<EncryptedContact, EncryptedService>;
     tryAndRecover: ContactFlavouredInGroupApi<Contact, Service>;
+    /**
+     *
+     *  In-group version of [ContactApi.withEncryptionMetadata]
+     */
     withEncryptionMetadata(entityGroupId: string, base: DecryptedContact | undefined, patient: GroupScoped<Patient> | undefined, options?: {
         user?: User | undefined;
         delegates?: ArrayWithUniqueKeys<{
@@ -24,45 +28,189 @@ export interface ContactInGroupApi {
         secretId?: SecretIdUseOption;
         alternateRootDelegateReference?: EntityReferenceInGroup | undefined;
     }): Promise<GroupScoped<DecryptedContact>>;
+    /**
+     *
+     *  In-group version of [ContactApi.getEncryptionKeysOf]
+     */
     getEncryptionKeysOf(contact: GroupScoped<Contact>): Promise<Array<HexString>>;
+    /**
+     *
+     *  In-group version of [ContactApi.hasWriteAccess]
+     */
     hasWriteAccess(contact: GroupScoped<Contact>): Promise<boolean>;
+    /**
+     *
+     *  In-group version of [ContactApi.decryptPatientIdOf]
+     */
     decryptPatientIdOf(contact: GroupScoped<Contact>): Promise<Array<EntityReferenceInGroup>>;
+    /**
+     *
+     *  In-group version of [ContactApi.createDelegationDeAnonymizationMetadata]
+     */
     createDelegationDeAnonymizationMetadata(entity: GroupScoped<Contact>, delegates: Array<EntityReferenceInGroup>): Promise<void>;
+    /**
+     *
+     *  In-group version of [ContactApi.decrypt]
+     */
     decrypt(contacts: Array<GroupScoped<EncryptedContact>>): Promise<Array<GroupScoped<DecryptedContact>>>;
+    /**
+     *
+     *  In-group version of [ContactApi.tryDecrypt]
+     */
     tryDecrypt(contacts: Array<GroupScoped<EncryptedContact>>): Promise<Array<GroupScoped<Contact>>>;
+    /**
+     *
+     *  In-group version of [ContactApi.decryptService]
+     */
     decryptService(service: GroupScoped<EncryptedService>): Promise<GroupScoped<DecryptedService>>;
+    /**
+     *
+     *  In-group version of [ContactApi.tryDecryptService]
+     */
     tryDecryptService(service: GroupScoped<EncryptedService>): Promise<GroupScoped<Service>>;
+    /**
+     *
+     *  In-group version of [ContactApi.matchContactsBy]
+     */
     matchContactsBy(groupId: string, filter: FilterOptions<Contact>): Promise<Array<string>>;
+    /**
+     *
+     *  In-group version of [ContactApi.matchContactsBySorted]
+     */
     matchContactsBySorted(groupId: string, filter: SortableFilterOptions<Contact>): Promise<Array<string>>;
+    /**
+     *
+     *  In-group version of [ContactApi.matchServicesBy]
+     */
     matchServicesBy(groupId: string, filter: FilterOptions<Service>): Promise<Array<string>>;
+    /**
+     *
+     *  In-group version of [ContactApi.matchServicesBySorted]
+     */
     matchServicesBySorted(groupId: string, filter: SortableFilterOptions<Service>): Promise<Array<string>>;
+    /**
+     *
+     *  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 [ContactFlavouredApi.shareWith]
+     */
     shareWith(delegate: EntityReferenceInGroup, contact: GroupScoped<DecryptedContact>, options?: {
         options?: ContactShareOptions | undefined;
     }): Promise<GroupScoped<DecryptedContact>>;
+    /**
+     *
+     *  In-group version of [ContactFlavouredApi.shareWithMany]
+     */
     shareWithMany(contact: GroupScoped<DecryptedContact>, delegates: ArrayWithUniqueKeys<{
         delegate: EntityReferenceInGroup;
         shareOptions: ContactShareOptions;
     }, 'delegate'>): Promise<GroupScoped<DecryptedContact>>;
+    /**
+     *
+     *  In-group version of [ContactFlavouredApi.filterContactsBy]
+     */
     filterContactsBy(groupId: string, filter: FilterOptions<Contact>): Promise<PaginatedListIterator<GroupScoped<DecryptedContact>>>;
+    /**
+     *
+     *  In-group version of [ContactFlavouredApi.filterContactsBySorted]
+     */
     filterContactsBySorted(groupId: string, filter: SortableFilterOptions<Contact>): Promise<PaginatedListIterator<GroupScoped<DecryptedContact>>>;
+    /**
+     *
+     *  In-group version of [ContactBasicFlavouredApi.createContact].
+     */
     createContact(entity: GroupScoped<DecryptedContact>): Promise<GroupScoped<DecryptedContact>>;
+    /**
+     *
+     *  In-group version of [ContactBasicFlavouredApi.createContacts].
+     */
     createContacts(entities: Array<GroupScoped<DecryptedContact>>): Promise<Array<GroupScoped<DecryptedContact>>>;
+    /**
+     *
+     *  In-group version of [ContactBasicFlavouredApi.undeleteContactById]
+     */
     undeleteContactById(entityId: GroupScoped<StoredDocumentIdentifier>): Promise<GroupScoped<DecryptedContact>>;
+    /**
+     *
+     *  In-group version of [ContactBasicFlavouredApi.undeleteContactsByIds]
+     */
     undeleteContactsByIds(entityIds: Array<GroupScoped<StoredDocumentIdentifier>>): Promise<Array<GroupScoped<DecryptedContact>>>;
+    /**
+     *
+     *  In-group version of [ContactBasicFlavouredApi.undeleteContact]
+     */
     undeleteContact(contact: GroupScoped<Contact>): Promise<GroupScoped<DecryptedContact>>;
+    /**
+     *
+     *  In-group version of [ContactBasicFlavouredApi.undeleteContacts]
+     */
     undeleteContacts(contacts: Array<GroupScoped<DecryptedContact>>): Promise<Array<GroupScoped<DecryptedContact>>>;
+    /**
+     *
+     *  In-group version of [ContactBasicFlavouredApi.modifyContact]
+     */
     modifyContact(entity: GroupScoped<DecryptedContact>): Promise<GroupScoped<DecryptedContact>>;
+    /**
+     *
+     *  In-group version of [ContactBasicFlavouredApi.modifyContacts]
+     */
     modifyContacts(entities: Array<GroupScoped<DecryptedContact>>): Promise<Array<GroupScoped<DecryptedContact>>>;
+    /**
+     *
+     *  In-group version of [ContactBasicFlavouredApi.getContact]
+     */
     getContact(groupId: string, entityId: string): Promise<GroupScoped<DecryptedContact> | undefined>;
+    /**
+     *
+     *  In-group version of [ContactBasicFlavouredApi.getContacts]
+     */
     getContacts(groupId: string, entityIds: Array<string>): Promise<Array<GroupScoped<DecryptedContact>>>;
+    /**
+     *
+     *  In-group version of [ContactBasicFlavouredApi.getService]
+     */
     getService(groupId: string, serviceId: string): Promise<GroupScoped<DecryptedService> | undefined>;
+    /**
+     *
+     *  In-group version of [ContactBasicFlavouredApi.getServices]
+     */
     getServices(groupId: string, entityIds: Array<string>): Promise<Array<GroupScoped<DecryptedService>>>;
 }

package/api/CryptoApi.d.mts

@@ -4,11 +4,37 @@ import { RawDecryptedExchangeData } from '../crypto/entities/RawDecryptedExchang
 import { Pkcs8Bytes } from '../model/specializations/Pkcs8Bytes.mjs';
 import { CryptoInGroupApi } from './CryptoInGroupApi.mjs';
 import { ShamirKeysManagerApi } from './ShamirKeysManagerApi.mjs';
+/**
+ *
+ *  Gives access to cryptographic operations that should be managed by the user, such as the creation of recovery data for keys.
+ */
 export interface CryptoApi {
     shamirKeysManager: ShamirKeysManagerApi;
     inGroup: CryptoInGroupApi;
+    /**
+     *
+     *  @param entityType the type of entity to get access control keys for.
+     *  @return a List containing all the access control keys for an entity type in the current group. This method returns a non-empty list
+     *  only if the current data owner is not anonymous
+     */
     getAccessControlKeys(entityType: EntityWithEncryptionMetadataTypeName): Promise<Array<string>>;
+    /**
+     *
+     *  Clears the cache of the api and reloads the user keys and exchange keys.
+     *  In some cases this method could allow users to retrieve and decrypt data that was shared with them after the api
+     *  instantiation or last reload.
+     */
     forceReload(): Promise<void>;
+    /**
+     *
+     *  Get the available keys for the current data and his parents (if using hierarchical data owners).
+     *  The result is a map associating the current data owner or parent id to a map containing all the available keys
+     *  for that data owner.
+     *  The keys map associates the key fingerprint to the pkcs8 bytes of the private key.
+     *  @param filterTrustedKeys if true (default) only keys fully trusted by this instance of the sdk will be returned.
+     *  Otherwise, also unverified keys may be returned.
+     *  @return the available keys
+     */
     currentDataOwnerKeys(options?: {
         filterTrustedKeys?: boolean;
     }): Promise<{
@@ -17,5 +43,16 @@ export interface CryptoApi {
         };
     }>;
     keylessCreateExchangeDataTo(delegate: string): Promise<RawDecryptedExchangeData>;
+    /**
+     *
+     *  Allows injecting exchange data that would not be readable or decryptable by the SDK otherwise.
+     *  IMPORTANT: the SDK will not check that the provided exchange data details are valid for the provided exchange data
+     *  id. Providing invalid details could cause permanent corruption of data.
+     *  @param details the details of the exchange data to inject. Set verified to true to allow this data to be used for
+     *  encryption of new entity.
+     *  @param reEncryptWithOwnKeys can only be true if the api wasn't initialized in keyless mode. If true the injected
+     *  data will be re-encrypted with also the current data owner key, allowing to access it in future instances without
+     *  having to re-inject it (as long as the instance has access to the current private key).
+     */
     injectExchangeData(groupId: string | undefined, details: Array<ExchangeDataInjectionDetails>, reEncryptWithOwnKeys: boolean): Promise<void>;
 }

package/api/CryptoInGroupApi.d.mts

@@ -3,5 +3,12 @@ import { RawDecryptedExchangeData } from '../crypto/entities/RawDecryptedExchang
 import { EntityReferenceInGroup } from '../model/EntityReferenceInGroup.mjs';
 export interface CryptoInGroupApi {
     keylessCreateExchangeDataTo(groupId: string | undefined, delegate: EntityReferenceInGroup): Promise<RawDecryptedExchangeData>;
+    /**
+     *
+     *  @param groupId the id of the group where the access control keys will be used.
+     *  @param entityType the type of entity to get access control keys for.
+     *  @return a List containing all the access control keys for an entity type in a specific group. This method returns a non-empty list
+     *  only if the current data owner is not anonymous
+     */
     getAccessControlKeys(groupId: string | undefined, entityType: EntityWithEncryptionMetadataTypeName): Promise<Array<string>>;
 }

package/api/DataOwnerApi.d.mts

@@ -3,18 +3,102 @@ import { DataOwnerType } from '../model/DataOwnerType.mjs';
 import { DataOwnerWithType } from '../model/DataOwnerWithType.mjs';
 import { EntityReferenceInGroup } from '../model/EntityReferenceInGroup.mjs';
 export interface DataOwnerApi {
+    /**
+     *
+     *  Get the current data owner in full, regardless of its type. This method returns the full entity, including also
+     *  information that is outside the scope of the [com.icure.sdk.model.base.CryptoActor] interface.
+     *  Fails if the current user is not a data owner.
+     *  @return the data owner associated to the current user.
+     */
     getCurrentDataOwner(): Promise<DataOwnerWithType>;
+    /**
+     *
+     *  Get a stub of the current data owner. The stub contains only the information from the CryptoActor interface +
+     *  id and rev.
+     *  Fails if the current user is not a data owner.
+     *  @return the crypto actor stub of the data owner associated to the current user.
+     */
     getCurrentDataOwnerStub(): Promise<CryptoActorStubWithType>;
+    /**
+     *
+     *  If the logged user is a data owner get the current data owner id. This information is cached without expiration,
+     *  and will only be updated in case of forced refresh.
+     *  Fails if the current user is not a data owner.
+     *  @return the current data owner id
+     */
     getCurrentDataOwnerId(): Promise<string>;
     getCurrentDataOwnerReference(): Promise<EntityReferenceInGroup>;
+    /**
+     *
+     *  If the logged user is a data owner get its parent hierarchy. This information is cached without expiration, and
+     *  will only be updated in case of forced refresh.
+     *  The resulting list starts with the topmost parent (the only ancestor without a parent) and ends with the data
+     *  owner itself.
+     *  Fails if the current user is not a data owner.
+     *  @return a list containing the ids of the current data owner hierarchy, ending with the current data owner id.
+     */
     getCurrentDataOwnerHierarchyIds(): Promise<Array<string>>;
     getCurrentDataOwnerHierarchyIdsReference(): Promise<Array<EntityReferenceInGroup>>;
+    /**
+     *
+     *  Get a data owner regardless of its actual type. The logged user must have the permission to access the data
+     *  owner. For example, if [ownerId] turns out to be associated to a patient, and it is not shared with the current
+     *  user this method will fail.
+     *  If are interested only in the [com.icure.sdk.model.base.CryptoActor] information of the data owner and its
+     *  [com.icure.sdk.model.DataOwnerType] you should use the [getCryptoActorStub] method instead.
+     *  @param ownerId the id of a data owner (patient, hcp or device)
+     *  @return the full data owner associated to the provided id.
+     */
     getDataOwner(ownerId: string): Promise<DataOwnerWithType>;
+    /**
+     *
+     *  Get a data owner regardless of its actual type. Does not require any special permission.
+     *  @param ownerId the id of a data owner (patient, hcp or device)
+     *  @return the full data owner associated to the provided id.
+     */
     getCryptoActorStub(ownerId: string): Promise<CryptoActorStubWithType>;
+    /**
+     *
+     *  Get a data owner regardless of its actual type. Does not require any special permission.
+     *  @param ownerId the id of a data owner (patient, hcp or device)
+     *  @return the full data owner associated to the provided id.
+     */
     getCryptoActorStubInGroup(entityReferenceInGroup: EntityReferenceInGroup): Promise<CryptoActorStubWithType>;
+    /**
+     *
+     *  Get the hierarchy for the current data owner starting from the specified parent.
+     *  Fails if the current user is not a data owner.
+     *  @param parentId the id of a member of the current data owner hierarchy.
+     *  @return an array starting at the topmost parent and ending at the provided parent id.
+     *  @throws IllegalArgumentException If the provided id is not part of the hierarchy
+     */
     getCurrentDataOwnerHierarchyIdsFrom(parentId: string): Promise<Array<string>>;
+    /**
+     *
+     *  If the logged user is a data owner get the current data owner and all of his parents. The returned list starts
+     *  from the topmost ancestor of the current data owner and ends with the current data owner.
+     *  Fails if the current user is not a data owner.
+     *  @return a list containing the current data owner hierarchy, ending with the current data owner.
+     */
     getCurrentDataOwnerHierarchy(): Promise<Array<DataOwnerWithType>>;
+    /**
+     *
+     *  Modifies the crypto actor information of a data owner. The information that can be modified depend on the
+     *  permissions of the current user, by default only information that refer to the current user can be changed.
+     *  @param cryptoActorStubWithTypeDto the stub with updated information
+     *  @return the updated stub, with updated revision
+     */
     modifyDataOwnerStub(cryptoActorStubWithTypeDto: CryptoActorStubWithType): Promise<CryptoActorStubWithType>;
+    /**
+     *
+     *  If the logged user is a data owner get the type of the current data owner. This information is cached.
+     *  @return the type of the current data owner
+     */
     getCurrentDataOwnerType(): Promise<DataOwnerType>;
+    /**
+     *
+     *  Clears the cache of current data owner id and parent hierarchy ids. The hierarchy of a data owner should not
+     *  normally change over time, so this method should be rarely needed. The cache will be repopulated lazily.
+     */
     clearCurrentDataOwnerIdsCache(): void;
 }

package/api/DeviceApi.d.mts

@@ -13,14 +13,45 @@ export interface DeviceApi {
     createDevices(devices: Array<Device>): Promise<Array<Device>>;
     modifyDevice(device: Device): Promise<Device>;
     modifyDevices(devices: Array<Device>): Promise<Array<Device>>;
+    /**
+     *
+     *  Deletes a device. If you don't have write access to the device the method will fail.
+     *  @param entityId id of the device.
+     *  @param rev the latest known rev of the device to delete
+     *  @return the id and revision of the deleted device.
+     *  @throws RevisionConflictException if the provided revision doesn't match the latest known revision
+     */
     deleteDeviceById(entityId: string, rev: string): Promise<StoredDocumentIdentifier>;
+    /**
+     *
+     *  Deletes many devices. 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 devices to delete.
+     *  @return the id and revision of the deleted devices. 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.
+     */
     deleteDevicesByIds(entityIds: Array<StoredDocumentIdentifier>): Promise<Array<StoredDocumentIdentifier>>;
     deleteDevice(device: Device): Promise<StoredDocumentIdentifier>;
     deleteDevices(devices: Array<Device>): Promise<Array<StoredDocumentIdentifier>>;
+    /**
+     *
+     *  Restores a device 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
+     */
     undeleteDeviceById(id: string, rev: string): Promise<Device>;
     undeleteDevicesByIds(entityIds: Array<StoredDocumentIdentifier>): Promise<Array<Device>>;
     undeleteDevice(device: Device): Promise<Device>;
     undeleteDevices(devices: Array<Device>): Promise<Array<Device>>;
+    /**
+     *
+     *  Permanently deletes a device.
+     *  @param id id of the device to purge
+     *  @param rev latest revision of the device
+     *  @throws RevisionConflictException if the provided revision doesn't match the latest known revision
+     */
     purgeDeviceById(id: string, rev: string): Promise<void>;
     purgeDevicesByIds(entityIds: Array<StoredDocumentIdentifier>): Promise<Array<StoredDocumentIdentifier>>;
     purgeDevice(device: Device): Promise<void>;
@@ -29,6 +60,15 @@ export interface DeviceApi {
     filterDevicesBySorted(filter: BaseSortableFilterOptions<Device>): Promise<PaginatedListIterator<Device>>;
     matchDevicesBy(filter: BaseFilterOptions<Device>): Promise<Array<string>>;
     matchDevicesBySorted(filter: BaseSortableFilterOptions<Device>): Promise<Array<string>>;
+    /**
+     *
+     *  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<Device>, options?: {
         subscriptionConfig?: EntitySubscriptionConfiguration | undefined;
     }): Promise<EntitySubscription<Device>>;