@rentman/rm-core 0.0.0-RM4-44763

package/dist/types/src/models/ItemEntry.d.ts

@@ -0,0 +1,23 @@
+import { ApiItemType, ItemId } from '@rentman/backend-types';
+import { ColumnSet } from '../internal';
+export declare class ItemEntry<ItemTypeType extends ApiItemType = any> {
+    itemType: ItemTypeType;
+    itemId: ItemId;
+    columns: ColumnSet<ItemTypeType>;
+    private static currentId;
+    id: number;
+    isLockableSignal: import("@angular/core").WritableSignal<boolean>;
+    isLocalSignal: import("@angular/core").WritableSignal<boolean>;
+    private outdated;
+    constructor(itemType: ItemTypeType, itemId: ItemId, columns: ColumnSet<ItemTypeType>);
+    updateId(newItemId: number): void;
+    isOutdated(): boolean;
+    markOutdated(): void;
+    markUpToDate(): void;
+    isLocal(): boolean;
+    isLockable(): boolean;
+    toJSON(): {
+        id: number;
+        columns: ColumnSet<ItemTypeType>;
+    };
+}

package/dist/types/src/models/ItemOptions.d.ts

@@ -0,0 +1,25 @@
+import { ApiItemType } from '@rentman/backend-types';
+import { ApiRequestColumnArray, ChildCollectionsOption, EntryParent, FieldMap, ItemAggregatedChangesListener, ItemResource, RequestParameters } from '../internal';
+export interface ItemOptions<ItemTypeType extends ApiItemType, RequestColumns extends ApiRequestColumnArray<ItemTypeType> = ApiRequestColumnArray<ItemTypeType>, Children extends ChildCollectionsOption = ChildCollectionsOption> {
+    columns: RequestColumns;
+    children?: Children;
+    abortSignal?: AbortSignal;
+    /**
+     * Note: When using the `changesListener` option the `context` parameter is untyped. (This would require self
+     * reference.)
+     *
+     * If you need access to the context, you should: either declare (and explicitly type) a named changes listener
+     * or use the `registerChangesListener` method on the collection resource.
+     */
+    changesListener?: ItemAggregatedChangesListener<ItemResource<ItemTypeType, any, any>>;
+    immediatelyCallChangesListener?: boolean;
+}
+export interface NewItemOptions<ItemTypeType extends ApiItemType, RequestColumns extends ApiRequestColumnArray<ItemTypeType> = ApiRequestColumnArray<ItemTypeType>, Children extends ChildCollectionsOption = ChildCollectionsOption> extends ItemOptions<ItemTypeType, RequestColumns, Children> {
+    parent?: EntryParent;
+    templateOptions?: Partial<RequestParameters<ItemTypeType>>;
+    defaultValues?: Partial<FieldMap<ItemTypeType>>;
+}
+export interface ItemsByQueryOptions<ItemTypeType extends ApiItemType, RequestColumns extends ApiRequestColumnArray<ItemTypeType> = ApiRequestColumnArray<ItemTypeType>, Children extends ChildCollectionsOption = ChildCollectionsOption> extends ItemOptions<ItemTypeType, RequestColumns, Children> {
+    parent?: EntryParent;
+    preventCaching?: boolean;
+}

package/dist/types/src/models/ItemResource.d.ts

@@ -0,0 +1,135 @@
+import { Signal } from '@angular/core';
+import { ApiItemType } from '@rentman/backend-types';
+import { AggregatedChangesListenerFunction, ApiRequestColumns, DeregFunction, DerivedStringToRequestColumnPath, EntryParentNull, FieldMap, ItemAggregatedChangesListener, ItemEntry, ItemResourceFactory, ItemTypeColumnIds, RequestColumnsFieldMap, RequestColumnsSignalFieldMap, RequestColumnsToDerivedArrayPaths, RequestColumnsToDerivedStringPaths, RequestParameters, RequestToItemColumns, ResolveDerivedValue, ResolveDerivedValues, ResponseColumnMap, TransactionCache } from '../internal';
+/**
+ * This type is used to constrain the `Children` type parameter of item resources and collection resources. We don't
+ * specify the whole collection resource here to prevent creating a circular type.
+ */
+export type ChildCollectionResources = {
+    [ChildItemType in ApiItemType]?: {
+        itemType: ChildItemType;
+        items: any[];
+    };
+};
+export type ItemResourceComputedSignalFunction<ItemTypeType extends ApiItemType, RequestColumns extends ApiRequestColumns<ItemTypeType>, ReturnValue = unknown> = (itemResource: {
+    transaction: TransactionCache;
+    entry: ItemEntry<ItemTypeType>;
+    fieldSignals: Readonly<RequestColumnsSignalFieldMap<ItemTypeType, RequestColumns>>;
+    getDerivedSignal: <GetDerivedSignalPath extends readonly string[] | string, DefaultValue = unknown>(pathInput: GetDerivedSignalPath, defaultValue?: DefaultValue) => Signal<MaybeDefaultValue<ResolveDerivedValue<ItemTypeType, GetDerivedSignalPath extends string ? DerivedStringToRequestColumnPath<GetDerivedSignalPath> : GetDerivedSignalPath>, DefaultValue>>;
+}) => ReturnValue;
+type MaybeDefaultValue<T, DefaultValue> = DefaultValue extends number | bigint | string | boolean | null | object ? DefaultValue | T : T;
+export declare class ItemResource<ItemTypeType extends ApiItemType = ApiItemType, RequestColumns extends ApiRequestColumns<ItemTypeType> = ItemTypeColumnIds<ItemTypeType>, Children extends ChildCollectionResources | undefined = undefined> {
+    protected readonly factory: ItemResourceFactory;
+    readonly entry: ItemEntry<ItemTypeType>;
+    readonly transaction: TransactionCache;
+    private readonly _isNew;
+    columns: ResponseColumnMap<ItemTypeType, RequestToItemColumns<ItemTypeType, RequestColumns>>;
+    fields: Readonly<RequestColumnsFieldMap<ItemTypeType, RequestColumns>>;
+    initial: Readonly<RequestColumnsFieldMap<ItemTypeType, RequestColumns>>;
+    fieldSignals: Readonly<RequestColumnsSignalFieldMap<ItemTypeType, RequestColumns>>;
+    itemType: ItemTypeType;
+    children: Children;
+    /**
+     * We type this loosely to prevent TypeScript inferring a complex type when comparing item resources.
+     */
+    private readonly aggregatedChangesListeners;
+    private derivedFieldSignals;
+    private __computedFunctions;
+    constructor(factory: ItemResourceFactory, entry: ItemEntry<ItemTypeType>, transaction: TransactionCache, _isNew: boolean, abortSignal?: AbortSignal | null);
+    onConstruct(): void;
+    computedSignal<FunctionReference extends ItemResourceComputedSignalFunction<ItemTypeType, RequestColumns>>(functionReference: FunctionReference): Signal<ReturnType<FunctionReference>>;
+    /**
+     * We type this loosely to prevent TypeScript inferring a complex type when comparing item resources.
+     * @internal
+     */
+    getAggregatedChangesListeners<ChangesListeners extends Set<AggregatedChangesListenerFunction<any, any>>>(accumulator?: ChangesListeners): ChangesListeners;
+    clearResource(): void;
+    deregisterChangesListener(listener: ItemAggregatedChangesListener<ItemResource<ItemTypeType, RequestColumns, Children>>): void;
+    registerChangesListener(listener: ItemAggregatedChangesListener<ItemResource<ItemTypeType, RequestColumns, Children>>): DeregFunction;
+    setChildCollectionResources(children: Children): void;
+    /**
+     * Collects all the fields from this item, useful while debugging when you want to look at the complete fieldset
+     * (because this.fields is now a proxy class)
+     */
+    collectFields(): RequestColumnsFieldMap<ItemTypeType, RequestColumns>;
+    /**
+     * @description
+     * Updates the fields of the item and calls onChange, when updating many fields of many items it's better to create a {@link ChangesDelta ChangesDelta} yourself so all changes can be applied at once
+     */
+    setFields(values: Partial<FieldMap<ItemTypeType>>): Promise<this>;
+    /**
+     * Copies the fields of the item resource to `destination`.
+     * Note: When you want to create lots of copies, there are some straightforward optimizations that can be done here.
+     * @param destination - For the resulting type to be correct, the columns of the destination should be known. Existing
+     * properties will be preserved.
+     * @param columnIds - The columns that should be copied. Only fields specified in the item resource type can be set here.
+     * Will copy all available columns by default. (Note: may include columns not specified in the type.)
+     * @returns The `destination` object.
+     */
+    copyFields<DestinationColumnIds extends ItemTypeColumnIds<ItemTypeType> = [], ColumnIds extends readonly RequestToItemColumns<ItemTypeType, RequestColumns>[number][] = RequestToItemColumns<ItemTypeType, RequestColumns>[number][]>(destination?: FieldMap<ItemTypeType, DestinationColumnIds>, columnIds?: ColumnIds): FieldMap<ItemTypeType, DestinationColumnIds | ColumnIds>;
+    /**
+     * Fetches the ItemResource's parent with the current fields
+     *
+     * ----------------
+     *
+     * @remark
+     * Use this if you need to get the parent after an item has been deleted
+     */
+    getParent(fromInitial?: boolean): EntryParentNull;
+    /**
+     * @description
+     * Utility function to easily check if a field is changed.
+     * Will return `false` if the field is changed
+     *
+     * @example
+     * onChange: (
+     *     itemResource,
+     *     previous,
+     *     compareItemField
+     * ) {
+     *     if (!compareItemField('columnId')) {
+     *         processItem(itemResource);
+     *     }
+     * }
+     */
+    compareItemField(columnId: RequestToItemColumns<ItemTypeType, RequestColumns>[number], previous: RequestColumnsFieldMap<ItemTypeType, RequestColumns>): boolean;
+    hasChanges(): boolean;
+    setTransactionParameters(parameters: Partial<RequestParameters<ItemTypeType>>): void;
+    /**
+     * @description
+     * 'isNew' means that the {@link ItemEntry ItemEntry} is a local item and that this resource was created when the {@link ItemEntry ItemEntry} was first created
+     */
+    isNew(): boolean;
+    isLocal(): boolean;
+    toJSON(): {
+        columns: string[];
+        fields: Readonly<RequestColumnsFieldMap<ItemTypeType, RequestColumns>>;
+        entry: ItemEntry<ItemTypeType>;
+    };
+    getDerivedSignal<const T extends RequestColumnsToDerivedStringPaths<RequestColumns>, DefaultValue = unknown>(pathInput: T, defaultValue?: DefaultValue): Signal<MaybeDefaultValue<ResolveDerivedValue<ItemTypeType, DerivedStringToRequestColumnPath<T>>, DefaultValue>>;
+    getDerivedSignal<const T extends RequestColumnsToDerivedArrayPaths<RequestColumns>, DefaultValue = unknown>(pathInput: T, defaultValue?: DefaultValue): Signal<MaybeDefaultValue<ResolveDerivedValue<ItemTypeType, T>, DefaultValue>>;
+    /**
+     * @description
+     * Returns the value of the columnPath, or undefined when the path couldn't be traversed
+     *
+     * @param columnPath Can either be an array of columnIds (['column', 'column2']) or a config column string ('column>column2')
+     */
+    getDerivedValue<const T extends RequestColumnsToDerivedStringPaths<RequestColumns>, DefaultValue = unknown>(columnPath: T, defaultValue?: DefaultValue): MaybeDefaultValue<ResolveDerivedValue<ItemTypeType, DerivedStringToRequestColumnPath<T>>, DefaultValue>;
+    getDerivedValue<const T extends RequestColumnsToDerivedArrayPaths<RequestColumns>, DefaultValue = unknown>(columnPath: T, defaultValue?: DefaultValue): MaybeDefaultValue<ResolveDerivedValue<ItemTypeType, T>, DefaultValue>;
+    /**
+     * @description
+     * Traverses the column path and returns the fields of the derived item, returns undefined if the item isn't found
+     *
+     * ---------------------
+     *
+     * @remark
+     * Assumes the derived item's values are already cached
+     */
+    getDerivedValues<const T extends readonly string[]>(columnPath: T): ResolveDerivedValues<ItemTypeType, T> | undefined;
+    /**
+     * @description
+     * Clears all the child CollectionResource attached to an itemResource
+     */
+    clearChildCollections(): void;
+}
+export {};

package/dist/types/src/models/LimitedCollectionResource.d.ts

@@ -0,0 +1,26 @@
+import { ApiItemType } from '@rentman/backend-types';
+import { ApiRequestColumnArray, ChildCollectionResources, CollectionItemResourceChanges, CollectionResource, ItemEntry, OrderedCollectionResource, RootCollectionOptionsWithLimit } from '../internal';
+export declare class LimitedCollectionResource<ItemTypeType extends ApiItemType, RequestColumns extends ApiRequestColumnArray<ItemTypeType>, Children extends ChildCollectionResources | undefined = undefined> extends OrderedCollectionResource<ItemTypeType, RequestColumns, Children> {
+    options: RootCollectionOptionsWithLimit<ItemTypeType>;
+    setLimit(newLimit: number): Promise<void>;
+    handleMatchedItemEntries(fittingItemEntries: Iterable<ItemEntry<ItemTypeType>>, nonFittingItemEntries: Set<ItemEntry<ItemTypeType>> | undefined, clearChildCollectionResources: boolean): Promise<CollectionItemResourceChanges<CollectionResource<ItemTypeType, RequestColumns, Children>>>;
+    /**
+     * @returns A *sorted* array of item entries representing `baseItemEntries` with `itemEntriesToBeAdded` and
+     * `itemEntriesToBeRemovedSet` applied.
+     */
+    private applyAddedRemovedItemEntries;
+    /**
+     * When adding items to or removing items from a collection having a `limit` property set, we want to express the
+     * limit in the items that will be added / removed, instead of basing it on items currently present in the
+     * collection. This way, when a changes listener is registered, we ensure that:
+     *
+     * - The changes listener is called only once;
+     * - The changes listener is called with item resources representing the final added / removed items.
+     */
+    private limitItemEntriesToBeAdded;
+    /**
+     * When were removing items from the collection, we want to add additional items as well, such that we still
+     * adhere to the limit. See: {@link limitItemEntriesToBeAdded}.
+     */
+    private increaseItemEntriesToBeAdded;
+}

package/dist/types/src/models/OrderedCollectionResource.d.ts

@@ -0,0 +1,19 @@
+import { ApiItemType } from '@rentman/backend-types';
+import { AddedRemovedItemResources, ApiRequestColumnArray, ChildCollectionResources, CollectionResource, ItemEntry, ItemResource, ParentIdMap, RootCollectionOptionsWithOrder } from '../internal';
+type CompareFunction<ValueType> = (value1: ValueType, value2: ValueType) => number;
+export declare class OrderedCollectionResource<ItemTypeType extends ApiItemType, RequestColumns extends ApiRequestColumnArray<ItemTypeType>, Children extends ChildCollectionResources | undefined = undefined> extends CollectionResource<ItemTypeType, RequestColumns, Children> {
+    options: RootCollectionOptionsWithOrder<ItemTypeType>;
+    initializeItems(initialItemEntries: ItemEntry<ItemTypeType>[], childCollectionResourceMap: ParentIdMap<Children>): void;
+    /**
+     * Note that `updateItemsProperty` is called whenever items are updated, so there's no reason to register a listener
+     * as well.
+     */
+    protected updateItemsProperty(itemEntriesToBeAdded: ItemEntry<ItemTypeType>[], itemEntriesToBeRemovedSet: Set<ItemEntry<ItemTypeType>>, clearChildCollectionResources: boolean): Promise<AddedRemovedItemResources<ItemResource<ItemTypeType, RequestColumns, Children>>>;
+    protected getSortCompareTuple(): {
+        compareFunction: CompareFunction<unknown>;
+        isDescending: boolean;
+    };
+    protected sortItemResources(): void;
+    protected sortItemEntries(itemEntries: ItemEntry<ItemTypeType>[]): ItemEntry<ItemTypeType>[];
+}
+export {};

package/dist/types/src/models/Template.d.ts

@@ -0,0 +1,17 @@
+import { ApiItemType, ItemId } from '@rentman/backend-types';
+import { ApiResponseProcessor, ColumnSet, ColumnSetFactory, FieldMap, ItemEntryService, ResponseColumnItemTypeMap } from '../internal';
+export declare class Template<ItemTypeType extends ApiItemType> {
+    readonly itemType: ItemTypeType;
+    readonly response: ApiResponseProcessor<ItemTypeType>;
+    private readonly columnSetFactory;
+    private readonly itemEntryService;
+    private readonly additionalResponseColumns;
+    /**
+     * Also contains the additional response columns.
+     */
+    private readonly responseColumns;
+    constructor(itemType: ItemTypeType, response: ApiResponseProcessor<ItemTypeType>, columnSetFactory: ColumnSetFactory, itemEntryService: ItemEntryService, additionalResponseColumns: ResponseColumnItemTypeMap);
+    getFields<FieldsItemType extends ApiItemType = ItemTypeType>(itemType?: FieldsItemType, itemId?: ItemId<FieldsItemType>): FieldMap<FieldsItemType>;
+    getMainColumnSet(): ColumnSet<ItemTypeType>;
+    getColumnSet<ColumnSetItemType extends ApiItemType>(itemType: ColumnSetItemType): ColumnSet<ColumnSetItemType>;
+}

package/dist/types/src/services/rm-holidays.service.d.ts

@@ -0,0 +1,31 @@
+import moment from 'moment';
+import { CollectionResource, RmCore } from '../internal';
+export declare const HOLIDAY_ICON = "beach_access";
+declare const holidayColumns: readonly ["id", "date", "name", "yearly"];
+export type HolidayFields = {
+    uid: `hol-${number}` | `hol-${number}-${number}`;
+    name: string;
+    date: moment.Moment;
+};
+/**
+ * A service handling 'Holiday' items.
+ *
+ * Note that methods querying the holiday items have a `rmCoreInstance` parameter. This is to accommodate the app, where
+ * multiple users can be logged in simultaneously, each having a separate core instance. The `rmCoreInstance` parameter
+ * is optional; when absent the first instance will be picked.
+ *
+ * Warning: for each core instance, the service should be initialized before querying the holiday items. It will throw
+ * an exception otherwise.
+ */
+export declare class RmHolidaysService {
+    private holidayCollectionResourcesMap;
+    rangeContainsHoliday$(start: moment.Moment, end: moment.Moment, rmCoreInstance?: RmCore): boolean;
+    getHolidaysInDateRange$(start: moment.Moment, end: moment.Moment, rmCoreInstance?: RmCore): HolidayFields[];
+    rangeContainsHoliday(start: moment.Moment, end: moment.Moment, rmCoreInstance?: RmCore): boolean;
+    getHolidaysInDateRange(start: moment.Moment, end: moment.Moment, rmCoreInstance?: RmCore): HolidayFields[];
+    initialize(rmCoreInstance: RmCore): Promise<void>;
+    clear(rmCoreInstance: RmCore): boolean;
+    getHolidaysInDateRangeIterator$(start: moment.Moment, end: moment.Moment, rmCoreInstance?: RmCore): Generator<HolidayFields>;
+    getHolidaysCollection(rmCoreInstance?: RmCore): CollectionResource<'Holiday', typeof holidayColumns>;
+}
+export {};

package/dist/types/src/types/AggregatedChangesListener.d.ts

@@ -0,0 +1,99 @@
+import { AddedRemovedItemResources, ChangesListenerContextItemResourceShape, CollectionItemChangesListenerContext, CollectionToItemResource, ItemChangesListenerContext } from '../internal';
+/**
+ * We're using the array index as the current value here.
+ */
+export type PreviousNumber = [never, 0, 1, 2, 3];
+/**
+ * `CollectionChildrenShape`, `ItemResourceShape` and `CollectionResourceShape` describe the `children` property of item
+ * resources, item resources themselves, and collection resources respectively, using only the properties required
+ * to infer the aggregated changes listener context.
+ */
+type CollectionChildrenShape = {
+    [itemType: string]: CollectionResourceShape;
+};
+type ItemResourceShape = {
+    itemType: string;
+    children: CollectionChildrenShape | undefined;
+};
+type CollectionResourceShape = {
+    itemType: string;
+    items: ItemResourceShape[];
+};
+/**
+ * Changes listener context for a single collection resource. Includes added, removed, and changed items.
+ *
+ * Related to the {@link CollectionItemResourceChanges}, but stores {@link CollectionItemChangesListenerContext}
+ * instances instead of item resources for changed items.
+ */
+export interface CollectionChangesListenerContext<CollectionResourceType extends {
+    items: any[];
+}> extends AddedRemovedItemResources<CollectionToItemResource<CollectionResourceType>> {
+    changedItems: CollectionItemChangesListenerContext<CollectionResourceType>[];
+    collectionResource: CollectionResourceType;
+}
+/**
+ * Describes aggregated changes for collections. Does not include children.
+ */
+type CollectionAggregatedChanges<CollectionResourceType extends CollectionResourceShape> = {
+    [itemType in CollectionResourceType['itemType']]?: CollectionChangesListenerContext<CollectionResourceType>[];
+};
+type CollectionChildrenAggregatedChanges<CollectionChildren extends CollectionChildrenShape> = {
+    [childItemType in keyof CollectionChildren]?: CollectionChangesListenerContext<CollectionChildren[childItemType]>[];
+};
+type InferCollectionChildren<CollectionResourceType extends CollectionResourceShape> = CollectionResourceType['items'][number]['children'];
+type UnionToIntersection<Union> = (Union extends any ? (x: Union) => void : never) extends ((x: infer Intersection) => void) ? Intersection : never;
+/**
+ * Describes aggregated changes for a specific collection, and recursively includes child collections. We want to use
+ * this type independently of the `AggregatedChangesListener` type. It does not need to handle unions in that case.
+ *
+ * Because `CollectionResourceToAggregatedChanges` is defined as a conditional type it automatically distributes over a
+ * union type parameter value.
+ */
+type CollectionResourceToAggregatedChanges<CollectionResourceType extends CollectionResourceShape> = InferCollectionChildren<CollectionResourceType> extends CollectionChildrenShape ? CollectionAggregatedChanges<CollectionResourceType> & CollectionDescendantsToAggregatedChanges<InferCollectionChildren<CollectionResourceType>> : CollectionAggregatedChanges<CollectionResourceType>;
+/**
+ * Note that `CollectionResourceToAggregatedChanges` and `CollectionDescendantsToAggregatedChanges` are defined in such
+ * a way that they always produce a type that adheres to `CollectionResourceAggregatedChanges` or
+ * `CollectionChildrenAggregatedChanges`, respectively. This increases the readability of type hints.
+ *
+ * Because `CollectionDescendantsToAggregatedChanges` is defined as a conditional type it automatically distributes over a
+ * union type parameter value.
+ */
+export type CollectionDescendantsToAggregatedChanges<CollectionChildrenType extends CollectionChildrenShape, MaxDepth extends PreviousNumber[number] = 3> = [PreviousNumber[MaxDepth]] extends [never] ? CollectionChildrenAggregatedChanges<CollectionChildrenType> : CollectionChildrenAggregatedChanges<CollectionChildrenType> & UnionToIntersection<{
+    [childItemType in keyof CollectionChildrenType]: InferCollectionChildren<CollectionChildrenType[childItemType]> extends CollectionChildrenShape ? CollectionDescendantsToAggregatedChanges<InferCollectionChildren<CollectionChildrenType[childItemType]>, PreviousNumber[MaxDepth]> : never;
+}[keyof CollectionChildrenType]>;
+/**
+ * Because `ItemResourceToAggregatedChanges` is defined as a conditional type it automatically distributes over a
+ * union type parameter value.
+ */
+export type ItemResourceToAggregatedChanges<ItemResourceType extends ItemResourceShape> = ItemResourceType extends ChangesListenerContextItemResourceShape ? {
+    [itemType in ItemResourceType['itemType']]?: ItemChangesListenerContext<ItemResourceType>[];
+} : never;
+/**
+ * We can use this type to loosely describe an aggregated changes listener function by leaving the parameters untyped.
+ */
+export type AggregatedChangesListenerFunction<AggregatedCollectionChanges, AggregatedItemChanges> = (aggregatedCollectionChanges: AggregatedCollectionChanges, aggregatedItemChanges: AggregatedItemChanges, isCalledAfterSocketUpdate: boolean) => void;
+/**
+ * A convenience type that produces an aggregated changes listener for a single item resource.
+ */
+export type ItemAggregatedChangesListener<ItemResourceType extends ItemResourceShape> = AggregatedChangesListenerFunction<ItemResourceType extends {
+    children: CollectionChildrenShape;
+} ? CollectionDescendantsToAggregatedChanges<ItemResourceType['children']> : any, ItemResourceToAggregatedChanges<ItemResourceType>>;
+/**
+ * The aggregated changes listener function. Use this type when defining an aggregated changes listener.
+ *
+ * This type should not be used in the core itself. We can use the {@link AggregatedChangesListenerFunction} type instead.
+ */
+export type AggregatedChangesListener<CollectionResourceUnion extends CollectionResourceShape | undefined, ItemResourceUnion extends ItemResourceShape | undefined> = AggregatedChangesListenerFunction<UnionToIntersection<(CollectionResourceUnion extends CollectionResourceShape ? CollectionResourceToAggregatedChanges<CollectionResourceUnion> : never) | (ItemResourceUnion extends {
+    children: CollectionChildrenShape;
+} ? CollectionDescendantsToAggregatedChanges<ItemResourceUnion['children']> : never)>, UnionToIntersection<ItemResourceUnion extends ItemResourceShape ? ItemResourceToAggregatedChanges<ItemResourceUnion> : never>>;
+/**
+ * For each map entry, the listener should match the aggregated changes, but this is not possible to type when using a
+ * `Map`.
+ *
+ * Note that we're using the non-recursive `CollectionAggregatedChanges` type here.
+ */
+export type AggregatedChangesByListener = Map<AggregatedChangesListenerFunction<any, any>, {
+    collection: CollectionAggregatedChanges<any>;
+    item: ItemResourceToAggregatedChanges<any>;
+}>;
+export {};

package/dist/types/src/types/ApiQuery.d.ts

@@ -0,0 +1,95 @@
+import { ApiEnumApiType, ApiFields, ApiItemType, ApiQueryConditionBaseSimple, ApiQueryConditionComparatorBaseNull, ApiQueryConditionCustom, ApiQueryConditionExtendedSubQueryBase, ApiQueryConditionInBase, ApiQueryConditionLinkedToBase, ApiQueryConditionSearch, ApiQueryConditionShortBase, ApiQueryConditionSubQueryBase, ApiQueryEmpty, ApiQueryWithConditionsBase, EnumApiField, ExtendedSubQuerySubColumnId, ItemApiFields, ValueComparatorTuple, ValueEqualToComparatorTuple } from '@rentman/backend-types';
+import moment from 'moment';
+import { ApiEnumApiTypeToTsTypeMap, ItemTypeColumnId } from './ItemTypesCollection';
+interface ApiField {
+    type: keyof ApiEnumApiTypeToTsTypeMap;
+}
+interface DateDurationApiField {
+    type: ApiEnumApiType.TYPE_DATETIME | ApiEnumApiType.TYPE_DATE | ApiEnumApiType.TYPE_DURATION | ApiEnumApiType.TYPE_TIMESTAMP | ApiEnumApiType.TYPE_TIMESTAMP_MS;
+}
+interface QueryableApiField extends ApiField {
+    type: keyof ApiEnumApiTypeToTsTypeMap;
+    queryable: true;
+}
+type ApiFieldToNullType<ApiFieldType extends QueryableApiField> = ApiFieldType extends {
+    nullable: false;
+} | DateDurationApiField ? never : null;
+type ApiFieldToValueComparatorTuple<ApiFieldType extends QueryableApiField> = ApiFieldType extends EnumApiField ? ValueEqualToComparatorTuple<keyof ApiFieldType['enum']> : ApiFieldType['type'] extends ApiEnumApiType.TYPE_DATETIME | ApiEnumApiType.TYPE_DATE | ApiEnumApiType.TYPE_TIMESTAMP | ApiEnumApiType.TYPE_TIMESTAMP_MS ? ValueComparatorTuple<moment.Moment | 'NOW'> : ApiFieldType['type'] extends ApiEnumApiType.TYPE_DURATION ? ValueComparatorTuple<moment.Duration> : ApiEnumApiTypeToTsTypeMap[ApiFieldType['type']] extends number ? ValueComparatorTuple<number> : ValueEqualToComparatorTuple<ApiEnumApiTypeToTsTypeMap[ApiFieldType['type']]>;
+/**
+ * Note that the types using `ApiQueryConditionComparator`, `ApiQueryConditionIn` and `ApiQueryConditionComparatorShort`
+ * are only used for typing individual conditions, and are not part of the final `ApiQuery` type, where they are replaced by
+ * `ApiQueryConditionSimple`.
+ */
+type ApiFieldToValueType<ApiFieldType extends QueryableApiField> = ApiFieldToValueComparatorTuple<ApiFieldType>['value'] | ApiFieldToNullType<ApiFieldType>;
+export type ApiQueryConditionComparator<ItemTypeType extends ApiItemType, ColumnIdType extends ItemTypeColumnId<ItemTypeType>> = ApiFields[ItemTypeType][ColumnIdType] extends QueryableApiField ? ApiQueryConditionComparatorBaseNull<ColumnIdType, ApiFieldToValueComparatorTuple<ApiFields[ItemTypeType][ColumnIdType]>, ApiFieldToNullType<ApiFields[ItemTypeType][ColumnIdType]>> : never;
+export type ApiQueryConditionIn<ItemTypeType extends ApiItemType, ColumnIdType extends ItemTypeColumnId<ItemTypeType>> = ApiFields[ItemTypeType][ColumnIdType] extends QueryableApiField ? ApiQueryConditionInBase<ColumnIdType, ApiFieldToValueType<ApiFields[ItemTypeType][ColumnIdType]>> : never;
+export type ApiQueryConditionComparatorShort<ItemTypeType extends ApiItemType, ColumnIdType extends ItemTypeColumnId<ItemTypeType>> = ApiFields[ItemTypeType][ColumnIdType] extends QueryableApiField ? ApiQueryConditionShortBase<ColumnIdType, ApiFieldToValueType<ApiFields[ItemTypeType][ColumnIdType]>> : never;
+export interface ApiQueryWithConditions<ItemTypeType extends ApiItemType> extends ApiQueryWithConditionsBase {
+    conditions: ApiQuery<ItemTypeType>[];
+}
+export interface ApiQueryConditionLinkedTo<ItemTypeType extends ApiItemType> extends ApiQueryConditionLinkedToBase<ItemTypeType> {
+    query?: ApiQuery<ItemTypeType>;
+}
+export interface ApiQueryConditionSubQuery<ItemTypeType extends ApiItemType, ColumnIdType extends keyof ItemApiFields<ItemTypeType>> extends ApiQueryConditionSubQueryBase<ColumnIdType> {
+    query: ApiQuery<ItemApiFields<ItemTypeType>[ColumnIdType]['itemType']>;
+}
+export interface ApiQueryConditionExtendedSubQuery<MainItemType extends ApiItemType, ColumnIdType extends keyof ItemApiFields<MainItemType> | 'id', SubItemType extends ApiItemType, SubColumnIdType extends ExtendedSubQuerySubColumnId<MainItemType, ColumnIdType, SubItemType> = ExtendedSubQuerySubColumnId<MainItemType, ColumnIdType, SubItemType>> extends ApiQueryConditionExtendedSubQueryBase<ColumnIdType, SubItemType, SubColumnIdType> {
+    query: ApiQuery<SubItemType>;
+}
+type ApiQueryConditionSubQueryUnion<ItemTypeType extends ApiItemType> = {
+    [ColumnId in keyof ItemApiFields<ItemTypeType>]: ApiQueryConditionSubQuery<ItemTypeType, ColumnId> | ApiQueryConditionExtendedSubQuery<ItemTypeType, ColumnId, ApiItemType, any>;
+}[keyof ItemApiFields<ItemTypeType>];
+type ApiFieldToQueryConditionSimple<ColumnId extends string | number | symbol, ApiFieldType> = ApiFieldType extends QueryableApiField ? ApiQueryConditionBaseSimple<ColumnId, ApiFieldToValueComparatorTuple<ApiFieldType>, ApiFieldToNullType<ApiFieldType>> : never;
+type ApiQueryConditionSimple<ItemTypeType extends ApiItemType> = {
+    [ColumnId in keyof ApiFields[ItemTypeType]]: ApiFieldToQueryConditionSimple<ColumnId, ApiFields[ItemTypeType][ColumnId]>;
+}[keyof ApiFields[ItemTypeType]];
+/**
+ * Please note that this type has a few quirks:
+ * - `linkedTo` subqueries are only accepted when they apply to all item types. When doing an item-specific subquery,
+ * cast like so:
+ * ```
+ *  {
+ *      linkedTo: 'MateriaalCat',
+ * 	    query: {
+ *          extragescand: true,
+ *      },
+ *  } as ApiQueryConditionLinkedTo<'MateriaalCat'> as ApiQuery<'Planningmateriaal'>
+ * ```
+ * (This could be resolved by moving the link tree to the back-end types.)
+ * - Extended subqueries (using the `itemtype` and `field` properties to refer to the subcolumn) should also be
+ * cast.
+ * ```
+ *  {
+ * 	    key: 'functie',
+ *      itemType: 'Functieuur',
+ *      field: 'functie',
+ *      query: {
+ *          ...
+ *      },
+ * 	} as ApiQueryConditionExtendedSubQuery<'Planningpersoneel', 'functie', 'Functieuur'>
+ * 	    as ApiQuery<'Planningpersoneel'>;
+ * ```
+ * - The errors generated by TypeScript for invalid queries can be unhelpful. The query type it picks might
+ * not be the most obvious. In these cases you can manually narrow down the type. The `ApiQueryConditionComparator`,
+ * `ApiQueryConditionComparatorShort`, and `ApiQueryConditionIn` types have been introduced for this purpose.
+ * ```
+ *  // Type '"sets"' is not comparable to type '"set" | "case" | "item"'.
+ *  {
+ * 	    key: 'type',
+ *      value: 'sets',
+ * 	    comparator: '=',
+ *  } as ApiQueryConditionComparator<'Materiaal', 'type'>
+ * ```
+ *
+ * This type is mirrored by the `BackendApiQuery` type, the main differences being in the values accepted for date and
+ * duration comparisons:
+ *
+ *  - For date comparisons, the back-end query type will accept a string, or `null` for nullable columns.
+ *  - The front-end type will accept a `moment` object only. For `null` values, use `moment.invalid()`. Additionally,
+ *  the front-end type will accept the 'NOW' keyword. This will be replaced by the current time whenever matching locally
+ *  or querying the back-end.
+ *  - For durations, the back-end type will accept a number (or `null`), whereas the front-end type accepts a
+ *  `moment.duration` object.
+ */
+export type ApiQuery<ItemTypeType extends ApiItemType> = ApiQueryEmpty | ApiQueryConditionSearch | ApiQueryConditionCustom<ItemTypeType> | ApiQueryConditionSimple<ItemTypeType> | ApiQueryWithConditions<ItemTypeType> | ApiQueryConditionLinkedTo<ApiItemType> | ApiQueryConditionSubQueryUnion<ItemTypeType> | ApiQueryConditionExtendedSubQuery<ItemTypeType, 'id', ApiItemType, any>;
+export {};