@rentman/rm-core 9.1.2 → 9.2.0

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

@@ -1,15 +1,17 @@
 import { ApiQueryConditionLinkedTo, ApiQueryConditionSubQuery } from '@rentman/backend-types';
 import { ApiQuery, ApiQueryConditionComparator, ApiQueryWithConditions, ItemIdConversionMap, QueryParserBase } from '../internal';
-export declare class QueryParserIdUpdater extends QueryParserBase<boolean> {
+declare type ReturnType = boolean;
+export declare class QueryParserIdUpdater extends QueryParserBase<ReturnType> {
     private itemIdConversionMap;
     constructor(itemIdConversionMap: ItemIdConversionMap, 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<T extends ApiQueryConditionComparator>(_key: T['key'], value: T['value'], _comparator: T['comparator'], _not: T['not'], queryPart: T): boolean;
-    protected parseLinkedToQuery<T extends ApiQueryConditionLinkedTo>(_linkedTo: T['linkedTo'], query?: T['query']): 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<T extends ApiQueryConditionComparator>(_key: T['key'], value: T['value'], _comparator: T['comparator'], _not: T['not'], queryPart: T): 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/RequestBufferManager.d.ts

@@ -1,5 +1,16 @@
 import { ApiEnumItemType, ApiQuery, ItemId } from '@rentman/backend-types';
 import { ApiRequestColumns, ApiRequestService, ChangesDeltaFactory, KeyService, PromiseInterface, PromiseLibraryInterface, RequestBufferResponse, RequestColumnExpansionFactory, ServerCache } from '../internal';
+/**
+ * @description
+ * Allows to have finer control over the RequestBuffer and to merge specific requests
+ *
+ * @param maxTimeout The maximum timeout to wait (if expectedSize is not reached) before doing the query anyways.
+ * @param expectedSize The amount of items expected to be in the query, when this amount is reached the buffer will flush before the maxTimeout is reached.
+ */
+export declare type RequestBufferManagerPrioritySettings = {
+    maxTimeout: number;
+    expectedSize: number;
+};
 export declare class RequestBufferManager {
     private promiseLibrary;
     private apiRequestService;
@@ -8,13 +19,14 @@ export declare class RequestBufferManager {
     private changesDeltaFactory;
     private pendingBufferMap;
     private pendingTrueBufferMap;
+    private pendingPriorityBufferMap;
     private serverCache;
     constructor(promiseLibrary: PromiseLibraryInterface, apiRequestService: ApiRequestService, requestColumnExpansionFactory: RequestColumnExpansionFactory, keyService: KeyService, changesDeltaFactory: ChangesDeltaFactory);
     setServerCache(serverCache: ServerCache): void;
     fetchByIds(itemType: ApiEnumItemType, itemIds: ItemId[], requestColumns: ApiRequestColumns): PromiseInterface<RequestBufferResponse>;
     fetchById(itemType: ApiEnumItemType, itemId: ItemId, requestColumns: ApiRequestColumns): PromiseInterface<RequestBufferResponse>;
-    fetchByQuery(itemType: ApiEnumItemType, query: [ApiQuery, string], // queryParser result
-    requestColumns: ApiRequestColumns): PromiseInterface<RequestBufferResponse>;
+    fetchByQuery(itemType: ApiEnumItemType, query: [ApiQuery, string], requestColumns: ApiRequestColumns, priorityBufferSettings: RequestBufferManagerPrioritySettings | null): PromiseInterface<RequestBufferResponse>;
+    private constructPriorityBuffer;
     private constructBuffer;
     private _constructBuffer;
 }

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

@@ -1,9 +1,9 @@
 import { ApiEnumItemType } from '@rentman/backend-types';
 import { ApiFormatter, ApiRequestService, CachedQueryItem, ChangesDeltaFactory, ErrorHandlerInterface, PromiseLibraryInterface, QueryMatcherFactory, RequestBufferManager, RequestColumnExpansionFactory, SocketMessage, TransactionCacheFactory } from '../internal';
 export declare type CachedQueryMatchingResult<ItemTypeType extends ApiEnumItemType> = {
-    fitting: Array<CachedQueryItem<ItemTypeType>>;
-    notfitting: Array<CachedQueryItem<ItemTypeType>>;
-    maybe: Array<CachedQueryItem<ItemTypeType>>;
+    fitting: CachedQueryItem<ItemTypeType>[];
+    notfitting: CachedQueryItem<ItemTypeType>[];
+    maybe: CachedQueryItem<ItemTypeType>[];
 };
 export declare class SocketMessageHandler {
     private requestBufferManager;

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

@@ -1,5 +1,5 @@
-import { ApiEnumItemType, ApiFields, ItemId } from '@rentman/backend-types';
-import { ApiRequestService, ApiResponse, ColumnHandler, ColumnUtil, EntryParentNull, ErrorHandlerInterface, PromiseInterface, PromiseLibraryInterface, RequestColumnExpansionFactory, Template, TemplateFactory } from '../internal';
+import { ApiEnumItemType, ItemId } from '@rentman/backend-types';
+import { ApiRequestService, ApiResponse, ColumnHandler, ColumnUtil, EntryParentNull, ErrorHandlerInterface, ItemTypeColumnIds, PromiseInterface, PromiseLibraryInterface, RequestColumnExpansionFactory, Template, TemplateFactory } from '../internal';
 export declare class TemplateCache {
     private columnUtil;
     private promiseService;
@@ -56,7 +56,7 @@ export declare class TemplateCache {
      *          );
      *  ```
      */
-    fetchTemplate<ItemTypeType extends ApiEnumItemType, ColumnIds extends Array<keyof ApiFields[ItemTypeType]> = Array<keyof ApiFields[ItemTypeType]>>(itemType: ItemTypeType, itemId?: ItemId, templateOptions?: any, templateColumns?: any, entryParentOrParentItemType?: EntryParentNull | ApiEnumItemType): PromiseInterface<Template<ItemTypeType, ColumnIds>>;
+    fetchTemplate<ItemTypeType extends ApiEnumItemType, ColumnIds extends ItemTypeColumnIds<ItemTypeType> = ItemTypeColumnIds<ItemTypeType>>(itemType: ItemTypeType, itemId?: ItemId, templateOptions?: any, templateColumns?: any, entryParentOrParentItemType?: EntryParentNull | ApiEnumItemType): PromiseInterface<Template<ItemTypeType, ColumnIds>>;
     private fetchTemplateById;
     private constructTemplateBuffer;
 }

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

@@ -5,10 +5,10 @@ export declare function hasProperties(object: any): boolean;
 export declare function getFirstProperty(object: any): string | null;
 export declare function inArray(needle: any, haystack: any): boolean;
 export declare function filterArray<T>(source: T[], callback: (elem: T) => boolean): boolean;
-export declare function emptyArray(array: any): void;
-export declare function pathExists(source: any, path: any): boolean;
-export declare function createPath<T>(object: any, path: Array<number | string>, defaults: any[]): T;
-export declare function getPath(object: {}, path: Array<number | string>, create?: boolean): any;
+export declare function emptyArray(array: any[]): void;
+export declare function pathExists(source: any, path: string[]): boolean;
+export declare function createPath<T>(object: any, path: (number | string)[], defaults: any[]): T;
+export declare function getPath(object: {}, path: (number | string)[], create?: boolean): any;
 export declare function extend(dst: any, ...args: any[]): any;
 export declare function merge(dst: any, ...args: any[]): any;
 export declare function isObject(value: any): boolean;

package/dist/types/classes/cache/AbstractCache.d.ts

@@ -75,7 +75,7 @@ export declare abstract class AbstractCache {
         result: ChangesDeltaResult;
         parentChangesDelta: ParentChangesDelta;
         matchingDelta: ParentChangesDelta;
-        undoFunctions: Array<(changesDelta: InternalChangesDelta) => void>;
+        undoFunctions: ((changesDelta: InternalChangesDelta) => void)[];
     };
     /**
      * @description

package/dist/types/classes/cache/CachedQueryHandlerBase.d.ts

@@ -26,12 +26,8 @@ export declare abstract class CachedQueryHandlerBase {
     /**
      * Every time a cached query item is created, either 'resolve' or 'reject' has to be called on the cached query item.
      */
-    setCachedQuery<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, parsedQuery: CollectionQuery, requestColumns: ApiRequestColumns, itemEntries?: Array<ItemEntry<ItemTypeType>>): CachedQueryItem<ItemTypeType>;
-    /**
-     * Every time a cached query item is created, either 'resolve' or 'reject' has to be called on the cached query item.
-     */
-    protected constructCachedQuery<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, parsedQuery: CollectionQuery, itemEntries: Array<ItemEntry<ItemTypeType>>, requestColumns: ApiRequestColumns): CachedQueryItem<ItemTypeType>;
-    getCachedQueryItems<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, queryString: string): undefined | Array<ItemEntry<ItemTypeType>>;
+    setCachedQuery<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, parsedQuery: CollectionQuery, requestColumns: ApiRequestColumns, itemEntries?: ItemEntry<ItemTypeType>[]): CachedQueryItem<ItemTypeType>;
+    getCachedQueryItems<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, queryString: string): undefined | ItemEntry<ItemTypeType>[];
     getCachedQueryObjectsByItemType(itemType: ApiEnumItemType): CachedQueryItem[];
     /**
      * @description
@@ -48,21 +44,25 @@ export declare abstract class CachedQueryHandlerBase {
      * Fetches collections linked to the passed parents
      */
     abstract __fetchLinkedCachedQueryItems<ItemTypeType extends ApiEnumItemType>(parentType: ApiEnumItemType, parentIdArray: ItemId[] | (() => ItemId[]), itemType: ItemTypeType, options: CollectionOptions): PromiseInterface<ParentIdMap<CachedQueryItem<ItemTypeType>>>;
-    /**
-     * @description
-     * Adds the passed {@link ItemEntry ItemEntries} to the Transaction's query cache,
-     * will skip the ItemEntry if the `skipEntryFilterFn` callback returns `true`
-     */
-    protected __addItemEntriesToCachedQueries<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, parsedQuery: CollectionQuery, itemEntries: Array<ItemEntry<ItemTypeType>>, skipEntryFilterFn: (temEntry: ItemEntry) => boolean): void;
     /**
      * @description
      * Removes the passed {@link ItemId ItemIds} from the Transaction's query cache
      */
-    __removeItemEntriesFromCachedQueries<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, parsedQuery: CollectionQuery, itemEntries: Array<ItemEntry<ItemTypeType>>): Array<ItemEntry<ItemTypeType>>;
+    __removeItemEntriesFromCachedQueries<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, parsedQuery: CollectionQuery, itemEntries: ItemEntry<ItemTypeType>[]): ItemEntry<ItemTypeType>[];
     /**
      * @description
-     * Expands the option's {@link CollectionOptions.columns columns} with the columns required for the {@link CollectionMatcherCachedCollectionProcessor CollectionMatcher} to function.
+     * Expands the option's {@link CollectionOptions.columns columns} with the columns required for the {@link CacheSyncer CacheSyncer} to function.
      * Data fetched for a parent transaction might also fit in a child transaction, so those {@link CollectionOptions.queryColumns queryColumns} should also be taken into account
      */
     expandColumnsWithQueryColumns(itemType: ApiEnumItemType, options: CollectionOptions, query: ApiQuery): void;
+    /**
+     * Every time a cached query item is created, either 'resolve' or 'reject' has to be called on the cached query item.
+     */
+    protected constructCachedQuery<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, parsedQuery: CollectionQuery, itemEntries: ItemEntry<ItemTypeType>[], requestColumns: ApiRequestColumns): CachedQueryItem<ItemTypeType>;
+    /**
+     * @description
+     * Adds the passed {@link ItemEntry ItemEntries} to the Transaction's query cache,
+     * will skip the ItemEntry if the `skipEntryFilterFn` callback returns `true`
+     */
+    protected __addItemEntriesToCachedQueries<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, parsedQuery: CollectionQuery, itemEntries: ItemEntry<ItemTypeType>[], skipEntryFilterFn: (temEntry: ItemEntry) => boolean): void;
 }

package/dist/types/classes/cache/ItemHandlerBase.d.ts

@@ -43,12 +43,12 @@ export declare abstract class ItemHandlerBase {
      * @description
      * Fetches the ItemEntries for the given query, does not look in the cache, since we don't know which ItemIds belong to the query !
      */
-    abstract fetchItemEntriesByQuery<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, query: ApiQuery, entryOptions: ItemEntryOptions): PromiseInterface<Array<ItemEntry<ItemTypeType>>>;
+    abstract fetchItemEntriesByQuery<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, query: ApiQuery, entryOptions: ItemEntryOptions): PromiseInterface<ItemEntry<ItemTypeType>[]>;
     /**
      * @description
      * Fetches the ItemEntries for the given ItemIds
      */
-    abstract fetchItemEntries<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, itemIds: ItemId[], options: ItemEntryOptions): PromiseInterface<Array<ItemEntry<ItemTypeType>>>;
+    abstract fetchItemEntries<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, itemIds: ItemId[], options: ItemEntryOptions): PromiseInterface<ItemEntry<ItemTypeType>[]>;
     /**
      * @description
      * Fetches an ItemEntry with the given itemId
@@ -87,8 +87,8 @@ export declare abstract class ItemHandlerBase {
      * Recursively fetches derived values as separate requests, instead of as columns of a primary item
      * Can be used when derived values of a local item have to be fetched, since a local item can't be used as root item of a query
      */
-    fetchDerivedValuesByColumn<ItemTypeType extends ApiEnumItemType>(itemEntries: Array<ItemEntry<ItemTypeType>>, rootColumn: ColumnInfo<ItemTypeType>, changesDelta?: ChangesDeltaBase): PromiseInterface<void | Array<ItemEntry<ItemTypeType>>>;
-    resolveDerivedValues<ItemTypeType extends ApiEnumItemType>(itemEntries: Array<ItemEntry<ItemTypeType>>, columns: Array<ColumnInfo<ItemTypeType>>, changesDelta?: ChangesDeltaBase): PromiseInterface<Array<ItemEntry<ItemTypeType>>>;
+    fetchDerivedValuesByColumn<ItemTypeType extends ApiEnumItemType>(itemEntries: ItemEntry<ItemTypeType>[], rootColumn: ColumnInfo<ItemTypeType>, changesDelta?: ChangesDeltaBase): PromiseInterface<void | ItemEntry<ItemTypeType>[]>;
+    resolveDerivedValues<ItemTypeType extends ApiEnumItemType>(itemEntries: ItemEntry<ItemTypeType>[], columns: ColumnInfo<ItemTypeType>[], changesDelta?: ChangesDeltaBase): PromiseInterface<ItemEntry<ItemTypeType>[]>;
     /**
      * @description
      * Creates a new {@link ItemEntry ItemEntry} from the passed {@link ChangesDeltaItemCreateDelta ChangesDeltaItemCreateDelta} and stores it in this transaction's {@link ItemCache ItemCache}

package/dist/types/classes/cache/server/ServerCachedQueryHandler.d.ts

@@ -10,7 +10,7 @@ export declare class ServerCachedQueryHandler extends CachedQueryHandlerBase {
     constructor(columnSubsetCacheFactory: ColumnSubsetCacheFactory, requestBufferManager: RequestBufferManager, requestColumnExpansionFactory: RequestColumnExpansionFactory, apiRequestService: ApiRequestService, collectionEntryService: CollectionEntryService, errorHandler: ErrorHandlerInterface, itemHandler: ServerItemHandler, promiseService: PromiseLibraryInterface, columnUtil: ColumnUtil, transaction: ServerCache);
     __fetchCachedQueryItem<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, options: CollectionOptions): PromiseInterface<CachedQueryItem<ItemTypeType>>;
     __fetchLinkedCachedQueryItems<ItemTypeType extends ApiEnumItemType>(parentType: ApiEnumItemType, parentIdArray: ItemId[] | (() => ItemId[]), itemType: ItemTypeType, options: CollectionOptions): PromiseInterface<ParentIdMap<CachedQueryItem<ItemTypeType>>>;
-    __addItemEntriesToCachedQueries<ItemTypeType extends ApiEnumItemType = any>(itemType: ItemTypeType, parsedQuery: CollectionQuery, itemEntries: Array<ItemEntry<ItemTypeType>>): void;
+    __addItemEntriesToCachedQueries<ItemTypeType extends ApiEnumItemType = any>(itemType: ItemTypeType, parsedQuery: CollectionQuery, itemEntries: ItemEntry<ItemTypeType>[]): void;
     /**
      * @description
      * Expands the columns of the items in the cached query

package/dist/types/classes/cache/server/ServerItemHandler.d.ts

@@ -18,9 +18,9 @@ export declare class ServerItemHandler extends ItemHandlerBase {
     processItemEntryChanges<ItemTypeType extends ApiEnumItemType = any>(itemEntryChangesTuple: ChangesDeltaItemUpdateDelta<ItemTypeType>, _isCalledAfterSocketUpdate?: boolean, _createItemChangesIfNoneExist?: boolean): ProcessItemEntryChangesResult<ItemTypeType>;
     copyTransactionItemEntryChanges<ItemTypeType extends ApiEnumItemType>(itemEntryChanges: TransactionItemEntryChanges<ItemTypeType>, entry: ItemEntry<ItemTypeType>): ItemEntryChanges<ItemTypeType>;
     fetchItemEntry<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, itemId: ItemId, options: ItemEntryOptions): PromiseInterface<ItemEntry<ItemTypeType>>;
-    fetchItemEntriesByQuery<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, query: ApiQuery, entryOptions: ItemEntryOptions): PromiseInterface<Array<ItemEntry<ItemTypeType>>>;
-    extendItemEntries<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, itemEntries: Array<ItemEntry<ItemTypeType>>, newColumns: ApiRequestColumns): PromiseInterface<Array<ItemEntry<ItemTypeType>>>;
-    fetchItemEntries<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, itemIds: ItemId[], options: ItemEntryOptions): PromiseInterface<Array<ItemEntry<ItemTypeType>>>;
+    fetchItemEntriesByQuery<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, query: ApiQuery, entryOptions: ItemEntryOptions): PromiseInterface<ItemEntry<ItemTypeType>[]>;
+    extendItemEntries<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, itemEntries: ItemEntry<ItemTypeType>[], newColumns: ApiRequestColumns): PromiseInterface<ItemEntry<ItemTypeType>[]>;
+    fetchItemEntries<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, itemIds: ItemId[], options: ItemEntryOptions): PromiseInterface<ItemEntry<ItemTypeType>[]>;
     /**
      * @description
      * Fetches the data for the ItemEntries linked to the parent Items

package/dist/types/classes/cache/transaction/TransactionCache.d.ts

@@ -1,5 +1,5 @@
-import { ApiEnumItemType, ApiFields, ItemId } from '@rentman/backend-types';
-import { AbstractCache, AbstractCacheDependencyInterface, ApiQuery, ApiRequestColumn, ApiRequestColumns, CachedQueryItem, CachedQueryItemTree, ChangesDelta, ChangesDeltaResult, ChildCollectionOptions, ChildCollectionResources, ChildCollectionResourcesNull, CollectionDefinition, CollectionOptionsInterface, CollectionQuery, CollectionResource, CollectionResourceParentIdMap, ConversionMap, CreateRequestParameterMap, DeregFunction, EntryParentNull, FieldChangeCallback, FieldMap, InternalChangesDelta, ItemEntry, ItemEntryOptions, ItemIdConversionMap, ItemOptionsInterface, ItemResource, ItemResourcesItemTypeMap, ItemTypeMap, LinkCollectionDefinition, ModuleChangesCompilationResult, OnAfterCreateCallback, ParentChangesDelta, ParentItemMap, PromiseInterface, RmCore, ServerCache, TransactionCacheCallbackCondition, TransactionCacheCallbackType, TransactionCachedQueryHandler, TransactionCollectionHandler, TransactionEventHandler, TransactionItemEntryChangesTuple, TransactionItemHandler, TransactionOptions, TransactionValidatorFactory } from '../../../internal';
+import { ApiEnumItemType, ItemId } from '@rentman/backend-types';
+import { AbstractCache, AbstractCacheDependencyInterface, ApiQuery, ApiRequestColumn, ApiRequestColumns, CachedQueryItem, CachedQueryItemTree, ChangesDelta, ChangesDeltaResult, ChildCollectionOptions, ChildCollectionResources, ChildCollectionResourcesNull, CollectionDefinition, CollectionOptionsInterface, CollectionQuery, CollectionResource, CollectionResourceParentIdMap, ConversionMap, CreateRequestParameterMap, DeregFunction, EntryParentNull, FieldChangeCallback, FieldMap, InternalChangesDelta, ItemEntry, ItemEntryOptions, ItemIdConversionMap, ItemOptionsInterface, ItemResource, ItemResourcesItemTypeMap, ItemTypeColumnIds, ItemTypeMap, LinkCollectionDefinition, ModuleChangesCompilationResult, OnAfterCreateCallback, ParentChangesDelta, ParentItemMap, PromiseInterface, RmCore, ServerCache, TransactionCacheCallbackCondition, TransactionCacheCallbackType, TransactionCachedQueryHandler, TransactionCollectionHandler, TransactionEventHandler, TransactionItemEntryChangesTuple, TransactionItemHandler, TransactionOptions, TransactionValidatorFactory } from '../../../internal';
 declare type ItemResourceLinks<ItemTypeType extends ApiEnumItemType> = {
     main: ItemResource<ItemTypeType>;
     linked: ItemResourcesItemTypeMap;
@@ -46,7 +46,6 @@ export declare class TransactionCache extends AbstractCache {
             };
         };
     };
-    get isValid(): boolean;
     /**
      * @description
      * Stores the 'root' {@link ItemEntry ItemEntry}, this {@link ItemEntry ItemEntry} can be used as request parent to store the whole transaction at once
@@ -81,16 +80,17 @@ export declare class TransactionCache extends AbstractCache {
     readonly eventHandler: TransactionEventHandler;
     private readonly validator?;
     private readonly options;
-    private _isValid;
     private historyStep;
     private undoDeltas;
     private appliedDeltas;
+    private _isValid;
     constructor(dependencies: AbstractCacheDependencyInterface, core: RmCore, parent: AbstractCache, 
     /**
      * @description
      * For debugging purposes
      */
     id?: string | undefined, validatorFactory?: TransactionValidatorFactory, options?: Partial<TransactionOptions>);
+    get isValid(): boolean;
     undo(): ReturnType<UndoFunction>;
     redo(): ReturnType<TransactionCache['applyChangesDelta']>;
     createChild(id?: string, validatorFactory?: TransactionValidatorFactory, options?: TransactionOptions): TransactionCache;
@@ -163,6 +163,7 @@ export declare class TransactionCache extends AbstractCache {
      * @description
      * Traverses the transaction chain and returns the changes of the item on the first transaction
      *
+     * @param itemEntryId The entry ID of the ItemEntry you want to get the changes from
      * @param copyFields If set, will call {@link ApiFormatter.copyFields ApiFormatter.copyFields}, otherwise just returns the object
      */
     getItemChangesRecursively<ItemTypeType extends ApiEnumItemType>(itemEntryId: ItemEntry<ItemTypeType>['id'], copyFields?: boolean): FieldMap<ItemTypeType>;
@@ -179,7 +180,7 @@ export declare class TransactionCache extends AbstractCache {
      * @description
      * Returns whether or not the {@link TransactionCache.rootItem rootItem} is uses locks
      */
-    isLockable(): boolean;
+    isLockable(rootItem?: ItemEntry | undefined): rootItem is ItemEntry;
     /**
      * @description
      * Saves the transaction, this has a different effect depending on the transaction's parent.
@@ -202,7 +203,7 @@ export declare class TransactionCache extends AbstractCache {
      * @description
      * Removes an {@link ItemEntry ItemEntry} from the {@link TransactionCache TransactionCache} which means that changes on this entry will no longer be tracked.
      */
-    clearItemEntry(itemEntry: ItemEntry<any>): void;
+    clearItemEntry(itemEntry: ItemEntry): void;
     /**
      * @description
      * Adds a callback that will fire before the transaction is saved, rejecting this callback will prevent the transaction from saving
@@ -232,7 +233,7 @@ export declare class TransactionCache extends AbstractCache {
      */
     getLinkCollections<ItemTypeType extends ApiEnumItemType>(linkType: ApiEnumItemType, linkIdArray: ItemId[], itemType: ItemTypeType, options: CollectionOptionsInterface<ItemTypeType>): PromiseInterface<CollectionResourceParentIdMap<ItemTypeType>>;
     getCollectionFromDef<ItemTypeType extends ApiEnumItemType>(definition: CollectionDefinition<ItemTypeType>): PromiseInterface<CollectionResource<ItemTypeType>>;
-    getCollection<ItemTypeType extends ApiEnumItemType, ColumnIds extends Array<keyof ApiFields[ItemTypeType]> = Array<keyof ApiFields[ItemTypeType]>>(itemType: ItemTypeType, options: CollectionOptionsInterface<ItemTypeType>): PromiseInterface<CollectionResource<ItemTypeType, ColumnIds>>;
+    getCollection<ItemTypeType extends ApiEnumItemType, ColumnIds extends ItemTypeColumnIds<ItemTypeType> = ItemTypeColumnIds<ItemTypeType>>(itemType: ItemTypeType, options: CollectionOptionsInterface<ItemTypeType>): PromiseInterface<CollectionResource<ItemTypeType, ColumnIds>>;
     getCollectionDef<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, options: CollectionOptionsInterface<ItemTypeType>): CollectionDefinition<ItemTypeType>;
     getLinkCollectionsDef<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, linkField: string, options: CollectionOptionsInterface<ItemTypeType>): LinkCollectionDefinition<ItemTypeType>;
     /**
@@ -253,19 +254,19 @@ export declare class TransactionCache extends AbstractCache {
      * @description
      * Fetches multiple items with their respective changes of the current {@link TransactionCache transaction}
      */
-    getItemsByQuery<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, query: ApiQuery, options?: Partial<ItemEntryOptions>): PromiseInterface<Array<ItemResource<ItemTypeType>>>;
+    getItemsByQuery<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, query: ApiQuery, options?: Partial<ItemEntryOptions>): PromiseInterface<ItemResource<ItemTypeType>[]>;
     /**
      * @description
      * Fetches multiple items with their respective changes of the current {@link TransactionCache transaction}
      */
-    getItemsById<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, itemIds: ItemId[], options?: Partial<ItemEntryOptions>): PromiseInterface<Array<ItemResource<ItemTypeType>>>;
+    getItemsById<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, itemIds: ItemId[], options?: Partial<ItemEntryOptions>): PromiseInterface<ItemResource<ItemTypeType>[]>;
     /**
      * @description
      * Fetches the item with the changes of the current {@link TransactionCache transaction}
      *
      * @param isRoot Sets the item as the root item of the transaction, new items will be linked to this item (if there's a connection in the LinkTree)
      */
-    getItemById<ItemTypeType extends ApiEnumItemType, ColumnIds extends Array<keyof ApiFields[ItemTypeType]> = Array<keyof ApiFields[ItemTypeType]>>(itemType: ItemTypeType, itemId: ItemId, options?: Partial<ItemEntryOptions>, isRoot?: boolean): PromiseInterface<ItemResource<ItemTypeType, ColumnIds>>;
+    getItemById<ItemTypeType extends ApiEnumItemType, ColumnIds extends ItemTypeColumnIds<ItemTypeType> = ItemTypeColumnIds<ItemTypeType>>(itemType: ItemTypeType, itemId: ItemId, options?: Partial<ItemEntryOptions>, isRoot?: boolean): PromiseInterface<ItemResource<ItemTypeType, ColumnIds>>;
     /**
      * @description
      * Fetches the title of an item, does not create an {@link ItemResource ItemResource}
@@ -298,10 +299,11 @@ export declare class TransactionCache extends AbstractCache {
      */
     getDelta(): InternalChangesDelta;
     createItemResource<ItemTypeType extends ApiEnumItemType>(itemEntry: ItemEntry<ItemTypeType>, childCollectionMap?: ChildCollectionResourcesNull, isNew?: boolean): ItemResource<ItemTypeType>;
-    createItemResources<ItemTypeType extends ApiEnumItemType, ColumnIds extends Array<keyof ApiFields[ItemTypeType]>>(itemEntries: Array<ItemEntry<ItemTypeType>>, childCollectionResourceMap?: ChildCollectionResourcesNull): Array<ItemResource<ItemTypeType, ColumnIds>>;
+    createItemResources<ItemTypeType extends ApiEnumItemType, ColumnIds extends ItemTypeColumnIds<ItemTypeType>>(itemEntries: ItemEntry<ItemTypeType>[], childCollectionResourceMap?: ChildCollectionResourcesNull): ItemResource<ItemTypeType, ColumnIds>[];
     processLinkedItems<ItemTypeType extends ApiEnumItemType>(linkedEntries: ItemTypeMap<ItemEntry[]>): ItemResourcesItemTypeMap<ItemResource<ItemTypeType>>;
-    createCollectionResource<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, options: CollectionOptionsInterface<ItemTypeType>, initialEntries: Array<ItemEntry<ItemTypeType>>, childCollectionResourceMap?: ParentItemMap<CollectionResource> | null): CollectionResource<ItemTypeType>;
+    createCollectionResource<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, options: CollectionOptionsInterface<ItemTypeType>, initialEntries: ItemEntry<ItemTypeType>[], childCollectionResourceMap?: ParentItemMap<CollectionResource> | null): CollectionResource<ItemTypeType>;
     createChildCollectionResources(parentType: ApiEnumItemType, options: ChildCollectionOptions, cachedQueryItems: ParentItemMap<CachedQueryItemTree>): ChildCollectionResources;
+    clearItemError(itemEntryId?: ItemEntry['id'], columnId?: string, errorKey?: string): void;
     private createChildCollectionResource;
     /**
      * @description
@@ -309,7 +311,6 @@ export declare class TransactionCache extends AbstractCache {
      */
     private expandItemsFromDelta;
     private clearGlobalError;
-    clearItemError(itemEntryId?: ItemEntry['id'], columnId?: string, errorKey?: string): void;
     private handleRemovedItemEntry;
     private handleCascadingDeletes;
     private cascadeDeleteByItemType;

package/dist/types/classes/cache/transaction/TransactionCachedQueryHandler.d.ts

@@ -14,7 +14,7 @@ export declare class TransactionCachedQueryHandler extends CachedQueryHandlerBas
     updateLocalItemIdReferences(conversionMap: ItemIdConversionMap): void;
     __fetchCachedQueryItem<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, options: CollectionOptions, batchedLinkedToQuery?: CollectionQuery): PromiseInterface<CachedQueryItem<ItemTypeType>>;
     __expandCachedQuery<ItemTypeType extends ApiEnumItemType>(cachedQuery: CachedQueryItem<ItemTypeType>, newColumns: ApiRequestColumns, force?: boolean): PromiseInterface<CachedQueryItem<ItemTypeType>>;
-    __addItemEntriesToCachedQueries<ItemTypeType extends ApiEnumItemType = any>(itemType: ItemTypeType, parsedQuery: CollectionQuery, itemEntries: Array<ItemEntry<ItemTypeType>>): void;
+    __addItemEntriesToCachedQueries<ItemTypeType extends ApiEnumItemType = any>(itemType: ItemTypeType, parsedQuery: CollectionQuery, itemEntries: ItemEntry<ItemTypeType>[]): void;
     /**
      * @remark
      * todo not only linkedTo should be checked, but it should check if there's a local ID anywhere in the query
@@ -22,13 +22,15 @@ export declare class TransactionCachedQueryHandler extends CachedQueryHandlerBas
      */
     isLocal(options: CollectionOptions | ItemEntryOptions, query: ApiQuery): boolean;
     __fetchItemEntriesByQueryData<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, options: CollectionOptions<ItemTypeType>, columnSubsetCache: ColumnSubsetCache<ItemTypeType>, collectionQuery: CollectionQuery, batchedLinkedToQuery?: CollectionQuery): PromiseInterface<CachedQueryItem<ItemTypeType>>;
+    __fetchLinkedCachedQueryItems<ItemTypeType extends ApiEnumItemType>(parentType: ApiEnumItemType, parentIdArray: ItemId[] | (() => ItemId[]), itemType: ItemTypeType, options: CollectionOptions): PromiseInterface<ParentIdMap<CachedQueryItem<ItemTypeType>>>;
+    __fetchParentCachedQueryItem<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, options: CollectionOptions, batchedLinkToQuery?: CollectionQuery): PromiseInterface<CachedQueryItemTree<ItemTypeType>>;
+    __fetchChildCachedQueryItems(parentType: ApiEnumItemType, parentIds: ItemId[], childCollectionOptions: ChildCollectionOptions): PromiseInterface<ParentItemMap<CachedQueryItemTree>>;
     private resolveLocalCachedQueryItem;
     /**
+     * @param itemType - The itemType of the entries you want to expand
      * @param itemEntries - All item entries passed to this function should be local.
+     * @param requestColumns - Columns to expand with
      */
     private expandLocalItemEntries;
     private syncCachedQueryWithLocalItems;
-    __fetchLinkedCachedQueryItems<ItemTypeType extends ApiEnumItemType>(parentType: ApiEnumItemType, parentIdArray: ItemId[] | (() => ItemId[]), itemType: ItemTypeType, options: CollectionOptions): PromiseInterface<ParentIdMap<CachedQueryItem<ItemTypeType>>>;
-    __fetchParentCachedQueryItem<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, options: CollectionOptions, batchedLinkToQuery?: CollectionQuery): PromiseInterface<CachedQueryItemTree<ItemTypeType>>;
-    __fetchChildCachedQueryItems(parentType: ApiEnumItemType, parentIds: ItemId[], childCollectionOptions: ChildCollectionOptions): PromiseInterface<ParentItemMap<CachedQueryItemTree>>;
 }

package/dist/types/classes/cache/transaction/TransactionCollectionHandler.d.ts

@@ -17,8 +17,8 @@ export declare class TransactionCollectionHandler {
     clearResource(resource: CollectionResource): void;
     /**
      * @description
-     * Updates the parents of the passed {@link ItemEntry ItemEntries}, returns `void` because you should use the {@link CollectionResourceOptions.onAdd onAdd} and {@link CollectionResourceOptions.onRemove onRemove} callbacks
+     * Updates the parents of the passed {@link ItemEntry ItemEntries}, returns `void` because you should use the {@link CollectionOptions.onAdd onAdd} and {@link CollectionOptions.onRemove onRemove} callbacks
      */
-    moveItems<CollectionEntryType extends CollectionEntry>(sourceCollectionEntry: CollectionEntryType, destinationCollectionEntry: CollectionEntryType, itemEntries: Array<ItemEntry<CollectionEntryType['itemType']>>): void;
+    moveItems<CollectionEntryType extends CollectionEntry>(sourceCollectionEntry: CollectionEntryType, destinationCollectionEntry: CollectionEntryType, itemEntries: ItemEntry<CollectionEntryType['itemType']>[]): void;
     cloneCollectionEntry<CollectionEntryType extends CollectionEntry>(changesDelta: ChangesDelta, sourceEntry: CollectionEntryType, conversionMap?: ItemIdConversionMap, modifyFieldsCallback?: ModifyFieldsCallback): void;
 }

package/dist/types/classes/cache/transaction/TransactionItemHandler.d.ts

@@ -57,25 +57,24 @@ export declare class TransactionItemHandler extends ItemHandlerBase {
      * @param itemEntryChangesTuple The changes tuple
      * @param isCalledAfterSocketUpdate Indicates that the change is done by a different user
      * @param createItemChangesIfNoneExist Is `true` when called from `applyChangesDelta`, we can assume that when you call `applyChangesDelta` with updates that aren't on the transaction yet you want to add those
-     * @param changesDelta Will be used to check which items should/shouldn't be updated when updating local ID references
      *
      * @returns
      * The previous changes {@link FieldMap FieldMap}, returns `null` when the item was not cached or no fields were changed.
      */
     processItemEntryChanges<ItemTypeType extends ApiEnumItemType = any>(itemEntryChangesTuple: ChangesDeltaItemUpdateDelta<ItemTypeType>, isCalledAfterSocketUpdate?: boolean, createItemChangesIfNoneExist?: boolean): ProcessItemEntryChangesResult<ItemTypeType>;
-    cloneItemEntries<ItemTypeType extends ApiEnumItemType>(changesDelta: ChangesDelta, itemEntries: Array<ItemEntry<ItemTypeType>>, conversionMap?: ItemIdConversionMap, modifyFieldsCallback?: ModifyFieldsCallback): ItemId[];
+    cloneItemEntries<ItemTypeType extends ApiEnumItemType>(changesDelta: ChangesDelta, itemEntries: ItemEntry<ItemTypeType>[], conversionMap?: ItemIdConversionMap, modifyFieldsCallback?: ModifyFieldsCallback): ItemId[];
     cloneItemEntry<ItemTypeType extends ApiEnumItemType>(changesDelta: ChangesDelta, sourceEntry: ItemEntry<ItemTypeType>, conversionMap?: ItemIdConversionMap, modifyFieldsCallback?: ModifyFieldsCallback): ItemId;
-    fetchItemEntriesByQuery<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, query: ApiQuery, entryOptions: ItemEntryOptions): PromiseInterface<Array<ItemEntry<ItemTypeType>>>;
+    fetchItemEntriesByQuery<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, query: ApiQuery, entryOptions: ItemEntryOptions): PromiseInterface<ItemEntry<ItemTypeType>[]>;
     fetchItemEntry<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, itemId: ItemId, options: ItemEntryOptions, isRoot?: boolean): PromiseInterface<ItemEntry<ItemTypeType>>;
     /**
      * @description
      * Fetches a template and creates a new {@link ItemEntry ItemEntry}, will error if the ItemEntry with the given ItemId already exists
      */
     fetchNewItemEntry<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, itemId: ItemId, options: ItemEntryOptions, isRoot?: boolean): PromiseInterface<ChangesDeltaResult>;
-    fetchItemEntries<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, itemIds: ItemId[], options: ItemEntryOptions): PromiseInterface<Array<ItemEntry<ItemTypeType>>>;
+    fetchItemEntries<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, itemIds: ItemId[], options: ItemEntryOptions): PromiseInterface<ItemEntry<ItemTypeType>[]>;
     fetchTitle(itemType: ApiEnumItemType, itemId: ItemId): PromiseInterface<string>;
     resolveLocalItemEntry<ItemTypeType extends ApiEnumItemType>(changesDelta: ChangesDelta, itemEntry: ItemEntry<ItemTypeType>, columnSubsetCache: ColumnSubsetCache<ItemTypeType>, options: ItemEntryOptions): PromiseInterface<ItemEntry<ItemTypeType>>;
-    expandLocalItemEntries<ItemTypeType extends ApiEnumItemType>(changesDelta: ChangesDeltaBase, itemType: ItemTypeType, itemEntries: Array<ItemEntry<ItemTypeType>>, requestColumns: ApiRequestColumns, responseColumns: ResponseColumnItemTypeMap): PromiseInterface<Array<ItemEntry<ItemTypeType>>>;
+    expandLocalItemEntries<ItemTypeType extends ApiEnumItemType>(changesDelta: ChangesDeltaBase, itemType: ItemTypeType, itemEntries: ItemEntry<ItemTypeType>[], requestColumns: ApiRequestColumns, responseColumns: ResponseColumnItemTypeMap): PromiseInterface<ItemEntry<ItemTypeType>[]>;
     /**
      * @description
      * Fetches the data for the passed ItemType/ItemId/columns, is able to __fetchCachedQueryItem non-local derived values.
@@ -83,8 +82,8 @@ export declare class TransactionItemHandler extends ItemHandlerBase {
      * @remark
      * Assumes the the ItemEntry with the given ItemType-ItemId is already cached
      */
-    fetchLocalItemEntryData<ItemTypeType extends ApiEnumItemType>(changesDelta: ChangesDelta, itemType: ItemTypeType, itemId: ItemId, columnSubsetCache: ColumnSubsetCache<ItemTypeType>, options: ItemEntryOptions): PromiseInterface<any>;
-    fetchLocalItemEntries<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, itemIds: ItemId[], options: ItemEntryOptions): PromiseInterface<Array<ItemEntry<ItemTypeType>>>;
+    fetchLocalItemEntryData<ItemTypeType extends ApiEnumItemType>(changesDelta: ChangesDelta, itemType: ItemTypeType, itemId: ItemId, columnSubsetCache: ColumnSubsetCache<ItemTypeType>, options: ItemEntryOptions): PromiseInterface<ItemEntry<ItemTypeType>>;
+    fetchLocalItemEntries<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, itemIds: ItemId[], options: ItemEntryOptions): PromiseInterface<ItemEntry<ItemTypeType>[]>;
     private getColumnDifference;
     private expandLocalItemEntry;
     private getLocalValues;

package/dist/types/core.d.ts

@@ -41,5 +41,5 @@ export declare class RmCore {
     constructor(_apiRequestService: ApiRequestServiceInterface, authInterface: AuthInterface, errorHandler: ErrorHandlerInterface, exceptionHandler: ExceptionHandlerInterface, promiseLibrary: PromiseLibraryInterface, linkTreeService: LinkTreeServiceInterface);
 }
 export declare function noop(): void;
-export declare function identity(value: any): any;
+export declare function identity<T extends any>(value: T): T;
 export declare function nullFunction(): null;

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

@@ -1,6 +1,6 @@
-import { ApiFormatter, ApiResponseProcessor } from '../internal';
+import { ApiFormatter, ApiResponse, ApiResponseProcessor } from '../internal';
 export declare class ApiResponseProcessorFactory {
     private apiFormatter;
     constructor(apiFormatter: ApiFormatter);
-    construct(response: any): ApiResponseProcessor;
+    construct(response: ApiResponse): ApiResponseProcessor;
 }

package/dist/types/factories/CollectionEntryFactory.d.ts

@@ -1,5 +1,5 @@
-import { ApiEnumItemType, ApiFields } from '@rentman/backend-types';
-import { CollectionEntry, CollectionEntryService, CollectionOptionsInterface, ColumnCache, ColumnSetFactory, KeyService, QueryService } from '../internal';
+import { ApiEnumItemType } from '@rentman/backend-types';
+import { CollectionEntry, CollectionEntryService, CollectionOptionsInterface, ColumnCache, ColumnSetFactory, ItemTypeColumnIds, KeyService, QueryService } from '../internal';
 export declare class CollectionEntryFactory {
     private collectionEntryService;
     private columnSetFactory;
@@ -7,5 +7,5 @@ export declare class CollectionEntryFactory {
     private queryService;
     private columnCache;
     constructor(collectionEntryService: CollectionEntryService, columnSetFactory: ColumnSetFactory, keyService: KeyService, queryService: QueryService, columnCache: ColumnCache);
-    construct<ItemTypeType extends ApiEnumItemType, ColumnIds extends Array<keyof ApiFields[ItemTypeType]> = Array<keyof ApiFields[ItemTypeType]>>(itemType: ItemTypeType, options: CollectionOptionsInterface<ItemTypeType, ColumnIds>): CollectionEntry<ItemTypeType, ColumnIds>;
+    construct<ItemTypeType extends ApiEnumItemType, ColumnIds extends ItemTypeColumnIds<ItemTypeType> = ItemTypeColumnIds<ItemTypeType>>(itemType: ItemTypeType, options: CollectionOptionsInterface<ItemTypeType, ColumnIds>): CollectionEntry<ItemTypeType, ColumnIds>;
 }

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

@@ -14,5 +14,5 @@ export declare class CollectionResourceFactory {
     /**
      * @internal
      */
-    construct<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, options: CollectionOptions<ItemTypeType>, transaction: TransactionCache, initialItemEntries: Array<ItemEntry<ItemTypeType>>, childCollectionResourceMap: ParentItemMap<CollectionResource> | null): CollectionResource<ItemTypeType>;
+    construct<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, options: CollectionOptions<ItemTypeType>, transaction: TransactionCache, initialItemEntries: ItemEntry<ItemTypeType>[], childCollectionResourceMap: ParentItemMap<CollectionResource> | null): CollectionResource<ItemTypeType>;
 }

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

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

package/dist/types/factories/ItemResourceFactory.d.ts

@@ -1,5 +1,5 @@
-import { ApiEnumItemType, ApiFields } from '@rentman/backend-types';
-import { ApiFormatter, ChildCollectionResourcesNull, ColumnUtil, ErrorHandlerInterface, ExceptionHandlerInterface, ItemEntry, ItemResource, PromiseLibraryInterface, TransactionCache } from '../internal';
+import { ApiEnumItemType } from '@rentman/backend-types';
+import { ApiFormatter, ChildCollectionResourcesNull, ColumnUtil, ErrorHandlerInterface, ExceptionHandlerInterface, ItemEntry, ItemResource, ItemTypeColumnIds, PromiseLibraryInterface, TransactionCache } from '../internal';
 export declare class ItemResourceFactory {
     apiFormatter: ApiFormatter;
     errorHandler: ErrorHandlerInterface;
@@ -7,5 +7,5 @@ export declare class ItemResourceFactory {
     exceptionHandler: ExceptionHandlerInterface;
     columnUtil: ColumnUtil;
     constructor(apiFormatter: ApiFormatter, errorHandler: ErrorHandlerInterface, promiseService: PromiseLibraryInterface, exceptionHandler: ExceptionHandlerInterface, columnUtil: ColumnUtil);
-    construct<ItemTypeType extends ApiEnumItemType, ColumnIds extends Array<keyof ApiFields[ItemTypeType]> = Array<keyof ApiFields[ItemTypeType]>, Children extends ChildCollectionResourcesNull = any>(itemEntry: ItemEntry<ItemTypeType>, transaction: TransactionCache, childCollections: Children, isNew?: boolean): ItemResource<ItemTypeType, ColumnIds, Children>;
+    construct<ItemTypeType extends ApiEnumItemType, ColumnIds extends ItemTypeColumnIds<ItemTypeType> = ItemTypeColumnIds<ItemTypeType>, Children extends ChildCollectionResourcesNull = any>(itemEntry: ItemEntry<ItemTypeType>, transaction: TransactionCache, childCollections: Children, isNew?: boolean): ItemResource<ItemTypeType, ColumnIds, Children>;
 }

package/dist/types/factories/QueryMatcherFactory.d.ts

@@ -3,5 +3,5 @@ import { ApiFormatter, EntryParentNull, FieldMap, QueryMatcher } from '../intern
 export declare class QueryMatcherFactory {
     private apiFormatter;
     constructor(apiFormatter: ApiFormatter);
-    construct(itemType: ApiEnumItemType, fields: FieldMap, parent: EntryParentNull): QueryMatcher;
+    construct(itemType: ApiEnumItemType, fields: FieldMap | [FieldMap, FieldMap], parent: EntryParentNull): QueryMatcher;
 }

package/dist/types/interfaces/PromiseLibraryInterface.d.ts

@@ -1,8 +1,8 @@
 import { PromiseInterface } from '../internal';
 export interface Deferred<T> {
+    promise: PromiseInterface<T>;
     resolve(value?: T | PromiseInterface<T>): void;
     reject(reason?: any): void;
-    promise: PromiseInterface<T>;
 }
 export interface PromiseLibraryInterface {
     all<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(values: [T1 | PromiseInterface<T1>, T2 | PromiseInterface<T2>, T3 | PromiseInterface<T3>, T4 | PromiseInterface<T4>, T5 | PromiseInterface<T5>, T6 | PromiseInterface<T6>, T7 | PromiseInterface<T7>, T8 | PromiseInterface<T8>, T9 | PromiseInterface<T9>, T10 | PromiseInterface<T10>]): PromiseInterface<[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]>;
@@ -14,8 +14,8 @@ export interface PromiseLibraryInterface {
     all<T1, T2, T3, T4>(values: [T1 | PromiseInterface<T1>, T2 | PromiseInterface<T2>, T3 | PromiseInterface<T3>, T4 | PromiseInterface<T4>]): PromiseInterface<[T1, T2, T3, T4]>;
     all<T1, T2, T3>(values: [T1 | PromiseInterface<T1>, T2 | PromiseInterface<T2>, T3 | PromiseInterface<T3>]): PromiseInterface<[T1, T2, T3]>;
     all<T1, T2>(values: [T1 | PromiseInterface<T1>, T2 | PromiseInterface<T2>]): PromiseInterface<[T1, T2]>;
-    all<TAll>(promises: Array<TAll | PromiseInterface<TAll>>): PromiseInterface<TAll[]>;
-    all(iterable: Array<PromiseInterface<any> | any>): PromiseInterface<any[]>;
+    all<TAll>(promises: (TAll | PromiseInterface<TAll>)[]): PromiseInterface<TAll[]>;
+    all(iterable: (PromiseInterface<any> | any)[]): PromiseInterface<any[]>;
     all<T>(promises: {
         [K in keyof T]: (PromiseInterface<T[K]> | T[K] | null);
     }): PromiseInterface<T>;

package/dist/types/models/CollectionEntry.d.ts

@@ -1,6 +1,6 @@
-import { ApiEnumItemType, ApiFields } from '@rentman/backend-types';
-import { CollectionEntryService, CollectionOptions, CollectionQuery, ColumnCache, ColumnExpansion, ColumnSet, ColumnSetFactory, EntryParentNull, KeyService, PromiseInterface, QueryService } from '../internal';
-export declare class CollectionEntry<ItemTypeType extends ApiEnumItemType = any, ColumnIds extends Array<keyof ApiFields[ItemTypeType]> = Array<keyof ApiFields[ItemTypeType]>> {
+import { ApiEnumItemType } from '@rentman/backend-types';
+import { CollectionEntryService, CollectionOptions, CollectionQuery, ColumnCache, ColumnExpansion, ColumnSet, ColumnSetFactory, EntryParentNull, ItemTypeColumnIds, KeyService, PromiseInterface, QueryService } from '../internal';
+export declare class CollectionEntry<ItemTypeType extends ApiEnumItemType = any, ColumnIds extends ItemTypeColumnIds<ItemTypeType> = ItemTypeColumnIds<ItemTypeType>> {
     private collectionEntryService;
     private queryService;
     private columnSetFactory;

package/dist/types/models/CollectionOptions.d.ts

@@ -1,11 +1,11 @@
-import { ApiEnumItemType, ApiFields } from '@rentman/backend-types';
-import { ApiQuery, ApiRequestColumns, ApiRequestLimit, ChildCollectionResourcesNull, CollectionResource, EntryParentNull, FieldChangeCallback, ItemResource } from '../internal';
-export declare type CollectionResourceOnRemoveCallback<ItemTypeType extends ApiEnumItemType, ColumnIds extends Array<keyof ApiFields[ItemTypeType]> = Array<keyof ApiFields[ItemTypeType]>, Children extends ChildCollectionResourcesNull = any> = (itemResources: Array<ItemResource<ItemTypeType, ColumnIds, Children>>, collectionResource: CollectionResource<ItemTypeType, ColumnIds, Children>, isCalledAfterSocketUpdate: boolean) => void;
-export declare type CollectionResourceOnAddCallback<ItemTypeType extends ApiEnumItemType, ColumnIds extends Array<keyof ApiFields[ItemTypeType]> = Array<keyof ApiFields[ItemTypeType]>, Children extends ChildCollectionResourcesNull = any> = (itemResources: Array<ItemResource<ItemTypeType, ColumnIds, Children>>, collectionResource: CollectionResource<ItemTypeType, ColumnIds, Children>, isInitialCall: boolean, isCalledAfterSocketUpdate: boolean) => void;
+import { ApiEnumItemType } from '@rentman/backend-types';
+import { ApiQuery, ApiRequestColumns, ApiRequestLimit, ChildCollectionResourcesNull, CollectionResource, EntryParentNull, FieldChangeCallback, ItemResource, ItemTypeColumnIds, RequestBufferManagerPrioritySettings } from '../internal';
+export declare type CollectionResourceOnRemoveCallback<ItemTypeType extends ApiEnumItemType, ColumnIds extends ItemTypeColumnIds<ItemTypeType> = ItemTypeColumnIds<ItemTypeType>, Children extends ChildCollectionResourcesNull = any> = (itemResources: ItemResource<ItemTypeType, ColumnIds, Children>[], collectionResource: CollectionResource<ItemTypeType, ColumnIds, Children>, isCalledAfterSocketUpdate: boolean) => void;
+export declare type CollectionResourceOnAddCallback<ItemTypeType extends ApiEnumItemType, ColumnIds extends ItemTypeColumnIds<ItemTypeType> = ItemTypeColumnIds<ItemTypeType>, Children extends ChildCollectionResourcesNull = any> = (itemResources: ItemResource<ItemTypeType, ColumnIds, Children>[], collectionResource: CollectionResource<ItemTypeType, ColumnIds, Children>, isInitialCall: boolean, isCalledAfterSocketUpdate: boolean) => void;
 export declare type ChildCollectionOptions = {
     [ChildItemType in ApiEnumItemType]?: CollectionOptions<ChildItemType>;
 };
-export interface CollectionOptionsInterface<ItemTypeType extends ApiEnumItemType = any, ColumnIds extends Array<keyof ApiFields[ItemTypeType]> = Array<keyof ApiFields[ItemTypeType]>> {
+export interface CollectionOptionsInterface<ItemTypeType extends ApiEnumItemType = any, ColumnIds extends ItemTypeColumnIds<ItemTypeType> = ItemTypeColumnIds<ItemTypeType>> {
     columns?: ApiRequestColumns;
     query?: ApiQuery | null;
     queryColumns?: ApiRequestColumns;
@@ -20,8 +20,9 @@ export interface CollectionOptionsInterface<ItemTypeType extends ApiEnumItemType
         [ChildItemType in ApiEnumItemType]?: CollectionOptionsInterface<ChildItemType>;
     } | null;
     preventCaching?: boolean;
+    priorityBufferSettings?: RequestBufferManagerPrioritySettings | null;
 }
-export declare class CollectionOptions<ItemTypeType extends ApiEnumItemType = any, ColumnIds extends Array<keyof ApiFields[ItemTypeType]> = Array<keyof ApiFields[ItemTypeType]>> implements Required<CollectionOptionsInterface> {
+export declare class CollectionOptions<ItemTypeType extends ApiEnumItemType = any, ColumnIds extends ItemTypeColumnIds<ItemTypeType> = ItemTypeColumnIds<ItemTypeType>> implements Required<CollectionOptionsInterface> {
     columns: ApiRequestColumns;
     query: ApiQuery | null;
     queryColumns: ApiRequestColumns;
@@ -38,5 +39,6 @@ export declare class CollectionOptions<ItemTypeType extends ApiEnumItemType = an
      * Prevents a CachedQueryItem from being cached (the CollectionResource will still be cached), you can use this when you fetch an Itemtype for which the backend doesn't send socket messages (so it never automatically updates)
      */
     preventCaching: boolean;
+    priorityBufferSettings: RequestBufferManagerPrioritySettings | null;
     constructor(optionsInterface: CollectionOptionsInterface<ItemTypeType, ColumnIds>);
 }