@rentman/rm-core 9.1.2 → 9.2.0

package/dist/types/classes/ApiFormatter.d.ts

@@ -1,6 +1,6 @@
 import { ApiEnumApiType, ApiEnumItemType, ApiFields, ResponseColumn } from '@rentman/backend-types';
 import moment from 'moment';
-import { ApiEnumApiTypeToTsTypeMap, ColumnInfo, FieldMap } from '../internal';
+import { ApiEnumApiTypeToTsTypeMap, ColumnInfo, FieldMap, ItemTypeColumnIds } from '../internal';
 declare type GetChangesResult<ItemTypeType extends ApiEnumItemType = any, ColumnId extends keyof ApiFields[ItemTypeType] = any> = {
     oldValue: FieldMap<ItemTypeType, [ColumnId]>[ColumnId];
     newValue: FieldMap<ItemTypeType, [ColumnId]>[ColumnId];
@@ -33,18 +33,18 @@ export declare class ApiFormatter {
      * @description
      * Overwrites the values in 'changes' if the values in 'initial' and 'changes' are the same (leaving user changes intact)
      */
-    mergeCopyFields<ItemTypeType extends ApiEnumItemType, ColumnIds extends Array<keyof ApiFields[ItemTypeType]> = any>(initial: FieldMap<ItemTypeType, ColumnIds>, changes: FieldMap<ItemTypeType, ColumnIds>, newInitial: FieldMap<ItemTypeType, ColumnIds>, columns: Array<ColumnInfo<ItemTypeType>>): FieldMap<ItemTypeType, ColumnIds>;
-    formatRequest<Fields extends FieldMap>(initial: Fields, modified: Fields, columns: Array<ColumnInfo>): {
+    mergeCopyFields<ItemTypeType extends ApiEnumItemType, ColumnIds extends ItemTypeColumnIds<ItemTypeType> = any>(initial: FieldMap<ItemTypeType, ColumnIds>, changes: FieldMap<ItemTypeType, ColumnIds>, newInitial: FieldMap<ItemTypeType, ColumnIds>, columns: ColumnInfo<ItemTypeType>[]): FieldMap<ItemTypeType, ColumnIds>;
+    formatRequest<ItemTypeType extends ApiEnumItemType>(initial: FieldMap<ItemTypeType>, modified: FieldMap<ItemTypeType>, columns: ColumnInfo<ItemTypeType>[]): {
         [columnId: string]: any;
     };
-    formatRequestLocal<Fields extends FieldMap>(fields: Fields, columns: ColumnInfo[]): {
+    formatRequestLocal<ItemTypeType extends ApiEnumItemType>(fields: FieldMap<ItemTypeType>, columns: ColumnInfo<ItemTypeType>[]): {
         [columnId: string]: any;
     };
-    hasChanges(initial: FieldMap, modified: FieldMap, columns: Array<ColumnInfo<any>>, includeReadOnlyColumns?: boolean, forceCompare?: boolean): boolean;
-    getChanges<ItemTypeType extends ApiEnumItemType = any, ColumnIds extends Array<keyof ApiFields[ItemTypeType]> = any>(initial: FieldMap<ItemTypeType, ColumnIds>, modified: FieldMap<ItemTypeType, ColumnIds>, columns: Array<ColumnInfo<ItemTypeType, ColumnIds[number]>>): Array<GetChangesResult<ItemTypeType, ColumnIds[number]>>;
-    copyFields<ItemTypeType extends ApiEnumItemType = any, ColumnIds extends Array<keyof ApiFields[ItemTypeType]> = any>(source: FieldMap<ItemTypeType, ColumnIds>, destination: Partial<FieldMap<ItemTypeType>>, columns: Array<ColumnInfo<ItemTypeType, ColumnIds[number]>>): FieldMap<ItemTypeType, ColumnIds>;
-    shallowCopyFields<Fields extends FieldMap>(shallowSource: Fields, deepSource: Fields, destination: Fields, columns: Array<ColumnInfo<any>>): Fields;
-    setDefaultValues<ItemTypeType extends ApiEnumItemType = any>(destination: FieldMap<ItemTypeType>, columns: Array<ColumnInfo<ItemTypeType>>): FieldMap<ItemTypeType>;
+    hasChanges<ItemTypeType extends ApiEnumItemType>(initial: FieldMap<ItemTypeType>, modified: FieldMap<ItemTypeType>, columns: ColumnInfo<ItemTypeType>[], includeReadOnlyColumns?: boolean, forceCompare?: boolean): boolean;
+    getChanges<ItemTypeType extends ApiEnumItemType = any, ColumnIds extends ItemTypeColumnIds<ItemTypeType> = any>(initial: FieldMap<ItemTypeType, ColumnIds>, modified: FieldMap<ItemTypeType, ColumnIds>, columns: ColumnInfo<ItemTypeType, ColumnIds[number]>[]): GetChangesResult<ItemTypeType, ColumnIds[number]>[];
+    copyFields<ItemTypeType extends ApiEnumItemType = any, ColumnIds extends ItemTypeColumnIds<ItemTypeType> = any>(source: FieldMap<ItemTypeType, ColumnIds>, destination: Partial<FieldMap<ItemTypeType>>, columns: ColumnInfo<ItemTypeType, ColumnIds[number]>[]): FieldMap<ItemTypeType, ColumnIds>;
+    shallowCopyFields<ItemTypeType extends ApiEnumItemType>(shallowSource: FieldMap<ItemTypeType>, deepSource: FieldMap<ItemTypeType>, destination: FieldMap<ItemTypeType>, columns: ColumnInfo<ItemTypeType>[]): FieldMap<ItemTypeType>;
+    setDefaultValues<ItemTypeType extends ApiEnumItemType = any>(destination: FieldMap<ItemTypeType>, columns: ColumnInfo<ItemTypeType>[]): FieldMap<ItemTypeType>;
     /**
      * @description
      * Compares the given fields, returns `true` when the fields are equal

package/dist/types/classes/ApiResponseProcessor.d.ts

@@ -1,8 +1,8 @@
 import { ApiEnumItemType, ItemId, ResponseColumn } from '@rentman/backend-types';
-import { ApiFormatter, ColumnInfo, FieldMap, ItemTypeMap, ResponseColumnItemTypeMap, ResponseColumnMap } from '../internal';
+import { ApiFormatter, ApiResponse, ColumnInfo, FieldMap, ItemTypeMap, ResponseColumnItemTypeMap, ResponseColumnMap } from '../internal';
 export declare class ApiResponseProcessor<RequestItemType extends ApiEnumItemType = any> {
     apiFormatter: ApiFormatter;
-    response: any;
+    response: ApiResponse;
     itemType: RequestItemType;
     columns: ItemTypeMap<ResponseColumn[]>;
     links: ItemTypeMap<ItemId[]>;
@@ -15,14 +15,14 @@ export declare class ApiResponseProcessor<RequestItemType extends ApiEnumItemTyp
         };
     };
     columnMap: any;
-    constructor(apiFormatter: ApiFormatter, response: any);
+    constructor(apiFormatter: ApiFormatter, response: ApiResponse);
     fetchColumnObject(itemType: ApiEnumItemType): ResponseColumnMap;
     fetchValue(itemType: ApiEnumItemType, itemId: ItemId, columnId: string): any;
     fetchColumnArray(itemType: ApiEnumItemType): ResponseColumn[];
     fetchDerivedObject(itemType: ApiEnumItemType, itemId: ItemId, rootColumns: ColumnInfo[]): {};
     fetchDerivedValues(value: any, column: ColumnInfo, destination: any): void;
     fetchObject<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, itemId: string | ItemId): FieldMap<ItemTypeType> | undefined;
-    fetchObjectArray<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, idArray?: ItemId[] | null): Array<FieldMap<ItemTypeType>>;
+    fetchObjectArray<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, idArray?: ItemId[] | null): FieldMap<ItemTypeType>[];
     fetchColumnsObject(): ResponseColumnItemTypeMap;
     private addLazyFormattingFunction;
     private createColumnMaps;

package/dist/types/classes/CacheSyncer.d.ts

@@ -25,12 +25,6 @@ export declare class CacheSyncer {
     syncCachedQueries(_isCalledAfterSocketUpdate?: boolean, changesDelta?: ChangesDeltaBase): PromiseInterface<void[]>;
     expand<ItemEntryType extends ItemEntry>(itemEntry: ItemEntryType, fields: FieldMap<ItemEntryType['itemType']>): this;
     processDelta(parentChangesDelta: ParentChangesDelta): this;
-    /**
-     * Returns null if none of the promises resulted in an exception, or the exception otherwise.
-     */
-    private resolveAll;
-    private syncCollection;
-    private syncCachedQuery;
     groupMatchedItemEntries<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, query: CollectionQuery): {
         [key in 'fitting' | 'notFitting' | 'maybe']: ItemEntry<ItemTypeType>[];
     };
@@ -40,5 +34,11 @@ export declare class CacheSyncer {
      * by the caller.
      */
     protected processMaybeMatches<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, query: CollectionQuery, maybeItemEntries: ItemEntry<ItemTypeType>[], changesDelta: ChangesDeltaBase | undefined): PromiseInterface<ItemEntry<ItemTypeType>[]>;
+    /**
+     * Returns null if none of the promises resulted in an exception, or the exception otherwise.
+     */
+    private resolveAll;
+    private syncCollection;
+    private syncCachedQuery;
     private addMatchedEntriesToCollections;
 }

package/dist/types/classes/ChangesDelta.d.ts

@@ -1,5 +1,5 @@
 import { ApiEnumItemType, ApiFields, ItemId } from '@rentman/backend-types';
-import { ChangesDeltaBase, ColumnSet, CreatedChangesDelta, EntryParent, EntryParentNull, ErrorHandlerInterface, FieldMap, ItemCreateService, ItemEntry, ItemEntryService, PromiseInterface } from '../internal';
+import { ApiFormatter, ChangesDeltaBase, ColumnSet, CreatedChangesDelta, EntryParent, EntryParentNull, ErrorHandlerInterface, FieldMap, ItemCreateService, ItemEntry, ItemEntryService, PromiseInterface } from '../internal';
 export declare type ChangesDeltaItemDeleteDelta = ItemEntry;
 /**
  * @description
@@ -19,7 +19,7 @@ export declare class ChangesDelta extends ChangesDeltaBase {
     deleted: {
         [itemType: string]: ChangesDeltaItemDeleteDelta[];
     };
-    constructor(errorHandler: ErrorHandlerInterface, itemCreateService: ItemCreateService, itemEntryService: ItemEntryService);
+    constructor(errorHandler: ErrorHandlerInterface, itemCreateService: ItemCreateService, itemEntryService: ItemEntryService, apiFormatter: ApiFormatter);
     /**
      * @description
      * Fetches a template for the passed itemType and processes the passed values and sets the item to be created when the delta is applied
@@ -39,7 +39,7 @@ export declare class ChangesDelta extends ChangesDeltaBase {
      * - If the values don't contain an `id` a new one will be generated
      * - If you want to set a parent set the proper field, you can't pass it as a separate object
      */
-    setItemsCreated<ItemTypeType extends ApiEnumItemType, ColumnIds extends Array<keyof ApiFields[ItemTypeType]> = Array<keyof ApiFields[ItemTypeType]>>(itemType: ItemTypeType, valuesArray: Array<Partial<FieldMap<ItemTypeType, ColumnIds>>>): PromiseInterface<this>;
+    setItemsCreated<ItemTypeType extends ApiEnumItemType, ColumnIds extends (keyof ApiFields[ItemTypeType])[] = (keyof ApiFields[ItemTypeType])[]>(itemType: ItemTypeType, valuesArray: Partial<FieldMap<ItemTypeType, ColumnIds>>[]): PromiseInterface<this>;
     /**
      * @description
      * Will create an {@link ItemEntry ItemEntry} when the delta is applied

package/dist/types/classes/ChangesDeltaBase.d.ts

@@ -1,5 +1,5 @@
 import { ApiEnumItemType, ItemId } from '@rentman/backend-types';
-import { ColumnExpansionResult, EntryParentNull, FieldMap, ItemEntry, ItemEntryService, ItemIdConversionMap, TransactionItemEntryChanges, TransactionItemEntryChangesTuple } from '../internal';
+import { ApiFormatter, ColumnExpansionResult, EntryParentNull, FieldMap, ItemEntry, ItemEntryService, ItemIdConversionMap, TransactionItemEntryChanges, TransactionItemEntryChangesTuple } from '../internal';
 export declare type ChangesDeltaResult = {
     itemIdConversionMap: ItemIdConversionMap;
     created: ItemEntry[];
@@ -28,6 +28,7 @@ export declare type ChangesDeltaItemUpdateDelta<ItemTypeType extends ApiEnumItem
 };
 export declare abstract class ChangesDeltaBase {
     protected itemEntryService: ItemEntryService;
+    protected apiFormatter: ApiFormatter;
     updated: {
         [itemEntryId: number]: ChangesDeltaItemUpdateDelta;
     };
@@ -55,10 +56,12 @@ export declare abstract class ChangesDeltaBase {
      */
     _queryResults: {
         [itemType: string]: {
-            [queryString: string]: ItemId[];
+            [queryString: string]: {
+                [itemId: string]: true;
+            };
         };
     };
-    protected constructor(itemEntryService: ItemEntryService);
+    protected constructor(itemEntryService: ItemEntryService, apiFormatter: ApiFormatter);
     /**
      * @description
      * Adds a hint for the {@link CollectionMatcherBase CacheSyncer] to the ChangesDelta, when the CollectionMatcher encounters a collection
@@ -66,7 +69,9 @@ export declare abstract class ChangesDeltaBase {
      *
      * @private
      */
-    _setQueryResult(itemType: ApiEnumItemType, queryString: string, itemIds: ItemId[]): void;
+    _setQueryResult(itemType: ApiEnumItemType, queryString: string, itemIds: ItemId[] | {
+        [itemId: string]: true;
+    }): void;
     setItemUpdated<ItemTypeType extends ApiEnumItemType>(entry: ItemEntry<ItemTypeType>, fields: Partial<FieldMap<ItemTypeType>>, columnExpansionResult?: ColumnExpansionResult<ItemTypeType> | null, parent?: EntryParentNull, updateModified?: boolean, updateInitial?: boolean): this;
     setItemRestored<ItemTypeType extends ApiEnumItemType>(itemEntry: ItemEntry<ItemTypeType>, transactionItemEntryChanges: TransactionItemEntryChanges<ItemTypeType>): void;
     isEmpty(): boolean;

package/dist/types/classes/CollectionEntryService.d.ts

@@ -7,12 +7,12 @@ export declare class CollectionEntryService {
     createUnfoundLocalCollectionError(itemType: ApiEnumItemType): {
         message: string;
     };
-    cloneOptions(options: CollectionOptions, parent: EntryParentNull): CollectionOptions<any, (string | number | symbol)[]>;
+    cloneOptions(options: CollectionOptions, parent: EntryParentNull): CollectionOptions<any, import("../internal").ItemTypeColumnIds<any>>;
     processOptions<ItemTypeType extends ApiEnumItemType>(options: CollectionOptionsInterface<ItemTypeType>): CollectionOptions;
     createQuery(query: ApiQuery): CollectionQuery;
     createQueryFromOptions(options: CollectionOptions): CollectionQuery;
     createBatchedLinkToQuery(parentType: ApiEnumItemType, parentIdArray: ItemId[], options: CollectionOptions): CollectionQuery;
-    getIdArray(itemEntries: Array<ItemEntry<any>>, accumulator?: ItemId[]): ItemId[];
+    getIdArray(itemEntries: ItemEntry[], accumulator?: ItemId[]): ItemId[];
     /**
      * @description
      * Filters an array of {@link ItemEntry ItemEntries} according to the callback function.
@@ -20,5 +20,5 @@ export declare class CollectionEntryService {
      *
      * @returns {@link ItemEntry ItemEntries} that failed the condition
      */
-    filterArray<T extends ItemEntry<any> = ItemEntry<any>>(itemEntries: T[], callback: (itemEntry: T) => boolean): T[];
+    filterArray<T extends ItemEntry = ItemEntry>(itemEntries: T[], callback: (itemEntry: T) => boolean): T[];
 }

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

@@ -2,10 +2,8 @@ import { ApiEnumItemType, ResponseColumn } from '@rentman/backend-types';
 import { ApiRequestColumns, ColumnUtil, ResponseColumnItemTypeMap } from '../internal';
 export declare class ColumnCache {
     private columnUtil;
-    cache: ResponseColumnItemTypeMap;
-    allColumns: {
-        [itemType: string]: boolean;
-    };
+    private cache;
+    private allColumns;
     constructor(columnUtil: ColumnUtil);
     setColumn(itemType: ApiEnumItemType, responseColumn: ResponseColumn): ResponseColumn;
     setColumns(itemType: ApiEnumItemType, requestColumns: ApiRequestColumns, responseColumns: ResponseColumnItemTypeMap, columnFilter: string | false): ResponseColumnItemTypeMap;

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

@@ -1,5 +1,5 @@
 import { ApiEnumItemType } from '@rentman/backend-types';
-import { ApiRequestColumn, ApiRequestColumns, ColumnExpansionResult, ColumnInfo, ColumnInfoFactory, ColumnSet, ResponseColumnItemTypeMap } from '../internal';
+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
@@ -8,14 +8,12 @@ export declare class ColumnExpansion<ItemTypeType extends ApiEnumItemType> {
     private columnInfoFactory;
     itemType: ItemTypeType;
     responseColumns: ResponseColumnItemTypeMap;
-    expansionMap: {
-        [columnSetId: string]: ColumnExpansionResult<ItemTypeType> | null;
-    };
-    expansionMapSize: number;
-    requestColumnsTrue: boolean;
-    requestColumns: ApiRequestColumn[];
+    private expansionMap;
+    private expansionMapSize;
+    private requestColumnsTrue;
+    private requestColumns;
     constructor(columnInfoFactory: ColumnInfoFactory, itemType: ItemTypeType, requestColumns: ApiRequestColumns, responseColumns: ResponseColumnItemTypeMap);
     run(columnSet: ColumnSet<ItemTypeType>): ColumnExpansionResult<ItemTypeType> | null;
-    aggregateRootColumns(): Array<ColumnInfo<ItemTypeType>>;
+    aggregateRootColumns(): ColumnInfo<ItemTypeType>[];
     private expandRootColumnMap;
 }

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

@@ -1,5 +1,6 @@
-import { ApiEnumItemType, ApiFields, GetColumnType } from '@rentman/backend-types';
-export declare class ColumnInfo<ItemTypeType extends ApiEnumItemType = any, ColumnId extends keyof ApiFields[ItemTypeType] = any> {
+import { ApiEnumItemType, GetColumnType } from '@rentman/backend-types';
+import { ItemTypeColumnId } from '..';
+export declare class ColumnInfo<ItemTypeType extends ApiEnumItemType = any, ColumnId extends ItemTypeColumnId<ItemTypeType> = any> {
     readonly apiColumn: GetColumnType<ItemTypeType, ColumnId>;
     readonly parent: ColumnInfo | null;
     id: ColumnId;
@@ -7,8 +8,8 @@ export declare class ColumnInfo<ItemTypeType extends ApiEnumItemType = any, Colu
     path: string;
     tailPath: string;
     itemType: ItemTypeType | null;
-    children: Array<ColumnInfo<ItemTypeType>>;
+    children: ColumnInfo<ItemTypeType>[];
     isLeaf: boolean;
     constructor(apiColumn: GetColumnType<ItemTypeType, ColumnId>, parent?: ColumnInfo | null);
-    setChildren(itemType: ItemTypeType, children: Array<ColumnInfo<ItemTypeType>>): this;
+    setChildren(itemType: ItemTypeType, children: ColumnInfo<ItemTypeType>[]): this;
 }

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

@@ -9,19 +9,19 @@ export declare class ColumnSet<ItemTypeType extends ApiEnumItemType = any> {
     requestColumnsTrue: boolean;
     response: ResponseColumnItemTypeMap;
     link: ColumnInfo<ItemTypeType> | null;
-    main: Array<ColumnInfo<ItemTypeType>>;
-    derived: Array<ColumnInfo<ItemTypeType>>;
-    root: Array<ColumnInfo<ItemTypeType>>;
-    leaf: Array<ColumnInfo<ItemTypeType>>;
+    main: ColumnInfo<ItemTypeType>[];
+    derived: ColumnInfo<ItemTypeType>[];
+    root: ColumnInfo<ItemTypeType>[];
+    leaf: ColumnInfo<ItemTypeType>[];
     formatted: {
-        main: Array<ColumnInfo<ItemTypeType>>;
-        derived: Array<ColumnInfo<ItemTypeType>>;
+        main: ColumnInfo<ItemTypeType>[];
+        derived: ColumnInfo<ItemTypeType>[];
     };
-    filtered: Array<ColumnInfo<ItemTypeType>>;
-    custom: Array<ColumnInfo<ItemTypeType>>;
-    searchable: Array<ColumnInfo<ItemTypeType>>;
-    item: Array<ColumnInfo<ItemTypeType>>;
-    notItem: Array<ColumnInfo<ItemTypeType>>;
+    filtered: ColumnInfo<ItemTypeType>[];
+    custom: ColumnInfo<ItemTypeType>[];
+    searchable: ColumnInfo<ItemTypeType>[];
+    item: ColumnInfo<ItemTypeType>[];
+    notItem: ColumnInfo<ItemTypeType>[];
     constructor(columnUtil: ColumnUtil, columnSetFactory: ColumnSetFactory, itemType: ItemTypeType);
     groupColumnInfo(columnInfo: ColumnInfo): void;
     toJSON(): {
@@ -29,9 +29,9 @@ export declare class ColumnSet<ItemTypeType extends ApiEnumItemType = any> {
         derived: any[];
     };
     isSupersetOf(columnsToCompare: ApiRequestColumns): boolean;
-    private getMergedColumnSet;
     mergeRequestColumns(requestColumns: ApiRequestColumns): RequestColumnMergeResult;
     mergeResponseColumns(responseColumns: ResponseColumnItemTypeMap): ResponseColumnItemTypeMap;
     merge(columnSet: ColumnSet<ItemTypeType>): ColumnSet<ItemTypeType>;
     expand(requestColumns: ApiRequestColumns, requestColumnsTrue: boolean, responseColumns: ResponseColumnItemTypeMap): ColumnExpansionResult<ItemTypeType>;
+    private getMergedColumnSet;
 }

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

@@ -13,13 +13,13 @@ export declare class ConversionMapService {
     createLocalConversionMap(itemType: ApiEnumItemType, itemId: ItemId, doExtend: boolean | undefined, apiResponse: ApiResponse): ItemIdConversionMap;
     expandLocalConversionMap(parentType: ApiEnumItemType, parentId: ItemId, apiResponse: ApiResponse, conversionMap: ItemIdConversionMap): void;
     expandConversionMap(itemType: ApiEnumItemType, itemId: ItemId, conversionMap: ItemIdConversionMap, newItemId?: ItemId): ItemId;
-    batchExpandConversionMap(itemEntries: Array<ItemEntry<any>>, conversionMap: ItemIdConversionMap): ItemIdConversionMap;
+    batchExpandConversionMap(itemEntries: ItemEntry<any>[], conversionMap: ItemIdConversionMap): ItemIdConversionMap;
     getConversionValue(itemType: ApiEnumItemType, 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.
+     *
+     * @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 ApiEnumItemType>(source: FieldMap<ItemTypeType>, destination: FieldMap<ItemTypeType>, itemColumns: Array<ColumnInfo<ItemTypeType>>, conversionMap: ItemIdConversionMap, parent?: EntryParentNull): void;
+    updateItemValues<ItemTypeType extends ApiEnumItemType>(source: FieldMap<ItemTypeType>, destination: FieldMap<ItemTypeType>, itemColumns: ColumnInfo<ItemTypeType>[], conversionMap: ItemIdConversionMap, parent?: EntryParentNull): void;
 }

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

@@ -7,7 +7,7 @@ export declare class CreateRequest<ItemTypeType extends ApiEnumItemType> {
     private compilation;
     private transaction;
     private breakupByParent;
-    requests: Array<CreateRequestEntry<ItemTypeType>>;
+    requests: CreateRequestEntry<ItemTypeType>[];
     constructor(apiFormatter: ApiFormatter, keyService: KeyService, requestColumnExpansionFactory: RequestColumnExpansionFactory, compilation: CreateCompilation, transaction: TransactionCache, breakupByParent?: boolean);
     finalizeRequest(requestResource: CreateRequestEntry<ItemTypeType>): CreateRequestEntry<ItemTypeType>;
     setRequestParent(parentType: CreateRequestCompilationParent, requestEntry: CreateRequestEntry<ItemTypeType>): boolean;

package/dist/types/classes/InternalChangesDelta.d.ts

@@ -1,5 +1,5 @@
 import { ApiEnumItemType } from '@rentman/backend-types';
-import { ChangesDeltaBase, EntryParent, FieldMap, ItemEntry, ItemEntryService, ItemIdConversionMap, TransactionItemEntryChangesTuple } from '../internal';
+import { ApiFormatter, ChangesDeltaBase, EntryParent, FieldMap, ItemEntry, ItemEntryService, ItemIdConversionMap, TransactionItemEntryChangesTuple } from '../internal';
 export declare type InternalCreateDelta<ItemTypeType extends ApiEnumItemType = any> = {
     entry: ItemEntry<ItemTypeType>;
     fields: FieldMap<ItemTypeType>;
@@ -29,10 +29,9 @@ export declare class InternalChangesDelta extends ChangesDeltaBase {
         };
     };
     itemIdConversionMap: ItemIdConversionMap;
-    constructor(itemEntryService: ItemEntryService);
+    constructor(itemEntryService: ItemEntryService, apiFormatter: ApiFormatter);
     setItemDeleted(tuple: TransactionItemEntryChangesTuple<any>): this;
     setItemsDeleted(deleted: TransactionItemEntryChangesTuple<any>[]): this;
-    private itemIsDeleted;
     setItemCreated<ItemTypeType extends ApiEnumItemType>(itemEntry: ItemEntry<ItemTypeType>, fields: FieldMap<ItemTypeType>): void;
     /**
      * @remark
@@ -40,4 +39,5 @@ export declare class InternalChangesDelta extends ChangesDeltaBase {
      */
     setItemMoved(entry: ItemEntry, to: EntryParent): void;
     isEmpty(): boolean;
+    private itemIsDeleted;
 }

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

@@ -10,18 +10,18 @@ export declare class ItemCache {
     constructor(queryMatcherFactory: QueryMatcherFactory, transaction: AbstractCache);
     getByEntryId(itemEntryId: ItemEntry['id']): ItemEntry | undefined;
     some(callback: (itemEntry: ItemEntry) => boolean): boolean;
-    getByItemType<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType): Array<ItemEntry<ItemTypeType>>;
-    getByQuery<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, query: CollectionQuery['object']): Array<ItemEntry<ItemTypeType>>;
-    getLocalByQuery<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, query: CollectionQuery['object']): Array<ItemEntry<ItemTypeType>>;
+    getByItemType<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType): ItemEntry<ItemTypeType>[];
+    getByQuery<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, query: CollectionQuery['object']): ItemEntry<ItemTypeType>[];
+    getLocalByQuery<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, query: CollectionQuery['object']): ItemEntry<ItemTypeType>[];
     getByParent<ItemTypeType extends ApiEnumItemType>(parentType: ApiEnumItemType, parentId: ItemId, itemType: ItemTypeType): ItemEntry<ItemTypeType>[];
     batchGetLocalByParent<ItemTypeType extends ApiEnumItemType>(parentType: ApiEnumItemType, parentIds: ItemId[], itemType: ItemTypeType, additionalQuery: CollectionQuery['object']): ItemEntryParentIdMap<ItemTypeType>;
     forEach(callback: (itemEntry: ItemEntry) => void): void;
-    toArray(): ItemEntry<any>[];
+    toArray(): ItemEntry[];
     add<ItemTypeType extends ApiEnumItemType>(itemEntry: ItemEntry<ItemTypeType>): ItemEntry<ItemTypeType>;
     get<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, itemId: string | ItemId): undefined | ItemEntry<ItemTypeType>;
     contains(itemType: ApiEnumItemType, itemId: string | ItemId): boolean;
     updateItemId<T extends ItemEntry<any>>(itemEntry: T, oldItemId: string | ItemId): T;
     clear(itemEntry?: ItemEntry<any>): boolean;
     clearByItemId(itemType: ApiEnumItemType, itemId: ItemId): boolean;
-    matchQuery(itemEntry: ItemEntry<any>, query: CollectionQuery['object']): boolean;
+    matchQuery(itemEntry: ItemEntry, query: CollectionQuery['object']): boolean;
 }

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

@@ -12,7 +12,7 @@ export declare class ItemCreateService {
      * @description
      * Fetches a new {@link Template template} and sets the items created on the passed {@link ChangesDelta}
      */
-    createItemsFromValues<ItemTypeType extends ApiEnumItemType, ColumnIds extends Array<keyof ApiFields[ItemTypeType]> = Array<keyof ApiFields[ItemTypeType]>>(changesDelta: ChangesDelta, itemType: ItemTypeType, valuesArray: Array<Partial<FieldMap<ItemTypeType, ColumnIds>>>, parent?: EntryParentNull): PromiseInterface<void>;
-    processTemplate<ItemTypeType extends ApiEnumItemType, ColumnIds extends Array<keyof ApiFields[ItemTypeType]> = Array<keyof ApiFields[ItemTypeType]>>(changesDelta: ChangesDelta, itemType: ItemTypeType, itemId: ItemId, parent: EntryParentNull, template: Template<ItemTypeType, ColumnIds>, filterItemEntryCallback?: FilterItemEntryCallback, modifyFieldsCallback?: ModifyFieldsCallback, isRoot?: boolean): void;
+    createItemsFromValues<ItemTypeType extends ApiEnumItemType, ColumnIds extends (keyof ApiFields[ItemTypeType])[] = (keyof ApiFields[ItemTypeType])[]>(changesDelta: ChangesDelta, itemType: ItemTypeType, valuesArray: Partial<FieldMap<ItemTypeType, ColumnIds>>[], parent?: EntryParentNull): PromiseInterface<void>;
+    processTemplate<ItemTypeType extends ApiEnumItemType, ColumnIds extends (keyof ApiFields[ItemTypeType])[] = (keyof ApiFields[ItemTypeType])[]>(changesDelta: ChangesDelta, itemType: ItemTypeType, itemId: ItemId, parent: EntryParentNull, template: Template<ItemTypeType, ColumnIds>, filterItemEntryCallback?: FilterItemEntryCallback, modifyFieldsCallback?: ModifyFieldsCallback, isRoot?: boolean): void;
     processTemplateLinkItems<ParentItemType extends ApiEnumItemType>(changesDelta: ChangesDelta, parentType: ParentItemType, localParentId: ItemId, template: Template<ParentItemType>, itemIdConversion: ItemIdConversionMap, filterItemEntryCallback?: FilterItemEntryCallback, modifyFieldsCallback?: ModifyFieldsCallback): void;
 }

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

@@ -5,7 +5,7 @@ export declare class KeyService {
     private idCounter;
     constructor();
     getSingleKey(itemType: string, itemId: ItemId | string): string;
-    getCssKey(...args: any[]): string;
+    getCssKey(...args: (string | number)[]): string;
     parseStateKey(stateKey: string): StateKey | null;
     getDuplicateStateKey(itemId: string | ItemId): string;
     getNewStateKey(templateType: string): string;

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

@@ -20,10 +20,10 @@ export declare class LockService {
     fetchLock(itemEntry: ItemEntry): PromiseInterface<LockToken>;
     deleteLock(itemEntry: ItemEntry): PromiseInterface<void>;
     clearLock(itemEntry: ItemEntry): boolean;
+    isRemoteLock(token: LockToken): token is LockTokenError;
     private requestLock;
     private fetchCachedLock;
     private getValue;
     private setValue;
-    isRemoteLock(token: LockToken): token is LockTokenError;
 }
 export {};

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

@@ -1,5 +1,5 @@
 import { ApiEnumItemType } from '@rentman/backend-types';
-import { ChangesDeltaBase, ChangesDeltaItemDeleteDelta, EntryParent, FieldMap, InternalCreateDelta, ItemEntry, ItemEntryService, ItemIdConversionMap } from '../internal';
+import { ApiFormatter, ChangesDeltaBase, ChangesDeltaItemDeleteDelta, EntryParent, FieldMap, InternalCreateDelta, ItemEntry, ItemEntryService, ItemIdConversionMap } from '../internal';
 export declare type ParentChangesDeltaItemDeleteDelta = ItemEntry;
 /**
  * @description
@@ -26,7 +26,7 @@ export declare class ParentChangesDelta extends ChangesDeltaBase {
         };
     };
     itemIdConversionMap: ItemIdConversionMap;
-    constructor(itemEntryService: ItemEntryService);
+    constructor(itemEntryService: ItemEntryService, apiFormatter: ApiFormatter);
     setItemDeleted(deleted: ChangesDeltaItemDeleteDelta): this;
     setItemsDeleted(deleted: ChangesDeltaItemDeleteDelta[]): this;
     setItemCreated<ItemTypeType extends ApiEnumItemType>(itemEntry: ItemEntry<ItemTypeType>, fields: FieldMap<ItemTypeType>): void;

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

@@ -1,18 +1,18 @@
 import { ApiEnumItemType, ApiQueryConditionLinkedTo, ApiQueryConditionSubQuery } from '@rentman/backend-types';
 import { ApiQuery, ApiQueryConditionComparator, ApiQueryWithConditions, ApiRequestColumn, ColumnUtil, QueryParserBase } from '../internal';
-export declare class QueryColumnExtractor extends QueryParserBase<ApiRequestColumn[]> {
+declare type ReturnType = ApiRequestColumn[];
+export declare class QueryColumnExtractor extends QueryParserBase<ReturnType> {
     private columnUtil;
     private itemType;
     constructor(columnUtil: ColumnUtil, itemType: ApiEnumItemType, query: ApiQuery);
-    protected parseEmptyQuery(): never[];
-    protected parseSubQuery<T extends ApiQueryConditionSubQuery>(key: T['key'], subQuery: T['query']): {
-        [x: string]: ApiRequestColumn[];
-    }[];
-    protected parseSubFieldQuery(): never[];
-    protected parseSearchQuery(): never[];
-    protected parseCustomQuery(): never[];
-    protected parseSimpleQuery<T extends ApiQueryConditionComparator>(key: T['key']): T["key"][];
-    protected parseLinkedToQuery<T extends ApiQueryConditionLinkedTo>(linkedTo: T['linkedTo'], _query: T['query'], reverse: T['reverse']): ApiRequestColumn[];
-    protected parseComplexQuery<T extends ApiQueryWithConditions>(conditions: T['conditions']): ApiRequestColumn[];
+    protected parseEmptyQuery(): ReturnType;
+    protected parseSubQuery<T extends ApiQueryConditionSubQuery>(key: T['key'], subQuery: T['query']): ReturnType;
+    protected parseSubFieldQuery(): ReturnType;
+    protected parseSearchQuery(): ReturnType;
+    protected parseCustomQuery(): ReturnType;
+    protected parseSimpleQuery<T extends ApiQueryConditionComparator>(key: T['key']): ReturnType;
+    protected parseLinkedToQuery<T extends ApiQueryConditionLinkedTo>(linkedTo: T['linkedTo'], _query: T['query'], reverse: T['reverse']): ReturnType;
+    protected parseComplexQuery<T extends ApiQueryWithConditions>(conditions: T['conditions']): ReturnType;
     private parseConditions;
 }
+export {};

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

@@ -1,15 +1,17 @@
 import { ApiQueryConditionLinkedTo, ApiQueryConditionSubQuery } from '@rentman/backend-types';
-import { ApiQueryConditionComparator, ApiQueryWithConditions, KeyService, QueryParserBase } from '../internal';
-export declare class QueryContainsLocalIdParser extends QueryParserBase<boolean> {
+import { ApiQuery, ApiQueryConditionComparator, ApiQueryWithConditions, KeyService, QueryParserBase } from '../internal';
+declare type ReturnType = boolean;
+export declare class QueryContainsLocalIdParser extends QueryParserBase<ReturnType> {
     private keyService;
-    constructor(keyService: KeyService, query: any);
-    protected parseEmptyQuery(): boolean;
-    protected parseSubQuery<T extends ApiQueryConditionSubQuery>(_key: T['key'], subQuery: T['query']): boolean;
-    protected parseSubFieldQuery<T extends ApiQueryConditionSubQuery>(_key: T['key'], _itemType: T['itemType'], field: T['field'], query: T['query']): boolean;
-    protected parseSearchQuery(): boolean;
-    protected parseCustomQuery(): boolean;
-    protected parseSimpleQuery<T extends ApiQueryConditionComparator>(_key: T['key'], value: T['value']): boolean;
-    protected parseLinkedToQuery<T extends ApiQueryConditionLinkedTo>(_linkedTo: T['linkedTo'], query: T['query']): boolean;
-    protected parseComplexQuery<T extends ApiQueryWithConditions>(conditions: T['conditions']): boolean;
+    constructor(keyService: KeyService, query: ApiQuery);
+    protected parseEmptyQuery(): ReturnType;
+    protected parseSubQuery<T extends ApiQueryConditionSubQuery>(_key: T['key'], subQuery: T['query']): ReturnType;
+    protected parseSubFieldQuery<T extends ApiQueryConditionSubQuery>(_key: T['key'], _itemType: T['itemType'], field: T['field'], query: T['query']): ReturnType;
+    protected parseSearchQuery(): ReturnType;
+    protected parseCustomQuery(): ReturnType;
+    protected parseSimpleQuery<T extends ApiQueryConditionComparator>(_key: T['key'], value: T['value']): ReturnType;
+    protected parseLinkedToQuery<T extends ApiQueryConditionLinkedTo>(_linkedTo: T['linkedTo'], query: T['query']): ReturnType;
+    protected parseComplexQuery<T extends ApiQueryWithConditions>(conditions: T['conditions']): ReturnType;
     private parseConditions;
 }
+export {};

package/dist/types/classes/QueryLinkedToParser.d.ts

@@ -1,15 +1,17 @@
 import { ApiEnumItemType, ApiQueryConditionLinkedTo, ApiQueryConditionSubQuery } from '@rentman/backend-types';
 import { ApiQuery, ApiQueryWithConditions, QueryParserBase } from '../internal';
-export declare class QueryLinkedToParser extends QueryParserBase<boolean> {
+declare type ReturnType = boolean;
+export declare class QueryLinkedToParser extends QueryParserBase<ReturnType> {
     private callback;
     constructor(callback: <ItemTypeType extends ApiEnumItemType>(linkedTo: ItemTypeType, query: ApiQuery<ItemTypeType>) => boolean, query: ApiQuery);
-    protected parseEmptyQuery(): boolean;
-    protected parseSubQuery<T extends ApiQueryConditionSubQuery>(_key: T['key'], subQuery: T['query']): boolean;
-    protected parseSubFieldQuery(): boolean;
-    protected parseSearchQuery(): boolean;
-    protected parseCustomQuery(): boolean;
-    protected parseSimpleQuery(): boolean;
-    protected parseLinkedToQuery<T extends ApiQueryConditionLinkedTo>(linkedTo: T['linkedTo'], query: T['query'], _reverse: T['reverse'], not?: T['not']): boolean;
-    protected parseComplexQuery<T extends ApiQueryWithConditions>(conditions: T['conditions']): boolean;
+    protected parseEmptyQuery(): ReturnType;
+    protected parseSubQuery<T extends ApiQueryConditionSubQuery>(_key: T['key'], subQuery: T['query']): ReturnType;
+    protected parseSubFieldQuery(): ReturnType;
+    protected parseSearchQuery(): ReturnType;
+    protected parseCustomQuery(): ReturnType;
+    protected parseSimpleQuery(): ReturnType;
+    protected parseLinkedToQuery<T extends ApiQueryConditionLinkedTo>(linkedTo: T['linkedTo'], query: T['query'], _reverse: T['reverse'], not?: T['not']): ReturnType;
+    protected parseComplexQuery<T extends ApiQueryWithConditions>(conditions: T['conditions']): ReturnType;
     private parseConditions;
 }
+export {};

package/dist/types/classes/QueryLocallyMatchableParser.d.ts

@@ -1,18 +1,20 @@
 import { ApiQueryConditionLinkedTo } from '@rentman/backend-types';
 import { ApiQuery, ApiQueryWithConditions, QueryParserBase } from '../internal';
+declare type ReturnType = boolean;
 /**
  * @description
  * Returns whether or not a query can be parsed by the {@link QueryMatcher QueryMatcher}
  */
-export declare class QueryLocallyMatchableParser extends QueryParserBase<boolean> {
+export declare class QueryLocallyMatchableParser extends QueryParserBase<ReturnType> {
     constructor(query: ApiQuery);
-    protected parseEmptyQuery(): boolean;
-    protected parseSubQuery(): boolean;
-    protected parseSubFieldQuery(): boolean;
-    protected parseSearchQuery(): boolean;
-    protected parseCustomQuery(): boolean;
-    protected parseSimpleQuery(): boolean;
-    protected parseLinkedToQuery<T extends ApiQueryConditionLinkedTo>(_linkedTo: T['linkedTo'], _query: T['query'], reverse: T['reverse'], _not: T['not']): boolean;
-    protected parseComplexQuery<T extends ApiQueryWithConditions>(conditions: T['conditions']): boolean;
+    protected parseEmptyQuery(): ReturnType;
+    protected parseSubQuery(): ReturnType;
+    protected parseSubFieldQuery(): ReturnType;
+    protected parseSearchQuery(): ReturnType;
+    protected parseCustomQuery(): ReturnType;
+    protected parseSimpleQuery(): ReturnType;
+    protected parseLinkedToQuery<T extends ApiQueryConditionLinkedTo>(_linkedTo: T['linkedTo'], _query: T['query'], reverse: T['reverse'], _not: T['not']): ReturnType;
+    protected parseComplexQuery<T extends ApiQueryWithConditions>(conditions: T['conditions']): ReturnType;
     private parseConditions;
 }
+export {};

package/dist/types/classes/QueryMatcher.d.ts

@@ -3,15 +3,21 @@ import { ApiFormatter, ApiQuery, EntryParentNull, FieldMap } from '../internal';
 export declare class QueryMatcher {
     private apiFormatter;
     itemType: ApiEnumItemType;
-    fields: FieldMap;
+    fields: FieldMap | [FieldMap, FieldMap];
     parent: EntryParentNull;
-    constructor(apiFormatter: ApiFormatter, itemType: ApiEnumItemType, fields: FieldMap, parent?: EntryParentNull);
-    private compareValues;
+    /**
+     * @param apiFormatter
+     * @param itemType
+     * @param fields The fields to match against, if "fields" is an array index [0] should be the new/updated values, and index [1] the cached ones
+     * @param parent
+     */
+    constructor(apiFormatter: ApiFormatter, itemType: ApiEnumItemType, fields: FieldMap | [FieldMap, FieldMap], parent?: EntryParentNull);
     /**
      * @remark
      * When changing this code also change {@link QueryLocallyMatchableParser QueryLocallyMatchableParser}
      */
     matchQuery(query: ApiQuery): boolean | 'maybe';
+    private compareValues;
     private matchLinkedToQuery;
     private matchComplexQuery;
     private matchSimpleQuery;

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

@@ -14,7 +14,7 @@ export declare class QueryParser extends QueryParserBase<ReturnType> {
     protected parseSearchQuery(value: any, not?: boolean): ReturnType;
     protected parseCustomQuery(custom: string, parameters: any, not?: boolean): ReturnType;
     protected parseCustomParameters(parameters: any): ReturnType;
-    protected parseSimpleQuery<T extends ApiQueryConditionComparator | ApiQueryConditionInShort<any, any>>(key: T['key'], value: T['value'], comparator: T['comparator'] | undefined, not?: T['not']): ReturnType;
+    protected parseSimpleQuery<T extends ApiQueryConditionComparator | ApiQueryConditionInShort<any, any>>(key: T['key'], value: T['value'], comparator: T['comparator'], not?: T['not']): ReturnType;
     protected parseLinkedToQuery(linkedTo: any, query?: ApiQuery, reverse?: boolean, not?: boolean): ReturnType;
     protected parseComplexQuery<T extends ApiQueryWithConditions>(conditions: T['conditions'], operator?: T['operator'], not?: T['not']): ReturnType;
     private parseConditions;