@rentman/rm-core 8.0.1 → 8.0.3

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

@@ -52,7 +52,7 @@ export declare class ChangesDelta extends ChangesDeltaBase {
      *
      * @internal
      */
-    _setItemCreated<ItemTypeType extends ApiEnumItemType, Fields extends FieldMap<ItemTypeType>>(itemId: ItemId, fields: Fields, columns: ColumnSet<ItemTypeType>, parent?: EntryParentNull): this;
+    _setItemCreated<ItemTypeType extends ApiEnumItemType, Fields extends FieldMap<ItemTypeType>>(itemId: ItemId, fields: Fields, columns: ColumnSet<ItemTypeType>, parent?: EntryParentNull, isRoot?: boolean): this;
     /**
      * @description
      * Convenience function to assign the proper parent fields, will call {@link ChangesDeltaBase.setItemUpdated setItemUpdated} internally

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

@@ -1,5 +1,5 @@
-import { ApiRequestService, CollectionEntryService, ItemEntryService } from '../classes';
-import { ChangesCompilationFactory, ColumnExpansionFactory, CreateRequestFactory, RequestColumnExpansionFactory } from '../factories';
+import { ApiRequestService, ItemEntryService } from '../classes';
+import { ChangesCompilationFactory, CreateRequestFactory, RequestColumnExpansionFactory } from '../factories';
 import { ChangesDeltaFactory } from '../factories/ChangesDeltaFactory';
 import { ErrorHandlerInterface, PromiseLibraryInterface } from '../interfaces';
 import { ItemIdConversionMap, PromiseInterface } from '../types';
@@ -13,19 +13,17 @@ export declare class ChangesProcessor {
     private changesDeltaFactory;
     private apiRequestService;
     private changesCompilationFactory;
-    private columnExpansionFactory;
     private createRequestFactory;
     private errorHandler;
     private promiseService;
     private requestColumnExpansionFactory;
-    private collectionEntryService;
     private itemEntryService;
     private transaction;
     private breakUpByParent?;
     private onAfterCreateCallback?;
     private itemIdConversionMap;
     private serverCache;
-    constructor(changesDeltaFactory: ChangesDeltaFactory, apiRequestService: ApiRequestService, changesCompilationFactory: ChangesCompilationFactory, columnExpansionFactory: ColumnExpansionFactory, createRequestFactory: CreateRequestFactory, errorHandler: ErrorHandlerInterface, promiseService: PromiseLibraryInterface, requestColumnExpansionFactory: RequestColumnExpansionFactory, collectionEntryService: CollectionEntryService, itemEntryService: ItemEntryService, transaction: TransactionCache, breakUpByParent?: boolean | undefined, onAfterCreateCallback?: OnAfterCreateCallback | undefined);
+    constructor(changesDeltaFactory: ChangesDeltaFactory, apiRequestService: ApiRequestService, changesCompilationFactory: ChangesCompilationFactory, createRequestFactory: CreateRequestFactory, errorHandler: ErrorHandlerInterface, promiseService: PromiseLibraryInterface, requestColumnExpansionFactory: RequestColumnExpansionFactory, itemEntryService: ItemEntryService, transaction: TransactionCache, breakUpByParent?: boolean | undefined, onAfterCreateCallback?: OnAfterCreateCallback | undefined);
     /**
      * @description
      * Executes the requests in the order of:

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

@@ -5,12 +5,13 @@ export declare type ChangesDeltaItemCreateDelta<ItemTypeType extends ApiEnumItem
     itemId: ItemId;
     fields: FieldMap<ItemTypeType>;
     columns: ColumnSet<ItemTypeType>;
+    isRoot: boolean;
 };
 export declare class CreatedChangesDelta {
     private tuples;
     constructor();
     remove(itemType: ApiEnumItemType, itemId: ItemId): boolean;
-    add<ItemTypeType extends ApiEnumItemType>(itemId: ItemId, fields: FieldMap<ItemTypeType>, columns: ColumnSet<ItemTypeType>): void;
+    add<ItemTypeType extends ApiEnumItemType>(itemId: ItemId, fields: FieldMap<ItemTypeType>, columns: ColumnSet<ItemTypeType>, isRoot?: boolean): void;
     isEmpty(): boolean;
     forEach(callback: (tuple: ChangesDeltaItemCreateDelta, itemType: ApiEnumItemType, index: number) => void): void;
     contains(itemType: ApiEnumItemType): boolean;

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

@@ -20,6 +20,6 @@ export declare class ItemCreateService {
      * 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): 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;
     processTemplateLinkItems<ParentItemType extends ApiEnumItemType>(changesDelta: ChangesDelta, parentType: ParentItemType, localParentId: ItemId, template: Template<ParentItemType>, itemIdConversion: ItemIdConversionMap, filterItemEntryCallback?: FilterItemEntryCallback, modifyFieldsCallback?: ModifyFieldsCallback): void;
 }

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

@@ -1,16 +1,16 @@
 import { ApiQueryConditionLinkedTo, ApiQueryConditionSubQuery } from '@rentman/backend-types';
 import { ApiQuery, ApiQueryConditionComparator, ApiQueryWithConditions, ItemIdConversionMap } from '../types';
 import { QueryParserBase } from './QueryParserBase';
-export declare class QueryParserIdUpdater extends QueryParserBase<void> {
+export declare class QueryParserIdUpdater extends QueryParserBase<boolean> {
     private itemIdConversionMap;
     constructor(itemIdConversionMap: ItemIdConversionMap, query: ApiQuery);
-    protected parseEmptyQuery(): void;
-    protected parseSubQuery<T extends ApiQueryConditionSubQuery>(_key: T['key'], subQuery: T['query']): void;
-    protected parseSubFieldQuery(): void;
-    protected parseSearchQuery(): void;
-    protected parseCustomQuery(): void;
-    protected parseSimpleQuery<T extends ApiQueryConditionComparator>(_key: T['key'], value: T['value'], _comparator: T['comparator'], _not: T['not'], queryPart: T): void;
-    protected parseLinkedToQuery<T extends ApiQueryConditionLinkedTo>(_linkedTo: T['linkedTo'], query?: T['query']): void;
-    protected parseComplexQuery<T extends ApiQueryWithConditions>(conditions: T['conditions']): void;
+    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;
     private parseConditions;
 }

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

@@ -8,6 +8,7 @@ import { ChangesDeltaBase, ChangesDeltaItemUpdateDelta } from '../ChangesDeltaBa
 import { ColumnInfo } from '../ColumnInfo';
 import { ColumnUtil } from '../ColumnUtil';
 import { ChangesDeltaItemCreateDelta } from '../CreatedChangesDelta';
+import { InternalChangesDelta } from '../InternalChangesDelta';
 import { ItemCache } from '../ItemCache';
 import { AbstractCache } from './AbstractCache';
 import { ServerItemEntryChanges } from './server/ServerItemHandler';
@@ -58,12 +59,12 @@ export declare abstract class ItemHandlerBase {
      * @description
      * Fetches an ItemEntry with the given itemId
      */
-    abstract fetchItemEntry<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, itemId: ItemId, options: ItemEntryOptions): PromiseInterface<ItemEntry<ItemTypeType>>;
+    abstract fetchItemEntry<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, itemId: ItemId, options: ItemEntryOptions, isRoot?: boolean): PromiseInterface<ItemEntry<ItemTypeType>>;
     /**
      * @description
      * Processes the passed {@link ChangesDeltaItemUpdateDelta update delta} on the transaction, if there are no {@link TransactionItemHandler.itemChanges itemChanges} the new values will not be processed
      */
-    abstract processItemEntryChanges<ItemTypeType extends ApiEnumItemType>(itemEntryChangesTuple: ChangesDeltaItemUpdateDelta<ItemTypeType>, forceOverwrite: boolean, updateInitial: boolean, isCalledAfterSocketUpdate: boolean, createItemChangesIfNoneExist: boolean): ProcessItemEntryChangesResult<ItemTypeType>;
+    abstract processItemEntryChanges<ItemTypeType extends ApiEnumItemType>(itemEntryChangesTuple: ChangesDeltaItemUpdateDelta<ItemTypeType>, forceOverwrite: boolean, updateInitial: boolean, isCalledAfterSocketUpdate: boolean, createItemChangesIfNoneExist: boolean, changesDelta?: InternalChangesDelta): ProcessItemEntryChangesResult<ItemTypeType>;
     /**
      * @description
      * Traverses the column path and returns the fields of the derived item, returns undefined if the item isn't found

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

@@ -27,7 +27,7 @@ export declare class ServerCache extends AbstractCache {
     getServerCache(): ServerCache;
     createChild(id?: string, validatorFactory?: TransactionValidatorFactory): TransactionCache;
     expandCollectionResources<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, collections: CollectionResourceParentIdMap<ItemTypeType>, newRequestColumns: ApiRequestColumn[]): PromiseInterface<CollectionResourceParentIdMap>;
-    processResponse(response: ApiResponseProcessor, requestColumnMap: ApiRequestColumnMap, isCalledAfterApiSave?: boolean, isCalledAfterSocketUpdate?: boolean, changesDelta?: ChangesDelta): PromiseInterface<ChangesDeltaResult>;
+    processResponse(response: ApiResponseProcessor, requestColumnMap: ApiRequestColumnMap, isCalledAfterApiSave?: boolean, isCalledAfterSocketUpdate?: boolean, changesDelta?: ChangesDelta, conversionMap?: ItemIdConversionMap): PromiseInterface<ChangesDeltaResult>;
     /**
      * @description
      * Applies the changes of the changesDelta created by the API call ({@link ChangesProcessor ChangesProcessor}/{@link SocketMessageHandler SocketMessageHandler}, or manually through a module function) on all caches

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

@@ -204,7 +204,7 @@ export declare class TransactionCache extends AbstractCache {
      * Rejects when another user is holding the lock, as opposed to {@link LockService.fetchLock}.
      */
     fetchLock(): PromiseInterface<void>;
-    detectChanges(): boolean;
+    detectChanges(force?: boolean): boolean;
     /**
      * @description
      * Removes an {@link ItemEntry ItemEntry} through an {@link ItemResource ItemResource} from the {@link TransactionCache TransactionCache} which means that changes on this entry will no longer be tracked.
@@ -309,7 +309,7 @@ export declare class TransactionCache extends AbstractCache {
      * won't be included
      */
     getDelta(): InternalChangesDelta;
-    createItemResource<ItemTypeType extends ApiEnumItemType>(itemEntry: ItemEntry<ItemTypeType>, isRoot?: boolean, isNew?: boolean): ItemResource<ItemTypeType>;
+    createItemResource<ItemTypeType extends ApiEnumItemType>(itemEntry: ItemEntry<ItemTypeType>, isNew?: boolean): ItemResource<ItemTypeType>;
     createItemResources<ItemTypeType extends ApiEnumItemType, ColumnIds extends Array<keyof ApiFields[ItemTypeType]> = Array<keyof ApiFields[ItemTypeType]>>(itemEntries: Array<ItemEntry<ItemTypeType>>): Array<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>>): CollectionResource<ItemTypeType>;
@@ -321,5 +321,6 @@ export declare class TransactionCache extends AbstractCache {
     private expandItemsFromDelta;
     private clearGlobalError;
     clearItemError(itemEntryId?: ItemEntry['id'], columnId?: string, errorKey?: string): void;
+    private handleRemovedItemEntry;
 }
 export {};

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

@@ -1,5 +1,5 @@
 import { ApiEnumItemType, ItemId } from '@rentman/backend-types';
-import { ApiQuery, ApiRequestColumns, CollectionQuery, ColumnSubsetCache, ItemEntryOptions, ParentIdMap, PromiseInterface, TransactionCollectionHandlerDependencyInterface, TransactionItemHandler } from '../../../index';
+import { ApiQuery, ApiRequestColumns, CollectionQuery, ColumnSubsetCache, ItemEntryOptions, ItemIdConversionMap, ParentIdMap, PromiseInterface, TransactionCollectionHandlerDependencyInterface, TransactionItemHandler } from '../../../index';
 import { ItemEntry } from '../../../models';
 import { CollectionOptions } from '../../../models/CollectionOptions';
 import { CachedQueryHandlerBase, CachedQueryItem } from '../CachedQueryHandlerBase';
@@ -9,6 +9,7 @@ export declare class TransactionCachedQueryHandler extends CachedQueryHandlerBas
     private itemHandler;
     protected transaction: TransactionCache;
     constructor(dependencies: TransactionCollectionHandlerDependencyInterface, itemHandler: TransactionItemHandler, transaction: TransactionCache);
+    updateLocalItemIdReferences(conversionMap: ItemIdConversionMap, isCalledAfterSave: boolean): void;
     __fetchCachedQueryItem<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, options: CollectionOptions): 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;

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

@@ -17,6 +17,7 @@ export declare class TransactionCollectionHandler {
         };
     };
     constructor(itemHandler: TransactionItemHandler, cachedQueryHandler: TransactionCachedQueryHandler, dependencies: TransactionCollectionHandlerDependencyInterface, transaction: TransactionCache);
+    updateLocalItemIdReferences(conversionMap: ItemIdConversionMap): void;
     expandCollectionResource<ItemTypeType extends ApiEnumItemType = any>(collectionResource: CollectionResource<ItemTypeType>, newColumns: ApiRequestColumns): PromiseInterface<void>;
     addResource(resource: CollectionResource): void;
     clearResource(resource: CollectionResource): void;

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

@@ -4,7 +4,7 @@ import { ItemEntry, ItemEntryOptions } from '../../../models';
 import { ApiQuery, ApiRequestColumns, DeregFunction, FieldChangeCallback, FieldMap, ItemIdConversionMap, ItemTypeMap, ModifyFieldsCallback, PromiseInterface, ResponseColumnItemTypeMap } from '../../../types';
 import { ChangesDelta } from '../../ChangesDelta';
 import { ChangesDeltaBase, ChangesDeltaItemUpdateDelta, ChangesDeltaResult } from '../../ChangesDeltaBase';
-import { ChangesDeltaItemCreateDelta, ColumnSubsetCache } from '../../index';
+import { ChangesDeltaItemCreateDelta, ColumnSubsetCache, InternalChangesDelta } from '../../index';
 import { ItemHandlerBase, ProcessItemEntryChangesResult } from '../ItemHandlerBase';
 import { TransactionCache } from './TransactionCache';
 import { TransactionValidator } from './TransactionValidator';
@@ -21,6 +21,10 @@ export declare class TransactionItemHandler extends ItemHandlerBase {
     private dependencies;
     protected transaction: TransactionCache;
     private validator?;
+    /**
+     * @warning
+     * Can contain both local and non-local {@link ItemEntry itemEntries}
+     */
     deletedItems: ItemTypeMap<ItemEntry[]>;
     itemChanges: {
         [itemEntryId: number]: TransactionItemEntryChanges;
@@ -60,20 +64,21 @@ export declare class TransactionItemHandler extends ItemHandlerBase {
      * @param updateInitial Should be `true` if called by applyChangesFromParent
      * @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>, forceOverwrite?: boolean, updateInitial?: boolean, isCalledAfterSocketUpdate?: boolean, createItemChangesIfNoneExist?: boolean): ProcessItemEntryChangesResult<ItemTypeType>;
+    processItemEntryChanges<ItemTypeType extends ApiEnumItemType = any>(itemEntryChangesTuple: ChangesDeltaItemUpdateDelta<ItemTypeType>, forceOverwrite?: boolean, updateInitial?: boolean, isCalledAfterSocketUpdate?: boolean, createItemChangesIfNoneExist?: boolean, changesDelta?: InternalChangesDelta): ProcessItemEntryChangesResult<ItemTypeType>;
     cloneItemEntries<ItemTypeType extends ApiEnumItemType>(changesDelta: ChangesDelta, itemEntries: Array<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>>>;
-    fetchItemEntry<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, itemId: ItemId, options: 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): PromiseInterface<ChangesDeltaResult>;
+    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>>>;
     fetchTitle(itemType: ApiEnumItemType, itemId: ItemId): PromiseInterface<string>;
     resolveLocalItemEntry<ItemTypeType extends ApiEnumItemType>(changesDelta: ChangesDelta, itemEntry: ItemEntry<ItemTypeType>, columnSubsetCache: ColumnSubsetCache<ItemTypeType>, options: ItemEntryOptions): PromiseInterface<ItemEntry<ItemTypeType>>;

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

@@ -1,22 +1,19 @@
-import { ApiRequestService, ChangesProcessor, CollectionEntryService, ItemEntryService, OnAfterCreateCallback } from '../classes';
+import { ApiRequestService, ChangesProcessor, ItemEntryService, OnAfterCreateCallback } from '../classes';
 import { TransactionCache } from '../classes/cache/transaction/TransactionCache';
 import { ErrorHandlerInterface, PromiseLibraryInterface } from '../interfaces';
 import { ChangesCompilationFactory } from './ChangesCompilationFactory';
 import { ChangesDeltaFactory } from './ChangesDeltaFactory';
-import { ColumnExpansionFactory } from './ColumnExpansionFactory';
 import { CreateRequestFactory } from './CreateRequestFactory';
 import { RequestColumnExpansionFactory } from './RequestColumnExpansionFactory';
 export declare class ChangesProcessorFactory {
     private changesDeltaFactory;
     private apiRequestService;
     private changesCompilationFactory;
-    private columnExpansionFactory;
     private createRequestFactory;
     private errorHandler;
     private promiseService;
     private requestColumnExpansionFactory;
-    private collectionEntryService;
     private itemEntryService;
-    constructor(changesDeltaFactory: ChangesDeltaFactory, apiRequestService: ApiRequestService, changesCompilationFactory: ChangesCompilationFactory, columnExpansionFactory: ColumnExpansionFactory, createRequestFactory: CreateRequestFactory, errorHandler: ErrorHandlerInterface, promiseService: PromiseLibraryInterface, requestColumnExpansionFactory: RequestColumnExpansionFactory, collectionEntryService: CollectionEntryService, itemEntryService: ItemEntryService);
+    constructor(changesDeltaFactory: ChangesDeltaFactory, apiRequestService: ApiRequestService, changesCompilationFactory: ChangesCompilationFactory, createRequestFactory: CreateRequestFactory, errorHandler: ErrorHandlerInterface, promiseService: PromiseLibraryInterface, requestColumnExpansionFactory: RequestColumnExpansionFactory, itemEntryService: ItemEntryService);
     construct(transaction: TransactionCache, breakUpByParent?: boolean, onAfterCreateCallback?: OnAfterCreateCallback): ChangesProcessor;
 }

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

@@ -1,4 +1,4 @@
-import { ApiFormatter, ColumnHandler, ColumnUtil, ConversionMapService, ItemCreateService, ItemEntryService, KeyService } from '../classes';
+import { ApiFormatter, CollectionEntryService, ColumnHandler, ColumnUtil, ConversionMapService, ItemCreateService, ItemEntryService, KeyService } from '../classes';
 import { TemplateCache } from '../classes/TemplateCache';
 import { ChangesDeltaFactory, ColumnExpansionFactory, ColumnSetFactory, ColumnSubsetCacheFactory, ItemCacheFactory, ItemEntryFactory, RequestColumnExpansionFactory } from '../factories';
 import { ErrorHandlerInterface } from './ErrorHandlerInterface';
@@ -23,4 +23,5 @@ export interface TransactionItemHandlerDependencyInterface {
     promiseService: PromiseLibraryInterface;
     requestColumnExpansionFactory: RequestColumnExpansionFactory;
     templateCache: TemplateCache;
+    collectionEntryService: CollectionEntryService;
 }

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

@@ -211,7 +211,7 @@ export declare type CollectionQuery = {
     object: BackendApiQuery;
     string: string;
 };
-export declare type CollectionResourceParentIdMap<ItemTypeType extends ApiEnumItemType = any> = ParentIdMap<CollectionResource<ItemTypeType>>;
+export declare type CollectionResourceParentIdMap<ItemTypeType extends ApiEnumItemType = any, ColumnIds extends Array<keyof ApiFields[ItemTypeType]> = any> = ParentIdMap<CollectionResource<ItemTypeType, ColumnIds>>;
 export declare type ResponseColumnMap<ItemTypeType extends ApiEnumItemType = any, ColumnIds extends Array<keyof ApiFields[ItemTypeType]> = any> = {
     [ColumnId in ColumnIds[number]]: GetColumnType<ItemTypeType, ColumnId>;
 };

package/package.json

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