@rentman/rm-core 0.0.0-RM4-44763

package/dist/types/src/classes/cache/transaction/TransactionValidatorWithDependencies.d.ts

@@ -0,0 +1,15 @@
+import { ItemId } from '@rentman/backend-types';
+import { ItemResource, ItemResourceToAggregatedChanges, TransactionCache } from '../../../internal';
+import { TransactionValidatorBase } from './TransactionValidatorBase';
+export interface TransactionValidatorDependencies {
+    rootItem: ItemResource<any, any, any>;
+}
+/**
+ * Base class for a transaction validator which manages their own dependencies.
+ * You are expected to use item and collection change listeners to call the validation functions.
+ */
+export declare abstract class TransactionValidatorWithDependencies<Dependency extends TransactionValidatorDependencies> extends TransactionValidatorBase {
+    dependencies: Dependency;
+    abstract validate(aggregatedCollectionChanges: unknown, aggregatedItemChanges: ItemResourceToAggregatedChanges<Dependency['rootItem']>, isCalledAfterSocketUpdate: boolean): void;
+    abstract fetchDependencies(transaction: TransactionCache, rootItemId: ItemId): Promise<Dependency>;
+}

package/dist/types/src/classes/changes/CollectionItemChangesListenerContext.d.ts

@@ -0,0 +1,22 @@
+import { ChangesListenerContextItemResourceShape, CollectionToItemResource, ItemChangesListenerContextBase, ItemIdConversionMap } from '../../internal';
+export declare class CollectionItemChangesListenerContext<CollectionResourceType extends {
+    items: ChangesListenerContextItemResourceShape[];
+}> extends ItemChangesListenerContextBase<CollectionToItemResource<CollectionResourceType>> {
+    /**
+     * @deprecated This property will be removed once the `onChange` collection callback is phased out.
+     */
+    readonly collectionResource: CollectionResourceType;
+    /**
+     * @deprecated This property will be removed once the `onChange` collection callback is phased out.
+     */
+    readonly isCalledAfterSocketUpdate: boolean;
+    constructor(
+    /**
+     * @deprecated This property will be removed once the `onChange` collection callback is phased out.
+     */
+    collectionResource: CollectionResourceType, itemResource: CollectionToItemResource<CollectionResourceType>, 
+    /**
+     * @deprecated This property will be removed once the `onChange` collection callback is phased out.
+     */
+    isCalledAfterSocketUpdate: boolean, partialPrevious: Partial<CollectionToItemResource<CollectionResourceType>['fields']>, itemIdConversionMap: ItemIdConversionMap | undefined);
+}

package/dist/types/src/classes/changes/ItemChangesListenerContext.d.ts

@@ -0,0 +1,7 @@
+import { ItemIdConversionMap } from '../../types/ItemTypesCollection';
+import { TransactionItemHandler } from '../cache/transaction/TransactionItemHandler';
+import { ChangesListenerContextItemResourceShape, ItemChangesListenerContextBase } from './ItemChangesListenerContextBase';
+export declare class ItemChangesListenerContext<ItemResourceType extends ChangesListenerContextItemResourceShape> extends ItemChangesListenerContextBase<ItemResourceType> {
+    readonly isCalledAfterSocketUpdate: boolean;
+    constructor(itemResource: ItemResourceType, itemHandler: TransactionItemHandler, partialPrevious: Partial<ItemResourceType['fields']>, itemIdConversionMap: ItemIdConversionMap | undefined, isCalledAfterSocketUpdate: boolean, isInitialCall?: boolean);
+}

package/dist/types/src/classes/changes/ItemChangesListenerContextBase.d.ts

@@ -0,0 +1,44 @@
+import { ItemEntry, ItemIdConversionMap, TransactionCache, TransactionItemHandler } from '../../internal';
+export type ChangesListenerContextItemResourceShape = {
+    itemType: string;
+    entry: ItemEntry<any>;
+    transaction: TransactionCache;
+    fields: {
+        [columnId: string]: any;
+    };
+};
+export declare abstract class ItemChangesListenerContextBase<ItemResourceType extends ChangesListenerContextItemResourceShape> {
+    readonly itemResource: ItemResourceType;
+    /**
+     * Note that `fields` is a proxy object for the `CollectionItemChangesListenerContext` subclass.
+     */
+    readonly fields: ItemResourceType['fields'];
+    private readonly itemHandler;
+    private readonly partialPrevious;
+    private readonly itemIdConversionMap;
+    private readonly isInitialCall;
+    protected constructor(itemResource: ItemResourceType, 
+    /**
+     * Note that `fields` is a proxy object for the `CollectionItemChangesListenerContext` subclass.
+     */
+    fields: ItemResourceType['fields'], itemHandler: TransactionItemHandler, partialPrevious: Partial<ItemResourceType['fields']>, itemIdConversionMap: ItemIdConversionMap | undefined, isInitialCall?: boolean);
+    private _previous?;
+    /**
+     * `previous` is defined as a getter here because it is not used very often, and should be evaluated lazily.
+     */
+    get previous(): ItemResourceType['fields'];
+    /**
+     * Returns `false` if the field changed. If `includeItemIdConversion` is `false`, an update to an item field because
+     * of a save is not interpreted as a change.
+     *
+     * When a field cannot be found, returns `true`.
+     */
+    compareField(columnId: keyof ItemResourceType['fields'], includeItemIdConversion?: boolean): boolean;
+    /**
+     * Returns `false` if one of the fields changed. If `includeItemIdConversion` is `false`, an update to an item field
+     * because of a save is not interpreted as a change.
+     *
+     * When a field cannot be found, returns `true`.
+     */
+    compareFields(fields: (keyof ItemResourceType['fields'])[] | readonly (keyof ItemResourceType['fields'])[], includeItemIdConversion?: boolean): boolean;
+}

package/dist/types/src/classes/matcher/CompatorQueryNode.d.ts

@@ -0,0 +1,24 @@
+import { ApiItemType } from '@rentman/backend-types';
+import { ErrorHandlerInterface } from '../../interfaces/ErrorHandlerInterface';
+import { ItemIdConversionMap, ItemTypeColumnId } from '../../types/ItemTypesCollection';
+import { GetField, LeafQueryNode, MatchesAccumulator, ModifyLeafNodeTupleFunction, QueryNode, QueryNodeTuple } from './QueryNode';
+import { ExtractEdgeValueType, ValueTransformer } from './ValueTransformers';
+export declare abstract class ComparatorQueryNode<ItemTypeType extends ApiItemType, ValueTransformerType extends ValueTransformer<any, any>> extends QueryNode<ItemTypeType> {
+    protected readonly columnId: ItemTypeColumnId<ItemTypeType>;
+    readonly valueTransformer: ValueTransformerType;
+    protected readonly errorHandler: ErrorHandlerInterface;
+    readonly edgeMap: Map<ExtractEdgeValueType<ValueTransformerType>, QueryNodeTuple>;
+    protected constructor(token: string, columnId: ItemTypeColumnId<ItemTypeType>, valueTransformer: ValueTransformerType, errorHandler: ErrorHandlerInterface);
+    protected static findValueTransformer<ValueTransformerType extends ValueTransformer<any, any>>(queryValue: any, valueTransformers: ValueTransformerType[]): ValueTransformerType | null;
+    connectLeafNode(queryValue: any, node: LeafQueryNode): this;
+    connectBranchNode(queryValue: any, nodeToConnect: QueryNode<ItemTypeType>): this;
+    /**
+     * Copies edges from source `sourceNode` into the node itself. The column ID and type should be equal.
+     */
+    copyEdgesFrom(sourceNode: ComparatorQueryNode<ItemTypeType, ValueTransformerType>, modifyLeafNodeTuple: ModifyLeafNodeTupleFunction | undefined): this;
+    updateLocalItemIdReferences(itemIdConversionMap: ItemIdConversionMap): boolean;
+    abstract clone(modifyLeafNodeTuple: ModifyLeafNodeTupleFunction | undefined): ComparatorQueryNode<ItemTypeType, ValueTransformerType>;
+    getValues(): ExtractEdgeValueType<ValueTransformerType>[];
+    protected matchUndefinedValue<MatchKeyType>(matchKey: MatchKeyType, getField: GetField<ItemTypeType>, matchesAccumulator: MatchesAccumulator<MatchKeyType>): MatchesAccumulator<MatchKeyType>;
+    private getQueryNodeTuple;
+}

package/dist/types/src/classes/matcher/CustomQueryNode.d.ts

@@ -0,0 +1,8 @@
+import { ApiItemType, ApiQueryConditionCustom } from '@rentman/backend-types';
+import { NonMatchableQueryNode } from './NonMatchableQueryNode';
+import { ModifyLeafNodeTupleFunction } from './QueryNode';
+export declare class CustomQueryNode<ItemTypeType extends ApiItemType> extends NonMatchableQueryNode<ItemTypeType> {
+    constructor(apiQuery: ApiQueryConditionCustom<ItemTypeType>);
+    clone(modifyLeafNodeTuple: ModifyLeafNodeTupleFunction | undefined): CustomQueryNode<ItemTypeType>;
+    apiQuery: ApiQueryConditionCustom<ItemTypeType>;
+}

package/dist/types/src/classes/matcher/GraphQueryParser.d.ts

@@ -0,0 +1,34 @@
+import { ApiFields, ApiItemType, ApiQueryConditionCustom, ApiQueryConditionSearch, ApiQueryOperator, ItemApiFields, ItemId } from '@rentman/backend-types';
+import { LinkTreeServiceInterface } from '../../interfaces/LinkTreeServiceInterface';
+import { ApiQuery, ApiQueryConditionComparator, ApiQueryConditionIn, ApiQueryConditionLinkedTo, ApiQueryWithConditions, ErrorHandlerInterface } from '../../internal';
+import { QueryParserBase } from '../QueryParserBase';
+import { ComparatorQueryNode } from './CompatorQueryNode';
+import { CustomQueryNode } from './CustomQueryNode';
+import { IsComparatorQueryNode } from './IsComparatorQueryNode';
+import { NotIsComparatorQueryNode } from './NotIsComparatorQueryNode';
+import { LeafQueryNode, QueryNode } from './QueryNode';
+import { RootQueryNode } from './RootQueryNode';
+import { SearchQueryNode } from './SearchQueryNode';
+import { SubQueryNode } from './SubQueryNode';
+export declare class GraphQueryParser<ItemTypeType extends ApiItemType, QueryId extends LeafQueryNode> extends QueryParserBase<RootQueryNode<ItemTypeType>, QueryNode<any>[] | QueryId | null> {
+    private itemType;
+    private queryId;
+    private linkTreeService;
+    private errorHandler;
+    constructor(itemType: ItemTypeType, queryId: QueryId, linkTreeService: LinkTreeServiceInterface, errorHandler: ErrorHandlerInterface);
+    run<QueryItemType extends ApiItemType>(query: ApiQuery<QueryItemType>): RootQueryNode<ItemTypeType>;
+    protected parseEmptyQuery(): QueryId;
+    static createLinkedToComparatorQueryNode<MainItemType extends ApiItemType, SubItemType extends ApiItemType>(mainItemType: MainItemType, linkedToItemType: SubItemType, leafNodeTuples: {
+        value: ItemId;
+        node: LeafQueryNode;
+    }[], linkTreeService: LinkTreeServiceInterface, errorHandler: ErrorHandlerInterface): ComparatorQueryNode<MainItemType, any>;
+    protected parseComparatorQuery<SubItemType extends ApiItemType, ColumnId extends keyof ApiFields[SubItemType]>(key: ApiQueryConditionComparator<SubItemType, ColumnId>['key'], value: ApiQueryConditionComparator<SubItemType, ColumnId>['value'], comparator: ApiQueryConditionComparator<SubItemType, ColumnId>['comparator']): [ComparatorQueryNode<SubItemType, any>];
+    protected parseInQuery<SubItemType extends ApiItemType, ColumnId extends keyof ApiFields[SubItemType]>(key: ApiQueryConditionIn<SubItemType, ColumnId>['key'], values: ApiQueryConditionIn<SubItemType, ColumnId>['value'], not: boolean): [IsComparatorQueryNode<SubItemType> | NotIsComparatorQueryNode<SubItemType>] | QueryId | null;
+    protected parseLinkedToQuery<MainItemType extends ApiItemType, SubItemType extends ApiItemType>(linkedTo: ApiQueryConditionLinkedTo<SubItemType>['linkedTo'], query: Exclude<ApiQueryConditionLinkedTo<SubItemType>['query'], undefined>, reverse: boolean, not: boolean, subQueryDepth: number): QueryNode<MainItemType>[] | null;
+    protected parseSubQuery<MainItemType extends ApiItemType, SubItemType extends ApiItemType>(key: keyof ItemApiFields<MainItemType>, itemType: SubItemType, field: keyof ItemApiFields<SubItemType>, query: ApiQuery<SubItemType>, not: boolean): SubQueryNode<MainItemType>[];
+    protected parseSearchQuery<SubItemType extends ApiItemType>(search: ApiQueryConditionSearch['search'], not: boolean): [SearchQueryNode<SubItemType>];
+    protected parseCustomQuery<SubItemType extends ApiItemType, QueryType extends ApiQueryConditionCustom<SubItemType>>(custom: QueryType['custom'], parameters: QueryType['parameters'], not: boolean): [CustomQueryNode<SubItemType>];
+    protected parseComplexQuery<SubItemType extends ApiItemType>(conditions: ApiQueryWithConditions<SubItemType>['conditions'], operator: Extract<ApiQueryOperator, 'AND' | 'OR'>, not: boolean, subQueryDepth: number): QueryNode<SubItemType>[] | QueryId | null;
+    protected rewriteOrConditions<SubItemType extends ApiItemType>(parsedConditions: (QueryNode<SubItemType>[] | QueryId | null)[]): null | QueryId | QueryNode<SubItemType>[];
+    protected rewriteAndConditions<SubItemType extends ApiItemType>(parsedConditions: (QueryNode<SubItemType>[] | QueryId | null)[]): null | QueryId | QueryNode<SubItemType>[][];
+}

package/dist/types/src/classes/matcher/IsComparatorQueryNode.d.ts

@@ -0,0 +1,13 @@
+import { ApiFields, ApiItemType } from '@rentman/backend-types';
+import { ApiQueryConditionComparator, ErrorHandlerInterface } from '../../internal';
+import { ItemTypeColumnId } from '../../types/ItemTypesCollection';
+import { ComparatorQueryNode } from './CompatorQueryNode';
+import { GetField, MatchesAccumulator, ModifyLeafNodeTupleFunction, PositiveMatchingResult } from './QueryNode';
+import { ValueTransformer } from './ValueTransformers';
+export declare const isComparatorQueryNodeValueTransformers: [ValueTransformer<number | boolean | null, number | boolean | null, number | boolean | null>, ValueTransformer<string | null, string | null, string | null>, ValueTransformer<import("moment").Moment, number | null, number | null>, import("./ValueTransformers").EdgeValueTransformer<import("moment").Duration, number, number>];
+export declare class IsComparatorQueryNode<ItemTypeType extends ApiItemType> extends ComparatorQueryNode<ItemTypeType, typeof isComparatorQueryNodeValueTransformers[number]> {
+    constructor(columnId: ItemTypeColumnId<ItemTypeType>, valueTransformer: typeof isComparatorQueryNodeValueTransformers[number], errorHandler: ErrorHandlerInterface);
+    static construct<ItemTypeType extends ApiItemType, ColumnId extends keyof ApiFields[ItemTypeType]>(key: ApiQueryConditionComparator<ItemTypeType, ColumnId>['key'], value: ApiQueryConditionComparator<ItemTypeType, ColumnId>['value'], comparator: ApiQueryConditionComparator<ItemTypeType, ColumnId>['comparator'], errorHandler: ErrorHandlerInterface): IsComparatorQueryNode<ItemTypeType> | null;
+    match<MatchKeyType>(matchKey: MatchKeyType, getField: GetField<ItemTypeType>, parentMatch: PositiveMatchingResult, matchesAccumulator: MatchesAccumulator<MatchKeyType>): MatchesAccumulator<MatchKeyType>;
+    clone(modifyLeafNodeTuple: ModifyLeafNodeTupleFunction | undefined): IsComparatorQueryNode<ItemTypeType>;
+}

package/dist/types/src/classes/matcher/LinkedToQueryNode.d.ts

@@ -0,0 +1,9 @@
+import { ApiItemType } from '@rentman/backend-types';
+import { ApiQueryConditionLinkedTo } from '../../internal';
+import { NonMatchableQueryNode } from './NonMatchableQueryNode';
+import { ModifyLeafNodeTupleFunction } from './QueryNode';
+export declare class LinkedToQueryNode<ItemTypeType extends ApiItemType> extends NonMatchableQueryNode<ItemTypeType> {
+    apiQuery: ApiQueryConditionLinkedTo<any>;
+    clone(modifyLeafNodeTuple: ModifyLeafNodeTupleFunction | undefined): LinkedToQueryNode<ItemTypeType>;
+    constructor(apiQuery: ApiQueryConditionLinkedTo<any>);
+}

package/dist/types/src/classes/matcher/NonMatchableQueryNode.d.ts

@@ -0,0 +1,9 @@
+import { ApiItemType } from '@rentman/backend-types';
+import { ApiQuery } from '../../internal';
+import { GetField, MatchesAccumulator, PositiveMatchingResult } from './QueryNode';
+import { ValuelessEdgeQueryNode } from './ValuelessEdgeQueryNode';
+export declare abstract class NonMatchableQueryNode<ItemTypeType extends ApiItemType> extends ValuelessEdgeQueryNode<ItemTypeType> {
+    readonly apiQuery: ApiQuery<ItemTypeType>;
+    constructor(token: string, apiQuery: ApiQuery<ItemTypeType>);
+    match<MatchKeyType>(matchKey: MatchKeyType, getField: GetField<ItemTypeType>, _parentMatch: PositiveMatchingResult, matchesAccumulator: MatchesAccumulator<MatchKeyType>): MatchesAccumulator<MatchKeyType>;
+}

package/dist/types/src/classes/matcher/NotIsComparatorQueryNode.d.ts

@@ -0,0 +1,14 @@
+import { ApiFields, ApiItemType } from '@rentman/backend-types';
+import { ApiQueryConditionComparator, ErrorHandlerInterface } from '../../internal';
+import { ItemTypeColumnId } from '../../types/ItemTypesCollection';
+import { ComparatorQueryNode } from './CompatorQueryNode';
+import { GetField, MatchesAccumulator, ModifyLeafNodeTupleFunction, PositiveMatchingResult } from './QueryNode';
+import { ValueTransformer } from './ValueTransformers';
+declare const valueTransformers: [ValueTransformer<number | boolean | null, number | boolean | null, number | boolean | null>, ValueTransformer<string | null, string | null, string | null>, ValueTransformer<import("moment").Moment, number | null, number | null>, import("./ValueTransformers").EdgeValueTransformer<import("moment").Duration, number, number>];
+export declare class NotIsComparatorQueryNode<ItemTypeType extends ApiItemType> extends ComparatorQueryNode<ItemTypeType, typeof valueTransformers[number]> {
+    constructor(columnId: ItemTypeColumnId<ItemTypeType>, valueTransformer: typeof valueTransformers[number], errorHandler: ErrorHandlerInterface);
+    static construct<ItemTypeType extends ApiItemType, ColumnId extends keyof ApiFields[ItemTypeType]>(key: ApiQueryConditionComparator<ItemTypeType, ColumnId>['key'], value: ApiQueryConditionComparator<ItemTypeType, ColumnId>['value'], comparator: ApiQueryConditionComparator<ItemTypeType, ColumnId>['comparator'], errorHandler: ErrorHandlerInterface): NotIsComparatorQueryNode<ItemTypeType> | null;
+    match<MatchKeyType>(matchKey: MatchKeyType, getField: GetField<ItemTypeType>, parentMatch: PositiveMatchingResult, matchesAccumulator: MatchesAccumulator<MatchKeyType>): MatchesAccumulator<MatchKeyType>;
+    clone(modifyLeafNodeTuple: ModifyLeafNodeTupleFunction | undefined): NotIsComparatorQueryNode<ItemTypeType>;
+}
+export {};

package/dist/types/src/classes/matcher/QueryNode.d.ts

@@ -0,0 +1,49 @@
+import { ApiItemType } from '@rentman/backend-types';
+import { GetFieldValueType, ItemIdConversionMap, ItemTypeColumnId } from '../../types/ItemTypesCollection';
+/**
+ * There are multiple reason we're not using the string representation of the query as a leaf node:
+ * - When item IDs are updated after a save, the string representation of a query might change, yet we don't want to
+ * replace all leaf nodes.
+ */
+export type LeafQueryNode = {
+    string: string;
+};
+/**
+ * A map consisting of (branching) query nodes as a value and the query node token as a key.
+ */
+export type BranchNodeMap = Map<string, QueryNode>;
+export type QueryNodeTuple = {
+    leafNodes: LeafQueryNode[];
+    branchNodeMap: BranchNodeMap | null;
+};
+export type PositiveMatchingResult = true | 'maybe';
+export interface MatchesAccumulatorTuple<MatchKeyType> {
+    true: Set<MatchKeyType>;
+    maybe?: Set<MatchKeyType>;
+}
+export type MatchesAccumulator<MatchKeyType> = Map<string, MatchesAccumulatorTuple<MatchKeyType>>;
+export type GetField<ItemTypeType extends ApiItemType> = <ColumnId extends ItemTypeColumnId<ItemTypeType>>(columnId: ColumnId) => GetFieldValueType<ItemTypeType, ColumnId> | undefined;
+/**
+ * Function that allows us to modify a node tuple (consisting of leaf and branching nodes) of the destination query
+ * graph whenever the corresponding node tuple of the source query graph is a leaf node tuple (it has no branching nodes
+ * attached).
+ *
+ * It can be used to expand the resulting (destination) query graph when cloning.
+ */
+export type ModifyLeafNodeTupleFunction = (leafNodeTuple: QueryNodeTuple) => void;
+export declare abstract class QueryNode<ItemTypeType extends ApiItemType = ApiItemType> {
+    readonly TOKEN: string;
+    protected constructor(TOKEN: string);
+    static addBranchNode(destinationQueryNodeTuple: QueryNodeTuple, node: QueryNode): void;
+    protected static matchQueryNodes<ItemTypeType extends ApiItemType, MatchKeyType>(queryNodeTuple: QueryNodeTuple, matchKey: MatchKeyType, getField: GetField<ItemTypeType>, parentMatch: PositiveMatchingResult, matchesAccumulator: MatchesAccumulator<MatchKeyType>): MatchesAccumulator<MatchKeyType>;
+    /**
+     * This method will be called when graph merging, which is what we should optimize for.
+     * @param sourceQueryNodeTuple - We enforce unique tokens by passing a branch node map here. Objects will be cloned.
+     **/
+    protected static cloneQueryNodesInto(destinationQueryNodeTuple: QueryNodeTuple, sourceQueryNodeTuple: QueryNodeTuple, modifyLeafNodeTuple: ModifyLeafNodeTupleFunction | undefined): void;
+    protected static _updateLocalItemIdReferences(branchNodeMap: BranchNodeMap | null, itemIdConversionMap: ItemIdConversionMap): boolean;
+    abstract match<MatchKey>(matchKey: MatchKey, getField: GetField<ItemTypeType>, parentMatch: PositiveMatchingResult, matchesAccumulator: MatchesAccumulator<MatchKey>): MatchesAccumulator<MatchKey>;
+    abstract clone(modifyLeafNodeTuple: ModifyLeafNodeTupleFunction | undefined): QueryNode<ItemTypeType>;
+    abstract updateLocalItemIdReferences(itemIdConversionMap: ItemIdConversionMap): boolean;
+    abstract copyEdgesFrom(sourceNode: QueryNode<ItemTypeType>, modifyLeafNodeTuple: ModifyLeafNodeTupleFunction | undefined): this;
+}

package/dist/types/src/classes/matcher/RootQueryNode.d.ts

@@ -0,0 +1,14 @@
+import { ApiItemType } from '@rentman/backend-types';
+import { GetField, MatchesAccumulator, ModifyLeafNodeTupleFunction, QueryNodeTuple } from './QueryNode';
+import { ValuelessEdgeQueryNode } from './ValuelessEdgeQueryNode';
+export declare class RootQueryNode<ItemTypeType extends ApiItemType> extends ValuelessEdgeQueryNode<ItemTypeType> {
+    constructor(connectionNodesTuple?: QueryNodeTuple);
+    clone(modifyLeafNodeTuple: ModifyLeafNodeTupleFunction | undefined): RootQueryNode<ItemTypeType>;
+    match<MatchKeyType>(matchKey: MatchKeyType, getField: GetField<ItemTypeType>, parentMatch: true, matchesAccumulator: MatchesAccumulator<MatchKeyType>): MatchesAccumulator<MatchKeyType>;
+    /**
+     * Convenience method that sets a default value for `matchesAccumulator`.
+     * @param matchKey - The value that is added to the `true` or `maybe` sets in `matchesAccumulator` when a match is
+     * found.
+     */
+    doMatch<MatchKeyType>(matchKey: MatchKeyType, getField: GetField<ItemTypeType>, matchesAccumulator?: MatchesAccumulator<MatchKeyType>): MatchesAccumulator<MatchKeyType>;
+}

package/dist/types/src/classes/matcher/SearchQueryNode.d.ts

@@ -0,0 +1,8 @@
+import { ApiItemType, ApiQueryConditionSearch } from '@rentman/backend-types';
+import { NonMatchableQueryNode } from './NonMatchableQueryNode';
+import { ModifyLeafNodeTupleFunction } from './QueryNode';
+export declare class SearchQueryNode<ItemTypeType extends ApiItemType> extends NonMatchableQueryNode<ItemTypeType> {
+    constructor(apiQuery: ApiQueryConditionSearch);
+    apiQuery: ApiQueryConditionSearch;
+    clone(modifyLeafNodeTuple: ModifyLeafNodeTupleFunction | undefined): SearchQueryNode<ItemTypeType>;
+}

package/dist/types/src/classes/matcher/SubQueryNode.d.ts

@@ -0,0 +1,8 @@
+import { ApiItemType } from '@rentman/backend-types';
+import { ApiQuery } from '../../types/ApiQuery';
+import { NonMatchableQueryNode } from './NonMatchableQueryNode';
+import { ModifyLeafNodeTupleFunction } from './QueryNode';
+export declare class SubQueryNode<ItemTypeType extends ApiItemType> extends NonMatchableQueryNode<ItemTypeType> {
+    constructor(apiQuery: ApiQuery<ItemTypeType>);
+    clone(modifyLeafNodeTuple: ModifyLeafNodeTupleFunction | undefined): SubQueryNode<ItemTypeType>;
+}

package/dist/types/src/classes/matcher/ValueTransformers.d.ts

@@ -0,0 +1,41 @@
+import moment from 'moment';
+export declare const unsupportedQueryValue: unique symbol;
+export type ExtractEdgeValueType<ValueTransformerType extends ValueTransformer<any, any>> = ValueTransformerType extends ValueTransformer<any, infer EdgeValueType> ? EdgeValueType : never;
+/**
+ * Each of our comparator query nodes represent an operation ({@link IsComparatorQueryNode},
+ * {@link NotIsComparatorQueryNode}, {@link GreaterSmallerThanComparatorQueryNode}). To prevent having to create
+ * a separate class for each supported data type (number, string, date, etc.), we introduce value transformers.
+ */
+export interface ValueTransformer<FieldValueType, EdgeValueType, EdgeCompareValueType = EdgeValueType> {
+    /**
+     * Converts a value used in a query to a value stored with a query graph edge. Used when converting a query to a
+     * graph. Might return a {@link unsupportedQueryValue} symbol.
+     */
+    readonly queryToEdgeValue: (queryValue: any) => EdgeValueType | typeof unsupportedQueryValue;
+    /**
+     * Converts an item field value to a value stored with a query graph edge. Used during the matching process.
+     */
+    readonly fieldToEdgeValue: (fieldValue: FieldValueType) => EdgeCompareValueType;
+}
+/**
+ * An edge value transformer is used for the {@link GreaterSmallerThanComparatorQueryNode} exclusively. It adds a
+ * `edgeToEdgeCompareValue` method, which is used to facilitate the 'NOW' value for date queries. When using the
+ * 'NOW' value, we're storing the 'NOW' string literal with the edge, while comparing with the current time.
+ */
+export interface EdgeValueTransformer<FieldValueType, EdgeValueType, EdgeCompareValueType> extends ValueTransformer<FieldValueType, EdgeValueType, EdgeCompareValueType> {
+    readonly edgeToEdgeCompareValue: (edgeValue: EdgeValueType) => EdgeCompareValueType;
+}
+export declare const numberValueTransformer: EdgeValueTransformer<number, number, number>;
+/**
+ * String comparisons are always case-insensitive because the backend also does this because the MySQL collation we use
+ * is case-insensitive.
+ */
+export declare const stringNullValueTransformer: ValueTransformer<string | null, string | null>;
+/**
+ * Since `number`, `boolean` and `null` types don't require any special treatment, we can use a single value transformer
+ * for these types.
+ */
+export declare const numberBooleanNullValueTransformer: ValueTransformer<number | boolean | null, number | boolean | null>;
+export declare const dateNowValueTransformer: EdgeValueTransformer<moment.Moment, number | 'NOW', number>;
+export declare const dateNullValueTransformer: ValueTransformer<moment.Moment, number | null>;
+export declare const durationValueTransformer: EdgeValueTransformer<moment.Duration, number, number>;

package/dist/types/src/classes/matcher/ValuelessEdgeQueryNode.d.ts

@@ -0,0 +1,11 @@
+import { ApiItemType } from '@rentman/backend-types';
+import { ItemIdConversionMap } from '../../types/ItemTypesCollection';
+import { LeafQueryNode, ModifyLeafNodeTupleFunction, QueryNode, QueryNodeTuple } from './QueryNode';
+export declare abstract class ValuelessEdgeQueryNode<ItemTypeType extends ApiItemType> extends QueryNode<ItemTypeType> {
+    readonly connectedNodesTuple: QueryNodeTuple;
+    constructor(token: string, connectedNodesTuple?: QueryNodeTuple);
+    connectLeafNode(nodeToConnect: LeafQueryNode): this;
+    connectBranchNode(nodeToConnect: QueryNode<ItemTypeType>): this;
+    updateLocalItemIdReferences(itemIdConversionMap: ItemIdConversionMap): boolean;
+    copyEdgesFrom(sourceNode: ValuelessEdgeQueryNode<ItemTypeType>, modifyLeafNodeTuple: ModifyLeafNodeTupleFunction | undefined): this;
+}

package/dist/types/src/classes/matcher/greater-smaller-than-comparator-query.node.d.ts

@@ -0,0 +1,25 @@
+import { ApiFields, ApiItemType, ApiQueryComparator } from '@rentman/backend-types';
+import { ApiQueryConditionComparator, ErrorHandlerInterface } from '../../internal';
+import { ItemTypeColumnId } from '../../types/ItemTypesCollection';
+import { ComparatorQueryNode } from './CompatorQueryNode';
+import { GetField, MatchesAccumulator, ModifyLeafNodeTupleFunction, PositiveMatchingResult } from './QueryNode';
+import { EdgeValueTransformer } from './ValueTransformers';
+type GreaterSmallerThanCompareFunction = (fieldValue: number, edgeValue: number) => boolean;
+export type GreaterSmallerThanComparator = Exclude<ApiQueryComparator, '=' | '!='>;
+declare const valueTransformers: [EdgeValueTransformer<number, number, number>, EdgeValueTransformer<import("moment").Moment, number | "NOW", number>, EdgeValueTransformer<import("moment").Duration, number, number>];
+/**
+ * The `Map` implementation we're using for the edges lends itself well for equality testing, which is what we're
+ * optimizing for. All other comparators function in the same way, as we need to test each key in the map individually.
+ * We could create a subclass for each comparator in the future.
+ */
+export declare class GreaterSmallerThanComparatorQueryNode<ItemTypeType extends ApiItemType> extends ComparatorQueryNode<ItemTypeType, typeof valueTransformers[number]> {
+    protected readonly comparator: GreaterSmallerThanComparator;
+    protected compareValue: GreaterSmallerThanCompareFunction;
+    protected constructor(columnId: ItemTypeColumnId<ItemTypeType>, comparator: GreaterSmallerThanComparator, valueTransformer: typeof valueTransformers[number], errorHandler: ErrorHandlerInterface);
+    static construct<ItemTypeType extends ApiItemType, ColumnId extends keyof ApiFields[ItemTypeType]>(key: ApiQueryConditionComparator<ItemTypeType, ColumnId>['key'], value: ApiQueryConditionComparator<ItemTypeType, ColumnId>['value'], comparator: ApiQueryConditionComparator<ItemTypeType, ColumnId>['comparator'], errorHandler: ErrorHandlerInterface): GreaterSmallerThanComparatorQueryNode<ItemTypeType> | null;
+    protected static isSupportedComparator(comparator: ApiQueryComparator): comparator is GreaterSmallerThanComparator;
+    match<MatchKeyType>(matchKey: MatchKeyType, getField: GetField<ItemTypeType>, parentMatch: PositiveMatchingResult, matchesAccumulator: MatchesAccumulator<MatchKeyType>): MatchesAccumulator<MatchKeyType>;
+    protected static getCompareFunction(comparator: GreaterSmallerThanComparator): GreaterSmallerThanCompareFunction;
+    clone(modifyLeafNodeTuple: ModifyLeafNodeTupleFunction | undefined): GreaterSmallerThanComparatorQueryNode<ItemTypeType>;
+}
+export {};

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

@@ -0,0 +1,2 @@
+export declare const ALL_PERMISSIONS = 7;
+export declare const COLUMN_SEPERATOR = ">";

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

@@ -0,0 +1,63 @@
+import { ApiFieldsOnDeleteRule, ItemId } from '@rentman/backend-types';
+import { ApiRequestService } from './classes/ApiRequestService';
+import { BusinessLogicManager } from './classes/BusinessLogicManager/BusinessLogicManager';
+import { BusinessLogicRule } from './classes/BusinessLogicManager/BusinessLogicRule';
+import { ColumnCache } from './classes/ColumnCache';
+import { ColumnHandler } from './classes/ColumnHandler';
+import { ConversionMapService } from './classes/ConversionMapService';
+import { ItemCreateService } from './classes/ItemCreateService';
+import { ItemEntryService } from './classes/ItemEntryService';
+import { LockService } from './classes/LockService';
+import { QueryService } from './classes/QueryService';
+import { SocketMessageHandler } from './classes/SocketMessageHandler';
+import { TemplateCache } from './classes/TemplateCache';
+import { ApiResponseProcessorFactory } from './factories/ApiResponseProcessorFactory';
+import { ChangesCompilationFactory } from './factories/ChangesCompilationFactory';
+import { ChangesDeltaFactory } from './factories/ChangesDeltaFactory';
+import { CollectionResourceFactory } from './factories/CollectionResourceFactory';
+import { ColumnExpansionFactory } from './factories/ColumnExpansionFactory';
+import { ColumnInfoFactory } from './factories/ColumnInfoFactory';
+import { ColumnSetFactory } from './factories/ColumnSetFactory';
+import { ItemCacheFactory } from './factories/ItemCacheFactory';
+import { ItemResourceFactory } from './factories/ItemResourceFactory';
+import { ModuleChangesCompilationFactory } from './factories/ModuleChangesCompilationFactory';
+import { RequestColumnExpansionFactory } from './factories/RequestColumnExpansionFactory';
+import { RequestColumnsOperationsCacheFactory } from './factories/RequestColumnsOperationsCacheFactory';
+import { TransactionCacheFactory } from './factories/TransactionCacheFactory';
+import { ApiRequestServiceInterface } from './interfaces/ApiRequestServiceInterface';
+import { ErrorHandlerInterface } from './interfaces/ErrorHandlerInterface';
+import { LinkTreeServiceInterface } from './interfaces/LinkTreeServiceInterface';
+export declare class RmCore {
+    version: string;
+    apiRequestService: ApiRequestService;
+    apiResponseProcessorFactory: ApiResponseProcessorFactory;
+    changesCompilationFactory: ChangesCompilationFactory;
+    changesDeltaFactory: ChangesDeltaFactory;
+    collectionResourceFactory: CollectionResourceFactory;
+    columnCache: ColumnCache;
+    columnExpansionFactory: ColumnExpansionFactory;
+    columnHandler: ColumnHandler;
+    columnInfoFactory: ColumnInfoFactory;
+    columnSetFactory: ColumnSetFactory;
+    requestColumnOperationsCacheFactory: RequestColumnsOperationsCacheFactory;
+    conversionMapService: ConversionMapService;
+    itemCacheFactory: ItemCacheFactory;
+    itemCreateService: ItemCreateService;
+    itemEntryService: ItemEntryService;
+    itemResourceFactory: ItemResourceFactory;
+    lockService: LockService;
+    moduleChangesCompilationFactory: ModuleChangesCompilationFactory;
+    queryService: QueryService;
+    requestColumnExpansionFactory: RequestColumnExpansionFactory;
+    socketMessageHandler: SocketMessageHandler;
+    templateCache: TemplateCache;
+    transactionCacheFactory: TransactionCacheFactory;
+    businessLogicManager: BusinessLogicManager;
+    constructor(userId: ItemId, _apiRequestService: ApiRequestServiceInterface, errorHandler: ErrorHandlerInterface, linkTreeService: LinkTreeServiceInterface, businessLogicRuleInstances: BusinessLogicRule<any, any>[], 
+    /**
+     * We specify an `apiFieldsOnDeleteRule` parameter in order to easily mock it in unit tests. This prevents
+     * issues where a mocked API response does not contain required fields that are added at a later point in time.
+     */
+    apiFieldsOnDeleteRule?: typeof ApiFieldsOnDeleteRule);
+}
+export declare function identity<T extends any>(value: T): T;

package/dist/types/src/exceptions/CriticalBusinessLogicRuleException.d.ts

@@ -0,0 +1,4 @@
+export declare class CriticalBusinessLogicRuleException extends Error {
+    readonly context?: any;
+    constructor(message: string, context?: any);
+}

package/dist/types/src/exceptions/ItemAlreadyExistsException.d.ts

@@ -0,0 +1,4 @@
+import { ApiItemType, ItemId } from '@rentman/backend-types';
+export declare class ItemAlreadyExistsException extends Error {
+    constructor(itemType: ApiItemType, itemId: ItemId);
+}

package/dist/types/src/exceptions/ItemLockedException.d.ts

@@ -0,0 +1,2 @@
+export declare class ItemLockedException extends Error {
+}

package/dist/types/src/exceptions/ItemNotFoundException.d.ts

@@ -0,0 +1,5 @@
+import { ApiItemType, ItemId } from '@rentman/backend-types';
+export declare class ItemNotFoundException extends Error {
+    constructor(entryId: number, itemId?: undefined);
+    constructor(itemType: ApiItemType, itemId: ItemId);
+}

package/dist/types/src/exceptions/MissingColumnException.d.ts

@@ -0,0 +1,6 @@
+import { ApiItemType } from '@rentman/backend-types';
+import { ItemEntry } from '../models/ItemEntry';
+import { ItemTypeColumnId } from '../types/ItemTypesCollection';
+export declare class MissingColumnException<ItemTypeType extends ApiItemType> extends Error {
+    constructor(itemEntry: ItemEntry<ItemTypeType>, columnId: ItemTypeColumnId<ItemTypeType>);
+}

package/dist/types/src/exceptions/SavingInProgressException.d.ts

@@ -0,0 +1,2 @@
+export declare class SavingInProgressException extends Error {
+}

package/dist/types/src/exceptions/TransactionPendingException.d.ts

@@ -0,0 +1,2 @@
+export declare class TransactionPendingException extends Error {
+}

package/dist/types/src/factories/ApiResponseProcessorFactory.d.ts

@@ -0,0 +1,5 @@
+import { ApiItemType } from '@rentman/backend-types';
+import { ApiResponse, ApiResponseProcessor } from '../internal';
+export declare class ApiResponseProcessorFactory {
+    construct<ItemTypeType extends ApiItemType = any>(response: ApiResponse<ItemTypeType>): ApiResponseProcessor<ItemTypeType>;
+}

package/dist/types/src/factories/ChangesCompilationFactory.d.ts

@@ -0,0 +1,5 @@
+import { ChangesCompilation, TransactionCache } from '../internal';
+export declare class ChangesCompilationFactory {
+    constructor();
+    construct(transaction: TransactionCache): ChangesCompilation;
+}

package/dist/types/src/factories/ChangesDeltaFactory.d.ts

@@ -0,0 +1,13 @@
+import { ApiItemType } from '@rentman/backend-types';
+import { ChangesDelta, ChangesDeltaBase, ChildChangesDelta, ConversionMapService, ErrorHandlerInterface, ItemCreateService, ItemEntryService, ParentChangesDelta } from '../internal';
+export declare class ChangesDeltaFactory {
+    private conversionMapService;
+    private errorHandler;
+    private itemCreateService;
+    private itemEntryService;
+    constructor(conversionMapService: ConversionMapService, errorHandler: ErrorHandlerInterface, itemCreateService: ItemCreateService, itemEntryService: ItemEntryService);
+    construct(logMissingColumnErrors: boolean, queryItemTypes?: Iterable<ApiItemType>): ChangesDelta;
+    cloneCreatedChanges(sourceChangesDelta: ChangesDelta, destinationChangesDelta?: ChangesDelta): ChangesDelta;
+    constructChildDelta(): ChildChangesDelta;
+    constructParentDelta(querySource?: ChangesDeltaBase): ParentChangesDelta;
+}

package/dist/types/src/factories/CollectionResourceFactory.d.ts

@@ -0,0 +1,20 @@
+import { ApiItemType } from '@rentman/backend-types';
+import { CachedQueryItemsItemTypeTuple, ChildCollectionResources, CollectionResource, ColumnCache, ColumnSet, ColumnSetFactory, ErrorHandlerInterface, ItemEntryService, OptionsToCollectionResource, ParentCachedQueryItemTuple, ParentIdMap, QueryService, RequestColumnsOperationsCacheFactory, RootCollectionOptions, TransactionCache } from '../internal';
+export type ColumnSetMap<ItemTypeType extends ApiItemType> = {
+    [ColumnSetItemType in ItemTypeType]: ColumnSet<ColumnSetItemType>;
+};
+export declare class CollectionResourceFactory {
+    errorHandler: ErrorHandlerInterface;
+    itemEntryService: ItemEntryService;
+    queryService: QueryService;
+    requestColumnsOperationsCacheFactory: RequestColumnsOperationsCacheFactory;
+    private columnCache;
+    private columnSetFactory;
+    constructor(errorHandler: ErrorHandlerInterface, itemEntryService: ItemEntryService, queryService: QueryService, requestColumnsOperationsCacheFactory: RequestColumnsOperationsCacheFactory, columnCache: ColumnCache, columnSetFactory: ColumnSetFactory);
+    /**
+     * @internal
+     */
+    construct<ItemTypeType extends ApiItemType, OptionsType extends RootCollectionOptions<ItemTypeType>>(parentCachedQueryItemTuple: ParentCachedQueryItemTuple<ItemTypeType>, parentCollectionResource: CollectionResource<any, any, any> | null, transaction: TransactionCache, columnSetMap?: ColumnSetMap<ItemTypeType>): OptionsToCollectionResource<ItemTypeType, OptionsType>;
+    constructChildCollectionResources<Children extends ChildCollectionResources | undefined>(cachedQueryItemTypeTuples: CachedQueryItemsItemTypeTuple<ApiItemType>[] | null, parentCollectionResource: CollectionResource<any, any, any> | null, transaction: TransactionCache, columnSetMap?: Partial<ColumnSetMap<ApiItemType>>): ParentIdMap<Children>;
+    constructColumnSet<ItemTypeType extends ApiItemType>(cachedQueryItemTuple: ParentCachedQueryItemTuple<ItemTypeType>): ColumnSet<ItemTypeType>;
+}

package/dist/types/src/factories/ColumnExpansionFactory.d.ts

@@ -0,0 +1,7 @@
+import { ApiItemType } from '@rentman/backend-types';
+import { ApiRequestColumns, ColumnExpansion, ColumnInfoFactory, ResponseColumnItemTypeMap } from '../internal';
+export declare class ColumnExpansionFactory {
+    private columnInfoFactory;
+    constructor(columnInfoFactory: ColumnInfoFactory);
+    construct<ItemTypeType extends ApiItemType>(itemType: ItemTypeType, requestColumns: ApiRequestColumns<ItemTypeType>, responseColumns: ResponseColumnItemTypeMap): ColumnExpansion<ItemTypeType>;
+}

package/dist/types/src/factories/ColumnInfoFactory.d.ts

@@ -0,0 +1,7 @@
+import { ApiFields, ApiItemType, GetColumnType } from '@rentman/backend-types';
+import { ColumnInfo, ItemTypeColumnIds, RootColumnMap } from '../internal';
+export declare class ColumnInfoFactory {
+    constructor();
+    construct<ItemTypeType extends ApiItemType = any, ColumnId extends keyof ApiFields[ItemTypeType] = any>(apiColumn: GetColumnType<ItemTypeType, ColumnId>, parent: ColumnInfo | null): ColumnInfo<ItemTypeType>;
+    constructFromRootMap<ItemTypeType extends ApiItemType = any, ColumnIds extends ItemTypeColumnIds<ItemTypeType> = any>(rootColumnMap: RootColumnMap<ItemTypeType, ColumnIds>, parent?: ColumnInfo | null): ColumnInfo<ItemTypeType, ColumnIds[number]>[];
+}

package/dist/types/src/factories/ColumnSetFactory.d.ts

@@ -0,0 +1,15 @@
+import { ApiItemType } from '@rentman/backend-types';
+import { ApiRequestColumnArray, ApiRequestColumns, ColumnHandler, ColumnInfoFactory, ColumnSet, ErrorHandlerInterface, ResponseColumnItemTypeMap } from '../internal';
+export declare class ColumnSetFactory {
+    private columnHandler;
+    private columnInfoFactory;
+    private errorHandler;
+    constructor(columnHandler: ColumnHandler, columnInfoFactory: ColumnInfoFactory, errorHandler: ErrorHandlerInterface);
+    construct<ItemTypeType extends ApiItemType>(itemType: ItemTypeType, requestColumns: ApiRequestColumns<ItemTypeType>, responseColumns: ResponseColumnItemTypeMap, enableCaching?: boolean, includeIdColumn?: boolean): ColumnSet<ItemTypeType>;
+    constructFromRequest<ItemTypeType extends ApiItemType>(itemType: ItemTypeType, requestColumns: ApiRequestColumnArray<ItemTypeType>, requestColumnsTrue: boolean, responseColumns: ResponseColumnItemTypeMap, enableCaching?: boolean, includeIdColumn?: boolean): ColumnSet<ItemTypeType>;
+    constructFromResponse<ItemTypeType extends ApiItemType>(itemType: ItemTypeType, requestColumnsTrue: boolean, responseColumns: ResponseColumnItemTypeMap, enableCaching?: boolean): ColumnSet<ItemTypeType>;
+    private constructRequestColumnsFromRootColumnMap;
+    private expandRootColumnMapFromResponseColumns;
+    private processColumnInfo;
+    private expandRootColumnMap;
+}

package/dist/types/src/factories/GraphQueryParserFactory.d.ts

@@ -0,0 +1,10 @@
+import { ApiItemType } from '@rentman/backend-types';
+import { GraphQueryParser } from '../classes/matcher/GraphQueryParser';
+import { LeafQueryNode } from '../classes/matcher/QueryNode';
+import { ErrorHandlerInterface, LinkTreeServiceInterface } from '../internal';
+export declare class GraphQueryParserFactory {
+    private linkTreeService;
+    private errorHandler;
+    constructor(linkTreeService: LinkTreeServiceInterface, errorHandler: ErrorHandlerInterface);
+    construct<ItemTypeType extends ApiItemType, QueryId extends LeafQueryNode>(itemType: ItemTypeType, queryId: QueryId): GraphQueryParser<ItemTypeType, QueryId>;
+}

package/dist/types/src/factories/ItemCacheFactory.d.ts

@@ -0,0 +1,7 @@
+import { AbstractCache, ItemCache } from '../internal';
+import { GraphQueryParserFactory } from './GraphQueryParserFactory';
+export declare class ItemCacheFactory {
+    private graphQueryParserFactory;
+    constructor(graphQueryParserFactory: GraphQueryParserFactory);
+    construct(transaction: AbstractCache): ItemCache;
+}