@rentman/rm-core 11.0.4 → 12.0.0

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

@@ -1,11 +1,5 @@
 import { ApiEnumItemType, ItemId } from '@rentman/backend-types';
-import { ApiQuery, ApiRequestColumns, ChangesDelta, ChangesDeltaBase, ChangesDeltaItemCreateDelta, ChangesDeltaItemUpdateDelta, ChangesDeltaResult, ColumnSubsetCache, DeregFunction, FieldChangeCallback, FieldMap, ItemEntry, ItemEntryChanges, ItemEntryChangesTuple, ItemEntryOptions, ItemHandlerBase, ItemIdConversionMap, ItemTypeMap, ModifyFieldsCallback, ProcessItemEntryChangesResult, PromiseInterface, ResponseColumnItemTypeMap, TransactionCache, TransactionItemHandlerDependencyInterface, TransactionValidator } from '../../../internal';
-export interface TransactionItemEntryChanges<ItemTypeType extends ApiEnumItemType> extends ItemEntryChanges<ItemTypeType> {
-    initial: FieldMap<ItemTypeType>;
-}
-export interface TransactionItemEntryChangesTuple<ItemTypeType extends ApiEnumItemType> extends ItemEntryChangesTuple<ItemTypeType> {
-    changes: TransactionItemEntryChanges<ItemTypeType>;
-}
+import { ApiQuery, ApiRequestColumns, ChangesDelta, ChangesDeltaBase, ChangesDeltaItemCreateDelta, ChangesDeltaItemUpdateDelta, ChangesDeltaResult, DeregFunction, FieldChangeCallback, ItemEntry, ItemEntryOptions, ItemHandlerBase, ItemIdConversionMap, ItemTypeMap, ModifyFieldsCallback, ProcessItemEntryChangesResult, PromiseInterface, RequestColumnsOperationsCache, ResponseColumnItemTypeMap, TransactionCache, TransactionItemHandlerDependencyInterface, TransactionValidator } from '../../../internal';
 /**
  * @description
  * In a {@link TransactionCache Transaction} only local items can be stored, so all entries in {@link TransactionItemHandler.entries this.entries} are local
@@ -20,18 +14,14 @@ export declare class TransactionItemHandler extends ItemHandlerBase {
      * Can contain both local and non-local {@link ItemEntry itemEntries}
      */
     deletedItems: ItemTypeMap<ItemEntry[]>;
-    itemChanges: {
-        [itemEntryId: string]: TransactionItemEntryChanges<any>;
-    };
     fieldChangeCallbacks: {
         [itemType: string]: {
             [itemId: string]: FieldChangeCallback[];
         };
     };
     constructor(dependencies: TransactionItemHandlerDependencyInterface, transaction: TransactionCache, validator?: TransactionValidator | undefined);
-    updateLocalItemIdReferences(itemType: ApiEnumItemType, oldItemId: ItemId, newItemId: ItemId, changesDelta?: ChangesDeltaBase): void;
+    updateLocalItemIdReferences(itemType: ApiEnumItemType, oldItemId: ItemId, newItemId: ItemId): void;
     registerFieldChangeCallback<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, itemId: ItemId, callback: FieldChangeCallback<ItemTypeType>): DeregFunction;
-    copyTransactionItemEntryChanges<ItemTypeType extends ApiEnumItemType>(itemEntryChanges: TransactionItemEntryChanges<ItemTypeType>, entry: ItemEntry<ItemTypeType>): TransactionItemEntryChanges<ItemTypeType>;
     createItemEntry(createTuple: ChangesDeltaItemCreateDelta): ItemEntry;
     /**
      * @description
@@ -72,8 +62,8 @@ export declare class TransactionItemHandler extends ItemHandlerBase {
      */
     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<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>>;
+    fetchTitle<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, itemId: ItemId): PromiseInterface<string>;
+    resolveLocalItemEntry<ItemTypeType extends ApiEnumItemType>(changesDelta: ChangesDelta, itemEntry: ItemEntry<ItemTypeType>, columnsOperationsCache: RequestColumnsOperationsCache<ItemTypeType>, options: ItemEntryOptions): PromiseInterface<ItemEntry<ItemTypeType>>;
     expandLocalItemEntries<ItemTypeType extends ApiEnumItemType>(changesDelta: ChangesDeltaBase, itemType: ItemTypeType, itemEntries: ItemEntry<ItemTypeType>[], requestColumns: ApiRequestColumns, responseColumns: ResponseColumnItemTypeMap): PromiseInterface<ItemEntry<ItemTypeType>[]>;
     /**
      * @description
@@ -82,7 +72,7 @@ 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<ItemEntry<ItemTypeType>>;
+    fetchLocalItemEntryData<ItemTypeType extends ApiEnumItemType>(changesDelta: ChangesDelta, itemType: ItemTypeType, itemId: ItemId, columnsOperationsCache: RequestColumnsOperationsCache<ItemTypeType>, options: ItemEntryOptions): PromiseInterface<ItemEntry<ItemTypeType>>;
     fetchLocalItemEntries<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, itemIds: ItemId[], options: ItemEntryOptions): PromiseInterface<ItemEntry<ItemTypeType>[]>;
     private getColumnDifference;
     private expandLocalItemEntry;

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

@@ -1,6 +1,6 @@
 import { ApiModuleFunctionLocalsGetLocals } from '@rentman/backend-types';
 import { BusinessLogicManager } from './classes/BusinessLogicManager/BusinessLogicManager';
-import { ApiFormatter, ApiRequestService, ApiRequestServiceInterface, ApiResponseProcessorFactory, AuthInterface, CacheSyncerFactory, ChangesCompilationFactory, ChangesDeltaFactory, ChangesProcessorFactory, CollectionEntryFactory, CollectionEntryService, CollectionResourceFactory, CollectionResourceService, ColumnCache, ColumnExpansionFactory, ColumnHandler, ColumnInfoFactory, ColumnSetFactory, ColumnSubsetCacheFactory, ColumnUtil, ConversionMapService, CreateRequestFactory, ErrorHandlerInterface, ExceptionHandlerInterface, ItemCacheFactory, ItemCreateService, ItemEntryFactory, ItemEntryService, ItemResourceFactory, KeyService, LinkTreeServiceInterface, LockService, ModuleChangesCompilationFactory, PromiseLibraryInterface, QueryMatcherFactory, QueryParserFactory, QueryService, RequestColumnExpansionFactory, SocketMessageHandler, TemplateCache, TemplateFactory, TransactionCacheFactory } from './internal';
+import { ApiFormatter, ApiRequestService, ApiRequestServiceInterface, ApiResponseProcessorFactory, AuthInterface, CacheSyncerFactory, ChangesCompilationFactory, ChangesDeltaFactory, ChangesProcessorFactory, CollectionEntryFactory, CollectionEntryService, CollectionResourceFactory, CollectionResourceService, ColumnCache, ColumnExpansionFactory, ColumnHandler, ColumnInfoFactory, ColumnSetFactory, ColumnUtil, ConversionMapService, CreateRequestFactory, ErrorHandlerInterface, ExceptionHandlerInterface, ItemCacheFactory, ItemCreateService, ItemEntryFactory, ItemEntryService, ItemResourceFactory, KeyService, LinkTreeServiceInterface, LockService, ModuleChangesCompilationFactory, PromiseLibraryInterface, QueryMatcherFactory, QueryParserFactory, QueryService, RequestColumnExpansionFactory, RequestColumnsOperationsCacheFactory, SocketMessageHandler, TemplateCache, TemplateFactory, TransactionCacheFactory } from './internal';
 export declare class RmCore {
     version: string;
     noop: typeof noop;
@@ -20,7 +20,7 @@ export declare class RmCore {
     columnHandler: ColumnHandler;
     columnInfoFactory: ColumnInfoFactory;
     columnSetFactory: ColumnSetFactory;
-    columnSubsetCacheFactory: ColumnSubsetCacheFactory;
+    requestColumnOperationsCacheFactory: RequestColumnsOperationsCacheFactory;
     columnUtil: ColumnUtil;
     conversionMapService: ConversionMapService;
     createRequestFactory: CreateRequestFactory;

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

@@ -1,4 +1,5 @@
-import { AbstractCache, ApiRequestService, CacheSyncer, CacheSyncerQueryMap, PromiseLibraryInterface, QueryMatcherFactory, QueryService } from '../internal';
+import { ApiEnumItemType } from '@rentman/backend-types';
+import { AbstractCache, ApiRequestService, CachedQueryItem, CacheSyncer, CacheSyncerQueryMap, PromiseLibraryInterface, QueryMatcherFactory, QueryService } from '../internal';
 export declare class CacheSyncerFactory {
     private queryMatcherFactory;
     private queryService;
@@ -6,5 +7,8 @@ export declare class CacheSyncerFactory {
     private promiseService;
     constructor(queryMatcherFactory: QueryMatcherFactory, queryService: QueryService, apiRequestService: ApiRequestService, promiseService: PromiseLibraryInterface);
     construct(transaction: AbstractCache, queryStringMap?: CacheSyncerQueryMap): CacheSyncer;
+    constructForItemType(transaction: AbstractCache, itemType: ApiEnumItemType): CacheSyncer;
+    constructForCachedQuery(transaction: AbstractCache, cachedQueryItem: CachedQueryItem): CacheSyncer;
     private collectQueries;
+    private createCacheSyncerQueryMapEntry;
 }

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

@@ -1,7 +1,8 @@
 import { ApiEnumItemType } from '@rentman/backend-types';
-import { ApiFormatter, EntryParentNull, FieldMap, QueryMatcher } from '../internal';
+import { ApiFormatter, FieldMap, LinkTreeServiceInterface, QueryMatcher } from '../internal';
 export declare class QueryMatcherFactory {
     private apiFormatter;
-    constructor(apiFormatter: ApiFormatter);
-    construct(itemType: ApiEnumItemType, fields: FieldMap | [FieldMap, FieldMap], parent: EntryParentNull): QueryMatcher;
+    private linkTreeService;
+    constructor(apiFormatter: ApiFormatter, linkTreeService: LinkTreeServiceInterface);
+    construct<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, fields: FieldMap | [FieldMap, FieldMap]): QueryMatcher<ItemTypeType>;
 }

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

@@ -1,8 +1,6 @@
-import { ApiEnumItemType } from '@rentman/backend-types';
-import { AbstractCache, ApiRequestColumnMap, ApiRequestColumns, ColumnUtil, RequestColumnExpansion } from '../internal';
+import { ColumnUtil, RequestColumnExpansion } from '../internal';
 export declare class RequestColumnExpansionFactory {
     private columnUtil;
     constructor(columnUtil: ColumnUtil);
     construct(): RequestColumnExpansion;
-    expandColumnsWithCachedQueryColumns(transaction: AbstractCache, itemType: ApiEnumItemType, requestColumns?: ApiRequestColumns, requestColumnExpansion?: RequestColumnExpansion): ApiRequestColumnMap;
 }

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

@@ -0,0 +1,8 @@
+import { ApiEnumItemType } from '@rentman/backend-types';
+import { ApiRequestColumns, ColumnCache, ColumnUtil, RequestColumnsOperationsCache } from '../internal';
+export declare class RequestColumnsOperationsCacheFactory {
+    private columnUtil;
+    private columnCache;
+    constructor(columnUtil: ColumnUtil, columnCache: ColumnCache);
+    construct<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, requestColumns: ApiRequestColumns): RequestColumnsOperationsCache<ItemTypeType>;
+}

package/dist/types/src/interfaces/AbstractCacheDependencyInterface.d.ts

@@ -1,10 +1,10 @@
 import { BusinessLogicManager } from '../classes/BusinessLogicManager/BusinessLogicManager';
-import { ApiFormatter, ApiRequestService, AuthInterface, CacheSyncerFactory, ChangesDeltaFactory, CollectionEntryFactory, CollectionEntryService, CollectionResourceFactory, ColumnCache, ColumnExpansionFactory, ColumnHandler, ColumnSetFactory, ColumnSubsetCacheFactory, ColumnUtil, ConversionMapService, ErrorHandlerInterface, ExceptionHandlerInterface, ItemCacheFactory, ItemCreateService, ItemEntryFactory, ItemEntryService, ItemResourceFactory, KeyService, LinkTreeServiceInterface, LockService, ModuleChangesCompilationFactory, PromiseLibraryInterface, QueryMatcherFactory, QueryParserFactory, QueryService, RequestBufferManager, RequestColumnExpansionFactory, TemplateCache } from '../internal';
+import { ApiFormatter, ApiRequestService, AuthInterface, CacheSyncerFactory, ChangesDeltaFactory, CollectionEntryFactory, CollectionEntryService, CollectionResourceFactory, ColumnCache, ColumnExpansionFactory, ColumnHandler, ColumnSetFactory, ColumnUtil, ConversionMapService, ErrorHandlerInterface, ExceptionHandlerInterface, ItemCacheFactory, ItemCreateService, ItemEntryFactory, ItemEntryService, ItemResourceFactory, KeyService, LinkTreeServiceInterface, LockService, ModuleChangesCompilationFactory, PromiseLibraryInterface, QueryMatcherFactory, QueryParserFactory, QueryService, RequestBufferManager, RequestColumnExpansionFactory, RequestColumnsOperationsCacheFactory, TemplateCache } from '../internal';
 export interface AbstractCacheDependencyInterface {
-    businessLogicManager: BusinessLogicManager;
     apiFormatter: ApiFormatter;
     apiRequestService: ApiRequestService;
     authInterface: AuthInterface;
+    businessLogicManager: BusinessLogicManager;
     changesDeltaFactory: ChangesDeltaFactory;
     collectionEntryFactory: CollectionEntryFactory;
     collectionEntryService: CollectionEntryService;
@@ -14,7 +14,6 @@ export interface AbstractCacheDependencyInterface {
     columnExpansionFactory: ColumnExpansionFactory;
     columnHandler: ColumnHandler;
     columnSetFactory: ColumnSetFactory;
-    columnSubsetCacheFactory: ColumnSubsetCacheFactory;
     columnUtil: ColumnUtil;
     conversionMapService: ConversionMapService;
     errorHandler: ErrorHandlerInterface;
@@ -34,5 +33,6 @@ export interface AbstractCacheDependencyInterface {
     queryService: QueryService;
     requestBufferManager: RequestBufferManager;
     requestColumnExpansionFactory: RequestColumnExpansionFactory;
+    requestColumnsOperationsCacheFactory: RequestColumnsOperationsCacheFactory;
     templateCache: TemplateCache;
 }

package/dist/types/src/interfaces/TransactionCollectionHandlerDependencyInterface.d.ts

@@ -1,17 +1,17 @@
-import { CacheSyncerFactory, ChangesDeltaFactory, CollectionEntryService, ColumnCache, ColumnExpansionFactory, ColumnHandler, ColumnSubsetCacheFactory, ColumnUtil, ErrorHandlerInterface, ExceptionHandlerInterface, KeyService, PromiseLibraryInterface, QueryService, RequestColumnExpansionFactory } from '../internal';
+import { CacheSyncerFactory, ChangesDeltaFactory, CollectionEntryService, ColumnCache, ColumnExpansionFactory, ColumnHandler, ColumnUtil, ErrorHandlerInterface, ExceptionHandlerInterface, KeyService, PromiseLibraryInterface, QueryService, RequestColumnExpansionFactory, RequestColumnsOperationsCacheFactory } from '../internal';
 export interface TransactionCollectionHandlerDependencyInterface {
-    requestColumnExpansionFactory: RequestColumnExpansionFactory;
-    columnUtil: ColumnUtil;
-    columnSubsetCacheFactory: ColumnSubsetCacheFactory;
-    columnExpansionFactory: ColumnExpansionFactory;
     changesDeltaFactory: ChangesDeltaFactory;
     collectionEntryService: CollectionEntryService;
     collectionMatcherFactory: CacheSyncerFactory;
+    columnCache: ColumnCache;
+    columnExpansionFactory: ColumnExpansionFactory;
     columnHandler: ColumnHandler;
+    columnUtil: ColumnUtil;
     errorHandler: ErrorHandlerInterface;
+    exceptionHandler: ExceptionHandlerInterface;
     keyService: KeyService;
     promiseService: PromiseLibraryInterface;
-    exceptionHandler: ExceptionHandlerInterface;
     queryService: QueryService;
-    columnCache: ColumnCache;
+    requestColumnExpansionFactory: RequestColumnExpansionFactory;
+    requestColumnsOperationsCacheFactory: RequestColumnsOperationsCacheFactory;
 }

package/dist/types/src/interfaces/TransactionItemHandlerDependencyInterface.d.ts

@@ -1,11 +1,11 @@
-import { ApiFormatter, ChangesDeltaFactory, CollectionEntryService, ColumnExpansionFactory, ColumnHandler, ColumnSetFactory, ColumnSubsetCacheFactory, ColumnUtil, ConversionMapService, ErrorHandlerInterface, ExceptionHandlerInterface, ItemCacheFactory, ItemCreateService, ItemEntryFactory, ItemEntryService, KeyService, PromiseLibraryInterface, RequestColumnExpansionFactory, TemplateCache } from '../internal';
+import { ApiFormatter, ChangesDeltaFactory, CollectionEntryService, ColumnExpansionFactory, ColumnHandler, ColumnSetFactory, ColumnUtil, ConversionMapService, ErrorHandlerInterface, ExceptionHandlerInterface, ItemCacheFactory, ItemCreateService, ItemEntryFactory, ItemEntryService, KeyService, PromiseLibraryInterface, RequestColumnExpansionFactory, RequestColumnsOperationsCacheFactory, TemplateCache } from '../internal';
 export interface TransactionItemHandlerDependencyInterface {
     apiFormatter: ApiFormatter;
     changesDeltaFactory: ChangesDeltaFactory;
+    collectionEntryService: CollectionEntryService;
     columnExpansionFactory: ColumnExpansionFactory;
     columnHandler: ColumnHandler;
     columnSetFactory: ColumnSetFactory;
-    columnSubsetCacheFactory: ColumnSubsetCacheFactory;
     columnUtil: ColumnUtil;
     conversionMapService: ConversionMapService;
     errorHandler: ErrorHandlerInterface;
@@ -17,6 +17,6 @@ export interface TransactionItemHandlerDependencyInterface {
     keyService: KeyService;
     promiseService: PromiseLibraryInterface;
     requestColumnExpansionFactory: RequestColumnExpansionFactory;
+    requestColumnsOperationsCacheFactory: RequestColumnsOperationsCacheFactory;
     templateCache: TemplateCache;
-    collectionEntryService: CollectionEntryService;
 }

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

@@ -34,7 +34,7 @@ export * from './classes/ColumnExpansion';
 export * from './classes/ColumnHandler';
 export * from './classes/ColumnInfo';
 export * from './classes/ColumnSet';
-export * from './classes/ColumnSubsetCache';
+export * from './classes/RequestColumnsOperationsCache';
 export * from './classes/ColumnUtil';
 export * from './classes/ConversionMapService';
 export * from './classes/CreateRequest';
@@ -108,7 +108,7 @@ export * from './factories/CollectionResourceFactory';
 export * from './factories/ColumnExpansionFactory';
 export * from './factories/ColumnInfoFactory';
 export * from './factories/ColumnSetFactory';
-export * from './factories/ColumnSubsetCacheFactory';
+export * from './factories/RequestColumnsOperationsCacheFactory';
 export * from './factories/CreateRequestFactory';
 export * from './factories/ItemCacheFactory';
 export * from './factories/ItemEntryFactory';

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

@@ -1,10 +1,10 @@
 import { ApiEnumItemType } from '@rentman/backend-types';
-import { ApiRequestColumns, CollectionQuery, ItemEntry, PromiseInterface, PromiseLibraryInterface } from '../internal';
+import { CollectionQuery, ItemEntry, PromiseInterface, PromiseLibraryInterface, RequestColumnsTuple } from '../internal';
 export declare class CachedQueryItem<ItemTypeType extends ApiEnumItemType = any> {
     readonly itemType: ItemTypeType;
     query: CollectionQuery;
     items: ItemEntry<ItemTypeType>[];
-    requestColumns: ApiRequestColumns;
+    requestColumnsTuple: RequestColumnsTuple;
     private promiseService;
     promise: PromiseInterface<this>;
     /**
@@ -29,7 +29,7 @@ export declare class CachedQueryItem<ItemTypeType extends ApiEnumItemType = any>
     get matches(): number;
     creation: Date;
     private deferred;
-    constructor(itemType: ItemTypeType, query: CollectionQuery, items: ItemEntry<ItemTypeType>[], requestColumns: ApiRequestColumns, promiseService: PromiseLibraryInterface);
+    constructor(itemType: ItemTypeType, query: CollectionQuery, items: ItemEntry<ItemTypeType>[], requestColumnsTuple: RequestColumnsTuple, promiseService: PromiseLibraryInterface);
     itemsResolved(): boolean;
     /**
      * Resolve can be called on items that are already resolved. The request buffer might or might not combine

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

@@ -1,6 +1,6 @@
 import { ApiEnumItemType } from '@rentman/backend-types';
-import { ApiQuery, ApiRequestColumns, ApiRequestLimit, ChildCollectionResourcesNull, CollectionResource, EntryParentNull, FieldChangeCallback, ItemResource, ItemTypeColumnIds } 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;
+import { ApiQuery, ApiRequestColumns, ApiRequestLimit, ChildCollectionResourcesNull, CollectionResource, EntryParentNull, FieldChangeCallback, ItemEntry, ItemResource, ItemTypeColumnIds } from '../internal';
+export declare type CollectionResourceOnRemoveCallback<ItemTypeType extends ApiEnumItemType, ColumnIds extends ItemTypeColumnIds<ItemTypeType> = ItemTypeColumnIds<ItemTypeType>, Children extends ChildCollectionResourcesNull = any> = (itemEntries: ItemEntry<ItemTypeType>[], 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>;

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

@@ -52,10 +52,10 @@ export declare class CollectionResource<ItemTypeType extends ApiEnumItemType = a
      * Returns the {@link ItemResource ItemResources} that where removed from the {@link CollectionResource collection}.
      * Filters on {@link ItemResource ItemResource}.{@link ItemEntry entry} === {@link ItemEntry entry}
      */
-    removeItemResources(itemEntries: ItemEntry<ItemTypeType>[], isCalledAfterSocketUpdate: boolean): ItemResource<ItemTypeType, ColumnIds, Children>[];
+    removeItemResources(itemEntries: ItemEntry<ItemTypeType>[], isCalledAfterSocketUpdate: boolean): ItemEntry<ItemTypeType>[];
     callOnAdd(itemResources: ItemResource<ItemTypeType, ColumnIds, Children>[], isInitialCall?: boolean, isCalledAfterSocketUpdate?: boolean): void;
     callOnChange(itemEntry: ItemEntry<ItemTypeType>, compareField: CompareFieldCallback<FieldMap<ItemTypeType, ColumnIds>>, fields: FieldMap<ItemTypeType, ColumnIds>, isCalledAfterSocketUpdate: boolean, previous: FieldMap<ItemTypeType, ColumnIds>): void;
-    callOnRemove(itemResources: ItemResource<ItemTypeType, ColumnIds, Children>[], isCalledAfterSocketUpdate: boolean): void;
+    callOnRemove(itemEntries: ItemEntry<ItemTypeType>[], isCalledAfterSocketUpdate: boolean): void;
     forEach(callback: (itemResource: ItemResource<ItemTypeType, ColumnIds, Children>) => void): void;
     filter(callback: (itemResource: ItemResource<ItemTypeType, ColumnIds, Children>) => boolean): ItemResource<ItemTypeType, ColumnIds, Children>[];
     first(callback: (itemResource: ItemResource<ItemTypeType, ColumnIds, Children>) => boolean): ItemResource<ItemTypeType, ColumnIds, Children> | null;

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

@@ -250,9 +250,22 @@ export declare type ApiRequestItemMap = {
     };
 };
 export declare type ApiRequestColumn = string | {
-    [columnId: string]: ApiRequestColumn[];
+    readonly [columnId: string]: ApiRequestColumnArray;
+};
+export declare type ApiRequestColumnArray = readonly ApiRequestColumn[];
+export declare type ApiRequestColumns = ApiRequestColumnArray | true;
+export declare type MutableApiRequestColumnArray = ApiRequestColumn[];
+/**
+ * Both the array and string representation are read-only, because whenever the object changes, the string representation
+ * should change too.
+ */
+export declare type RequestColumnsTuple = {
+    readonly object: true;
+    readonly string: 'true';
+} | {
+    readonly object: ApiRequestColumns;
+    readonly string: string;
 };
-export declare type ApiRequestColumns = ApiRequestColumn[] | true;
 export declare type ApiRequestColumnMap = {
     [itemType: string]: ApiRequestColumns;
 };
@@ -285,11 +298,11 @@ export declare enum ApiLinkTreeType {
 export declare type ApiLinkTreeEntryItemTable = {
     type: ApiLinkTreeType.ITEMTABLE;
 };
-export declare type ApiLinkTreeEntryDirect = {
+export declare type ApiLinkTreeEntryDirect<ItemTypeType extends ApiEnumItemType = any> = {
     type: ApiLinkTreeType.DIRECT;
-    field: string;
+    field: ItemTypeColumnId<ItemTypeType>;
 };
-export declare type ApiLinkTreeEntry = ApiLinkTreeEntryItemTable | ApiLinkTreeEntryDirect;
+export declare type ApiLinkTreeEntry<ItemTypeType extends ApiEnumItemType = any> = ApiLinkTreeEntryItemTable | ApiLinkTreeEntryDirect<ItemTypeType>;
 export declare type ApiLinkTree = {
     [itemType: string]: {
         [childType: string]: ApiLinkTreeEntry;
@@ -324,7 +337,7 @@ export declare type OnAddCallback<ItemTypeType extends ApiEnumItemType, ColumnId
     isCalledAfterSocketUpdate: boolean;
 }) => void;
 export declare type OnRemoveCallback<ItemTypeType extends ApiEnumItemType, ColumnIds extends ItemTypeColumnIds<ItemTypeType>, Children extends ChildCollectionResourcesNull> = (args: {
-    itemResources: ItemResource<ItemTypeType, ColumnIds, Children>[];
+    itemEntries: ItemEntry<ItemTypeType>[];
     collectionResource: CollectionResource<ItemTypeType, ColumnIds, Children>;
     isCalledAfterSocketUpdate: boolean;
 }) => void;

package/dist/types/tests/integration/helpers/helpers.d.ts

@@ -1,5 +1,6 @@
 import { ApiRequestServiceInterface, AuthInterface, ErrorHandlerInterface, LinkTreeServiceInterface, RmCore } from '../../../src';
 import { ApiMocked } from '../../mocks/ApiMocked';
+export declare function sleep(time: number): Promise<unknown>;
 export declare const defaultMockAuthInterface: {
     getUserId: () => number;
     getUniqueUserId(): string;

package/dist/types/tests/integration/transactions/field_lookup.test.d.ts

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rentman/rm-core",
-  "version": "11.0.4",
+  "version": "12.0.0",
   "description": "Rentman core functionalities",
   "main": "./dist/rm-core.js",
   "types": "./dist/types/src/index.d.ts",

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

@@ -1,14 +0,0 @@
-import { ApiEnumItemType } from '@rentman/backend-types';
-import { ApiRequestColumn, ApiRequestColumns, ColumnCache, ColumnSet, ColumnUtil } from '../internal';
-export declare class ColumnSubsetCache<ItemTypeType extends ApiEnumItemType> {
-    private columnUtil;
-    private columnCache;
-    itemType: ItemTypeType;
-    requestColumns: ApiRequestColumns;
-    aggregateColumns: ApiRequestColumn[];
-    private cache;
-    constructor(columnUtil: ColumnUtil, columnCache: ColumnCache, itemType: ItemTypeType, requestColumns: ApiRequestColumns);
-    run(columnSet: ColumnSet<ItemTypeType>): boolean;
-    runWithRequestColumns(cachedRequestColumns: ApiRequestColumns): boolean;
-    private extractAggregateColumns;
-}

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

@@ -1,8 +0,0 @@
-import { ApiEnumItemType } from '@rentman/backend-types';
-import { ApiRequestColumns, ColumnCache, ColumnSubsetCache, ColumnUtil } from '../internal';
-export declare class ColumnSubsetCacheFactory {
-    private columnUtil;
-    private columnCache;
-    constructor(columnUtil: ColumnUtil, columnCache: ColumnCache);
-    construct<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, requestColumns: ApiRequestColumns): ColumnSubsetCache<ItemTypeType>;
-}