@rentman/rm-core 0.0.0-RM4-44763

package/dist/types/src/classes/ChildChangesDelta.d.ts

@@ -0,0 +1,38 @@
+import { ApiItemType } from '@rentman/backend-types';
+import { ChangesDeltaBase, ChangesDeltaBaseItemDeleteDelta, ChangesDeltaBaseItemUpdateDelta, ChangesDeltaItemUpdateMode, FieldMap, ItemEntry, ItemEntryService } from '../internal';
+export type ChildChangesDeltaItemCreateDelta<ItemTypeType extends ApiItemType = any> = {
+    entry: ItemEntry<ItemTypeType>;
+    fields: FieldMap<ItemTypeType>;
+};
+export interface ChildChangesDeltaItemUpdateDelta<ItemTypeType extends ApiItemType> extends ChangesDeltaBaseItemUpdateDelta<ItemTypeType> {
+    entry: ItemEntry<ItemTypeType>;
+    changes: {
+        fields: Readonly<FieldMap<ItemTypeType>>;
+    };
+    mode: ChangesDeltaItemUpdateMode;
+}
+export interface ChildChangesDeltaItemDeleteDelta<ItemTypeType extends ApiItemType> extends ChangesDeltaBaseItemDeleteDelta<ItemTypeType> {
+    changes: FieldMap<ItemTypeType>;
+    isCascaded: boolean;
+}
+/**
+ * @description
+ * The difference between {@link ChildChangesDelta} and {@link ChangesDelta} is that the {@link ChildChangesDelta}
+ * assumes 'created' entries are already existing, so it has a different format.
+ *
+ * Use this when calling {@link TransactionCache.applyChangesFromChild}.
+ */
+export declare class ChildChangesDelta extends ChangesDeltaBase<ChildChangesDeltaItemDeleteDelta<any>> {
+    updated: {
+        [itemEntryId: number]: ChildChangesDeltaItemUpdateDelta<any>;
+    };
+    created: {
+        [itemEntryId: string]: ChildChangesDeltaItemCreateDelta;
+    };
+    constructor(itemEntryService: ItemEntryService);
+    setItemUpdated<ItemTypeType extends ApiItemType>(entry: ItemEntry<ItemTypeType>, fields: Readonly<Partial<FieldMap<ItemTypeType>>>, mode?: ChangesDeltaItemUpdateMode): this;
+    setItemDeleted(tuple: ChildChangesDeltaItemDeleteDelta<any>): this;
+    setItemsDeleted(deleted: ChildChangesDeltaItemDeleteDelta<any>[]): this;
+    setItemCreated<ItemTypeType extends ApiItemType>(itemEntry: ItemEntry<ItemTypeType>, fields: Partial<FieldMap<ItemTypeType>>): void;
+    isEmpty(): boolean;
+}

package/dist/types/src/classes/ColumnCache.d.ts

@@ -0,0 +1,22 @@
+import { ApiItemType, GetColumnType, ResponseColumn } from '@rentman/backend-types';
+import { ApiRequestColumnArray, ApiRequestColumns, ApiResponseProcessor, ItemTypeColumnId, ResponseColumnItemTypeMap } from '../internal';
+export declare class ColumnCache {
+    private cache;
+    private pendingCache;
+    private allColumns;
+    setColumn<ItemTypeType extends ApiItemType>(itemType: ItemTypeType, responseColumn: ResponseColumn<ItemTypeType>): ResponseColumn<ItemTypeType>;
+    setColumns<ItemTypeType extends ApiItemType>(itemType: ItemTypeType, requestColumns: ApiRequestColumns<ItemTypeType>, responseColumns: ResponseColumnItemTypeMap, columnFilter: string | false): ResponseColumnItemTypeMap;
+    setPendingColumn<ItemTypeType extends ApiItemType>(itemType: ItemTypeType, columnId: ItemTypeColumnId<ItemTypeType>, promise: Promise<ApiResponseProcessor>): void;
+    clearPendingColumns<ItemTypeType extends ApiItemType>(itemType: ItemTypeType, requestColumns: ApiRequestColumnArray<ItemTypeType>): void;
+    setPendingColumns<ItemTypeType extends ApiItemType>(itemType: ItemTypeType, requestColumns: ApiRequestColumnArray<ItemTypeType>, promise: Promise<ApiResponseProcessor>): void;
+    retrieve<ItemTypeType extends ApiItemType>(itemType: ItemTypeType, requestColumns: ApiRequestColumns<ItemTypeType>): {
+        cached: Partial<ResponseColumnItemTypeMap>;
+        missing: ApiRequestColumns<ItemTypeType>;
+        pending: Promise<ApiRequestColumns<ItemTypeType>> | null;
+    };
+    containsAll(itemType: ApiItemType): boolean;
+    getColumns(itemType: ApiItemType): ResponseColumnItemTypeMap;
+    getColumn<ItemTypeType extends ApiItemType, ColumnId extends ItemTypeColumnId<ItemTypeType>>(itemType: ItemTypeType, columnId: ColumnId): GetColumnType<ItemTypeType, ColumnId> | undefined;
+    private retrieveColumns;
+    private retrieveColumn;
+}

package/dist/types/src/classes/ColumnExpansion.d.ts

@@ -0,0 +1,18 @@
+import { ApiItemType } from '@rentman/backend-types';
+import { ApiRequestColumns, ColumnExpansionResult, ColumnInfo, ColumnInfoFactory, ColumnSet, ResponseColumnItemTypeMap } from '../internal';
+/**
+ * @description
+ * A ColumnExpansion is used to make sure {@link ItemEntry ItemEntries} that have the same {@link ColumnSet ColumnSet} (matched on {@link ColumnSet.id ColumnSet.id}) will all get the same new expanded ColumnSet
+ */
+export declare class ColumnExpansion<ItemTypeType extends ApiItemType> {
+    private columnInfoFactory;
+    itemType: ItemTypeType;
+    responseColumns: ResponseColumnItemTypeMap;
+    private expansionMap;
+    private requestColumnsTrue;
+    private requestColumns;
+    constructor(columnInfoFactory: ColumnInfoFactory, itemType: ItemTypeType, requestColumns: ApiRequestColumns<ItemTypeType>, responseColumns: ResponseColumnItemTypeMap);
+    run(columnSet: ColumnSet<ItemTypeType>): ColumnExpansionResult<ItemTypeType>;
+    aggregateRootColumns(): ColumnInfo<ItemTypeType>[];
+    private expandRootColumnMap;
+}

package/dist/types/src/classes/ColumnHandler.d.ts

@@ -0,0 +1,16 @@
+import { ApiItemType, ResponseColumn, ResponseColumnCustom } from '@rentman/backend-types';
+import { ApiRequestColumns, ApiRequestService, ColumnCache, ResponseColumnItemTypeMap } from '../internal';
+export declare class ColumnHandler {
+    private apiRequestService;
+    private cache;
+    constructor(apiRequestService: ApiRequestService, cache: ColumnCache);
+    setColumn<ItemTypeType extends ApiItemType>(itemType: ItemTypeType, responseColumn: ResponseColumn<ItemTypeType>): ResponseColumn<ItemTypeType>;
+    setColumns<ItemTypeType extends ApiItemType>(itemType: ItemTypeType, requestColumns: ApiRequestColumns<ItemTypeType>, responseColumns: ResponseColumnItemTypeMap, filter?: string | false): ResponseColumnItemTypeMap;
+    fetchItemTypeTranslations(itemTypes: ApiItemType[]): Promise<{
+        [itemType: string]: string;
+    }>;
+    fetch<ItemTypeType extends ApiItemType>(itemType: ItemTypeType, requestColumns: ApiRequestColumns<ItemTypeType>, params?: any): Promise<ResponseColumnItemTypeMap>;
+    fetchAll(itemType: ApiItemType): Promise<ResponseColumnItemTypeMap>;
+    fetchEditableCustomColumns<ItemTypeType extends ApiItemType>(itemType: ItemTypeType): Promise<ResponseColumnCustom[]>;
+    private request;
+}

package/dist/types/src/classes/ColumnInfo.d.ts

@@ -0,0 +1,16 @@
+import { ApiItemType, GetColumnType } from '@rentman/backend-types';
+import { ApiRequestColumnArray, ItemTypeColumnId } from '..';
+export declare class ColumnInfo<ItemTypeType extends ApiItemType = any, ColumnId extends ItemTypeColumnId<ItemTypeType> = any> {
+    readonly apiColumn: GetColumnType<ItemTypeType, ColumnId>;
+    readonly parent: ColumnInfo | null;
+    id: ColumnId;
+    level: number;
+    path: string;
+    tailPath: string;
+    itemType: ItemTypeType | null;
+    children: ColumnInfo<ApiItemType>[];
+    isLeaf: boolean;
+    constructor(apiColumn: GetColumnType<ItemTypeType, ColumnId>, parent?: ColumnInfo | null);
+    toRequestColumns(): ApiRequestColumnArray<ItemTypeType>;
+    setChildren(itemType: ItemTypeType, children: ColumnInfo<ApiItemType>[]): this;
+}

package/dist/types/src/classes/ColumnSet.d.ts

@@ -0,0 +1,79 @@
+import { ApiItemType } from '@rentman/backend-types';
+import { ApiRequestColumnArray, ApiRequestColumns, ColumnInfo, ColumnSetFactory, RequestColumnMergeResult, ResponseColumnItemTypeMap } from '../internal';
+export type ColumnExpansionResult<ItemTypeType extends ApiItemType> = {
+    merged: ColumnSet<ItemTypeType>;
+    difference: ColumnSet<ItemTypeType> | null;
+};
+export declare class ColumnSet<ItemTypeType extends ApiItemType> {
+    private columnSetFactory;
+    readonly itemType: ItemTypeType;
+    readonly request: ApiRequestColumnArray<ItemTypeType>;
+    readonly requestColumnsTrue: boolean;
+    readonly response: ResponseColumnItemTypeMap;
+    readonly id: number;
+    link: ColumnInfo<ItemTypeType> | null;
+    /**
+     * The item's own columns
+     */
+    readonly main: ColumnInfo<ItemTypeType>[];
+    /**
+     * Columns which contain children, can be used to determine which derived values need to be refreshed when the root value changes.
+     *
+     * @example
+     * columns: [
+     *     {
+     *         // 'exemplaar' is the root
+     *         exemplaar: [
+     *             'displayname',
+     *         ],
+     *     },
+     * ]
+     */
+    readonly root: ColumnInfo<ItemTypeType>[];
+    /**
+     * Columns which should be searchable in the frontend (mainly used for grids)
+     */
+    readonly searchable: {
+        main: ColumnInfo<ItemTypeType>[];
+        derived: ColumnInfo<ItemTypeType>[];
+    };
+    /**
+     * Custom columns fetched for this set
+     */
+    readonly custom: {
+        main: ColumnInfo<ItemTypeType>[];
+        derived: ColumnInfo<ItemTypeType>[];
+    };
+    /**
+     * Columns which reference another item
+     */
+    readonly item: {
+        main: ColumnInfo<ItemTypeType>[];
+        derived: ColumnInfo<ItemTypeType>[];
+    };
+    /**
+     * Warning: Contains both main and derived columns!
+     */
+    readonly leaf: {
+        main: ColumnInfo<ItemTypeType>[];
+        derived: ColumnInfo<ItemTypeType>[];
+    };
+    /**
+     * Warning: Contains both main and derived columns!
+     */
+    readonly filtered: {
+        main: ColumnInfo<ItemTypeType>[];
+        derived: ColumnInfo<ItemTypeType>[];
+    };
+    constructor(columnSetFactory: ColumnSetFactory, itemType: ItemTypeType, request: ApiRequestColumnArray<ItemTypeType>, requestColumnsTrue: boolean, response: ResponseColumnItemTypeMap);
+    groupColumnInfo(columnInfo: ColumnInfo): void;
+    toJSON(): any[];
+    /**
+     * @param columnsToCompare
+     * @param columnsToCompareTrue - Set this to true if you know `columnsToCompare` contains all request columns.
+     */
+    isSupersetOf(columnsToCompare: ApiRequestColumns<ItemTypeType>, columnsToCompareTrue?: boolean): boolean;
+    mergeRequestColumns(requestColumns: ApiRequestColumns<ItemTypeType>): RequestColumnMergeResult;
+    mergeResponseColumns(responseColumns: ResponseColumnItemTypeMap): ResponseColumnItemTypeMap;
+    expand(requestColumns: ApiRequestColumnArray<ItemTypeType>, requestColumnsTrue: boolean, responseColumns: ResponseColumnItemTypeMap): ColumnExpansionResult<ItemTypeType>;
+}

package/dist/types/src/classes/ColumnUtil.d.ts

@@ -0,0 +1,97 @@
+import { ApiEnumApiType, ApiItemType, ResponseColumn, ResponseColumnCustom, ResponseColumnItem } from '@rentman/backend-types';
+import { UnknownResponseColumn } from '@rentman/backend-types/dist/manual/api-response-column';
+import { ApiRequestColumn, ApiRequestColumnArray, ApiRequestColumns, ItemTypeColumnId, MutableApiRequestColumnArray, RequestColumnsTuple, ResponseColumnItemTypeMap, ResponseColumnMap } from '../internal';
+export type RequestColumnMergeResult<T extends ApiRequestColumns = ApiRequestColumns, U extends ApiRequestColumns = ApiRequestColumns> = {
+    merged: T;
+    difference: U;
+};
+export declare enum API_COLUMN_LOCATION {
+    NO = 0,
+    IMPORT = 1,
+    EXPORT = 2,
+    GRID = 4,
+    TEMPLATE = 8,
+    EDIT = 16,
+    API = 20,
+    SOCKET = 32,
+    ALL = 63,
+    GRID_SELECTABLE = 32768,
+    LOCATION_LABELS = 524288
+}
+/**
+ * @description
+ * A service which provides functions to help on {@link ResponseColumn ResponseColumns}
+ *
+ * @warning
+ * The code in these functions can be *very hot* on large databases, therefore performance must be kept in mind.
+ * This is also the reason why all column types are written out instead of using the enum
+ */
+export declare abstract class ColumnUtil {
+    static isStringColumn(column: UnknownResponseColumn): boolean;
+    static isFloatColumn(column: UnknownResponseColumn): boolean;
+    static isIntColumn(column: UnknownResponseColumn): boolean;
+    static isNumberColumn(column: UnknownResponseColumn): boolean;
+    static isCustomColumn<ItemTypeType extends ApiItemType>(column: ResponseColumn<ItemTypeType>): column is ResponseColumnCustom<ItemTypeType>;
+    static isAggregateColumn(column: UnknownResponseColumn): boolean;
+    static isItemColumn<ItemTypeType extends ApiItemType>(column: UnknownResponseColumn | ResponseColumn<ItemTypeType>, includeId?: boolean): column is ResponseColumnItem<ItemTypeType>;
+    static isDateColumn(column: UnknownResponseColumn): boolean;
+    static isRenderedColumn(column: UnknownResponseColumn): boolean;
+    static isFilteredColumn(column: UnknownResponseColumn): boolean;
+    static hasLocationProperty(column: UnknownResponseColumn, location: API_COLUMN_LOCATION): boolean;
+    static isEditableColumn(column: UnknownResponseColumn): boolean;
+    static isSearchableColumn(column: UnknownResponseColumn): boolean;
+    static getComparators(column: UnknownResponseColumn & {
+        type: ApiEnumApiType.TYPE_DIMENSION | ApiEnumApiType.TYPE_WEIGHT | ApiEnumApiType.TYPE_PRICE;
+    }): ['=', '>', '<'];
+    static getComparators(column: UnknownResponseColumn & {
+        type: ApiEnumApiType.TYPE_DATE | ApiEnumApiType.TYPE_DATETIME | ApiEnumApiType.TYPE_DURATION | ApiEnumApiType.TYPE_TIMESTAMP | ApiEnumApiType.TYPE_TIMESTAMP_MS;
+    }): ['>', '<'];
+    static getComparators(column: UnknownResponseColumn & {
+        type: ApiEnumApiType.TYPE_TIME;
+    }): ['>', '<', '=', '!='];
+    static getComparators(column: UnknownResponseColumn): ['=', '!='];
+    static containsColumn<ItemTypeType extends ApiItemType = ApiItemType>(requestColumn: ApiRequestColumn<ItemTypeType>, destination: ApiRequestColumnArray<ItemTypeType>): boolean;
+    static containsDerivedColumns(requestColumns: ApiRequestColumnArray): boolean;
+    static responseColumnsAvailable(itemType: ApiItemType, requestColumns: ApiRequestColumnArray, responseColumnMap: ResponseColumnItemTypeMap): boolean;
+    static copyRequestColumns<ItemTypeType extends ApiItemType>(columns: true): true;
+    static copyRequestColumns<ItemTypeType extends ApiItemType>(columns: ApiRequestColumns<ItemTypeType>): ApiRequestColumns<ItemTypeType>;
+    static copyRequestColumn(requestColumn: ApiRequestColumn): ApiRequestColumn;
+    static mergeRequestColumns<T extends true, U extends ApiRequestColumns>(first: T, second: U): RequestColumnMergeResult<true, []>;
+    static mergeRequestColumns<T extends ApiRequestColumnArray, U extends true>(first: T, second: U): RequestColumnMergeResult<true, true>;
+    static mergeRequestColumns<T extends ApiRequestColumnArray, U extends ApiRequestColumnArray>(first: T, second: U): RequestColumnMergeResult<[...T, ...U], ApiRequestColumnArray>;
+    static mergeRequestColumns<T extends ApiRequestColumns, U extends ApiRequestColumns>(first: T, second: U): RequestColumnMergeResult<ApiRequestColumns, ApiRequestColumns>;
+    static mergeRequestColumn<ItemTypeType extends ApiItemType>(requestColumn: ApiRequestColumn<ItemTypeType>, destination: MutableApiRequestColumnArray<ItemTypeType>): ApiRequestColumn | null;
+    static createRequestColumnSetId(requestColumns: ApiRequestColumns): RequestColumnsTuple['string'];
+    static getRequestColumnId(requestColumn: ApiRequestColumn): string;
+    static parseRequestColumn<ItemTypeType extends ApiItemType>(requestColumn: ApiRequestColumn<ItemTypeType>): {
+        id: ItemTypeColumnId<ItemTypeType>;
+        children: ApiRequestColumnArray;
+    };
+    /**
+     * @description
+     * Merges two sets of {@link ResponseColumnItemTypeMap ResponseColumnItemTypeMaps}.
+     *
+     * @returns
+     * - Merged: The merged set of columns
+     * - Difference: Columns that are in second, but not in first
+     */
+    static mergeResponseColumns(first: Partial<ResponseColumnItemTypeMap>, second: Partial<ResponseColumnItemTypeMap>): {
+        merged: ResponseColumnItemTypeMap;
+        difference: ResponseColumnItemTypeMap;
+    };
+    /**
+     * @description
+     * Merges two sets of {@link ResponseColumnMap response columns}.
+     *
+     * @returns
+     * - Merged: The merged set of columns
+     * - Difference: Columns that are in second, but not in first
+     */
+    static mergeResponseColumnMap<ItemTypeType extends ApiItemType>(first: ResponseColumnMap<ItemTypeType>, second: ResponseColumnMap<ItemTypeType>): {
+        merged: ResponseColumnMap<ItemTypeType>;
+        difference: ResponseColumnMap<ItemTypeType>;
+    };
+    static findRequestColumn(columnId: string, requestColumns: ApiRequestColumnArray): number;
+    static requestColumnToPath(requestColumn: ApiRequestColumn): string[];
+    private static createRequestColumnId;
+}

package/dist/types/src/classes/ConversionMapService.d.ts

@@ -0,0 +1,23 @@
+import { ApiItemType, ItemId } from '@rentman/backend-types';
+import { ApiResponseProcessor, ColumnInfo, EntryParentNull, FieldMap, ItemEntry, ItemIdConversionMap } from '../internal';
+/**
+ * @description A 'ConversionMap' is used to update a set of item IDs to another. This happens when processing back-end
+ * responses (create / template) or cloning items in the front-end. A conversion map is grouped by item type, as item
+ * ID's are not unique across types.
+ *
+ * TODO: In the future, we should create a class and a 'ConversionMapFactory'.
+ */
+export declare class ConversionMapService {
+    createLocalConversionMap<ItemTypeType extends ApiItemType>(rootItemType: ItemTypeType, rootLocalItemId: ItemId, apiResponse: ApiResponseProcessor<ItemTypeType>): ItemIdConversionMap;
+    expandConversionMap(itemType: ApiItemType, itemId: ItemId, conversionMap: ItemIdConversionMap, newItemId?: ItemId): ItemId;
+    batchExpandConversionMap(itemEntries: ItemEntry<any>[], conversionMap: ItemIdConversionMap): ItemIdConversionMap;
+    getConversionValue(itemType: ApiItemType, itemId: ItemId, map: ItemIdConversionMap): ItemId | undefined;
+    /**
+     * @description
+     * Updates the columns in `fields` using the `parent` and `conversionMap`.
+     *
+     * @param parent - When retrieving an item the 'link' column is not present in the template response, and is added at a later stage. The value for this column can be read from this parameter.
+     */
+    updateItemValues<ItemTypeType extends ApiItemType>(source: FieldMap<ItemTypeType>, destination: FieldMap<ItemTypeType>, itemColumns: ColumnInfo<ItemTypeType>[], conversionMap: ItemIdConversionMap, parent?: EntryParentNull): void;
+    private expandLocalConversionMap;
+}

package/dist/types/src/classes/CreateRequest.d.ts

@@ -0,0 +1,16 @@
+import { ApiItemType } from '@rentman/backend-types';
+import { CreateCompilation, CreateRequestCompilationParent, CreateRequestEntry, RequestColumnExpansionFactory, TransactionCache } from '../internal';
+export declare class CreateRequest<ItemTypeType extends ApiItemType> {
+    private requestColumnExpansionFactory;
+    private compilation;
+    private transaction;
+    private breakupByParent;
+    private uniqueTransactionId?;
+    requests: CreateRequestEntry<ItemTypeType>[];
+    constructor(requestColumnExpansionFactory: RequestColumnExpansionFactory, compilation: CreateCompilation, transaction: TransactionCache, breakupByParent?: boolean, uniqueTransactionId?: string | undefined);
+    finalizeRequest(requestResource: CreateRequestEntry<ItemTypeType>): CreateRequestEntry<ItemTypeType>;
+    setRequestParent(parentType: CreateRequestCompilationParent, requestEntry: CreateRequestEntry<ItemTypeType>): boolean;
+    run(): CreateRequestEntry<ItemTypeType>[];
+    initializeRequest(): CreateRequestEntry<ItemTypeType>;
+    private extendRequest;
+}

package/dist/types/src/classes/CreatedChangesDelta.d.ts

@@ -0,0 +1,22 @@
+import { ApiItemType, ItemId } from '@rentman/backend-types';
+import { ColumnSet, FieldMap } from '../internal';
+import { MatchesAccumulator } from './matcher/QueryNode';
+import { RootQueryNode } from './matcher/RootQueryNode';
+export type ChangesDeltaItemCreateDelta<ItemTypeType extends ApiItemType = any> = {
+    itemId: ItemId;
+    fields: FieldMap<ItemTypeType>;
+    columns: ColumnSet<ItemTypeType>;
+    isRoot: boolean;
+};
+export declare class CreatedChangesDelta {
+    private tuples;
+    remove(itemType: ApiItemType, itemId: ItemId): boolean;
+    add<ItemTypeType extends ApiItemType>(itemId: ItemId, fields: Partial<FieldMap<ItemTypeType>>, columns: ColumnSet<ItemTypeType>, isRoot?: boolean): void;
+    isEmpty(): boolean;
+    getTuplesIterator<ItemTypeType extends ApiItemType>(itemType: ItemTypeType): IterableIterator<ChangesDeltaItemCreateDelta<ItemTypeType>>;
+    forEach(callback: (tuple: ChangesDeltaItemCreateDelta, itemType: ApiItemType) => void): void;
+    forEachOfItemType(itemType: ApiItemType, callback: (tuple: ChangesDeltaItemCreateDelta) => void): void;
+    contains(itemType: ApiItemType): boolean;
+    getTupleByItemId<ItemTypeType extends ApiItemType>(itemType: ItemTypeType, itemId: ItemId): ChangesDeltaItemCreateDelta<ItemTypeType> | undefined;
+    matchTuplesToQueryGraph<ItemTypeType extends ApiItemType>(itemType: ItemTypeType, queryGraph: RootQueryNode<ItemTypeType>, matchesAccumulator: MatchesAccumulator<ChangesDeltaItemCreateDelta<ItemTypeType>>): MatchesAccumulator<ChangesDeltaItemCreateDelta<ItemTypeType>>;
+}

package/dist/types/src/classes/ItemCache.d.ts

@@ -0,0 +1,26 @@
+import { ApiItemType, ItemId } from '@rentman/backend-types';
+import { GraphQueryParserFactory } from '../factories/GraphQueryParserFactory';
+import { AbstractCache, ApiQuery, ItemEntry } from '../internal';
+export declare class ItemCache {
+    private graphQueryParserFactory;
+    private transaction;
+    private entries;
+    private entriesByEntryId;
+    constructor(graphQueryParserFactory: GraphQueryParserFactory, transaction: AbstractCache);
+    getByEntryId(itemEntryId: ItemEntry['id']): ItemEntry;
+    containsByEntryId(itemEntryId: ItemEntry['id']): boolean;
+    some(callback: (itemEntry: ItemEntry) => boolean): boolean;
+    getByItemType<ItemTypeType extends ApiItemType>(itemType: ItemTypeType): ItemEntry<ItemTypeType>[];
+    getByQuery<ItemTypeType extends ApiItemType>(itemType: ItemTypeType, query: ApiQuery<ItemTypeType>): ItemEntry<ItemTypeType>[];
+    getLocalByQuery<ItemTypeType extends ApiItemType>(itemType: ItemTypeType, query: ApiQuery<ItemTypeType>): ItemEntry<ItemTypeType>[];
+    getByParent<ItemTypeType extends ApiItemType>(parentType: ApiItemType, parentId: ItemId, itemType: ItemTypeType): ItemEntry<ItemTypeType>[];
+    forEach(callback: (itemEntry: ItemEntry) => void): void;
+    [Symbol.iterator](): Iterator<ItemEntry>;
+    toArray(): ItemEntry[];
+    add<ItemTypeType extends ApiItemType>(itemEntry: ItemEntry<ItemTypeType>): ItemEntry<ItemTypeType>;
+    get<ItemTypeType extends ApiItemType>(itemType: ItemTypeType, itemId: string | ItemId): ItemEntry<ItemTypeType>;
+    contains(itemType: ApiItemType, itemId: string | ItemId): boolean;
+    updateItemId<T extends ItemEntry<any>>(itemEntry: T, oldItemId: string | ItemId): T;
+    clear(itemEntry?: ItemEntry<any>): boolean;
+    clearByItemId(itemType: ApiItemType, itemId: ItemId): boolean;
+}

package/dist/types/src/classes/ItemCreateService.d.ts

@@ -0,0 +1,14 @@
+import { ApiFields, ApiItemType, ItemId } from '@rentman/backend-types';
+import { ChangesDelta, ConversionMapService, EntryParentNull, FieldMap, FilterItemEntryCallback, ItemIdConversionMap, ModifyFieldsCallback, RequestParameters, Template, TemplateCache } from '../internal';
+export declare class ItemCreateService {
+    private conversionMapService;
+    private templateCache;
+    constructor(conversionMapService: ConversionMapService, templateCache: TemplateCache);
+    /**
+     * @description
+     * Fetches a new {@link Template template} and sets the items created on the passed {@link ChangesDelta}
+     */
+    createItemsFromValues<ItemTypeType extends ApiItemType, ColumnIds extends (keyof ApiFields[ItemTypeType])[] = (keyof ApiFields[ItemTypeType])[]>(changesDelta: ChangesDelta, itemType: ItemTypeType, valuesArray: Partial<FieldMap<ItemTypeType, ColumnIds>>[], parent?: EntryParentNull, templateOptions?: Partial<RequestParameters<ItemTypeType>>): Promise<void[]>;
+    processTemplate<ItemTypeType extends ApiItemType>(changesDelta: ChangesDelta, itemType: ItemTypeType, itemId: ItemId, parent: EntryParentNull, template: Template<ItemTypeType>, filterItemEntryCallback?: FilterItemEntryCallback, modifyFieldsCallback?: ModifyFieldsCallback, isRoot?: boolean): void;
+    processTemplateLinkItems<ParentItemType extends ApiItemType>(changesDelta: ChangesDelta, parentType: ParentItemType, localParentId: ItemId, template: Template<any>, itemIdConversion: ItemIdConversionMap, filterItemEntryCallback?: FilterItemEntryCallback, modifyFieldsCallback?: ModifyFieldsCallback): void;
+}

package/dist/types/src/classes/ItemEntryService.d.ts

@@ -0,0 +1,29 @@
+import { ApiEnumApiType, ApiItemType, ItemId } from '@rentman/backend-types';
+import { EntryParent, EntryParentNull, FieldMap, GetColumnIdsOfType, ItemEntry, LinkTreeServiceInterface } from '../internal';
+type TextColumn<ItemTypeType extends ApiItemType> = GetColumnIdsOfType<ItemTypeType, ApiEnumApiType.TYPE_TEXT>;
+export declare class ItemEntryService {
+    private userId;
+    private linkTreeService;
+    constructor(userId: ItemId, linkTreeService: LinkTreeServiceInterface);
+    matchParent(oldParent: EntryParentNull, newParent: EntryParentNull): boolean;
+    /**
+     * @description
+     * Gets the fields required to set the parent
+     *
+     * @remark
+     * Opposite of {@link ItemEntryService.getParentByFields ItemEntryService.getParentByFields}
+     */
+    getLinkFieldsByParent<ParentItemType extends ApiItemType, ItemTypeType extends ApiItemType>(parent: EntryParent<ParentItemType>, itemType: ItemTypeType): Partial<FieldMap<ItemTypeType>>;
+    /**
+     * @description
+     * Gets an {@link EntryParent EntryParent} object from the fields
+     *
+     * @remark
+     * Opposite of {@link ItemEntryService.getLinkFieldsByParent ItemEntryService.getLinkFieldsByParent}
+     */
+    getParentByFields<ItemTypeType extends ApiItemType>(parentType: ApiItemType, itemEntry: ItemEntry<ItemTypeType>, fields: FieldMap<ItemTypeType>): EntryParent;
+    getFullName(firstName: string, infix: string, lastName: string): string;
+    getTitleField<ItemTypeType extends ApiItemType>(itemType: ItemTypeType): TextColumn<ItemTypeType>;
+    getLocalDefaultValues<ItemTypeType extends ApiItemType>(): FieldMap<ItemTypeType, ['permissions', 'creator', 'created']>;
+}
+export {};

package/dist/types/src/classes/KeyService.d.ts

@@ -0,0 +1,10 @@
+import { ItemId } from '@rentman/backend-types';
+export declare abstract class KeyService {
+    private static readonly NEW_PREFIX;
+    private static idCounter;
+    static getCssKey(...args: (string | number)[]): string;
+    static getLocalId(): ItemId;
+    static isLocalId(itemId: any): boolean;
+    static isNewId(itemId: any): boolean;
+    private static incrementIdCounter;
+}

package/dist/types/src/classes/LockService.d.ts

@@ -0,0 +1,28 @@
+import { Signal } from '@angular/core';
+import { ItemId } from '@rentman/backend-types';
+import { ApiRequestService, FieldMap, ItemEntry, ItemMap } from '../internal';
+type LockTokenError = {
+    isForeign: true;
+    message: string;
+};
+export type LockToken = FieldMap<'Locktoken', ['token', 'id']> | LockTokenError;
+export declare class LockService {
+    private apiRequestService;
+    private lockItems;
+    private promises;
+    constructor(apiRequestService: ApiRequestService);
+    getLocksSignal(): Signal<ItemMap<LockToken>>;
+    getLocks(): ItemMap<LockToken>;
+    hasLock(lockTokenId: ItemId): boolean;
+    isLocked(itemEntry: ItemEntry): boolean;
+    getMessage(itemEntry: ItemEntry): undefined | string;
+    fetchLock(itemEntry: ItemEntry): Promise<LockToken>;
+    deleteLock(itemEntry: ItemEntry): Promise<void>;
+    isRemoteLock(token: LockToken): token is LockTokenError;
+    private clearLock;
+    private requestLock;
+    private getValue;
+    private setPromise;
+    private setToken;
+}
+export {};

package/dist/types/src/classes/ModuleChangesCompilation.d.ts

@@ -0,0 +1,20 @@
+import { ApiItemType, ItemId } from '@rentman/backend-types';
+import { ApiRequestItemMap, LinkTreeServiceInterface, TransactionCache } from '../internal';
+export type ModuleChangesCompilationResult = {
+    itemType: ApiItemType;
+    itemId: ItemId;
+    items: ApiRequestItemMap;
+};
+export declare class ModuleChangesCompilation {
+    private linkTreeService;
+    private transaction;
+    destination: ApiRequestItemMap;
+    private itemsMappedOnParent;
+    private transactionChain;
+    constructor(linkTreeService: LinkTreeServiceInterface, transaction: TransactionCache);
+    process(): ModuleChangesCompilationResult;
+    private constructChildItemMap;
+    private processItems;
+    private processItem;
+    private getItemsByParent;
+}

package/dist/types/src/classes/ParentChangesDelta.d.ts

@@ -0,0 +1,42 @@
+import { ApiItemType } from '@rentman/backend-types';
+import { ChangesDeltaBase, ChangesDeltaBaseItemUpdateDelta, ChangesDeltaItemUpdateMode, ChildChangesDeltaItemCreateDelta, FieldMap, ItemEntry, ItemEntryService } from '../internal';
+export interface ParentChangesDeltaItemUpdateDelta<ItemTypeType extends ApiItemType> extends ChangesDeltaBaseItemUpdateDelta<ItemTypeType> {
+    entry: ItemEntry<ItemTypeType>;
+    changes: {
+        fields: Readonly<FieldMap<ItemTypeType>>;
+    };
+    previous: Partial<FieldMap<ItemTypeType>> | null;
+    mode: ChangesDeltaItemUpdateMode;
+}
+/**
+ * @description
+ * ChangesDelta used internally by the core
+ *
+ * ----------
+ *
+ * The difference between {@link ParentChangesDelta ParentChangesDelta} and {@link ChangesDelta ChangesDelta} is that the ParentChangesDelta
+ * assumes 'created' entries are already existing, and deletedEntries don't have changes (since you cannot undo an action that happened on a parent on a child transaction)
+ *
+ * Use this when calling {@link TransactionCache.applyChangesFromParent applyChangesFromParent}
+ */
+export declare class ParentChangesDelta extends ChangesDeltaBase {
+    updated: {
+        [itemEntryId: number]: ParentChangesDeltaItemUpdateDelta<any>;
+    };
+    created: {
+        [itemEntryId: string]: ChildChangesDeltaItemCreateDelta;
+    };
+    constructor(itemEntryService: ItemEntryService, queryItemTypes?: Iterable<ApiItemType>);
+    /**
+     * @param entry
+     * @param fields
+     * @param previous - The values of the affected fields before the changes were applied, or `null` if no changes have
+     * been made. Because of the nature of item changes also includes values on ancestor transactions.
+     * @param mode
+     */
+    setItemUpdated<ItemTypeType extends ApiItemType>(entry: ItemEntry<ItemTypeType>, fields: Readonly<Partial<FieldMap<ItemTypeType>>>, previous?: Partial<FieldMap<ItemTypeType>> | null, mode?: ChangesDeltaItemUpdateMode): this;
+    setItemDeleted(itemEntry: ItemEntry<any>): this;
+    setItemsDeleted(deleted: ItemEntry<any>[]): this;
+    setItemCreated<ItemTypeType extends ApiItemType>(itemEntry: ItemEntry<ItemTypeType>, fields: FieldMap<ItemTypeType>): void;
+    isEmpty(): boolean;
+}

package/dist/types/src/classes/QueryColumnExtractor.d.ts

@@ -0,0 +1,16 @@
+import { ApiFields, ApiItemType, ApiQueryOperator, ItemApiFields } from '@rentman/backend-types';
+import { ApiQuery, ApiQueryConditionComparator, ApiQueryConditionIn, ApiQueryConditionLinkedTo, ApiQueryWithConditions, ApiRequestColumnArray, LinkTreeServiceInterface, QueryParserBase } from '../internal';
+export declare class QueryColumnExtractor<ItemTypeType extends ApiItemType> extends QueryParserBase<ApiRequestColumnArray> {
+    private linkTreeService;
+    private itemType;
+    constructor(linkTreeService: LinkTreeServiceInterface, itemType: ItemTypeType);
+    protected parseEmptyQuery(): ApiRequestColumnArray<ItemTypeType>;
+    protected parseSubQuery<MainItemType extends ApiItemType, SubItemType extends ApiItemType>(key: keyof ItemApiFields<MainItemType>, itemType: SubItemType, field: keyof ItemApiFields<SubItemType>, query: ApiQuery<SubItemType>, _not: boolean, subQueryDepth: number): ApiRequestColumnArray<ItemTypeType>;
+    protected parseSearchQuery(): ApiRequestColumnArray<ItemTypeType>;
+    protected parseCustomQuery(): ApiRequestColumnArray<ItemTypeType>;
+    protected parseComparatorQuery<QueryItemType extends ApiItemType, ColumnId extends keyof ApiFields[QueryItemType]>(key: ApiQueryConditionComparator<QueryItemType, ColumnId>['key']): ApiRequestColumnArray<QueryItemType>;
+    protected parseInQuery<QueryItemType extends ApiItemType, ColumnId extends keyof ApiFields[QueryItemType]>(key: ApiQueryConditionIn<QueryItemType, ColumnId>['key'], _value: ApiQueryConditionIn<QueryItemType, ColumnId>['value']): ApiRequestColumnArray;
+    protected parseLinkedToQuery<SubItemType extends ApiItemType>(linkedTo: ApiQueryConditionLinkedTo<SubItemType>['linkedTo'], _query: Exclude<ApiQueryConditionLinkedTo<SubItemType>['query'], undefined>, reverse: boolean, _not: boolean, subQueryDepth: number): ApiRequestColumnArray<ItemTypeType>;
+    protected parseComplexQuery<QueryItemType extends ApiItemType>(conditions: ApiQueryWithConditions<QueryItemType>['conditions'], _operator: Extract<ApiQueryOperator, 'AND' | 'OR'>, _not: boolean, subQueryDepth: number): ApiRequestColumnArray<QueryItemType>;
+    private parseConditions;
+}

package/dist/types/src/classes/QueryContainsLocalIdParser.d.ts

@@ -0,0 +1,14 @@
+import { ApiFields, ApiItemType, ApiQueryOperator, ItemApiFields } from '@rentman/backend-types';
+import { ApiQuery, ApiQueryConditionComparator, ApiQueryConditionIn, ApiQueryConditionLinkedTo, ApiQueryWithConditions, QueryParserBase } from '../internal';
+type ReturnType = boolean;
+export declare class QueryContainsLocalIdParser extends QueryParserBase<ReturnType> {
+    protected parseEmptyQuery(): ReturnType;
+    protected parseSubQuery<MainItemType extends ApiItemType, SubItemType extends ApiItemType>(_key: keyof ItemApiFields<MainItemType>, _itemType: SubItemType, _field: keyof ItemApiFields<SubItemType>, query: ApiQuery<SubItemType>, _not: boolean, subQueryDepth: number): ReturnType;
+    protected parseSearchQuery(): ReturnType;
+    protected parseCustomQuery(): ReturnType;
+    protected parseComparatorQuery<ItemTypeType extends ApiItemType, ColumnId extends keyof ApiFields[ItemTypeType]>(_key: ApiQueryConditionComparator<ItemTypeType, ColumnId>['key'], value: ApiQueryConditionComparator<ItemTypeType, ColumnId>['value']): ReturnType;
+    protected parseInQuery<ItemTypeType extends ApiItemType, ColumnId extends keyof ApiFields[ItemTypeType]>(_key: ApiQueryConditionIn<ItemTypeType, ColumnId>['key'], value: ApiQueryConditionIn<ItemTypeType, ColumnId>['value']): ReturnType;
+    protected parseLinkedToQuery<SubItemType extends ApiItemType>(_linkedTo: ApiQueryConditionLinkedTo<SubItemType>['linkedTo'], query: Exclude<ApiQueryConditionLinkedTo<SubItemType>['query'], undefined>, _reverse: boolean, _not: boolean, subQueryDepth: number): ReturnType;
+    protected parseComplexQuery<ItemTypeType extends ApiItemType>(conditions: ApiQueryWithConditions<ItemTypeType>['conditions'], _operator: Extract<ApiQueryOperator, 'AND' | 'OR'>, _not: boolean, subQueryDepth: number): ReturnType;
+}
+export {};

package/dist/types/src/classes/QueryParser.d.ts

@@ -0,0 +1,18 @@
+import { ApiFields, ApiItemType, ApiQueryConditionCustom, ApiQueryConditionSearch, ApiQueryOperator, ItemApiFields } from '@rentman/backend-types';
+import { ApiQuery, ApiQueryConditionComparator, ApiQueryConditionIn, ApiQueryConditionLinkedTo, ApiQueryWithConditions, CollectionQuery, QueryParserBase } from '../internal';
+export declare class QueryParser extends QueryParserBase<CollectionQuery<any>> {
+    private static formatStringParameters;
+    private static formatValue;
+    private static processValue;
+    private static compareParsedQueries;
+    protected parseEmptyQuery(): CollectionQuery<ApiItemType>;
+    protected parseSubQuery<MainItemType extends ApiItemType, SubItemType extends ApiItemType>(key: keyof ItemApiFields<MainItemType>, itemType: SubItemType, field: keyof ItemApiFields<SubItemType>, query: ApiQuery<SubItemType>, not: boolean, subQueryDepth: number): CollectionQuery<MainItemType>;
+    protected parseSearchQuery<ItemTypeType extends ApiItemType>(value: ApiQueryConditionSearch['search'], not: boolean): CollectionQuery<ItemTypeType>;
+    protected parseCustomQuery<ItemTypeType extends ApiItemType, QueryType extends ApiQueryConditionCustom<ItemTypeType>>(custom: QueryType['custom'], parameters: QueryType['parameters'], not: boolean): CollectionQuery<ItemTypeType>;
+    protected parseComparatorQuery<ItemTypeType extends ApiItemType, ColumnId extends keyof ApiFields[ItemTypeType]>(key: ApiQueryConditionComparator<ItemTypeType, ColumnId>['key'], value: ApiQueryConditionComparator<ItemTypeType, ColumnId>['value'], comparator: ApiQueryConditionComparator<ItemTypeType, ColumnId>['comparator']): CollectionQuery<ItemTypeType>;
+    protected parseInQuery<ItemTypeType extends ApiItemType, ColumnId extends keyof ApiFields[ItemTypeType]>(key: ApiQueryConditionIn<ItemTypeType, ColumnId>['key'], value: ApiQueryConditionIn<ItemTypeType, ColumnId>['value'], not: boolean): CollectionQuery<ItemTypeType>;
+    protected parseLinkedToQuery<MainItemType extends ApiItemType, SubItemType extends ApiItemType>(linkedTo: ApiQueryConditionLinkedTo<SubItemType>['linkedTo'], query: Exclude<ApiQueryConditionLinkedTo<SubItemType>['query'], undefined>, reverse: boolean, not: boolean, subQueryDepth: number): CollectionQuery<MainItemType>;
+    protected parseComplexQuery<ItemTypeType extends ApiItemType>(conditions: ApiQueryWithConditions<ItemTypeType>['conditions'], operator: Extract<ApiQueryOperator, 'AND' | 'OR'>, not: boolean, subQueryDepth: number): CollectionQuery<ItemTypeType>;
+    private parseCustomParameters;
+    private parseConditions;
+}

package/dist/types/src/classes/QueryParserBase.d.ts

@@ -0,0 +1,32 @@
+import { ApiFields, ApiItemType, ApiQueryConditionCustom, ApiQueryConditionSearch, ApiQueryOperator, ItemApiFields } from '@rentman/backend-types';
+import { ApiQuery, ApiQueryConditionComparator, ApiQueryConditionIn, ApiQueryConditionLinkedTo, ApiQueryWithConditions } from '../internal';
+/**
+ * When extending this class, note that:
+ * - It already provides default values (`not` for `IN` queries, `operator` for `conditions` queries, `field` for
+ * sub queries, etc.).
+ * - It normalizes comparators (`not` `=` becomes `!=`, etc.).
+ */
+export declare abstract class QueryParserBase<ReturnType, ParseReturnType = ReturnType> {
+    private static normalizeOperator;
+    private static isLinkedToQuery;
+    private static isCustomQuery;
+    private static isSearchQuery;
+    private static isQueryWithConditions;
+    private static isSubQuery;
+    run<ItemTypeType extends ApiItemType>(query: ApiQuery<ItemTypeType>): ReturnType;
+    /**
+     * @param subQueryDepth As the query language supports nested queries, this parameter denotes how deeply we're
+     * nested. `subQueryDepth` should increase whenever this method is called from {@link parseSubQuery} or
+     * {@link parseLinkedToQuery}.
+     */
+    protected parseQuery<ItemTypeType extends ApiItemType>(query: unknown, subQueryDepth: number): ParseReturnType;
+    protected abstract parseEmptyQuery(): ParseReturnType;
+    protected abstract parseSubQuery<MainItemType extends ApiItemType, SubItemType extends ApiItemType>(key: keyof ItemApiFields<MainItemType>, itemType: SubItemType, field: keyof ItemApiFields<SubItemType>, query: ApiQuery<SubItemType>, not: boolean, subQueryDepth: number): ParseReturnType;
+    protected abstract parseSearchQuery(value: ApiQueryConditionSearch['search'], not: boolean): ParseReturnType;
+    protected abstract parseCustomQuery<ItemTypeType extends ApiItemType, QueryType extends ApiQueryConditionCustom<ItemTypeType>>(custom: QueryType['custom'], parameters: QueryType['parameters'], not: boolean): ParseReturnType;
+    protected abstract parseComparatorQuery<ItemTypeType extends ApiItemType, ColumnId extends keyof ApiFields[ItemTypeType]>(key: ApiQueryConditionComparator<ItemTypeType, ColumnId>['key'], value: ApiQueryConditionComparator<ItemTypeType, ColumnId>['value'], comparator: ApiQueryConditionComparator<ItemTypeType, ColumnId>['comparator'], query: ApiQueryConditionComparator<ItemTypeType, ColumnId>): ParseReturnType;
+    protected abstract parseInQuery<ItemTypeType extends ApiItemType, ColumnId extends keyof ApiFields[ItemTypeType]>(key: ApiQueryConditionIn<ItemTypeType, ColumnId>['key'], value: ApiQueryConditionIn<ItemTypeType, ColumnId>['value'], not: boolean): ParseReturnType;
+    protected abstract parseLinkedToQuery<SubItemType extends ApiItemType>(linkedTo: ApiQueryConditionLinkedTo<SubItemType>['linkedTo'], query: Exclude<ApiQueryConditionLinkedTo<SubItemType>['query'], undefined>, reverse: boolean, not: boolean, subQueryDepth: number): ParseReturnType;
+    protected abstract parseComplexQuery<ItemTypeType extends ApiItemType>(conditions: ApiQueryWithConditions<ItemTypeType>['conditions'], operator: Extract<ApiQueryOperator, 'AND' | 'OR'>, not: boolean, subQueryDepth: number): ParseReturnType;
+    private _parseSimpleQuery;
+}