@icure/cardinal-sdk 2.8.0 → 2.9.0

package/Kotlin-DateTime-library-kotlinx-datetime.mjs

@@ -367,7 +367,7 @@ function addFormatStructureForDate(structure) {
 function addFormatStructureForTime(structure) {
   this.u3z(structure);
 }
-initMetadataForInterface(AbstractWithDateTimeBuilder, 'AbstractWithDateTimeBuilder', VOID, VOID, [AbstractWithDateBuilder, AbstractWithTimeBuilder, WithTime, WithDate]);
+initMetadataForInterface(AbstractWithDateTimeBuilder, 'AbstractWithDateTimeBuilder', VOID, VOID, [AbstractWithDateBuilder, AbstractWithTimeBuilder, WithDate, WithTime]);
 initMetadataForClass(Builder_0, 'Builder', VOID, VOID, [AbstractDateTimeFormatBuilder, AbstractWithDateTimeBuilder]);
 initMetadataForClass(LocalDateTimeFormat, 'LocalDateTimeFormat', VOID, AbstractDateTimeFormat);
 function set_fractionOfSecond(value) {

package/api/CalendarItemApi.d.mts

@@ -2,6 +2,7 @@ import { FilterOptions, PaginatedListIterator, SortableFilterOptions } from '../
 import { CalendarItemShareOptions } from '../crypto/entities/CalendarItemShareOptions.mjs';
 import { SecretIdUseOption } from '../crypto/entities/SecretIdUseOption.mjs';
 import { CalendarItem, DecryptedCalendarItem, EncryptedCalendarItem } from '../model/CalendarItem.mjs';
+import { CalendarItemOccupancy } from '../model/CalendarItemOccupancy.mjs';
 import { EntityReferenceInGroup } from '../model/EntityReferenceInGroup.mjs';
 import { Patient } from '../model/Patient.mjs';
 import { StoredDocumentIdentifier } from '../model/StoredDocumentIdentifier.mjs';
@@ -153,6 +154,41 @@ export interface CalendarItemApi {
      *  @return a list of calendarItem ids
      */
     matchCalendarItemsBySorted(filter: SortableFilterOptions<CalendarItem>): Promise<Array<string>>;
+    /**
+     *
+     *  Computes the concurrent-occupancy histogram of the calendar items for the current data owner over the
+     *  period [startDate]..[endDate] (fuzzy date-times, either bound may be null = open).
+     *
+     *  Only calendar items whose whole interval fits within the search range are considered. By default, the
+     *  range is exactly [startDate]..[endDate], so items starting before [startDate] or ending after [endDate]
+     *  are ignored. Pass [extensionInDays] to widen the range by that many days on each side, which lets items
+     *  that start shortly before [startDate] (contributing to the occupancy baseline) or end shortly after
+     *  [endDate] be taken into account. Items reaching beyond the extended range are still ignored.
+     */
+    getCalendarItemsOccupancyByPeriodForSelf(startDate: number, endDate: number, extensionInDays: number | undefined): Promise<Array<CalendarItemOccupancy>>;
+    /**
+     *
+     *  Computes the concurrent-occupancy histogram of the calendar items of [hcPartyId] over the
+     *  period [startDate]..[endDate] (fuzzy date-times, either bound may be null = open).
+     *
+     *  Only calendar items whose whole interval fits within the search range are considered. By default, the
+     *  range is exactly [startDate]..[endDate], so items starting before [startDate] or ending after [endDate]
+     *  are ignored. Pass [extensionInDays] to widen the range by that many days on each side, which lets items
+     *  that start shortly before [startDate] (contributing to the occupancy baseline) or end shortly after
+     *  [endDate] be taken into account. Items reaching beyond the extended range are still ignored.
+     */
+    getCalendarItemsOccupancyByPeriodForHealthcareParty(startDate: number, endDate: number, hcPartyId: string, extensionInDays: number | undefined): Promise<Array<CalendarItemOccupancy>>;
+    /**
+     *
+     *  Computes the concurrent-occupancy histogram of the calendar items of the agenda [agendaId] over the
+     *  period [startDate]..[endDate] (fuzzy date-times, either bound may be null = open).
+     *
+     *  Only calendar items whose whole interval fits within the search range are considered. By default, the range
+     *  is exactly [startDate]..[endDate], you can pass a non-null [extensionInDays] to widen it by that many days on each side (e.g.
+     *  to include items that start before [startDate] but are still open during the period). Items reaching beyond
+     *  the extended range are ignored.
+     */
+    getCalendarItemsOccupancyByPeriodAndAgendaId(startDate: number, endDate: number, agendaId: string, extensionInDays: number | undefined): Promise<Array<CalendarItemOccupancy>>;
     /**
      *
      *  Deletes a calendarItem. If you don't have write access to the calendarItem the method will fail.

package/api/CalendarItemInGroupApi.d.mts

@@ -2,6 +2,7 @@ import { FilterOptions, PaginatedListIterator, SortableFilterOptions } from '../
 import { CalendarItemShareOptions } from '../crypto/entities/CalendarItemShareOptions.mjs';
 import { SecretIdUseOption } from '../crypto/entities/SecretIdUseOption.mjs';
 import { CalendarItem, DecryptedCalendarItem, EncryptedCalendarItem } from '../model/CalendarItem.mjs';
+import { CalendarItemOccupancy } from '../model/CalendarItemOccupancy.mjs';
 import { EntityReferenceInGroup } from '../model/EntityReferenceInGroup.mjs';
 import { GroupScoped } from '../model/GroupScoped.mjs';
 import { Patient } from '../model/Patient.mjs';
@@ -72,6 +73,21 @@ export interface CalendarItemInGroupApi {
      *  In-group version of [CalendarItemApi.matchCalendarItemsBySorted]
      */
     matchCalendarItemsBySorted(groupId: string, filter: SortableFilterOptions<CalendarItem>): Promise<Array<string>>;
+    /**
+     *
+     *  In-group version of [CalendarItemApi.getCalendarItemsOccupancyByPeriodForSelf].
+     */
+    getCalendarItemsOccupancyByPeriodForSelf(groupId: string, startDate: number, endDate: number, extensionInDays: number | undefined): Promise<Array<CalendarItemOccupancy>>;
+    /**
+     *
+     *  In-group version of [CalendarItemApi.getCalendarItemsOccupancyByPeriodForHealthcareParty].
+     */
+    getCalendarItemsOccupancyByPeriodForHealthcareParty(groupId: string, startDate: number, endDate: number, hcPartyId: string, extensionInDays: number | undefined): Promise<Array<CalendarItemOccupancy>>;
+    /**
+     *
+     *  In-group version of [CalendarItemApi.getCalendarItemsOccupancyByPeriodAndAgendaId].
+     */
+    getCalendarItemsOccupancyByPeriodAndAgendaId(groupId: string, startDate: number, endDate: number, agendaId: string, extensionInDays: number | undefined): Promise<Array<CalendarItemOccupancy>>;
     /**
      *
      *  In-group version of [CalendarItemBasicFlavourlessApi.deleteCalendarItemById]

package/api/InsuranceApi.d.mts

@@ -1,3 +1,4 @@
+import { BaseFilterOptions, BaseSortableFilterOptions, PaginatedListIterator } from '../cardinal-sdk-ts.mjs';
 import { Insurance } from '../model/Insurance.mjs';
 import { StoredDocumentIdentifier } from '../model/StoredDocumentIdentifier.mjs';
 import { InsuranceInGroupApi } from './InsuranceInGroupApi.mjs';
@@ -23,4 +24,8 @@ export interface InsuranceApi {
     purgeInsurances(insurances: Array<Insurance>): Promise<Array<StoredDocumentIdentifier>>;
     listInsurancesByCode(insuranceCode: string): Promise<Array<Insurance>>;
     listInsurancesByName(insuranceName: string): Promise<Array<Insurance>>;
+    matchInsurancesBy(filter: BaseFilterOptions<Insurance>): Promise<Array<string>>;
+    filterInsurancesBy(filter: BaseFilterOptions<Insurance>): Promise<PaginatedListIterator<Insurance>>;
+    matchInsurancesBySorted(filter: BaseSortableFilterOptions<Insurance>): Promise<Array<string>>;
+    filterInsurancesBySorted(filter: BaseSortableFilterOptions<Insurance>): Promise<PaginatedListIterator<Insurance>>;
 }

package/api/InsuranceInGroupApi.d.mts

@@ -1,3 +1,4 @@
+import { BaseFilterOptions, BaseSortableFilterOptions, PaginatedListIterator } from '../cardinal-sdk-ts.mjs';
 import { GroupScoped } from '../model/GroupScoped.mjs';
 import { Insurance } from '../model/Insurance.mjs';
 import { StoredDocumentIdentifier } from '../model/StoredDocumentIdentifier.mjs';
@@ -20,4 +21,8 @@ export interface InsuranceInGroupApi {
     purgeInsuranceByIds(entityIds: Array<GroupScoped<StoredDocumentIdentifier>>): Promise<Array<GroupScoped<StoredDocumentIdentifier>>>;
     purgeInsurance(insurance: GroupScoped<Insurance>): Promise<void>;
     purgeInsurances(insurances: Array<GroupScoped<Insurance>>): Promise<Array<GroupScoped<StoredDocumentIdentifier>>>;
+    matchInsurancesBy(groupId: string, filter: BaseFilterOptions<Insurance>): Promise<Array<string>>;
+    matchInsurancesBySorted(groupId: string, filter: BaseSortableFilterOptions<Insurance>): Promise<Array<string>>;
+    filterInsurancesBy(groupId: string, filter: BaseFilterOptions<Insurance>): Promise<PaginatedListIterator<GroupScoped<Insurance>>>;
+    filterInsurancesBySorted(groupId: string, filter: BaseSortableFilterOptions<Insurance>): Promise<PaginatedListIterator<GroupScoped<Insurance>>>;
 }

package/cardinal-sdk-ts.d.mts

@@ -509,6 +509,25 @@ export declare namespace InternalHealthcarePartyFiltersObj {
         }
     }
 }
+export declare abstract class InternalInsuranceFiltersObj {
+    static readonly getInstance: () => typeof InternalInsuranceFiltersObj.$metadata$.type;
+    private constructor();
+}
+export declare namespace InternalInsuranceFiltersObj {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        abstract class type extends KtSingleton<constructor>() {
+            private constructor();
+        }
+        abstract class constructor {
+            all(): BaseFilterOptions<model.Insurance>;
+            byIdentifiers(identifiers: Array<model.Identifier>): BaseFilterOptions<model.Insurance>;
+            byCode(codeType: string, options: any): BaseSortableFilterOptions<model.Insurance>;
+            byTag(tagType: string, options: any): BaseSortableFilterOptions<model.Insurance>;
+            private constructor();
+        }
+    }
+}
 export declare abstract class InternalMaintenanceTaskFiltersObj {
     static readonly getInstance: () => typeof InternalMaintenanceTaskFiltersObj.$metadata$.type;
     private constructor();