@icure/cardinal-sdk 2.1.0 → 2.1.2

package/api/AccessLogFlavouredApi.d.mts

@@ -3,22 +3,136 @@ import { AccessLogShareOptions } from '../crypto/entities/AccessLogShareOptions.
 import { AccessLog } from '../model/AccessLog.mjs';
 import { StoredDocumentIdentifier } from '../model/StoredDocumentIdentifier.mjs';
 export interface AccessLogFlavouredApi<E extends AccessLog> {
+    /**
+     *
+     *  Share an access log with another data owner.
+     *  @param delegateId the owner that will gain access to [accessLog]
+     *  @param accessLog the access log to share with [delegateId]
+     *  @param options specifies how the access log 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 access log.
+     *  @return the updated access log
+     */
     shareWith(delegateId: string, accessLog: E, options?: {
         options?: AccessLogShareOptions | undefined;
     }): Promise<E>;
+    /**
+     *
+     *  Share an access log with multiple data owners.
+     *  @param accessLog the access log 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 access log.
+     */
     shareWithMany(accessLog: E, delegates: {
         [key: string]: AccessLogShareOptions;
     }): Promise<E>;
+    /**
+     *
+     *  Get an iterator that iterates through all access logs 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 [filterAccessLogsBySorted] instead.
+     *
+     *  @param filter an access log filter
+     *  @return an iterator that iterates over all access logs matching the provided filter.
+     */
     filterAccessLogsBy(filter: FilterOptions<AccessLog>): Promise<PaginatedListIterator<E>>;
+    /**
+     *
+     *  Get an iterator that iterates through all access logs 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 [filterAccessLogsBy].
+     *
+     *  @param filter an access log filter
+     *  @return an iterator that iterates over all access logs matching the provided filter.
+     */
     filterAccessLogsBySorted(filter: SortableFilterOptions<AccessLog>): Promise<PaginatedListIterator<E>>;
+    /**
+     *
+     *  Create a new access log. The provided access log must have the encryption metadata initialized.
+     *  @param entity an access log with initialized encryption metadata
+     *  @return the created access log with updated revision.
+     *  @throws IllegalArgumentException if the encryption metadata of the input was not initialized.
+     */
     createAccessLog(entity: E): Promise<E>;
+    /**
+     *
+     *  Create a batch of new access logs. All the provided access log must have the encryption metadata initialized.
+     *  @param entities the accessLogs with initialized encryption metadata
+     *  @return the created access logs with updated revision.
+     *  @throws IllegalArgumentException if the encryption metadata was not initialized in any of the entities.
+     */
     createAccessLogs(entities: Array<E>): Promise<Array<E>>;
+    /**
+     *
+     *  Restores a accessLog 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
+     */
     undeleteAccessLogById(id: string, rev: string): Promise<E>;
+    /**
+     *
+     *  Restores a batch of accessLogs that were marked as deleted.
+     *  @param entityIds the ids and the revisions of the accessLogs to restore.
+     *  @return the restored accessLogs. 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.
+     */
     undeleteAccessLogsByIds(entityIds: Array<StoredDocumentIdentifier>): Promise<Array<E>>;
+    /**
+     *
+     *  Restores a accessLog that was marked as deleted.
+     *  @param accessLog the accessLog to undelete
+     *  @return the restored accessLog.
+     *  @throws RevisionConflictException if the provided accessLog doesn't match the latest known revision
+     */
     undeleteAccessLog(accessLog: AccessLog): Promise<E>;
+    /**
+     *
+     *  Restores a batch of accessLogs that were marked as deleted.
+     *  @param accessLogs the accessLogs to restore.
+     *  @return the restored accessLogs. 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.
+     */
     undeleteAccessLogs(accessLogs: Array<AccessLog>): Promise<Array<E>>;
+    /**
+     *
+     *  Modifies an access log. You need to have write access to the entity.
+     *  Flavoured method.
+     *  @param entity an access log with update content
+     *  @return the updated access log with a new revision.
+     */
     modifyAccessLog(entity: E): Promise<E>;
+    /**
+     *
+     *  Modifies a batch of accessLogs.
+     *  Flavoured method-
+     *  @param entities the updated accessLogs.
+     *  @return the updated accessLogs with their new revisions. If some entities couldn't be updated (because the user does not have access or the revision is not
+     *  up-to-date), then those entities will not be updated and will not appear in this list.
+     */
     modifyAccessLogs(entities: Array<E>): Promise<Array<E>>;
+    /**
+     *
+     *  Get an access log by its id. You must have read access to the access log. Fails if the access log does not exist
+     *  or if you don't have read access to it.
+     *  Flavoured method.
+     *  @param entityId an access log id.
+     *  @return the access log with id [entityId].
+     */
     getAccessLog(entityId: string): Promise<E | undefined>;
+    /**
+     *
+     *  Get multiple access logs by their ids. Ignores all ids that do not exist, or access logs that you can't access.
+     *  Flavoured method.
+     *  @param entityIds a list of access log ids
+     *  @return all access logs that you can access with one of the provided ids.
+     */
     getAccessLogs(entityIds: Array<string>): Promise<Array<E>>;
 }

package/api/AccessLogFlavouredInGroupApi.d.mts

@@ -6,23 +6,79 @@ import { GroupScoped } from '../model/GroupScoped.mjs';
 import { StoredDocumentIdentifier } from '../model/StoredDocumentIdentifier.mjs';
 import { ArrayWithUniqueKeys } from '../utils/ArrayWithUniqueKeys.mjs';
 export interface AccessLogFlavouredInGroupApi<E extends AccessLog> {
+    /**
+     *
+     *  In-group version of [AccessLogFlavouredApi.shareWith]
+     */
     shareWith(delegate: EntityReferenceInGroup, accessLog: GroupScoped<E>, options?: {
         options?: AccessLogShareOptions | undefined;
     }): Promise<GroupScoped<E>>;
+    /**
+     *
+     *  In-group version of [AccessLogFlavouredApi.shareWithMany]
+     */
     shareWithMany(accessLog: GroupScoped<E>, delegates: ArrayWithUniqueKeys<{
         delegate: EntityReferenceInGroup;
         shareOptions: AccessLogShareOptions;
     }, 'delegate'>): Promise<GroupScoped<E>>;
+    /**
+     *
+     *  In-group version of [AccessLogFlavouredApi.filterAccessLogsBy]
+     */
     filterAccessLogsBy(groupId: string, filter: FilterOptions<AccessLog>): Promise<PaginatedListIterator<GroupScoped<E>>>;
+    /**
+     *
+     *  In-group version of [AccessLogFlavouredApi.filterAccessLogsBySorted]
+     */
     filterAccessLogsBySorted(groupId: string, filter: SortableFilterOptions<AccessLog>): Promise<PaginatedListIterator<GroupScoped<E>>>;
+    /**
+     *
+     *  In-group version of [AccessLogBasicFlavouredApi.createAccessLog].
+     */
     createAccessLog(entity: GroupScoped<E>): Promise<GroupScoped<E>>;
+    /**
+     *
+     *  In-group version of [AccessLogBasicFlavouredApi.createAccessLogs].
+     */
     createAccessLogs(entities: Array<GroupScoped<E>>): Promise<Array<GroupScoped<E>>>;
+    /**
+     *
+     *  In-group version of [AccessLogBasicFlavouredApi.undeleteAccessLogById]
+     */
     undeleteAccessLogById(entityId: GroupScoped<StoredDocumentIdentifier>): Promise<GroupScoped<E>>;
+    /**
+     *
+     *  In-group version of [AccessLogBasicFlavouredApi.undeleteAccessLogsByIds]
+     */
     undeleteAccessLogsByIds(entityIds: Array<GroupScoped<StoredDocumentIdentifier>>): Promise<Array<GroupScoped<E>>>;
+    /**
+     *
+     *  In-group version of [AccessLogBasicFlavouredApi.undeleteAccessLog]
+     */
     undeleteAccessLog(accessLog: GroupScoped<AccessLog>): Promise<GroupScoped<E>>;
+    /**
+     *
+     *  In-group version of [AccessLogBasicFlavouredApi.undeleteAccessLogs]
+     */
     undeleteAccessLogs(accessLogs: Array<GroupScoped<AccessLog>>): Promise<Array<GroupScoped<E>>>;
+    /**
+     *
+     *  In-group version of [AccessLogBasicFlavouredApi.modifyAccessLog]
+     */
     modifyAccessLog(entity: GroupScoped<E>): Promise<GroupScoped<E>>;
+    /**
+     *
+     *  In-group version of [AccessLogBasicFlavouredApi.modifyAccessLogs]
+     */
     modifyAccessLogs(entities: Array<GroupScoped<E>>): Promise<Array<GroupScoped<E>>>;
+    /**
+     *
+     *  In-group version of [AccessLogBasicFlavouredApi.getAccessLog]
+     */
     getAccessLog(groupId: string, entityId: string): Promise<GroupScoped<E> | undefined>;
+    /**
+     *
+     *  In-group version of [AccessLogBasicFlavouredApi.getAccessLogs]
+     */
     getAccessLogs(groupId: string, entityIds: Array<string>): Promise<Array<GroupScoped<E>>>;
 }

package/api/AccessLogInGroupApi.d.mts

@@ -13,6 +13,10 @@ import { AccessLogFlavouredInGroupApi } from './AccessLogFlavouredInGroupApi.mjs
 export interface AccessLogInGroupApi {
     encrypted: AccessLogFlavouredInGroupApi<EncryptedAccessLog>;
     tryAndRecover: AccessLogFlavouredInGroupApi<AccessLog>;
+    /**
+     *
+     *  In-group version of [AccessLogApi.withEncryptionMetadata]
+     */
     withEncryptionMetadata(entityGroupId: string, base: DecryptedAccessLog | undefined, patient: GroupScoped<Patient>, options?: {
         user?: User | undefined;
         delegates?: ArrayWithUniqueKeys<{
@@ -22,30 +26,130 @@ export interface AccessLogInGroupApi {
         secretId?: SecretIdUseOption;
         alternateRootDelegateReference?: EntityReferenceInGroup | undefined;
     }): Promise<GroupScoped<DecryptedAccessLog>>;
+    /**
+     *
+     *  In-group version of [AccessLogApi.getEncryptionKeysOf]
+     */
     getEncryptionKeysOf(accessLog: GroupScoped<AccessLog>): Promise<Array<HexString>>;
+    /**
+     *
+     *  In-group version of [AccessLogApi.hasWriteAccess]
+     */
     hasWriteAccess(accessLog: GroupScoped<AccessLog>): Promise<boolean>;
+    /**
+     *
+     *  In-group version of [AccessLogApi.decryptPatientIdOf]
+     */
     decryptPatientIdOf(accessLog: GroupScoped<AccessLog>): Promise<Array<EntityReferenceInGroup>>;
+    /**
+     *
+     *  In-group version of [AccessLogApi.createDelegationDeAnonymizationMetadata]
+     */
     createDelegationDeAnonymizationMetadata(entity: GroupScoped<AccessLog>, delegates: Array<EntityReferenceInGroup>): Promise<void>;
+    /**
+     *
+     *  In-group version of [AccessLogApi.decrypt]
+     */
     decrypt(accessLogs: Array<GroupScoped<EncryptedAccessLog>>): Promise<Array<GroupScoped<DecryptedAccessLog>>>;
+    /**
+     *
+     *  In-group version of [AccessLogApi.tryDecrypt]
+     */
     tryDecrypt(accessLogs: Array<GroupScoped<EncryptedAccessLog>>): Promise<Array<GroupScoped<AccessLog>>>;
+    /**
+     *
+     *  In-group version of [AccessLogApi.matchAccessLogsBy]
+     */
     matchAccessLogsBy(groupId: string, filter: FilterOptions<AccessLog>): Promise<Array<string>>;
+    /**
+     *
+     *  In-group version of [AccessLogApi.matchAccessLogsBySorted]
+     */
     matchAccessLogsBySorted(groupId: string, filter: SortableFilterOptions<AccessLog>): Promise<Array<string>>;
+    /**
+     *
+     *  In-group version of [AccessLogBasicFlavourlessApi.deleteAccessLogById]
+     */
     deleteAccessLogById(entityId: GroupScoped<StoredDocumentIdentifier>): Promise<GroupScoped<StoredDocumentIdentifier>>;
+    /**
+     *
+     *  In-group version of [AccessLogBasicFlavourlessApi.deleteAccessLogsByIds]
+     */
     deleteAccessLogsByIds(entityIds: Array<GroupScoped<StoredDocumentIdentifier>>): Promise<Array<GroupScoped<StoredDocumentIdentifier>>>;
+    /**
+     *
+     *  In-group version of [AccessLogBasicFlavourlessApi.purgeAccessLogById]
+     */
     purgeAccessLogById(entityId: GroupScoped<StoredDocumentIdentifier>): Promise<void>;
+    /**
+     *
+     *  In-group version of [AccessLogBasicFlavourlessApi.purgeAccessLogsByIds]
+     */
     purgeAccessLogsByIds(entityIds: Array<GroupScoped<StoredDocumentIdentifier>>): Promise<Array<GroupScoped<StoredDocumentIdentifier>>>;
+    /**
+     *
+     *  In-group version of [AccessLogBasicFlavourlessApi.deleteAccessLog]
+     */
     deleteAccessLog(accessLog: GroupScoped<AccessLog>): Promise<GroupScoped<StoredDocumentIdentifier>>;
+    /**
+     *
+     *  In-group version of [AccessLogBasicFlavourlessApi.deleteAccessLogs]
+     */
     deleteAccessLogs(accessLogs: Array<GroupScoped<AccessLog>>): Promise<Array<GroupScoped<StoredDocumentIdentifier>>>;
+    /**
+     *
+     *  In-group version of [AccessLogBasicFlavourlessApi.purgeAccessLog]
+     */
     purgeAccessLog(accessLog: GroupScoped<AccessLog>): Promise<void>;
     purgeAccessLogs(accessLogs: Array<GroupScoped<AccessLog>>): Promise<Array<GroupScoped<StoredDocumentIdentifier>>>;
+    /**
+     *
+     *  In-group version of [AccessLogBasicFlavouredApi.createAccessLog].
+     */
     createAccessLog(entity: GroupScoped<DecryptedAccessLog>): Promise<GroupScoped<DecryptedAccessLog>>;
+    /**
+     *
+     *  In-group version of [AccessLogBasicFlavouredApi.createAccessLogs].
+     */
     createAccessLogs(entities: Array<GroupScoped<DecryptedAccessLog>>): Promise<Array<GroupScoped<DecryptedAccessLog>>>;
+    /**
+     *
+     *  In-group version of [AccessLogBasicFlavouredApi.undeleteAccessLogById]
+     */
     undeleteAccessLogById(entityId: GroupScoped<StoredDocumentIdentifier>): Promise<GroupScoped<DecryptedAccessLog>>;
+    /**
+     *
+     *  In-group version of [AccessLogBasicFlavouredApi.undeleteAccessLogsByIds]
+     */
     undeleteAccessLogsByIds(entityIds: Array<GroupScoped<StoredDocumentIdentifier>>): Promise<Array<GroupScoped<DecryptedAccessLog>>>;
+    /**
+     *
+     *  In-group version of [AccessLogBasicFlavouredApi.undeleteAccessLog]
+     */
     undeleteAccessLog(accessLog: GroupScoped<AccessLog>): Promise<GroupScoped<DecryptedAccessLog>>;
+    /**
+     *
+     *  In-group version of [AccessLogBasicFlavouredApi.undeleteAccessLogs]
+     */
     undeleteAccessLogs(accessLogs: Array<GroupScoped<AccessLog>>): Promise<Array<GroupScoped<DecryptedAccessLog>>>;
+    /**
+     *
+     *  In-group version of [AccessLogBasicFlavouredApi.modifyAccessLog]
+     */
     modifyAccessLog(entity: GroupScoped<DecryptedAccessLog>): Promise<GroupScoped<DecryptedAccessLog>>;
+    /**
+     *
+     *  In-group version of [AccessLogBasicFlavouredApi.modifyAccessLogs]
+     */
     modifyAccessLogs(entities: Array<GroupScoped<DecryptedAccessLog>>): Promise<Array<GroupScoped<DecryptedAccessLog>>>;
+    /**
+     *
+     *  In-group version of [AccessLogBasicFlavouredApi.getAccessLog]
+     */
     getAccessLog(groupId: string, entityId: string): Promise<GroupScoped<DecryptedAccessLog> | undefined>;
+    /**
+     *
+     *  In-group version of [AccessLogBasicFlavouredApi.getAccessLogs]
+     */
     getAccessLogs(groupId: string, entityIds: Array<string>): Promise<Array<GroupScoped<DecryptedAccessLog>>>;
 }

package/api/AgendaApi.d.mts

@@ -6,17 +6,103 @@ export interface AgendaApi {
     inGroup: AgendaInGroupApi;
     createAgenda(agenda: Agenda): Promise<Agenda>;
     createAgendas(agendas: Array<Agenda>): Promise<Array<Agenda>>;
+    /**
+     *
+     *  Deletes an agenda. If you don't have write access to the agenda the method will fail.
+     *  @param entityId id of the agenda.
+     *  @param rev the latest known rev of the agenda to delete
+     *  @return the id and revision of the deleted agenda.
+     *  @throws RevisionConflictException if the provided revision doesn't match the latest known revision
+     */
     deleteAgendaById(entityId: string, rev: string): Promise<StoredDocumentIdentifier>;
+    /**
+     *
+     *  Deletes many agendas. 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 agendas to delete.
+     *  @return the id and revision of the deleted agendas. 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.
+     */
     deleteAgendasByIds(entityIds: Array<StoredDocumentIdentifier>): Promise<Array<StoredDocumentIdentifier>>;
+    /**
+     *
+     *  Permanently deletes a agenda.
+     *  @param id id of the agenda to purge
+     *  @param rev latest revision of the agenda
+     *  @throws RevisionConflictException if the provided revision doesn't match the latest known revision
+     */
     purgeAgendaById(id: string, rev: string): Promise<void>;
+    /**
+     *
+     *  Permanently deletes a batch of agendas.
+     *  @param entityIds ids and revisions of the agendas to purge
+     *  @return the id and revision of the purged agendas. If some entities couldn't be deleted (for example
+     *  because you had no write access to them or their revision is outdated) they will not be included in this list.
+     */
     purgeAgendasByIds(entityIds: Array<StoredDocumentIdentifier>): Promise<Array<StoredDocumentIdentifier>>;
+    /**
+     *
+     *  Restores an agenda 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
+     */
     undeleteAgendaById(id: string, rev: string): Promise<Agenda>;
+    /**
+     *
+     *  Restores a batch of agendas that were marked as deleted.
+     *  @param entityIds the ids and the revisions of the agendas to restore.
+     *  @return the restored agendas. If some entities couldn't be restored (because the user does not have access or the revision is not
+     *  outdated), then those entities will not be restored and will not appear in this list.
+     */
     undeleteAgendasByIds(entityIds: Array<StoredDocumentIdentifier>): Promise<Array<Agenda>>;
+    /**
+     *
+     *  Deletes an agenda. If you don't have write access to the agenda the method will fail.
+     *  @param agenda the agenda to delete
+     *  @return the id and revision of the deleted agenda.
+     *  @throws RevisionConflictException if the provided agenda doesn't match the latest known revision
+     */
     deleteAgenda(agenda: Agenda): Promise<StoredDocumentIdentifier>;
+    /**
+     *
+     *  Deletes many agendas. Ignores agenda for which you don't have write access or that don't match the latest revision.
+     *  @param agendas the agendas to delete
+     *  @return the id and revision of the deleted agendas. If some entities couldn't be deleted they will not be
+     *  included in this list.
+     */
     deleteAgendas(agendas: Array<Agenda>): Promise<Array<StoredDocumentIdentifier>>;
+    /**
+     *
+     *  Permanently deletes a agenda.
+     *  @param agenda the agenda to purge.
+     *  @throws RevisionConflictException if the provided agenda doesn't match the latest known revision
+     */
     purgeAgenda(agenda: Agenda): Promise<void>;
+    /**
+     *
+     *  Permanently deletes a batch of agendas.
+     *  @param agendas the agendas to purge
+     *  @return the id and revision of the purged agendas. If some entities couldn't be deleted (for example
+     *  because you had no write access to them or their revision is outdated) they will not be included in this list.
+     */
     purgeAgendas(agendas: Array<Agenda>): Promise<Array<StoredDocumentIdentifier>>;
+    /**
+     *
+     *  Restores an agenda that was marked as deleted.
+     *  @param agenda the agenda to undelete
+     *  @return the restored agenda.
+     *  @throws RevisionConflictException if the provided agenda doesn't match the latest known revision
+     */
     undeleteAgenda(agenda: Agenda): Promise<Agenda>;
+    /**
+     *
+     *  Restores a batch of agendas that were marked as deleted.
+     *  @param agendas the agendas to restore.
+     *  @return the restored agendas. If some entities couldn't be restored (because the user does not have access or the revision is not
+     *  outdated), then those entities will not be restored and will not appear in this list.
+     */
     undeleteAgendas(agendas: Array<Agenda>): Promise<Array<Agenda>>;
     getAgenda(agendaId: string): Promise<Agenda | undefined>;
     getAgendas(agendaIds: Array<string>): Promise<Array<Agenda>>;

package/api/AnonymousRoleApi.d.mts

@@ -0,0 +1,7 @@
+export interface AnonymousRoleApi {
+    /**
+     *
+     *  @return a list containing all the permissions that can be used in roles.
+     */
+    getPermissions(): Promise<Array<string>>;
+}

package/api/AnonymousRoleApi.mjs

@@ -0,0 +1,2 @@
+// auto-generated file
+export {};