@icure/cardinal-sdk 2.1.1 → 2.1.2

package/api/TopicBasicInGroupApi.d.mts

@@ -3,26 +3,114 @@ import { GroupScoped } from '../model/GroupScoped.mjs';
 import { StoredDocumentIdentifier } from '../model/StoredDocumentIdentifier.mjs';
 import { EncryptedTopic, Topic } from '../model/Topic.mjs';
 export interface TopicBasicInGroupApi {
+    /**
+     *
+     *  In-group version of [TopicBasicApi.matchTopicsBy]
+     */
     matchTopicsBy(groupId: string, filter: BaseFilterOptions<Topic>): Promise<Array<string>>;
+    /**
+     *
+     *  In-group version of [TopicBasicApi.matchTopicsBySorted]
+     */
     matchTopicsBySorted(groupId: string, filter: BaseSortableFilterOptions<Topic>): Promise<Array<string>>;
+    /**
+     *
+     *  In-group version of [TopicBasicApi.filterTopicsBy]
+     */
     filterTopicsBy(groupId: string, filter: BaseFilterOptions<Topic>): Promise<PaginatedListIterator<GroupScoped<EncryptedTopic>>>;
+    /**
+     *
+     *  In-group version of [TopicBasicApi.filterTopicsBySorted]
+     */
     filterTopicsBySorted(groupId: string, filter: BaseSortableFilterOptions<Topic>): Promise<PaginatedListIterator<GroupScoped<EncryptedTopic>>>;
+    /**
+     *
+     *  In-group version of [TopicBasicFlavourlessApi.deleteTopicById]
+     */
     deleteTopicById(entityId: GroupScoped<StoredDocumentIdentifier>): Promise<GroupScoped<StoredDocumentIdentifier>>;
+    /**
+     *
+     *  In-group version of [TopicBasicFlavourlessApi.deleteTopicsByIds]
+     */
     deleteTopicsByIds(entityIds: Array<GroupScoped<StoredDocumentIdentifier>>): Promise<Array<GroupScoped<StoredDocumentIdentifier>>>;
+    /**
+     *
+     *  In-group version of [TopicBasicFlavourlessApi.purgeTopicById]
+     */
     purgeTopicById(entityId: GroupScoped<StoredDocumentIdentifier>): Promise<void>;
+    /**
+     *
+     *  In-group version of [TopicBasicFlavourlessApi.purgeTopicsByIds]
+     */
     purgeTopicsByIds(entityIds: Array<GroupScoped<StoredDocumentIdentifier>>): Promise<Array<GroupScoped<StoredDocumentIdentifier>>>;
+    /**
+     *
+     *  In-group version of [TopicBasicFlavourlessApi.deleteTopic]
+     */
     deleteTopic(topic: GroupScoped<Topic>): Promise<GroupScoped<StoredDocumentIdentifier>>;
+    /**
+     *
+     *  In-group version of [TopicBasicFlavourlessApi.deleteTopics]
+     */
     deleteTopics(topics: Array<GroupScoped<Topic>>): Promise<Array<GroupScoped<StoredDocumentIdentifier>>>;
+    /**
+     *
+     *  In-group version of [TopicBasicFlavourlessApi.purgeTopic]
+     */
     purgeTopic(topic: GroupScoped<Topic>): Promise<void>;
+    /**
+     *
+     *  In-group version of [TopicBasicFlavourlessApi.purgeTopics]
+     */
     purgeTopics(topics: Array<GroupScoped<Topic>>): Promise<Array<GroupScoped<StoredDocumentIdentifier>>>;
+    /**
+     *
+     *  In-group version of [TopicBasicFlavouredApi.createTopic]
+     */
     createTopic(entity: GroupScoped<EncryptedTopic>): Promise<GroupScoped<EncryptedTopic>>;
+    /**
+     *
+     *  In-group version of [TopicBasicFlavouredApi.createTopics]
+     */
     createTopics(entities: Array<GroupScoped<EncryptedTopic>>): Promise<Array<GroupScoped<EncryptedTopic>>>;
+    /**
+     *
+     *  In-group version of [TopicBasicFlavouredApi.undeleteTopicById]
+     */
     undeleteTopicById(entityId: GroupScoped<StoredDocumentIdentifier>): Promise<GroupScoped<EncryptedTopic>>;
+    /**
+     *
+     *  In-group version of [TopicBasicFlavouredApi.undeleteTopicsByIds]
+     */
     undeleteTopicsByIds(entityIds: Array<GroupScoped<StoredDocumentIdentifier>>): Promise<Array<GroupScoped<EncryptedTopic>>>;
+    /**
+     *
+     *  In-group version of [TopicBasicFlavouredApi.undeleteTopic]
+     */
     undeleteTopic(topic: GroupScoped<Topic>): Promise<GroupScoped<EncryptedTopic>>;
+    /**
+     *
+     *  In-group version of [TopicBasicFlavouredApi.undeleteTopics]
+     */
     undeleteTopics(topics: Array<GroupScoped<EncryptedTopic>>): Promise<Array<GroupScoped<EncryptedTopic>>>;
+    /**
+     *
+     *  In-group version of [TopicBasicFlavouredApi.modifyTopic]
+     */
     modifyTopic(entity: GroupScoped<EncryptedTopic>): Promise<GroupScoped<EncryptedTopic>>;
+    /**
+     *
+     *  In-group version of [TopicBasicFlavouredApi.modifyTopics]
+     */
     modifyTopics(entities: Array<GroupScoped<EncryptedTopic>>): Promise<Array<GroupScoped<EncryptedTopic>>>;
+    /**
+     *
+     *  In-group version of [TopicBasicFlavouredApi.getTopic]
+     */
     getTopic(groupId: string, entityId: string): Promise<GroupScoped<EncryptedTopic> | undefined>;
+    /**
+     *
+     *  In-group version of [TopicBasicFlavouredApi.getTopics]
+     */
     getTopics(groupId: string, entityIds: Array<string>): Promise<Array<GroupScoped<EncryptedTopic>>>;
 }

package/api/TopicFlavouredApi.d.mts

@@ -4,24 +4,167 @@ import { StoredDocumentIdentifier } from '../model/StoredDocumentIdentifier.mjs'
 import { Topic } from '../model/Topic.mjs';
 import { TopicRole } from '../model/TopicRole.mjs';
 export interface TopicFlavouredApi<E extends Topic> {
+    /**
+     *
+     *  Share a topic with another data owner. The topic must already exist in the database for this method to
+     *  succeed. If you want to share the topic 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 topic
+     *  @param topic the topic to share with [delegateId]
+     *  @param options specifies how the topic 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 topic. Refer
+     *  to the documentation of [TopicShareOptions] for more information.
+     *  @return the updated topic if the sharing was successful, or details on the errors if the sharing failed.
+     */
     shareWith(delegateId: string, topic: E, options?: {
         options?: TopicShareOptions | undefined;
     }): Promise<E>;
+    /**
+     *
+     *  Share a topic with multiple data owners. The topic must already exist in the database for this method to
+     *  succeed. If you want to share the topic 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 topic the topic 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 topic.
+     */
     shareWithMany(topic: E, delegates: {
         [key: string]: TopicShareOptions;
     }): Promise<E>;
+    /**
+     *
+     *  Get an iterator that iterates through all topics 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 [filterTopicsBySorted] instead.
+     *
+     *  @param filter a topic filter
+     *  @return an iterator that iterates over all topics matching the provided filter.
+     */
     filterTopicsBy(filter: FilterOptions<Topic>): Promise<PaginatedListIterator<E>>;
+    /**
+     *
+     *  Get an iterator that iterates through all topics 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 [filterTopicsBy].
+     *
+     *  @param filter a topic filter
+     *  @return an iterator that iterates over all topics matching the provided filter.
+     */
     filterTopicsBySorted(filter: SortableFilterOptions<Topic>): Promise<PaginatedListIterator<E>>;
+    /**
+     *
+     *  Create a new topic. The provided topic must have the encryption metadata initialized.
+     *  @param entity a topic with initialized encryption metadata
+     *  @return the created topic with updated revision.
+     *  @throws IllegalArgumentException if the encryption metadata of the input was not initialized.
+     */
     createTopic(entity: E): Promise<E>;
+    /**
+     *
+     *  Create multiple topics. All the provided topics must have the encryption metadata initialized, otherwise
+     *  this method fails without doing anything.
+     *  @param entities topics with initialized encryption metadata
+     *  @return the created topics with updated revision.
+     *  @throws IllegalArgumentException if the encryption metadata of any topic in the input was not initialized.
+     */
     createTopics(entities: Array<E>): Promise<Array<E>>;
+    /**
+     *
+     *  Restores a topic 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
+     */
     undeleteTopicById(id: string, rev: string): Promise<E>;
+    /**
+     *
+     *  Restores a batch of topics that were marked as deleted.
+     *  @param entityIds the ids and the revisions of the topics to restore.
+     *  @return the restored topics. 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.
+     */
     undeleteTopicsByIds(entityIds: Array<StoredDocumentIdentifier>): Promise<Array<E>>;
+    /**
+     *
+     *  Restores a topic that was marked as deleted.
+     *  @param topic the topic to undelete
+     *  @return the restored topic.
+     *  @throws RevisionConflictException if the provided topic doesn't match the latest known revision
+     */
     undeleteTopic(topic: Topic): Promise<E>;
+    /**
+     *
+     *  Restores a batch of topics that were marked as deleted.
+     *  @param topics the topics to restore.
+     *  @return the restored topics. 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.
+     */
     undeleteTopics(topics: Array<Topic>): Promise<Array<E>>;
+    /**
+     *
+     *  Modifies a topic. You need to have write access to the entity.
+     *  Flavoured method.
+     *  @param entity a topic with update content
+     *  @return the topic updated with the provided content and a new revision.
+     */
     modifyTopic(entity: E): Promise<E>;
+    /**
+     *
+     *  Modifies multiple topics. Ignores all topics for which you don't have write access.
+     *  Flavoured method.
+     *  @param entities topics with update content
+     *  @return the updated topics with a new revision.
+     */
     modifyTopics(entities: Array<E>): Promise<Array<E>>;
+    /**
+     *
+     *  Get a topic 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 topic, or corresponds to an entity for which you don't have
+     *  read access.
+     *  Flavoured method.
+     *  @param entityId a topic id.
+     *  @return the topic with id [entityId].
+     */
     getTopic(entityId: string): Promise<E | undefined>;
+    /**
+     *
+     *  Get multiple topics by their ids. Ignores all ids that do not correspond to an entity, correspond to
+     *  an entity that is not a topic, or correspond to an entity for which you don't have read access.
+     *  Flavoured method.
+     *  @param entityIds a list of topics ids
+     *  @return all topics that you can access with one of the provided ids.
+     */
     getTopics(entityIds: Array<string>): Promise<Array<E>>;
+    /**
+     *
+     *  Add a participant to the topic. The participant will be able to create messages associated to the topic.
+     *  Any user with a [TopicRole.Admin] on the can use this method, even if they don't have direct write access
+     *  to it through delegations.
+     *  @param entityId id of the topic
+     *  @param dataOwnerId id of the new participant
+     *  @param topicRole the role that the participant will have in the topic
+     *  @return the updated topic
+     */
     addParticipant(entityId: string, dataOwnerId: string, topicRole: TopicRole): Promise<E>;
+    /**
+     *
+     *  Removes a participant from a topic. The participant will not be able anymore to search for messages of that topic.
+     *  Any user with a [TopicRole.Admin] on the can use this method, even if they don't have direct write access
+     *  to it through delegations.
+     *  @param entityId id of the topic
+     *  @param dataOwnerId id of the participant to remove
+     *  @return the updated topic
+     */
     removeParticipant(entityId: string, dataOwnerId: string): Promise<E>;
 }

package/api/TopicFlavouredInGroupApi.d.mts

@@ -6,23 +6,79 @@ import { StoredDocumentIdentifier } from '../model/StoredDocumentIdentifier.mjs'
 import { Topic } from '../model/Topic.mjs';
 import { ArrayWithUniqueKeys } from '../utils/ArrayWithUniqueKeys.mjs';
 export interface TopicFlavouredInGroupApi<E extends Topic> {
+    /**
+     *
+     *  In-group version of [TopicFlavouredApi.shareWith]
+     */
     shareWith(delegate: EntityReferenceInGroup, topic: GroupScoped<E>, options?: {
         options?: TopicShareOptions | undefined;
     }): Promise<GroupScoped<E>>;
+    /**
+     *
+     *  In-group version of [TopicFlavouredApi.shareWithMany]
+     */
     shareWithMany(topic: GroupScoped<E>, delegates: ArrayWithUniqueKeys<{
         delegate: EntityReferenceInGroup;
         shareOptions: TopicShareOptions;
     }, 'delegate'>): Promise<GroupScoped<E>>;
+    /**
+     *
+     *  In-group version of [TopicFlavouredApi.filterTopicsBy]
+     */
     filterTopicsBy(groupId: string, filter: FilterOptions<Topic>): Promise<PaginatedListIterator<GroupScoped<E>>>;
+    /**
+     *
+     *  In-group version of [TopicFlavouredApi.filterTopicsBySorted]
+     */
     filterTopicsBySorted(groupId: string, filter: SortableFilterOptions<Topic>): Promise<PaginatedListIterator<GroupScoped<E>>>;
+    /**
+     *
+     *  In-group version of [TopicBasicFlavouredApi.createTopic]
+     */
     createTopic(entity: GroupScoped<E>): Promise<GroupScoped<E>>;
+    /**
+     *
+     *  In-group version of [TopicBasicFlavouredApi.createTopics]
+     */
     createTopics(entities: Array<GroupScoped<E>>): Promise<Array<GroupScoped<E>>>;
+    /**
+     *
+     *  In-group version of [TopicBasicFlavouredApi.undeleteTopicById]
+     */
     undeleteTopicById(entityId: GroupScoped<StoredDocumentIdentifier>): Promise<GroupScoped<E>>;
+    /**
+     *
+     *  In-group version of [TopicBasicFlavouredApi.undeleteTopicsByIds]
+     */
     undeleteTopicsByIds(entityIds: Array<GroupScoped<StoredDocumentIdentifier>>): Promise<Array<GroupScoped<E>>>;
+    /**
+     *
+     *  In-group version of [TopicBasicFlavouredApi.undeleteTopic]
+     */
     undeleteTopic(topic: GroupScoped<Topic>): Promise<GroupScoped<E>>;
+    /**
+     *
+     *  In-group version of [TopicBasicFlavouredApi.undeleteTopics]
+     */
     undeleteTopics(topics: Array<GroupScoped<E>>): Promise<Array<GroupScoped<E>>>;
+    /**
+     *
+     *  In-group version of [TopicBasicFlavouredApi.modifyTopic]
+     */
     modifyTopic(entity: GroupScoped<E>): Promise<GroupScoped<E>>;
+    /**
+     *
+     *  In-group version of [TopicBasicFlavouredApi.modifyTopics]
+     */
     modifyTopics(entities: Array<GroupScoped<E>>): Promise<Array<GroupScoped<E>>>;
+    /**
+     *
+     *  In-group version of [TopicBasicFlavouredApi.getTopic]
+     */
     getTopic(groupId: string, entityId: string): Promise<GroupScoped<E> | undefined>;
+    /**
+     *
+     *  In-group version of [TopicBasicFlavouredApi.getTopics]
+     */
     getTopics(groupId: string, entityIds: Array<string>): Promise<Array<GroupScoped<E>>>;
 }

package/api/TopicInGroupApi.d.mts

@@ -14,6 +14,10 @@ import { TopicFlavouredInGroupApi } from './TopicFlavouredInGroupApi.mjs';
 export interface TopicInGroupApi {
     encrypted: TopicFlavouredInGroupApi<EncryptedTopic>;
     tryAndRecover: TopicFlavouredInGroupApi<Topic>;
+    /**
+     *
+     *  In-group version of [TopicApi.withEncryptionMetadata]
+     */
     withEncryptionMetadata(groupId: string, base: DecryptedTopic | undefined, patient: GroupScoped<Patient> | undefined, options?: {
         user?: User | undefined;
         delegates?: {
@@ -22,39 +26,159 @@ export interface TopicInGroupApi {
         secretId?: SecretIdUseOption;
         alternateRootDelegateId?: string | undefined;
     }): Promise<GroupScoped<DecryptedTopic>>;
+    /**
+     *
+     *  In-group version of [TopicApi.getEncryptionKeysOf]
+     */
     getEncryptionKeysOf(topic: GroupScoped<Topic>): Promise<Array<HexString>>;
+    /**
+     *
+     *  In-group version of [TopicApi.hasWriteAccess]
+     */
     hasWriteAccess(topic: GroupScoped<Topic>): Promise<boolean>;
+    /**
+     *
+     *  In-group version of [TopicApi.decryptPatientIdOf]
+     */
     decryptPatientIdOf(topic: GroupScoped<Topic>): Promise<Array<EntityReferenceInGroup>>;
+    /**
+     *
+     *  In-group version of [TopicApi.createDelegationDeAnonymizationMetadata]
+     */
     createDelegationDeAnonymizationMetadata(entity: GroupScoped<Topic>, delegates: Array<EntityReferenceInGroup>): Promise<void>;
+    /**
+     *
+     *  In-group version of [TopicApi.decrypt]
+     */
     decrypt(topics: Array<GroupScoped<EncryptedTopic>>): Promise<Array<GroupScoped<DecryptedTopic>>>;
+    /**
+     *
+     *  In-group version of [TopicApi.tryDecrypt]
+     */
     tryDecrypt(topics: Array<GroupScoped<EncryptedTopic>>): Promise<Array<GroupScoped<Topic>>>;
+    /**
+     *
+     *  In-group version of [TopicApi.matchTopicsBy]
+     */
     matchTopicsBy(groupId: string, filter: FilterOptions<Topic>): Promise<Array<string>>;
+    /**
+     *
+     *  In-group version of [TopicApi.matchTopicsBySorted]
+     */
     matchTopicsBySorted(groupId: string, filter: SortableFilterOptions<Topic>): Promise<Array<string>>;
+    /**
+     *
+     *  In-group version of [TopicBasicFlavourlessApi.deleteTopicById]
+     */
     deleteTopicById(entityId: GroupScoped<StoredDocumentIdentifier>): Promise<GroupScoped<StoredDocumentIdentifier>>;
+    /**
+     *
+     *  In-group version of [TopicBasicFlavourlessApi.deleteTopicsByIds]
+     */
     deleteTopicsByIds(entityIds: Array<GroupScoped<StoredDocumentIdentifier>>): Promise<Array<GroupScoped<StoredDocumentIdentifier>>>;
+    /**
+     *
+     *  In-group version of [TopicBasicFlavourlessApi.purgeTopicById]
+     */
     purgeTopicById(entityId: GroupScoped<StoredDocumentIdentifier>): Promise<void>;
+    /**
+     *
+     *  In-group version of [TopicBasicFlavourlessApi.purgeTopicsByIds]
+     */
     purgeTopicsByIds(entityIds: Array<GroupScoped<StoredDocumentIdentifier>>): Promise<Array<GroupScoped<StoredDocumentIdentifier>>>;
+    /**
+     *
+     *  In-group version of [TopicBasicFlavourlessApi.deleteTopic]
+     */
     deleteTopic(topic: GroupScoped<Topic>): Promise<GroupScoped<StoredDocumentIdentifier>>;
+    /**
+     *
+     *  In-group version of [TopicBasicFlavourlessApi.deleteTopics]
+     */
     deleteTopics(topics: Array<GroupScoped<Topic>>): Promise<Array<GroupScoped<StoredDocumentIdentifier>>>;
+    /**
+     *
+     *  In-group version of [TopicBasicFlavourlessApi.purgeTopic]
+     */
     purgeTopic(topic: GroupScoped<Topic>): Promise<void>;
+    /**
+     *
+     *  In-group version of [TopicBasicFlavourlessApi.purgeTopics]
+     */
     purgeTopics(topics: Array<GroupScoped<Topic>>): Promise<Array<GroupScoped<StoredDocumentIdentifier>>>;
+    /**
+     *
+     *  In-group version of [TopicFlavouredApi.shareWith]
+     */
     shareWith(delegate: EntityReferenceInGroup, topic: GroupScoped<DecryptedTopic>, options?: {
         options?: TopicShareOptions | undefined;
     }): Promise<GroupScoped<DecryptedTopic>>;
+    /**
+     *
+     *  In-group version of [TopicFlavouredApi.shareWithMany]
+     */
     shareWithMany(topic: GroupScoped<DecryptedTopic>, delegates: ArrayWithUniqueKeys<{
         delegate: EntityReferenceInGroup;
         shareOptions: TopicShareOptions;
     }, 'delegate'>): Promise<GroupScoped<DecryptedTopic>>;
+    /**
+     *
+     *  In-group version of [TopicFlavouredApi.filterTopicsBy]
+     */
     filterTopicsBy(groupId: string, filter: FilterOptions<Topic>): Promise<PaginatedListIterator<GroupScoped<DecryptedTopic>>>;
+    /**
+     *
+     *  In-group version of [TopicFlavouredApi.filterTopicsBySorted]
+     */
     filterTopicsBySorted(groupId: string, filter: SortableFilterOptions<Topic>): Promise<PaginatedListIterator<GroupScoped<DecryptedTopic>>>;
+    /**
+     *
+     *  In-group version of [TopicBasicFlavouredApi.createTopic]
+     */
     createTopic(entity: GroupScoped<DecryptedTopic>): Promise<GroupScoped<DecryptedTopic>>;
+    /**
+     *
+     *  In-group version of [TopicBasicFlavouredApi.createTopics]
+     */
     createTopics(entities: Array<GroupScoped<DecryptedTopic>>): Promise<Array<GroupScoped<DecryptedTopic>>>;
+    /**
+     *
+     *  In-group version of [TopicBasicFlavouredApi.undeleteTopicById]
+     */
     undeleteTopicById(entityId: GroupScoped<StoredDocumentIdentifier>): Promise<GroupScoped<DecryptedTopic>>;
+    /**
+     *
+     *  In-group version of [TopicBasicFlavouredApi.undeleteTopicsByIds]
+     */
     undeleteTopicsByIds(entityIds: Array<GroupScoped<StoredDocumentIdentifier>>): Promise<Array<GroupScoped<DecryptedTopic>>>;
+    /**
+     *
+     *  In-group version of [TopicBasicFlavouredApi.undeleteTopic]
+     */
     undeleteTopic(topic: GroupScoped<Topic>): Promise<GroupScoped<DecryptedTopic>>;
+    /**
+     *
+     *  In-group version of [TopicBasicFlavouredApi.undeleteTopics]
+     */
     undeleteTopics(topics: Array<GroupScoped<DecryptedTopic>>): Promise<Array<GroupScoped<DecryptedTopic>>>;
+    /**
+     *
+     *  In-group version of [TopicBasicFlavouredApi.modifyTopic]
+     */
     modifyTopic(entity: GroupScoped<DecryptedTopic>): Promise<GroupScoped<DecryptedTopic>>;
+    /**
+     *
+     *  In-group version of [TopicBasicFlavouredApi.modifyTopics]
+     */
     modifyTopics(entities: Array<GroupScoped<DecryptedTopic>>): Promise<Array<GroupScoped<DecryptedTopic>>>;
+    /**
+     *
+     *  In-group version of [TopicBasicFlavouredApi.getTopic]
+     */
     getTopic(groupId: string, entityId: string): Promise<GroupScoped<DecryptedTopic> | undefined>;
+    /**
+     *
+     *  In-group version of [TopicBasicFlavouredApi.getTopics]
+     */
     getTopics(groupId: string, entityIds: Array<string>): Promise<Array<GroupScoped<DecryptedTopic>>>;
 }

package/api/UserApi.d.mts

@@ -37,19 +37,71 @@ export interface UserApi {
     enable2faForUser(userId: string, request: Enable2faRequest): Promise<void>;
     disable2faForUser(userId: string): Promise<void>;
     createAdminUser(user: User): Promise<User>;
+    /**
+     *
+     *  Deletes a user. If you don't have write access to the user the method will fail.
+     *  @param entityId id of the user.
+     *  @param rev the latest known rev of the user to delete
+     *  @return the id and revision of the deleted user.
+     *  @throws RevisionConflictException if the provided revision doesn't match the latest known revision
+     */
     deleteUserById(entityId: string, rev: string): Promise<StoredDocumentIdentifier>;
     deleteUsersByIds(userIds: Array<StoredDocumentIdentifier>): Promise<Array<StoredDocumentIdentifier>>;
+    /**
+     *
+     *  Permanently deletes a user.
+     *  @param id id of the user to purge
+     *  @param rev latest revision of the user
+     *  @throws RevisionConflictException if the provided revision doesn't match the latest known revision
+     */
     purgeUserById(id: string, rev: string): Promise<void>;
     purgeUsersByIds(userIds: Array<StoredDocumentIdentifier>): Promise<Array<StoredDocumentIdentifier>>;
+    /**
+     *
+     *  Restores a user 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
+     */
     undeleteUserById(id: string, rev: string): Promise<User>;
     undeleteUsersByIds(userIds: Array<StoredDocumentIdentifier>): Promise<Array<User>>;
+    /**
+     *
+     *  Deletes a user. If you don't have write access to the user the method will fail.
+     *  @param user the user to delete
+     *  @return the id and revision of the deleted user.
+     *  @throws RevisionConflictException if the provided user doesn't match the latest known revision
+     */
     deleteUser(user: User): Promise<StoredDocumentIdentifier>;
     deleteUsers(users: Array<User>): Promise<Array<StoredDocumentIdentifier>>;
+    /**
+     *
+     *  Permanently deletes a user.
+     *  @param user the user to purge.
+     *  @throws RevisionConflictException if the provided user doesn't match the latest known revision
+     */
     purgeUser(user: User): Promise<void>;
     purgeUsers(users: Array<User>): Promise<Array<StoredDocumentIdentifier>>;
+    /**
+     *
+     *  Restores a user that was marked as deleted.
+     *  @param user the user to undelete
+     *  @return the restored user.
+     *  @throws RevisionConflictException if the provided user doesn't match the latest known revision
+     */
     undeleteUser(user: User): Promise<User>;
     undeleteUsers(users: Array<User>): Promise<Array<User>>;
     setExternalJwtAuthByIdentifiersForCurrentUser(externalJwtConfigId: string, externalAuthenticationToken: string): Promise<boolean>;
+    /**
+     *
+     *  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<User>, options?: {
         subscriptionConfig?: EntitySubscriptionConfiguration | undefined;
     }): Promise<EntitySubscription<User>>;

package/api/UserInGroupApi.d.mts

@@ -41,6 +41,12 @@ export interface UserInGroupApi {
     enable2faForUser(user: GroupScoped<User>, request: Enable2faRequest): Promise<void>;
     disable2faForUser(user: GroupScoped<User>): Promise<void>;
     createAdminUser(user: GroupScoped<User>): Promise<GroupScoped<User>>;
+    /**
+     *
+     *  Defines if a user inherits the permission they have in their group in all the groups that are children of their group.
+     *
+     *  @param user the user to update
+     */
     setUserInheritsPermissions(user: GroupScoped<User>, value: boolean): Promise<void>;
     setLoginIdentifiers(user: GroupScoped<User>, identifier: LoginIdentifier, replaceExisting: boolean): Promise<boolean>;
 }

package/api.d.mts

@@ -15,6 +15,7 @@ export * from './api/MessageBasicApi.mjs';
 export * from './api/MessageInGroupApi.mjs';
 export * from './api/HealthElementFlavouredApi.mjs';
 export * from './api/HealthElementBasicApi.mjs';
+export * from './api/AnonymousRoleApi.mjs';
 export * from './api/ContactFlavouredApi.mjs';
 export * from './api/AccessLogBasicInGroupApi.mjs';
 export * from './api/CalendarItemInGroupApi.mjs';

package/api.mjs

@@ -15,6 +15,7 @@ export * from './api/MessageBasicApi.mjs';
 export * from './api/MessageInGroupApi.mjs';
 export * from './api/HealthElementFlavouredApi.mjs';
 export * from './api/HealthElementBasicApi.mjs';
+export * from './api/AnonymousRoleApi.mjs';
 export * from './api/ContactFlavouredApi.mjs';
 export * from './api/AccessLogBasicInGroupApi.mjs';
 export * from './api/CalendarItemInGroupApi.mjs';