@icure/cardinal-sdk 2.1.1 → 2.1.3

package/filters/AccessLogFilters.d.mts

@@ -4,36 +4,156 @@ import { EntityReferenceInGroup } from '../model/EntityReferenceInGroup.mjs';
 import { GroupScoped } from '../model/GroupScoped.mjs';
 import { Patient } from '../model/Patient.mjs';
 interface AccessLogFiltersFactory {
+    /**
+     *
+     *  Options for access log filtering which match all access logs shared directly (i.e. ignoring hierarchies) with a specific data owner
+     *  that are linked with one of the provided patients.
+     *  This Options also allows to restrict the access logs based on [AccessLog.date]:
+     *  - if [from] is not null, only the access logs where [AccessLog.date] is greater than or equal to [from] will be returned.
+     *  - if [to] is not null, only the access logs where [AccessLog.date] is less than or equal to [to] will be returned.
+     *
+     *  When using these options the sdk will automatically extract the secret ids from the provided patients and use
+     *  those for filtering.
+     *  If you already have the secret ids of the patient you may instead use [byPatientSecretIdsDateForDataOwner].
+     *  If the current data owner does not have access to any secret id of one of the provide patients the patient will
+     *  simply be ignored.
+     *  Note that these may not be used in methods of apis from [CardinalBaseApis].
+     *
+     *  These options are sortable. When sorting using these options the access logs will be sorted by [AccessLog.date] in ascending or
+     *  descending order according to the value of the [descending] parameter.
+     *
+     *  @param dataOwnerId a data owner id
+     *  @param patients a list of patients.
+     *  @param from the minimum value for [AccessLog.date] (default: no limit).
+     *  @param to the maximum value for [AccessLog.date] (default: no limit).
+     *  @param descending whether to sort the result in descending or ascending order by [AccessLog.date] (default: ascending).
+     */
     byPatientsDateForDataOwner(dataOwnerId: string, patients: Array<Patient>, options?: {
         from?: number | undefined;
         to?: number | undefined;
         descending?: boolean;
     }): SortableFilterOptions<AccessLog>;
+    /**
+     *
+     *  In group version of [byPatientsDateForDataOwner].
+     */
     byPatientsDateForDataOwnerInGroup(dataOwner: EntityReferenceInGroup, patients: Array<GroupScoped<Patient>>, options?: {
         from?: number | undefined;
         to?: number | undefined;
         descending?: boolean;
     }): SortableFilterOptions<AccessLog>;
+    /**
+     *
+     *  Options for access log filtering which match all access logs shared directly (i.e. ignoring hierarchies) with the current data owner
+     *  that are linked with one of the provided patients.
+     *  This Options also allows to restrict the access logs based on [AccessLog.date]:
+     *  - if [from] is not null, only the access logs where [AccessLog.date] is greater than or equal to [from] will be returned.
+     *  - if [to] is not null, only the access logs where [AccessLog.date] is less than or equal to [to] will be returned.
+     *
+     *  When using these options the sdk will automatically extract the secret ids from the provided patients and use
+     *  those for filtering.
+     *  If you already have the secret ids of the patient you may instead use [byPatientSecretIdsDateForSelf].
+     *  If the current data owner does not have access to any secret id of one of the provide patients the patient will
+     *  simply be ignored.
+     *  Note that these may not be used in methods of apis from [CardinalBaseApis].
+     *
+     *  These options are sortable. When sorting using these options the access logs will be sorted by [AccessLog.date] in ascending or
+     *  descending order according to the value of the [descending] parameter.
+     *
+     *  @param patients a list of patients.
+     *  @param from the minimum value for [AccessLog.date] (default: no limit).
+     *  @param to the maximum value for [AccessLog.date] (default: no limit).
+     *  @param descending whether to sort the result in descending or ascending order by [AccessLog.date] (default: ascending).
+     */
     byPatientsDateForSelf(patients: Array<Patient>, options?: {
         from?: number | undefined;
         to?: number | undefined;
         descending?: boolean;
     }): SortableFilterOptions<AccessLog>;
+    /**
+     *
+     *  Options for access log filtering which match all access logs shared directly (i.e. ignoring hierarchies) with a specific data owner
+     *  that are linked with a patient through one of the provided secret ids.
+     *  This Options also allows to restrict the access logs based on [AccessLog.date]:
+     *  - if [from] is not null, only the access logs where [AccessLog.date] is greater than or equal to [from] will be returned.
+     *  - if [to] is not null, only the access logs where [AccessLog.date] is less than or equal to [to] will be returned.
+     *
+     *  If the current data owner does not have access to any secret id of one of the provide patients the patient will
+     *  simply be ignored.
+     *
+     *  These options are sortable. When sorting using these options the access logs will be sorted by [AccessLog.date] in ascending or
+     *  descending order according to the value of the [descending] parameter.
+     *
+     *  @param dataOwnerId a data owner id
+     *  @param secretIds a list of patient secret ids.
+     *  @param from the minimum value for [AccessLog.date] (default: no limit).
+     *  @param to the maximum value for [AccessLog.date] (default: no limit).
+     *  @param descending whether to sort the result in descending or ascending order by [AccessLog.date] (default: ascending).
+     */
     byPatientSecretIdsDateForDataOwner(dataOwnerId: string, secretIds: Array<string>, options?: {
         from?: number | undefined;
         to?: number | undefined;
         descending?: boolean;
     }): BaseSortableFilterOptions<AccessLog>;
+    /**
+     *
+     *  Options for access log filtering which match all access logs shared directly (i.e. ignoring hierarchies) with the current data owner
+     *  that are linked with a patient through one of the provided secret ids.
+     *  This Options also allows to restrict the access logs based on [AccessLog.date]:
+     *  - if [from] is not null, only the access logs where [AccessLog.date] is greater than or equal to [from] will be returned.
+     *  - if [to] is not null, only the access logs where [AccessLog.date] is less than or equal to [to] will be returned.
+     *
+     *  If the current data owner does not have access to any secret id of one of the provide patients the patient will
+     *  simply be ignored.
+     *  Note that these may not be used in methods of apis from [CardinalBaseApis].
+     *
+     *  These options are sortable. When sorting using these options the access logs will be sorted by [AccessLog.date] in ascending or
+     *  descending order according to the value of the [descending] parameter.
+     *
+     *  @param secretIds a list of patient secret ids.
+     *  @param from the minimum value for [AccessLog.date] (default: no limit).
+     *  @param to the maximum value for [AccessLog.date] (default: no limit).
+     *  @param descending whether to sort the result in descending or ascending order by [AccessLog.date] (default: ascending).
+     */
     byPatientSecretIdsDateForSelf(secretIds: Array<string>, options?: {
         from?: number | undefined;
         to?: number | undefined;
         descending?: boolean;
     }): SortableFilterOptions<AccessLog>;
+    /**
+     *
+     *  Options for access log filtering based on [AccessLog.date]:
+     *  - if [from] is not null, only the access logs where [AccessLog.date] is greater than or equal to [from] will be returned.
+     *  - if [to] is not null, only the access logs where [AccessLog.date] is less than or equal to [to] will be returned.
+     *
+     *  These options are sortable. When sorting using these options the access logs will be sorted by [AccessLog.date] in ascending or
+     *  descending order according to the value of the [descending] parameter.
+     *
+     *  @param from the minimum value for [AccessLog.date] (default: no limit).
+     *  @param to the maximum value for [AccessLog.date] (default: no limit).
+     *  @param descending whether to sort the result in descending or ascending order by [AccessLog.date] (default: ascending).
+     */
     byDate(options?: {
         from?: number | undefined;
         to?: number | undefined;
         descending?: boolean;
     }): BaseSortableFilterOptions<AccessLog>;
+    /**
+     *
+     *  Options for access log filtering where [AccessLog.user] is equal to [userId], [AccessLog.accessType] is equal to [accessType] (if
+     *  provided), and [AccessLog.date] is greater than or equal to [from] (if provided).
+     *  If [from] is not null, then also [accessType] must not be null.
+     *
+     *  These options are sortable. When sorting using these options the access logs will be sorted by [AccessLog.accessType] and then by
+     *  [AccessLog.date] in ascending or
+     *  descending order according to the value of the [descending] parameter.
+     *
+     *  @param userId the id of the user associated to the access log.
+     *  @param accessType the [AccessLog.accessType] (default: any type).
+     *  @param from the minimum value for [AccessLog.date] (default: no limit).
+     *  @param descending whether to sort the result in descending or ascending order by [AccessLog.accessType] and [AccessLog.date  ] (default: ascending).
+     *  @throws IllegalArgumentException if [from] is not null and [accessType] is null.
+     */
     byUserTypeDate(userId: string, options?: {
         accessType?: string | undefined;
         from?: number | undefined;

package/filters/AgendaFilters.d.mts

@@ -2,17 +2,96 @@ import { BaseFilterOptions } from '../cardinal-sdk-ts.mjs';
 import { Agenda } from '../model/Agenda.mjs';
 import { EntityReferenceInGroup } from '../model/EntityReferenceInGroup.mjs';
 interface AgendaFiltersFactory {
+    /**
+     *
+     *  Filter options to match all agendas.
+     *  These options are not sortable.
+     */
     all(): BaseFilterOptions<Agenda>;
+    /**
+     *
+     *  Options for agenda filtering that returns all the agendas where [Agenda.userId] is equal to [userId].
+     *
+     *  @param userId the id of the user associated to the agenda.
+     */
     byUser(userId: string): BaseFilterOptions<Agenda>;
+    /**
+     *
+     *  Options for agenda filtering that returns all the agendas where [Agenda.userId] is equal to [userReference].
+     *
+     *  @param userReference the id of the user associated to the agenda.
+     */
     byUserInGroup(userReference: EntityReferenceInGroup): BaseFilterOptions<Agenda>;
+    /**
+     *
+     *  Options for agenda filtering that returns all the agendas where [Agenda.rights] contains [userId].
+     *
+     *  @param userId the id of that can read the agenda.
+     */
     readableByUser(userId: string): BaseFilterOptions<Agenda>;
+    /**
+     *
+     *  Options for agenda filtering that returns all the agendas where [Agenda.rights] contains [userReference].
+     *
+     *  @param userReference the id of that can read the agenda.
+     */
     readableByUserInGroup(userReference: EntityReferenceInGroup): BaseFilterOptions<Agenda>;
+    /**
+     *
+     *  Options for agenda filtering that returns all the agendas where [Agenda.userRights] contains [userId].
+     *
+     *  @param userId the id of that can read the agenda.
+     */
     readableByUserRights(userId: string): BaseFilterOptions<Agenda>;
+    /**
+     *
+     *  Options for agenda filtering that returns all the agendas where [Agenda.userRights] contains [userReference].
+     *
+     *  @param userReference the id of that can read the agenda.
+     */
     readableByUserRightsInGroup(userReference: EntityReferenceInGroup): BaseFilterOptions<Agenda>;
+    /**
+     *
+     *  Options for agenda filtering that returns all the agendas where [Agenda.properties] contains a property with id equal to [propertyId]
+     *  and a typed value with a string value equals to [propertyValue].
+     *
+     *  @param propertyId the id of the property.
+     *  @param propertyValue the string value of the property.
+     */
     byStringProperty(propertyId: string, propertyValue: string): BaseFilterOptions<Agenda>;
+    /**
+     *
+     *  Options for agenda filtering that returns all the agendas where [Agenda.properties] contains a property with id equal to [propertyId]
+     *  and a typed value with a boolean value equals to [propertyValue].
+     *
+     *  @param propertyId the id of the property.
+     *  @param propertyValue the boolean value of the property.
+     */
     byBooleanProperty(propertyId: string, propertyValue: boolean): BaseFilterOptions<Agenda>;
+    /**
+     *
+     *  Options for agenda filtering that returns all the agendas where [Agenda.properties] contains a property with id equal to [propertyId]
+     *  and a typed value with a long value equals to [propertyValue].
+     *
+     *  @param propertyId the id of the property.
+     *  @param propertyValue the long value of the property.
+     */
     byLongProperty(propertyId: string, propertyValue: number): BaseFilterOptions<Agenda>;
+    /**
+     *
+     *  Options for agenda filtering that returns all the agendas where [Agenda.properties] contains a property with id equal to [propertyId]
+     *  and a typed value with a double value equals to [propertyValue].
+     *
+     *  @param propertyId the id of the property.
+     *  @param propertyValue the double value of the property.
+     */
     byDoubleProperty(propertyId: string, propertyValue: number): BaseFilterOptions<Agenda>;
+    /**
+     *
+     *  Options for agenda filtering that returns all the agendas where [Agenda.properties] contains a property with id equal to [propertyId].
+     *
+     *  @param propertyId the id of the property.
+     */
     withProperty(propertyId: string): BaseFilterOptions<Agenda>;
 }
 export declare const AgendaFilters: AgendaFiltersFactory;

package/filters/CalendarItemFilters.d.mts

@@ -4,45 +4,211 @@ import { EntityReferenceInGroup } from '../model/EntityReferenceInGroup.mjs';
 import { GroupScoped } from '../model/GroupScoped.mjs';
 import { Patient } from '../model/Patient.mjs';
 interface CalendarItemFiltersFactory {
+    /**
+     *
+     *  Options for calendar item filtering which match all calendar items shared directly (i.e. ignoring hierarchies) with a specific data owner
+     *  that are linked with one of the provided patients.
+     *  This Options also allows to restrict the calendar items based on [CalendarItem.startTime]:
+     *  - if the [from] fuzzy date is not null, only the calendar items where [CalendarItem.startTime] is greater than or equal to [from] will be returned.
+     *  - if the [to] fuzzy date is not null, only the calendar items where [CalendarItem.startTime] is less than or equal to [to] will be returned.
+     *
+     *  When using these options the sdk will automatically extract the secret ids from the provided patients and use
+     *  those for filtering.
+     *  If you already have the secret ids of the patient you may instead use [byPatientSecretIdsStartTimeForDataOwner].
+     *  If the current data owner does not have access to any secret id of one of the provide patients the patient will
+     *  simply be ignored.
+     *  Note that these may not be used in methods of apis from [CardinalBaseApis].
+     *
+     *  These options are sortable. When sorting using these options the calendar items will be sorted by [CalendarItem.startTime] in ascending or
+     *  descending order according to the value of the [descending] parameter.
+     *
+     *  @param dataOwnerId a data owner id
+     *  @param patients a list of patients.
+     *  @param from the minimum fuzzy date for [CalendarItem.startTime], in the YYYYMMDDHHMMSS format (default: no limit).
+     *  @param to the maximum fuzzy date for [CalendarItem.startTime], in the YYYYMMDDHHMMSS format (default: no limit).
+     *  @param descending whether to sort the result in descending or ascending order by [CalendarItem.startTime] (default: ascending).
+     */
     byPatientsStartTimeForDataOwner(dataOwnerId: string, patients: Array<Patient>, options?: {
         from?: number | undefined;
         to?: number | undefined;
         descending?: boolean;
     }): SortableFilterOptions<CalendarItem>;
+    /**
+     *
+     *  In-group version of [byPatientsStartTimeForDataOwner].
+     *  The data owner and patients can be from a different group than the group of the user executing the query.
+     */
     byPatientsStartTimeForDataOwnerInGroup(dataOwner: EntityReferenceInGroup, patients: Array<GroupScoped<Patient>>, options?: {
         from?: number | undefined;
         to?: number | undefined;
         descending?: boolean;
     }): SortableFilterOptions<CalendarItem>;
+    /**
+     *
+     *  Options for calendar item filtering which match all calendar items shared directly (i.e. ignoring hierarchies) with the current data owner
+     *  that are linked with one of the provided patients.
+     *  This Options also allows to restrict the calendar items based on [CalendarItem.startTime]:
+     *  - if the [from] fuzzy date is not null, only the calendar items where [CalendarItem.startTime] is greater than or equal to [from] will be returned.
+     *  - if the [to] fuzzy date is not null, only the calendar items where [CalendarItem.startTime] is less than or equal to [to] will be returned.
+     *
+     *  When using these options the sdk will automatically extract the secret ids from the provided patients and use
+     *  those for filtering.
+     *  If you already have the secret ids of the patient you may instead use [byPatientSecretIdsStartTimeForSelf].
+     *  If the current data owner does not have access to any secret id of one of the provide patients the patient will
+     *  simply be ignored.
+     *  Note that these may not be used in methods of apis from [CardinalBaseApis].
+     *
+     *  These options are sortable. When sorting using these options the calendar items will be sorted by [CalendarItem.startTime] in ascending or
+     *  descending order according to the value of the [descending] parameter.
+     *
+     *  @param patients a list of patients.
+     *  @param from the minimum fuzzy date for [CalendarItem.startTime], in the YYYYMMDDHHMMSS format (default: no limit).
+     *  @param to the maximum fuzzy date for [CalendarItem.startTime], in the YYYYMMDDHHMMSS format (default: no limit).
+     *  @param descending whether to sort the result in descending or ascending order by [CalendarItem.startTime] (default: ascending).
+     */
     byPatientsStartTimeForSelf(patients: Array<Patient>, options?: {
         from?: number | undefined;
         to?: number | undefined;
         descending?: boolean;
     }): SortableFilterOptions<CalendarItem>;
+    /**
+     *
+     *  Options for calendar item filtering which match all calendar items shared directly (i.e. ignoring hierarchies) with a specific data owner
+     *  that are linked with one of the provided patients through one of the provided secret ids.
+     *  This Options also allows to restrict the calendar items based on [CalendarItem.startTime]:
+     *  - if the [from] fuzzy date is not null, only the calendar items where [CalendarItem.startTime] is greater than or equal to [from] will be returned.
+     *  - if the [to] fuzzy date is not null, only the calendar items where [CalendarItem.startTime] is less than or equal to [to] will be returned.
+     *
+     *  If the current data owner does not have access to any secret id of one of the provide patients the patient will
+     *  simply be ignored.
+     *
+     *  These options are sortable. When sorting using these options the calendar items will be sorted by [CalendarItem.startTime] in ascending or
+     *  descending order according to the value of the [descending] parameter.
+     *
+     *  @param dataOwnerId a data owner id
+     *  @param secretIds a list of patient secret ids.
+     *  @param from the minimum fuzzy date for [CalendarItem.startTime], in the YYYYMMDDHHMMSS format (default: no limit).
+     *  @param to the maximum fuzzy date for [CalendarItem.startTime], in the YYYYMMDDHHMMSS format (default: no limit).
+     *  @param descending whether to sort the result in descending or ascending order by [CalendarItem.startTime] (default: ascending).
+     */
     byPatientSecretIdsStartTimeForDataOwner(dataOwnerId: string, secretIds: Array<string>, options?: {
         from?: number | undefined;
         to?: number | undefined;
         descending?: boolean;
     }): BaseSortableFilterOptions<CalendarItem>;
+    /**
+     *
+     *  In-group version of [byPatientSecretIdsStartTimeForDataOwner].
+     *  The data owner can be from a different group than the group of the user executing the query.
+     */
     byPatientSecretIdsStartTimeForDataOwnerInGroup(dataOwner: EntityReferenceInGroup, secretIds: Array<string>, options?: {
         from?: number | undefined;
         to?: number | undefined;
         descending?: boolean;
     }): BaseSortableFilterOptions<CalendarItem>;
+    /**
+     *
+     *  Options for calendar item filtering which match all calendar items shared directly (i.e. ignoring hierarchies) with the current data owner
+     *  that are linked with one of the provided patients through one of the provided secret ids.
+     *  This Options also allows to restrict the calendar items based on [CalendarItem.startTime]:
+     *  - if the [from] fuzzy date is not null, only the calendar items where [CalendarItem.startTime] is greater than or equal to [from] will be returned.
+     *  - if the [to] fuzzy date is not null, only the calendar items where [CalendarItem.startTime] is less than or equal to [to] will be returned.
+     *
+     *  If the current data owner does not have access to any secret id of one of the provide patients the patient will
+     *  simply be ignored.
+     *  Note that these may not be used in methods of apis from [CardinalBaseApis].
+     *
+     *  These options are sortable. When sorting using these options the calendar items will be sorted by [CalendarItem.startTime] in ascending or
+     *  descending order according to the value of the [descending] parameter.
+     *
+     *  @param secretIds a list of patient secret ids.
+     *  @param from the minimum fuzzy date for [CalendarItem.startTime], in the YYYYMMDDHHMMSS format (default: no limit).
+     *  @param to the maximum fuzzy date for [CalendarItem.startTime], in the YYYYMMDDHHMMSS format (default: no limit).
+     *  @param descending whether to sort the result in descending or ascending order by [CalendarItem.startTime] (default: ascending).
+     */
     byPatientSecretIdsStartTimeForSelf(secretIds: Array<string>, options?: {
         from?: number | undefined;
         to?: number | undefined;
         descending?: boolean;
     }): SortableFilterOptions<CalendarItem>;
+    /**
+     *
+     *  Options for calendar items filtering which match all the calendar items where [CalendarItem.agendaId] is equal to [agendaId] and
+     *  the [CalendarItem.startTime] fuzzy date is between [from] (inclusive) and [to] (inclusive).
+     *
+     *  These options are sortable. When sorting using these options, the calendar items will be sorted by [CalendarItem.startTime] in
+     *  ascending or descending order according to the value of the [descending] parameter.
+     *
+     *  @param agendaId the value of [CalendarItem.agendaId] to search.
+     *  @param from the fuzzy date (in the YYYYMMDDHHMMSS format) that marks the start of the period.
+     *  @param to the fuzzy date (in the YYYYMMDDHHMMSS format) that marks the end of the period.
+     *  @param descending whether to sort the results in ascending or descending order by [CalendarItem.startTime] (default: ascending).
+     */
     byPeriodAndAgenda(agendaId: string, from: number, to: number, options?: {
         descending?: boolean;
     }): BaseSortableFilterOptions<CalendarItem>;
+    /**
+     *
+     *  Options for calendar item filtering which match all calendar items shared directly (i.e. ignoring hierarchies) with a specific data owner
+     *  and where the [CalendarItem.startTime] fuzzy date is between [from] (inclusive) and [to] (inclusive).
+     *
+     *  @param dataOwnerId a data owner id.
+     *  @param from the fuzzy date (in the YYYYMMDDHHMMSS format) that marks the start of the period.
+     *  @param to the fuzzy date (in the YYYYMMDDHHMMSS format) that marks the end of the period.
+     */
     byPeriodForDataOwner(dataOwnerId: string, from: number, to: number): BaseFilterOptions<CalendarItem>;
+    /**
+     *
+     *  In-group version of [byPeriodForDataOwner].
+     *  The data owner can be from a different group than the group of the user executing the query.
+     */
     byPeriodForDataOwnerInGroup(dataOwner: EntityReferenceInGroup, from: number, to: number): BaseFilterOptions<CalendarItem>;
+    /**
+     *
+     *  Options for calendar item filtering which match all calendar items shared directly (i.e. ignoring hierarchies) with the current data owner
+     *  and where the [CalendarItem.startTime] fuzzy date is between [from] (inclusive) and [to] (inclusive).
+     *
+     *  Note that these may not be used in methods of apis from [CardinalBaseApis].
+     *
+     *  @param from the fuzzy date (in the YYYYMMDDHHMMSS format) that marks the start of the period.
+     *  @param to the fuzzy date (in the YYYYMMDDHHMMSS format) that marks the end of the period.
+     */
     byPeriodForSelf(from: number, to: number): FilterOptions<CalendarItem>;
+    /**
+     *
+     *  Options for calendar item filtering which match all calendar items where [CalendarItem.recurrenceId] is equal to [recurrenceId].
+     *
+     *  @param recurrenceId the recurrence id to filter.
+     */
     byRecurrenceId(recurrenceId: string): FilterOptions<CalendarItem>;
+    /**
+     *
+     *  Options for calendar item filtering which match all calendar items shared directly (i.e. ignoring hierarchies) with a specific data owner
+     *  and where the max among [CalendarItem.created], [CalendarItem.modified], and [CalendarItem.deletionDate] is greater or equal than
+     *  [startTimestamp] (if provided) and less than or equal to [endTimestamp] (if provided).
+     *
+     *  @param dataOwnerId a data owner id.
+     *  @param startTimestamp the smallest lifecycle update that the filter will return.
+     *  @param endTimestamp the biggest lifecycle update that the filter will return.
+     *  @param descending whether to return the results sorted in ascending or descending order by last lifecycle update.
+     */
     lifecycleBetweenForDataOwner(dataOwnerId: string, startTimestamp: number | undefined, endTimestamp: number | undefined, descending: boolean): BaseFilterOptions<CalendarItem>;
+    /**
+     *
+     *  In-group version of [lifecycleBetweenForDataOwner].
+     *  The data owner can be from a different group than the group of the user executing the query.
+     */
     lifecycleBetweenForDataOwnerInGroup(dataOwner: EntityReferenceInGroup, startTimestamp: number | undefined, endTimestamp: number | undefined, descending: boolean): BaseFilterOptions<CalendarItem>;
+    /**
+     *
+     *  Options for calendar item filtering which match all calendar items shared directly (i.e. ignoring hierarchies) with the current data owner
+     *  and where the max among [CalendarItem.created], [CalendarItem.modified], and [CalendarItem.deletionDate] is greater or equal than
+     *  [startTimestamp] (if provided) and less than or equal to [endTimestamp] (if provided).
+     *
+     *  @param startTimestamp the smallest lifecycle update that the filter will return.
+     *  @param endTimestamp the biggest lifecycle update that the filter will return.
+     *  @param descending whether to return the results sorted in ascending or descending order by last lifecycle update.
+     */
     lifecycleBetweenForSelf(startTimestamp: number | undefined, endTimestamp: number | undefined, descending: boolean): FilterOptions<CalendarItem>;
 }
 export declare const CalendarItemFilters: CalendarItemFiltersFactory;

package/filters/ClassificationFilters.d.mts

@@ -2,21 +2,108 @@ import { BaseSortableFilterOptions, SortableFilterOptions } from '../cardinal-sd
 import { Classification } from '../model/Classification.mjs';
 import { Patient } from '../model/Patient.mjs';
 interface ClassificationFiltersFactory {
+    /**
+     *
+     *  Options for classification filtering which match all classifications shared directly (i.e. ignoring hierarchies) with a specific data owner
+     *  that are linked with one of the provided patients.
+     *  This Options also allows to restrict the classifications based on [Classification.created]:
+     *  - if the [from] timestamp is not null, only the classifications where [Classification.created] is greater than or equal to [from] will be returned.
+     *  - if the [to] timestamp is not null, only the classifications where [Classification.created] is less than or equal to [to] will be returned.
+     *
+     *  When using these options the sdk will automatically extract the secret ids from the provided patients and use
+     *  those for filtering.
+     *  If you already have the secret ids of the patient you may instead use [byPatientSecretIdsCreatedForDataOwner].
+     *  If the current data owner does not have access to any secret id of one of the provide patients the patient will
+     *  simply be ignored.
+     *  Note that these may not be used in methods of apis from [CardinalBaseApis].
+     *
+     *  These options are sortable. When sorting using these options the classifications will be sorted by [Classification.created] in ascending or
+     *  descending order according to the value of the [descending] parameter.
+     *
+     *  @param dataOwnerId a data owner id
+     *  @param patients a list of patients.
+     *  @param from the minimum timestamp for [Classification.created] (default: no limit).
+     *  @param to the maximum timestamp for [Classification.created] (default: no limit).
+     *  @param descending whether to sort the result in descending or ascending order by [Classification.created] (default: ascending).
+     */
     byPatientsCreatedForDataOwner(dataOwnerId: string, patients: Array<Patient>, options?: {
         from?: number | undefined;
         to?: number | undefined;
         descending?: boolean;
     }): SortableFilterOptions<Classification>;
+    /**
+     *
+     *  Options for classification filtering which match all classifications shared directly (i.e. ignoring hierarchies) with the current data owner
+     *  that are linked with one of the provided patients.
+     *  This Options also allows to restrict the classifications based on [Classification.created]:
+     *  - if the [from] timestamp is not null, only the classifications where [Classification.created] is greater than or equal to [from] will be returned.
+     *  - if the [to] timestamp is not null, only the classifications where [Classification.created] is less than or equal to [to] will be returned.
+     *
+     *  When using these options the sdk will automatically extract the secret ids from the provided patients and use
+     *  those for filtering.
+     *  If you already have the secret ids of the patient you may instead use [byPatientSecretIdsCreatedForSelf].
+     *  If the current data owner does not have access to any secret id of one of the provide patients the patient will
+     *  simply be ignored.
+     *  Note that these may not be used in methods of apis from [CardinalBaseApis].
+     *
+     *  These options are sortable. When sorting using these options the classifications will be sorted by [Classification.created] in ascending or
+     *  descending order according to the value of the [descending] parameter.
+     *
+     *  @param patients a list of patients.
+     *  @param from the minimum timestamp for [Classification.created] (default: no limit).
+     *  @param to the maximum timestamp for [Classification.created] (default: no limit).
+     *  @param descending whether to sort the result in descending or ascending order by [Classification.created] (default: ascending).
+     */
     byPatientsCreatedForSelf(patients: Array<Patient>, options?: {
         from?: number | undefined;
         to?: number | undefined;
         descending?: boolean;
     }): SortableFilterOptions<Classification>;
+    /**
+     *
+     *  Options for classification filtering which match all classifications shared directly (i.e. ignoring hierarchies) with a specific data owner
+     *  that are linked with one of the provided patients through one of the provided secret ids.
+     *  This Options also allows to restrict the classifications based on [Classification.created]:
+     *  - if the [from] timestamp is not null, only the classifications where [Classification.created] is greater than or equal to [from] will be returned.
+     *  - if the [to] timestamp is not null, only the classifications where [Classification.created] is less than or equal to [to] will be returned.
+     *
+     *  If the current data owner does not have access to any secret id of one of the provide patients the patient will
+     *  simply be ignored.
+     *
+     *  These options are sortable. When sorting using these options the classifications will be sorted by [Classification.created] in ascending or
+     *  descending order according to the value of the [descending] parameter.
+     *
+     *  @param dataOwnerId a data owner id.
+     *  @param secretIds a list of secret ids from one or more patients.
+     *  @param from the minimum timestamp for [Classification.created] (default: no limit).
+     *  @param to the maximum timestamp for [Classification.created] (default: no limit).
+     *  @param descending whether to sort the result in descending or ascending order by [Classification.created] (default: ascending).
+     */
     byPatientSecretIdsCreatedForDataOwner(dataOwnerId: string, secretIds: Array<string>, options?: {
         from?: number | undefined;
         to?: number | undefined;
         descending?: boolean;
     }): BaseSortableFilterOptions<Classification>;
+    /**
+     *
+     *  Options for classification filtering which match all classifications shared directly (i.e. ignoring hierarchies) with the current data owner
+     *  that are linked with one of the provided patients through one of the provided secret ids.
+     *  This Options also allows to restrict the classifications based on [Classification.created]:
+     *  - if the [from] timestamp is not null, only the classifications where [Classification.created] is greater than or equal to [from] will be returned.
+     *  - if the [to] timestamp is not null, only the classifications where [Classification.created] is less than or equal to [to] will be returned.
+     *
+     *  If the current data owner does not have access to any secret id of one of the provide patients the patient will
+     *  simply be ignored.
+     *  Note that these may not be used in methods of apis from [CardinalBaseApis].
+     *
+     *  These options are sortable. When sorting using these options the classifications will be sorted by [Classification.created] in ascending or
+     *  descending order according to the value of the [descending] parameter.
+     *
+     *  @param secretIds a list of secret ids from one or more patients.
+     *  @param from the minimum timestamp for [Classification.created] (default: no limit).
+     *  @param to the maximum timestamp for [Classification.created] (default: no limit).
+     *  @param descending whether to sort the result in descending or ascending order by [Classification.created] (default: ascending).
+     */
     byPatientSecretIdsCreatedForSelf(secretIds: Array<string>, options?: {
         from?: number | undefined;
         to?: number | undefined;