@rentman/rm-core 3.0.1 → 4.0.0

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

@@ -16,7 +16,6 @@ export declare class ApiResponseProcessor {
     };
     columnMap: any;
     constructor(apiFormatter: ApiFormatter, response: any);
-    private createColumnMaps;
     fetchColumnObject(itemType: ItemType): ResponseColumn;
     fetchValue(itemType: ItemType, itemId: ItemId, columnId: string): any;
     fetchColumnArray(itemType: ItemType): ResponseColumn[];
@@ -27,4 +26,6 @@ export declare class ApiResponseProcessor {
     fetchColumnsObject(): {
         [itemType: string]: ResponseColumn;
     };
+    private addLazyFormattingFunction;
+    private createColumnMaps;
 }

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

@@ -2,13 +2,9 @@ import { ItemEntry } from '../models';
 import { EntryParent, EntryParentNull, FieldMap, ItemId, ItemType, PromiseInterface } from '../types';
 import { ChangesDeltaBase } from './ChangesDeltaBase';
 import { ColumnSet } from './ColumnSet';
+import { CreatedChangesDelta } from './CreatedChangesDelta';
 import { ItemCreateService } from './ItemCreateService';
 import { ItemEntryService } from './ItemEntryService';
-export declare type ChangesDeltaItemCreateDelta<ItemTypeType extends ItemType = any> = {
-    itemId: ItemId;
-    fields: FieldMap<ItemTypeType>;
-    columns: ColumnSet<ItemTypeType>;
-};
 /**
  * @description
  * ChangesDelta used to apply changes from outside of the core to a transaction
@@ -22,7 +18,7 @@ export declare type ChangesDeltaItemCreateDelta<ItemTypeType extends ItemType =
  */
 export declare class ChangesDelta extends ChangesDeltaBase {
     private itemCreateService;
-    created: ChangesDeltaItemCreateDelta[];
+    created: CreatedChangesDelta;
     constructor(itemCreateService: ItemCreateService, itemEntryService: ItemEntryService);
     /**
      * @description
@@ -59,4 +55,5 @@ export declare class ChangesDelta extends ChangesDeltaBase {
      * Convenience function to assign the proper parent fields, will call {@link ChangesDeltaBase.setItemUpdated setItemUpdated} internally
      */
     setItemMoved(entry: ItemEntry, to: EntryParent): void;
+    isEmpty(): boolean;
 }

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

@@ -46,4 +46,5 @@ export declare abstract class ChangesDeltaBase {
     setItemUpdated<ItemEntryType extends ItemEntry>(entry: ItemEntryType, fields: FieldMap<ItemEntryType['itemType']>, columnExpansionResult?: ColumnExpansionResult<ItemEntryType['itemType']> | null, parent?: EntryParentNull): void;
     setItemDeleted(deleted: ItemEntry): void;
     setItemsDeleted(deleted: ItemEntry[]): void;
+    isEmpty(): boolean;
 }

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

@@ -0,0 +1,27 @@
+import { ItemEntry } from '../models';
+import { ApiResponse, EntryParentNull, FieldMap, ItemId, ItemIdConversionMap, ItemType } from '../types';
+import { ColumnInfo } from './ColumnInfo';
+import { KeyService } from './KeyService';
+/**
+ * @description A 'ConversionMap' is used to update a set of item IDs to another. This happens when processing back-end
+ * responses (create / template) or cloning items in the front-end. A conversion map is grouped by item type, as item
+ * ID's are not unique across types.
+ *
+ * TODO: In the future, we should create a class and a 'ConversionMapFactory'.
+ */
+export declare class ConversionMapService {
+    private keyService;
+    constructor(keyService: KeyService);
+    createLocalConversionMap(itemType: ItemType, itemId: ItemId, doExtend: boolean | undefined, apiResponse: ApiResponse): ItemIdConversionMap;
+    expandLocalConversionMap(parentType: ItemType, parentId: ItemId, apiResponse: ApiResponse, conversionMap: ItemIdConversionMap): void;
+    expandConversionMap(itemEntry: ItemEntry, conversionMap: ItemIdConversionMap, newItemId?: ItemId): ItemId;
+    batchExpandConversionMap(itemEntries: Array<ItemEntry<any>>, conversionMap: ItemIdConversionMap): ItemIdConversionMap;
+    getConversionValue(itemType: ItemType, itemId: ItemId, map: ItemIdConversionMap): ItemId | undefined;
+    /**
+     * @description
+     * Updates the columns in `fields` using the `parent` and `conversionMap`.
+     * @param parent - When retrieving an item the 'link' column is not present in the template response, and is
+     * added at a later stage. The value for this column can be read from this parameter.
+     */
+    updateItemValues<ItemTypeType extends ItemType>(source: FieldMap<ItemTypeType>, destination: FieldMap<ItemTypeType>, itemColumns: Array<ColumnInfo<ItemTypeType>>, conversionMap: ItemIdConversionMap, parent?: EntryParentNull): void;
+}

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

@@ -0,0 +1,15 @@
+import { FieldMap, ItemId, ItemType } from '../types';
+import { ColumnSet } from './ColumnSet';
+export declare type ChangesDeltaItemCreateDelta<ItemTypeType extends ItemType = any> = {
+    itemId: ItemId;
+    fields: FieldMap<ItemTypeType>;
+    columns: ColumnSet<ItemTypeType>;
+};
+export declare class CreatedChangesDelta {
+    private tuples;
+    constructor();
+    add<ItemTypeType extends ItemType>(itemId: ItemId, fields: FieldMap<ItemTypeType>, columns: ColumnSet<ItemTypeType>): void;
+    isEmpty(): boolean;
+    forEach(callback: (tuple: ChangesDeltaItemCreateDelta, itemType: ItemType, index: number) => void): void;
+    contains(itemType: ItemType): boolean;
+}

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

@@ -35,4 +35,5 @@ export declare class InternalChangesDelta extends ChangesDeltaBase {
      * Parent fields are non-writable so we need to keep track of moved entries another way (to do a linkTo request)
      */
     setItemMoved(entry: ItemEntry, to: EntryParent): void;
+    isEmpty(): boolean;
 }

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

@@ -17,7 +17,7 @@ export declare class ItemCache {
     getLocalByQuery<ItemTypeType extends ItemType>(itemType: ItemTypeType, query: CollectionQuery): ItemEntry<ItemTypeType>[];
     getByParent<ItemTypeType extends ItemType>(parentType: ItemType, parentId: ItemId, itemType: ItemTypeType): ItemEntry<ItemTypeType>[];
     batchGetLocalByParent<ItemTypeType extends ItemType>(parentType: ItemType, parentIds: ItemId[], itemType: ItemTypeType, additionalQuery: any): ItemEntryParentIdMap<ItemTypeType>;
-    forEach(callback: (itemEntry: ItemEntry<ItemType>) => void): void;
+    forEach(callback: (itemEntry: ItemEntry) => void): void;
     toArray(): ItemEntry<string>[];
     add<ItemTypeType extends ItemType>(itemEntry: ItemEntry<ItemTypeType>): ItemEntry<ItemTypeType>;
     get<ItemTypeType extends ItemType>(itemType: ItemTypeType, itemId: string | ItemId): undefined | ItemEntry<ItemTypeType>;

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

@@ -2,21 +2,18 @@ import { ColumnSetFactory } from '../factories';
 import { ErrorHandlerInterface, PromiseLibraryInterface } from '../interfaces';
 import { Template } from '../models';
 import { EntryParentNull, FieldMap, FilterItemEntryCallback, ItemId, ItemIdConversionMap, ItemType, ModifyFieldsCallback, PromiseInterface } from '../types';
-import { ApiFormatter } from './ApiFormatter';
 import { ChangesDelta } from './ChangesDelta';
-import { ColumnInfo } from './ColumnInfo';
-import { ItemEntryService } from './ItemEntryService';
+import { ConversionMapService } from './ConversionMapService';
 import { KeyService } from './KeyService';
 import { TemplateCache } from './TemplateCache';
 export declare class ItemCreateService {
+    private columnSetFactory;
+    private conversionMapService;
+    private errorHandler;
     private keyService;
-    private templateCache;
     private promiseService;
-    private errorHandler;
-    private itemEntryService;
-    private apiFormatter;
-    private columnSetFactory;
-    constructor(keyService: KeyService, templateCache: TemplateCache, promiseService: PromiseLibraryInterface, errorHandler: ErrorHandlerInterface, itemEntryService: ItemEntryService, apiFormatter: ApiFormatter, columnSetFactory: ColumnSetFactory);
+    private templateCache;
+    constructor(columnSetFactory: ColumnSetFactory, conversionMapService: ConversionMapService, errorHandler: ErrorHandlerInterface, keyService: KeyService, promiseService: PromiseLibraryInterface, templateCache: TemplateCache);
     /**
      * @description
      * Fetches a new {@link Template template} and sets the items created on the passed {@link ChangesDelta}
@@ -24,5 +21,4 @@ export declare class ItemCreateService {
     createItemsFromValues<ItemTypeType extends ItemType>(changesDelta: ChangesDelta, itemType: ItemTypeType, valuesArray: Array<FieldMap<ItemTypeType>>, parent?: EntryParentNull): PromiseInterface<void>;
     processTemplate<ItemTypeType extends ItemType>(changesDelta: ChangesDelta, itemType: ItemTypeType, itemId: ItemId, parent: EntryParentNull, template: Template<ItemTypeType>, filterItemEntryCallback?: FilterItemEntryCallback, modifyFieldsCallback?: ModifyFieldsCallback): void;
     processTemplateLinkItems<ParentItemType extends ItemType>(changesDelta: ChangesDelta, parentType: ParentItemType, localParentId: ItemId, template: Template<ParentItemType>, itemIdConversion: ItemIdConversionMap, filterItemEntryCallback?: FilterItemEntryCallback, modifyFieldsCallback?: ModifyFieldsCallback): void;
-    updateItemValues<ItemTypeType extends ItemType>(changes: FieldMap<ItemTypeType>, parent: EntryParentNull, itemColumns: Array<ColumnInfo<ItemTypeType>>, conversionMap: ItemIdConversionMap): FieldMap<ItemTypeType>;
 }

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

@@ -1,13 +1,11 @@
-import { KeyService } from '../classes';
 import { AuthInterface } from '../interfaces';
 import { LinkTreeServiceInterface } from '../interfaces/LinkTreeServiceInterface';
 import { ItemEntry, ItemEntryOptions } from '../models';
-import { ApiResponse, EntryParent, EntryParentNull, FieldMap, ItemError, ItemId, ItemIdConversionMap, ItemOptionsInterface, ItemType } from '../types';
+import { EntryParent, EntryParentNull, FieldMap, ItemError, ItemOptionsInterface, ItemType } from '../types';
 export declare class ItemEntryService {
     private authInterface;
-    private keyService;
     private linkTreeService;
-    constructor(authInterface: AuthInterface, keyService: KeyService, linkTreeService: LinkTreeServiceInterface);
+    constructor(authInterface: AuthInterface, linkTreeService: LinkTreeServiceInterface);
     matchParent(oldParent: EntryParentNull, newParent: EntryParentNull): boolean;
     /**
      * @description
@@ -30,11 +28,6 @@ export declare class ItemEntryService {
     createUnfoundRemoteItemError(): ItemError;
     createUnfoundLocalItemError(itemType: ItemType): ItemError;
     createExistingLocalItemError(itemType: ItemType): ItemError;
-    createLocalConversionMap(itemType: ItemType, itemId: ItemId, doExtend: boolean | undefined, apiResponse: ApiResponse): ItemIdConversionMap;
-    expandLocalConversionMap(parentType: ItemType, parentId: ItemId, apiResponse: ApiResponse, conversionMap: ItemIdConversionMap): void;
-    expandConversionMap(itemEntry: ItemEntry<any>, conversionMap: ItemIdConversionMap, newItemId?: ItemId): ItemId;
-    batchExpandConversionMap(itemEntries: Array<ItemEntry<any>>, conversionMap: ItemIdConversionMap): ItemIdConversionMap;
-    getConversionValue(itemType: ItemType, itemId: ItemId, map: ItemIdConversionMap): ItemId | undefined;
     getFullName(firstName?: string, infix?: string, lastName?: string): string;
     getTitleField(itemType: ItemType): string;
     getLocalDefaultValues(): FieldMap;

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

@@ -1,29 +1,13 @@
 import { RmCore } from '../../core';
-import { CollectionCacheFactory, CollectionEntryFactory, CollectionMatcherFactory, CollectionResourceFactory, ColumnExpansionFactory, ColumnSetFactory, ColumnSubsetCacheFactory, ItemCacheFactory, ItemEntryFactory, ItemResourceFactory, ModuleChangesCompilationFactory, QueryMatcherFactory, QueryParserFactory, RequestColumnExpansionFactory } from '../../factories';
-import { ChangesDeltaFactory } from '../../factories/ChangesDeltaFactory';
-import { AuthInterface, ErrorHandlerInterface, ExceptionHandlerInterface, PromiseLibraryInterface } from '../../interfaces';
-import { LinkTreeServiceInterface } from '../../interfaces/LinkTreeServiceInterface';
+import { AbstractCacheDependencyInterface } from '../../interfaces';
 import { CollectionEntry, ItemEntry } from '../../models';
 import { EntryParentNull, FieldMap, ItemIdConversionMap, ItemType, PromiseInterface } from '../../types';
-import { ApiFormatter } from '../ApiFormatter';
-import { ApiRequestService } from '../ApiRequestService';
 import { ChangesDelta } from '../ChangesDelta';
 import { ChangesDeltaResult } from '../ChangesDeltaBase';
 import { OnAfterCreateCallback } from '../ChangesProcessor';
 import { CollectionCache } from '../CollectionCache';
-import { CollectionEntryService } from '../CollectionEntryService';
-import { ColumnCache } from '../ColumnCache';
-import { ColumnHandler } from '../ColumnHandler';
-import { ColumnUtil } from '../ColumnUtil';
 import { InternalChangesDelta } from '../InternalChangesDelta';
 import { ItemCache } from '../ItemCache';
-import { ItemCreateService } from '../ItemCreateService';
-import { ItemEntryService } from '../ItemEntryService';
-import { KeyService } from '../KeyService';
-import { LockService } from '../LockService';
-import { QueryService } from '../QueryService';
-import { RequestBufferManager } from '../RequestBufferManager';
-import { TemplateCache } from '../TemplateCache';
 import { ServerCache } from './server/ServerCache';
 import { ServerCollectionHandler } from './server/ServerCollectionHandler';
 import { ServerItemEntryChanges, ServerItemHandler } from './server/ServerItemHandler';
@@ -32,45 +16,13 @@ import { TransactionCollectionHandler } from './transaction/TransactionCollectio
 import { TransactionItemEntryChanges, TransactionItemHandler } from './transaction/TransactionItemHandler';
 import { TransactionValidatorFactory } from './transaction/TransactionValidator';
 export declare abstract class AbstractCache {
+    protected dependencies: AbstractCacheDependencyInterface;
     core: RmCore;
-    protected columnCache: ColumnCache;
-    protected requestBufferManager: RequestBufferManager;
-    protected requestColumnExpansionFactory: RequestColumnExpansionFactory;
-    protected queryMatcherFactory: QueryMatcherFactory;
-    protected authInterface: AuthInterface;
-    protected changesDeltaFactory: ChangesDeltaFactory;
-    protected lockService: LockService;
-    protected moduleChangesCompilationFactory: ModuleChangesCompilationFactory;
-    protected collectionResourceFactory: CollectionResourceFactory;
-    protected itemResourceFactory: ItemResourceFactory;
-    protected templateCache: TemplateCache;
-    protected itemCacheFactory: ItemCacheFactory;
-    protected collectionCacheFactory: CollectionCacheFactory;
-    protected errorHandler: ErrorHandlerInterface;
-    protected exceptionHandler: ExceptionHandlerInterface;
-    protected promiseService: PromiseLibraryInterface;
-    protected apiRequestService: ApiRequestService;
-    protected columnExpansionFactory: ColumnExpansionFactory;
-    protected columnHandler: ColumnHandler;
-    protected columnSetFactory: ColumnSetFactory;
-    protected columnSubsetCacheFactory: ColumnSubsetCacheFactory;
-    protected columnUtil: ColumnUtil;
-    protected itemEntryFactory: ItemEntryFactory;
-    protected itemEntryService: ItemEntryService;
-    protected keyService: KeyService;
-    protected collectionEntryFactory: CollectionEntryFactory;
-    protected collectionEntryService: CollectionEntryService;
-    protected collectionMatcherFactory: CollectionMatcherFactory;
-    protected queryParserFactory: QueryParserFactory;
-    protected queryService: QueryService;
-    protected apiFormatter: ApiFormatter;
-    protected linkTreeService: LinkTreeServiceInterface;
-    protected changesDeltaService: ItemCreateService;
     children: TransactionCache[];
     readonly itemHandler: TransactionItemHandler | ServerItemHandler;
     readonly collectionHandler: TransactionCollectionHandler | ServerCollectionHandler;
     parent: AbstractCache | null;
-    protected constructor(core: RmCore, columnCache: ColumnCache, requestBufferManager: RequestBufferManager, requestColumnExpansionFactory: RequestColumnExpansionFactory, queryMatcherFactory: QueryMatcherFactory, authInterface: AuthInterface, changesDeltaFactory: ChangesDeltaFactory, lockService: LockService, moduleChangesCompilationFactory: ModuleChangesCompilationFactory, collectionResourceFactory: CollectionResourceFactory, itemResourceFactory: ItemResourceFactory, templateCache: TemplateCache, itemCacheFactory: ItemCacheFactory, collectionCacheFactory: CollectionCacheFactory, errorHandler: ErrorHandlerInterface, exceptionHandler: ExceptionHandlerInterface, promiseService: PromiseLibraryInterface, apiRequestService: ApiRequestService, columnExpansionFactory: ColumnExpansionFactory, columnHandler: ColumnHandler, columnSetFactory: ColumnSetFactory, columnSubsetCacheFactory: ColumnSubsetCacheFactory, columnUtil: ColumnUtil, itemEntryFactory: ItemEntryFactory, itemEntryService: ItemEntryService, keyService: KeyService, collectionEntryFactory: CollectionEntryFactory, collectionEntryService: CollectionEntryService, collectionMatcherFactory: CollectionMatcherFactory, queryParserFactory: QueryParserFactory, queryService: QueryService, apiFormatter: ApiFormatter, linkTreeService: LinkTreeServiceInterface, changesDeltaService: ItemCreateService);
+    protected constructor(dependencies: AbstractCacheDependencyInterface, core: RmCore);
     createChild(id?: string, validatorFactory?: TransactionValidatorFactory): TransactionCache;
     onChildDestroy(cache: TransactionCache): void;
     abstract getLocalCollectionEntryByQueryString(itemType: ItemType, queryString: string): CollectionEntry | undefined;

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

@@ -3,10 +3,10 @@ import { ErrorHandlerInterface, PromiseLibraryInterface } from '../../interfaces
 import { ItemEntry, ItemEntryOptions } from '../../models';
 import { ApiQuery, ApiRequestColumns, FieldMap, ItemId, ItemType, PromiseInterface } from '../../types';
 import { ApiFormatter } from '../ApiFormatter';
-import { ChangesDeltaItemCreateDelta } from '../ChangesDelta';
 import { ChangesDeltaBase, ChangesDeltaItemUpdateDelta } from '../ChangesDeltaBase';
 import { ColumnInfo } from '../ColumnInfo';
 import { ColumnUtil } from '../ColumnUtil';
+import { ChangesDeltaItemCreateDelta } from '../CreatedChangesDelta';
 import { ItemCache } from '../ItemCache';
 import { AbstractCache } from './AbstractCache';
 import { ServerItemEntryChanges } from './server/ServerItemHandler';

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

@@ -1,29 +1,12 @@
 import { RmCore } from '../../../core';
-import { CollectionCacheFactory, CollectionEntryFactory, CollectionMatcherFactory, CollectionResourceFactory, ColumnExpansionFactory, ColumnSetFactory, ColumnSubsetCacheFactory, ItemCacheFactory, ItemEntryFactory, ItemResourceFactory, ModuleChangesCompilationFactory, QueryMatcherFactory, QueryParserFactory, RequestColumnExpansionFactory } from '../../../factories';
-import { ChangesDeltaFactory } from '../../../factories/ChangesDeltaFactory';
-import { ChangesProcessorFactory } from '../../../factories/ChangesProcessorFactory';
-import { AuthInterface, ErrorHandlerInterface, ExceptionHandlerInterface, PromiseLibraryInterface } from '../../../interfaces';
-import { LinkTreeServiceInterface } from '../../../interfaces/LinkTreeServiceInterface';
+import { ServerCacheDependencyInterface } from '../../../interfaces';
 import { CollectionEntry, ItemEntry } from '../../../models';
 import { ApiRequestColumnMap, EntryParent, EntryParentNull, FieldMap, ItemIdConversionMap, ItemType, PromiseInterface } from '../../../types';
-import { ApiFormatter } from '../../ApiFormatter';
-import { ApiRequestService } from '../../ApiRequestService';
 import { ApiResponseProcessor } from '../../ApiResponseProcessor';
 import { ChangesDelta } from '../../ChangesDelta';
 import { ChangesDeltaResult } from '../../ChangesDeltaBase';
 import { OnAfterCreateCallback } from '../../ChangesProcessor';
-import { CollectionEntryService } from '../../CollectionEntryService';
-import { ColumnCache } from '../../ColumnCache';
-import { ColumnHandler } from '../../ColumnHandler';
-import { ColumnUtil } from '../../ColumnUtil';
 import { InternalChangesDelta } from '../../InternalChangesDelta';
-import { ItemCreateService } from '../../ItemCreateService';
-import { ItemEntryService } from '../../ItemEntryService';
-import { KeyService } from '../../KeyService';
-import { LockService } from '../../LockService';
-import { QueryService } from '../../QueryService';
-import { RequestBufferManager } from '../../RequestBufferManager';
-import { TemplateCache } from '../../TemplateCache';
 import { AbstractCache } from '../AbstractCache';
 import { TransactionCache } from '../transaction/TransactionCache';
 import { ServerCollectionHandler } from './ServerCollectionHandler';
@@ -36,11 +19,11 @@ import { ServerItemEntryChanges, ServerItemHandler } from './ServerItemHandler';
  * It's basically a local representation of the database
  */
 export declare class ServerCache extends AbstractCache {
-    private changesProcessorFactory;
+    protected dependencies: ServerCacheDependencyInterface;
     readonly itemHandler: ServerItemHandler;
     readonly collectionHandler: ServerCollectionHandler;
     parent: null;
-    constructor(changesProcessorFactory: ChangesProcessorFactory, core: RmCore, columnCache: ColumnCache, requestBufferManager: RequestBufferManager, requestColumnExpansionFactory: RequestColumnExpansionFactory, queryMatcherFactory: QueryMatcherFactory, authInterface: AuthInterface, changesDeltaFactory: ChangesDeltaFactory, lockService: LockService, moduleChangesCompilationFactory: ModuleChangesCompilationFactory, collectionResourceFactory: CollectionResourceFactory, itemResourceFactory: ItemResourceFactory, templateCache: TemplateCache, itemCacheFactory: ItemCacheFactory, collectionCacheFactory: CollectionCacheFactory, errorHandler: ErrorHandlerInterface, exceptionHandler: ExceptionHandlerInterface, promiseService: PromiseLibraryInterface, apiFormatter: ApiFormatter, apiRequestService: ApiRequestService, columnExpansionFactory: ColumnExpansionFactory, columnHandler: ColumnHandler, columnSetFactory: ColumnSetFactory, columnSubsetCacheFactory: ColumnSubsetCacheFactory, columnUtil: ColumnUtil, itemEntryFactory: ItemEntryFactory, itemEntryService: ItemEntryService, keyService: KeyService, collectionEntryFactory: CollectionEntryFactory, collectionEntryService: CollectionEntryService, collectionMatcherFactory: CollectionMatcherFactory, queryParserFactory: QueryParserFactory, queryService: QueryService, linkTreeService: LinkTreeServiceInterface, changesDeltaService: ItemCreateService);
+    constructor(dependencies: ServerCacheDependencyInterface, core: RmCore);
     getServerCache(): ServerCache;
     processResponse(response: ApiResponseProcessor, requestColumnMap: ApiRequestColumnMap, isCalledAfterApiSave?: boolean, isCalledAfterSocketUpdate?: boolean, changesDelta?: ChangesDelta): PromiseInterface<ChangesDeltaResult>;
     /**

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

@@ -2,8 +2,9 @@ import { ColumnSubsetCacheFactory, ItemCacheFactory, ItemEntryFactory, QueryPars
 import { ErrorHandlerInterface, PromiseLibraryInterface } from '../../../interfaces';
 import { ItemEntry, ItemEntryOptions } from '../../../models';
 import { ApiQuery, ApiRequestColumns, FieldMap, ItemId, ItemType, PromiseInterface } from '../../../types';
-import { ChangesDelta, ChangesDeltaItemCreateDelta } from '../../ChangesDelta';
+import { ChangesDelta } from '../../ChangesDelta';
 import { ChangesDeltaItemUpdateDelta } from '../../ChangesDeltaBase';
+import { ChangesDeltaItemCreateDelta } from '../../CreatedChangesDelta';
 import { ApiFormatter, ApiResponseProcessor, ColumnExpansion, ColumnSet, ColumnUtil, QueryService, RequestBufferManager, RequestBufferResponse, TransactionItemEntryChanges } from '../../index';
 import { ItemHandlerBase } from '../ItemHandlerBase';
 import { ServerCache } from './ServerCache';

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

@@ -1,22 +1,11 @@
 import { RmCore } from '../../../core';
-import { CollectionCacheFactory, CollectionEntryFactory, CollectionMatcherFactory, CollectionResourceFactory, ColumnExpansionFactory, ColumnSetFactory, ColumnSubsetCacheFactory, ItemCacheFactory, ItemEntryFactory, ItemResourceFactory, ModuleChangesCompilationFactory, QueryMatcherFactory, QueryParserFactory, RequestColumnExpansionFactory } from '../../../factories';
-import { ChangesDeltaFactory } from '../../../factories/ChangesDeltaFactory';
-import { AuthInterface, ErrorHandlerInterface, ExceptionHandlerInterface, PromiseLibraryInterface } from '../../../interfaces';
-import { LinkTreeServiceInterface } from '../../../interfaces/LinkTreeServiceInterface';
-import { CollectionEntry, CollectionResource, CollectionResourceOptionsInterface, ItemEntry, ItemResource } from '../../../models';
-import { ApiQuery, CollectionDefinition, CollectionOptionsInterface, CollectionResourceParentIdMap, ConversionMap, CreateRequestParameterMap, EntryParentNull, FieldMap, ItemId, ItemIdConversionMap, ItemOptionsInterface, ItemResourcesItemTypeMap, ItemType, ItemTypeMap, LinkCollectionDefinition, PromiseInterface } from '../../../types';
+import { AbstractCacheDependencyInterface } from '../../../interfaces/AbstractCacheDependencyInterface';
+import { CollectionEntry, CollectionResource, CollectionResourceOptionsInterface, ItemEntry, ItemEntryOptions, ItemResource } from '../../../models';
+import { ApiQuery, CollectionDefinition, CollectionOptionsInterface, CollectionResourceParentIdMap, ConversionMap, CreateRequestParameterMap, DeregFunction, EntryParentNull, FieldChangeCallback, FieldMap, ItemId, ItemIdConversionMap, ItemOptionsInterface, ItemResourcesItemTypeMap, ItemType, ItemTypeMap, LinkCollectionDefinition, PromiseInterface } from '../../../types';
 import { ChangesDelta } from '../../ChangesDelta';
 import { ChangesDeltaResult } from '../../ChangesDeltaBase';
-import { CollectionEntryService } from '../../CollectionEntryService';
-import { ColumnHandler } from '../../ColumnHandler';
-import { ColumnUtil } from '../../ColumnUtil';
-import { ApiFormatter, ApiRequestService, ColumnCache, LockService, ModuleChangesCompilationResult, OnAfterCreateCallback, RequestBufferManager, TransactionCacheCallbackCondition, TransactionCacheCallbackType, TransactionCollectionHandler, TransactionItemEntryChanges, TransactionItemHandler, TransactionValidatorFactory } from '../../index';
+import { ModuleChangesCompilationResult, OnAfterCreateCallback, TransactionCacheCallbackCondition, TransactionCacheCallbackType, TransactionCollectionHandler, TransactionItemEntryChanges, TransactionItemHandler, TransactionValidatorFactory } from '../../index';
 import { InternalChangesDelta } from '../../InternalChangesDelta';
-import { ItemCreateService } from '../../ItemCreateService';
-import { ItemEntryService } from '../../ItemEntryService';
-import { KeyService } from '../../KeyService';
-import { QueryService } from '../../QueryService';
-import { TemplateCache } from '../../TemplateCache';
 import { AbstractCache } from '../AbstractCache';
 import { ServerCache } from '../server/ServerCache';
 import { TransactionEventHandler } from './TransactionEventHandler';
@@ -99,13 +88,14 @@ export declare class TransactionCache extends AbstractCache {
     readonly eventHandler: TransactionEventHandler;
     private readonly validator?;
     private changesInterval;
-    constructor(core: RmCore, columnCache: ColumnCache, requestBufferManager: RequestBufferManager, requestColumnExpansionFactory: RequestColumnExpansionFactory, queryMatcherFactory: QueryMatcherFactory, authInterface: AuthInterface, changesDeltaFactory: ChangesDeltaFactory, lockService: LockService, moduleChangesCompilationFactory: ModuleChangesCompilationFactory, collectionResourceFactory: CollectionResourceFactory, itemResourceFactory: ItemResourceFactory, templateCache: TemplateCache, itemCacheFactory: ItemCacheFactory, collectionCacheFactory: CollectionCacheFactory, errorHandler: ErrorHandlerInterface, exceptionHandler: ExceptionHandlerInterface, promiseService: PromiseLibraryInterface, apiRequestService: ApiRequestService, columnExpansionFactory: ColumnExpansionFactory, columnHandler: ColumnHandler, columnSetFactory: ColumnSetFactory, columnSubsetCacheFactory: ColumnSubsetCacheFactory, columnUtil: ColumnUtil, itemEntryFactory: ItemEntryFactory, itemEntryService: ItemEntryService, keyService: KeyService, collectionEntryFactory: CollectionEntryFactory, collectionEntryService: CollectionEntryService, collectionMatcherFactory: CollectionMatcherFactory, queryParserFactory: QueryParserFactory, queryService: QueryService, apiFormatter: ApiFormatter, linkTreeService: LinkTreeServiceInterface, changesDeltaService: ItemCreateService, parent: AbstractCache, 
+    constructor(dependencies: AbstractCacheDependencyInterface, core: RmCore, parent: AbstractCache, 
     /**
      * @description
      * For debugging purposes
      */
     id?: string | undefined, validatorFactory?: TransactionValidatorFactory);
     destroy(): void;
+    registerFieldChangeCallback<ItemTypeType extends ItemType>(itemType: ItemTypeType, itemId: ItemId, callback: FieldChangeCallback<ItemTypeType>): DeregFunction;
     createChangesDelta(): ChangesDelta;
     getFirstErrorString(): undefined | string;
     /**
@@ -177,15 +167,6 @@ export declare class TransactionCache extends AbstractCache {
      * @param copyFields If set, will call {@link ApiFormatter.copyFields ApiFormatter.copyFields}, otherwise just returns the object
      */
     getItemChangesRecursively(itemEntryId: ItemEntry['id'], copyFields?: boolean): FieldMap;
-    /**
-     * @description
-     * Removes the {@link ItemResource ItemResource} from the transaction, preventing the {@link ItemResource.options.onChange the onChange callback} from being called.
-     * You should call this function when the resource is no longer needed
-     *
-     * @remark
-     * Does not remove changes
-     */
-    clearItemResource(resource: ItemResource): void;
     /**
      * @description
      * Removes the {@link CollectionResource CollectionResource} from the transaction, preventing the {@link CollectionResource.options.onAdd onAdd} and {@link CollectionResource.options.onRemove onRemove} callbacks from being called.
@@ -256,17 +237,6 @@ export declare class TransactionCache extends AbstractCache {
     updateItemIdMap(collectionMap: {
         [itemId: number]: any;
     }, conversionMap: ConversionMap): void;
-    /**
-     * @description
-     * Clones the {@link CollectionEntry CollectionEntry} and all {@link ItemEntry ItemEntries} in it, and sets the parent of the new entries.
-     * Returns a {@link CollectionResource CollectionResource} of the newly cloned {@link CollectionEntry CollectionEntry}
-     */
-    cloneCollection<ItemTypeType extends ItemType>(collectionResource: CollectionResource<ItemTypeType>, options: CollectionOptionsInterface<ItemTypeType>, conversionMap: ItemIdConversionMap): CollectionResource<ItemTypeType>;
-    /**
-     * @description
-     * Clones the {@link ItemEntry ItemEntry} and returns a {@link ItemResource ItemResource} of the newly cloned {@link ItemEntry ItemEntry}
-     */
-    cloneItem<ItemTypeType extends ItemType>(itemResource: ItemResource<ItemTypeType>, options: ItemOptionsInterface): PromiseInterface<ItemResource<ItemTypeType>>;
     getAllLinkCollections<ItemTypeType extends ItemType>(linkType: ItemType, itemType: ItemTypeType, options: CollectionOptionsInterface<ItemTypeType>): PromiseInterface<CollectionResourceParentIdMap<ItemTypeType>>;
     getLinkCollectionsFromDef<ItemTypeType extends ItemType>(linkType: ItemType, linkIdArray: ItemId[], definition: LinkCollectionDefinition<ItemTypeType>): PromiseInterface<CollectionResourceParentIdMap<ItemTypeType>>;
     getLinkCollections<ItemTypeType extends ItemType>(linkType: ItemType, linkIdArray: ItemId[], itemType: ItemTypeType, options: CollectionOptionsInterface<ItemTypeType>): PromiseInterface<CollectionResourceParentIdMap<ItemTypeType>>;
@@ -284,27 +254,27 @@ export declare class TransactionCache extends AbstractCache {
     getItemByState<ItemTypeType extends ItemType>(itemType: ItemTypeType, stateKey: ItemId | string, options?: ItemOptionsInterface, isRoot?: boolean): PromiseInterface<ItemResource<ItemTypeType>>;
     getDuplicateById<ItemTypeType extends ItemType>(itemType: ItemTypeType, duplicateId: ItemId, options: ItemOptionsInterface, returnLinks: true, isRoot?: boolean): PromiseInterface<ItemResourceLinks<ItemTypeType>>;
     getDuplicateById<ItemTypeType extends ItemType>(itemType: ItemTypeType, duplicateId: ItemId, options: ItemOptionsInterface, returnLinks?: boolean, isRoot?: boolean): PromiseInterface<ItemResource<ItemTypeType>>;
-    getNewResourceWithId<ItemTypeType extends ItemType>(itemType: ItemTypeType, itemId: ItemId, options: ItemOptionsInterface, returnLinks: true, isRoot?: boolean): PromiseInterface<ItemResourceLinks<ItemTypeType>>;
-    getNewResourceWithId<ItemTypeType extends ItemType>(itemType: ItemTypeType, itemId: ItemId, options: ItemOptionsInterface, returnLinks?: boolean, isRoot?: boolean): PromiseInterface<ItemResource<ItemTypeType>>;
+    getNewResourceWithId<ItemTypeType extends ItemType>(itemType: ItemTypeType, itemId: ItemId, options: Partial<ItemEntryOptions>, returnLinks: true, isRoot?: boolean): PromiseInterface<ItemResourceLinks<ItemTypeType>>;
+    getNewResourceWithId<ItemTypeType extends ItemType>(itemType: ItemTypeType, itemId: ItemId, options: Partial<ItemEntryOptions>, returnLinks?: boolean, isRoot?: boolean): PromiseInterface<ItemResource<ItemTypeType>>;
     getNewResource<ItemTypeType extends ItemType>(itemType: ItemTypeType, options: ItemOptionsInterface, returnLinks: true, isRoot?: boolean): PromiseInterface<ItemResourceLinks<ItemTypeType>>;
     getNewResource<ItemTypeType extends ItemType>(itemType: ItemTypeType, options: ItemOptionsInterface, returnLinks?: boolean, isRoot?: boolean): PromiseInterface<ItemResource<ItemTypeType>>;
     /**
      * @description
      * Fetches multiple items with their respective changes of the current {@link TransactionCache transaction}
      */
-    getItemsByQuery<ItemTypeType extends ItemType>(itemType: ItemTypeType, query: ApiQuery, options?: ItemOptionsInterface): PromiseInterface<Array<ItemResource<ItemTypeType>>>;
+    getItemsByQuery<ItemTypeType extends ItemType>(itemType: ItemTypeType, query: ApiQuery, options?: Partial<ItemEntryOptions>): PromiseInterface<Array<ItemResource<ItemTypeType>>>;
     /**
      * @description
      * Fetches multiple items with their respective changes of the current {@link TransactionCache transaction}
      */
-    getItemsById<ItemTypeType extends ItemType>(itemType: ItemTypeType, itemIds: ItemId[], options?: ItemOptionsInterface): PromiseInterface<Array<ItemResource<ItemTypeType>>>;
+    getItemsById<ItemTypeType extends ItemType>(itemType: ItemTypeType, itemIds: ItemId[], options?: Partial<ItemEntryOptions>): PromiseInterface<Array<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 ItemType>(itemType: ItemTypeType, itemId: ItemId, options?: ItemOptionsInterface, isRoot?: boolean): PromiseInterface<ItemResource<ItemTypeType>>;
+    getItemById<ItemTypeType extends ItemType>(itemType: ItemTypeType, itemId: ItemId, options?: Partial<ItemEntryOptions>, isRoot?: boolean): PromiseInterface<ItemResource<ItemTypeType>>;
     /**
      * @description
      * Fetches the title of an item, does not create an {@link ItemResource ItemResource}
@@ -349,9 +319,9 @@ export declare class TransactionCache extends AbstractCache {
      * won't be included
      */
     getDelta(): InternalChangesDelta;
-    createItemResource<ItemTypeType extends ItemType>(itemEntry: ItemEntry<ItemTypeType>, options: ItemOptionsInterface, isRoot?: boolean, isNew?: boolean): ItemResource<ItemTypeType>;
-    createItemResources<ItemTypeType extends ItemType>(itemEntries: Array<ItemEntry<ItemTypeType>>, options: ItemOptionsInterface): Array<ItemResource<ItemTypeType>>;
-    processLinkedItems<ItemTypeType extends ItemType>(linkedEntries: ItemTypeMap<ItemEntry[]>, options: ItemOptionsInterface): ItemResourcesItemTypeMap<ItemResource<ItemTypeType>>;
+    createItemResource<ItemTypeType extends ItemType>(itemEntry: ItemEntry<ItemTypeType>, isRoot?: boolean, isNew?: boolean): ItemResource<ItemTypeType>;
+    createItemResources<ItemTypeType extends ItemType>(itemEntries: Array<ItemEntry<ItemTypeType>>): Array<ItemResource<ItemTypeType>>;
+    processLinkedItems<ItemTypeType extends ItemType>(linkedEntries: ItemTypeMap<ItemEntry[]>): ItemResourcesItemTypeMap<ItemResource<ItemTypeType>>;
     createCollectionResource<ItemTypeType extends ItemType>(collectionEntry: CollectionEntry<ItemTypeType>, resourceOptions: CollectionResourceOptionsInterface<ItemTypeType>): CollectionResource<ItemTypeType>;
     getChangesFromItemChanges<ItemTypeType extends ItemType = any>(changesObject: TransactionItemEntryChanges<ItemTypeType>): FieldMap<ItemTypeType>;
     private createCollectionResources;

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

@@ -1,28 +1,17 @@
-import { CollectionCacheFactory, CollectionMatcherFactory, ColumnExpansionFactory, ColumnSubsetCacheFactory, RequestColumnExpansionFactory } from '../../../factories';
-import { ChangesDeltaFactory } from '../../../factories/ChangesDeltaFactory';
-import { ApiQuery, ApiRequestColumns, ChangesDelta, CollectionEntryOptions, CollectionResource, ColumnUtil, ConversionMap, EntryParent, ExceptionHandlerInterface, ItemEntryOptions, ItemIdConversionMap, PromiseInterface } from '../../../index';
-import { ErrorHandlerInterface, PromiseLibraryInterface } from '../../../interfaces';
+import { ApiQuery, ApiRequestColumns, ChangesDelta, CollectionEntryOptions, CollectionResource, ConversionMap, ItemEntryOptions, ItemIdConversionMap, ModifyFieldsCallback, PromiseInterface, TransactionCollectionHandlerDependencyInterface, TransactionItemHandler } from '../../../index';
 import { CollectionEntry, ItemEntry } from '../../../models';
 import { ApiRequestColumn, CollectionEntryParentIdMap, CollectionResourceParentIdMap, ItemId, ItemType, QueryCallback } from '../../../types';
-import { CollectionEntryService, CollectionMatcher, ColumnHandler, KeyService, TransactionItemHandler } from '../../index';
+import { CollectionMatcher } from '../../index';
 import { CollectionHandlerBase } from '../CollectionHandlerBase';
 import { TransactionCache } from './TransactionCache';
 export declare class TransactionCollectionHandler extends CollectionHandlerBase {
-    private columnSubsetCacheFactory;
-    private columnExpansionFactory;
-    private changesDeltaFactory;
-    private collectionMatcherFactory;
-    private columnHandler;
-    private errorHandler;
+    private dependencies;
     private itemHandler;
-    private keyService;
-    private promiseService;
-    private exceptionHandler;
     protected transaction: TransactionCache;
     collectionResources: {
         [collectionEntryId: number]: CollectionResource[];
     };
-    constructor(requestColumnExpansionFactory: RequestColumnExpansionFactory, columnUtil: ColumnUtil, columnSubsetCacheFactory: ColumnSubsetCacheFactory, columnExpansionFactory: ColumnExpansionFactory, changesDeltaFactory: ChangesDeltaFactory, collectionCacheFactory: CollectionCacheFactory, collectionEntryService: CollectionEntryService, collectionMatcherFactory: CollectionMatcherFactory, columnHandler: ColumnHandler, errorHandler: ErrorHandlerInterface, itemHandler: TransactionItemHandler, keyService: KeyService, promiseService: PromiseLibraryInterface, exceptionHandler: ExceptionHandlerInterface, transaction: TransactionCache);
+    constructor(dependencies: TransactionCollectionHandlerDependencyInterface, itemHandler: TransactionItemHandler, transaction: TransactionCache);
     fetchItemEntriesByQuery<ItemTypeType extends ItemType>(itemType: ItemTypeType, query: ApiQuery, options: ItemEntryOptions): PromiseInterface<Array<ItemEntry<ItemTypeType>>>;
     getAllCollectionsByItemType<ItemTypeType extends ItemType>(itemType: ItemTypeType): Array<CollectionEntry<ItemTypeType>>;
     createCollectionEntry<ItemTypeType extends ItemType>(itemType: ItemTypeType, options: CollectionEntryOptions): CollectionEntry<ItemTypeType>;
@@ -32,7 +21,7 @@ export declare class TransactionCollectionHandler extends CollectionHandlerBase
      * Can be used to update maps that use {@link ItemEntry.itemId ItemEntry.itemId}
      *
      * @deprecated
-     * You should use itemResource.onChange and compare previous.id with fields.id
+     * You should use register a {@link TransactionCache.registerFieldChangeCallback field change callback} and compare previous.id with fields.id
      */
     onItemEntriesCreated(collectionEntry: CollectionEntry, conversionMap: ConversionMap): void;
     clearEntry(entry: CollectionEntry): void;
@@ -44,7 +33,7 @@ export declare class TransactionCollectionHandler extends CollectionHandlerBase
      */
     moveItems<CollectionEntryType extends CollectionEntry>(sourceCollectionEntry: CollectionEntryType, destinationCollectionEntry: CollectionEntryType, itemEntries: Array<ItemEntry<CollectionEntryType['itemType']>>): void;
     extendCollectionEntry<CollectionEntryType extends CollectionEntry>(collectionEntry: CollectionEntryType, queryCallback: QueryCallback): PromiseInterface<CollectionEntryType>;
-    cloneCollectionEntry<CollectionEntryType extends CollectionEntry>(sourceEntry: CollectionEntryType, parent: EntryParent, conversionMap?: ItemIdConversionMap): CollectionEntry<CollectionEntryType['itemType']>;
+    cloneCollectionEntry<CollectionEntryType extends CollectionEntry>(changesDelta: ChangesDelta, sourceEntry: CollectionEntryType, conversionMap?: ItemIdConversionMap, modifyFieldsCallback?: ModifyFieldsCallback): void;
     getCollectionMatcher(): CollectionMatcher;
     fetchCollectionEntry<ItemTypeType extends ItemType>(itemType: ItemTypeType, options: CollectionEntryOptions): PromiseInterface<CollectionEntry<ItemTypeType>>;
     fetchLinkedCollectionEntries<ItemTypeType extends ItemType>(parentType: ItemType, parentIdArray: ItemId[] | (() => ItemId[]), itemType: ItemTypeType, options: CollectionEntryOptions): PromiseInterface<CollectionEntryParentIdMap<ItemTypeType>>;

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

@@ -1,12 +1,9 @@
-import { ChangesDeltaFactory, ColumnExpansionFactory, ColumnSubsetCacheFactory, ItemCacheFactory, ItemEntryFactory, RequestColumnExpansionFactory } from '../../../factories';
-import { ErrorHandlerInterface, ExceptionHandlerInterface, PromiseLibraryInterface } from '../../../interfaces';
-import { ItemEntry, ItemEntryOptions, ItemResource } from '../../../models';
-import { ApiQuery, ApiRequestColumns, FieldMap, ItemId, ItemIdConversionMap, ItemType, ItemTypeMap, ModifyFieldsCallback, PromiseInterface, ResponseColumnItemTypeMap } from '../../../types';
-import { ChangesDelta, ChangesDeltaItemCreateDelta } from '../../ChangesDelta';
+import { TransactionItemHandlerDependencyInterface } from '../../../interfaces';
+import { ItemEntry, ItemEntryOptions } from '../../../models';
+import { ApiQuery, ApiRequestColumns, DeregFunction, FieldChangeCallback, FieldMap, ItemId, ItemIdConversionMap, ItemType, ItemTypeMap, ModifyFieldsCallback, PromiseInterface, ResponseColumnItemTypeMap } from '../../../types';
+import { ChangesDelta } from '../../ChangesDelta';
 import { ChangesDeltaBase, ChangesDeltaItemUpdateDelta, ChangesDeltaResult } from '../../ChangesDeltaBase';
-import { ApiFormatter, ColumnHandler, ColumnSubsetCache, ColumnUtil, ItemEntryService, KeyService } from '../../index';
-import { ItemCreateService } from '../../ItemCreateService';
-import { TemplateCache } from '../../TemplateCache';
+import { ChangesDeltaItemCreateDelta, ColumnSubsetCache } from '../../index';
 import { ItemHandlerBase } from '../ItemHandlerBase';
 import { TransactionCache } from './TransactionCache';
 import { TransactionValidator } from './TransactionValidator';
@@ -20,25 +17,20 @@ export declare type TransactionItemEntryChanges<ItemTypeType extends ItemType =
  * If a non-local entry is requested it should be passed on to the {@link ServerItemHandler ServerItemHandler} which will fetchCollectionEntry the entry from the server
  */
 export declare class TransactionItemHandler extends ItemHandlerBase {
-    private changesDeltaFactory;
-    private exceptionHandler;
-    private templateCache;
-    private columnExpansionFactory;
-    private columnHandler;
-    private columnSubsetCacheFactory;
-    private itemEntryService;
-    private keyService;
-    private changesDeltaService;
+    private dependencies;
     protected transaction: TransactionCache;
     private validator?;
     deletedItems: ItemTypeMap<ItemEntry[]>;
     itemChanges: {
         [itemEntryId: number]: TransactionItemEntryChanges;
     };
-    itemResources: {
-        [itemEntryId: number]: ItemResource[];
+    fieldChangeCallbacks: {
+        [itemType: string]: {
+            [itemId: string]: FieldChangeCallback[];
+        };
     };
-    constructor(changesDeltaFactory: ChangesDeltaFactory, exceptionHandler: ExceptionHandlerInterface, templateCache: TemplateCache, columnExpansionFactory: ColumnExpansionFactory, columnHandler: ColumnHandler, columnSubsetCacheFactory: ColumnSubsetCacheFactory, errorHandler: ErrorHandlerInterface, itemEntryService: ItemEntryService, keyService: KeyService, changesDeltaService: ItemCreateService, promiseService: PromiseLibraryInterface, columnUtil: ColumnUtil, apiFormatter: ApiFormatter, itemEntryFactory: ItemEntryFactory, itemCacheFactory: ItemCacheFactory, requestColumnExpansionFactory: RequestColumnExpansionFactory, transaction: TransactionCache, validator?: TransactionValidator | undefined);
+    constructor(dependencies: TransactionItemHandlerDependencyInterface, transaction: TransactionCache, validator?: TransactionValidator | undefined);
+    registerFieldChangeCallback<ItemTypeType extends ItemType>(itemType: ItemTypeType, itemId: ItemId, callback: FieldChangeCallback<ItemTypeType>): DeregFunction;
     copyTransactionItemEntryChanges(itemEntryChanges: TransactionItemEntryChanges, entry: ItemEntry): TransactionItemEntryChanges;
     createItemEntry(createTuple: ChangesDeltaItemCreateDelta): ItemEntry;
     /**
@@ -46,18 +38,6 @@ export declare class TransactionItemHandler extends ItemHandlerBase {
      * Gets the local {@link FieldMap changes} of the {@link ItemEntry entry} on the {@link TransactionCache transaction} in a formatted way the API accepts
      */
     formatRequest<ItemEntryType extends ItemEntry>(entry: ItemEntryType): FieldMap<ItemEntryType['itemType']>;
-    clearItemEntry(entry: ItemEntry): void;
-    /**
-     * @description
-     * Stores am {@link ItemResource ItemResource} on the transaction, used to call {@link ItemResource.options.onChange the onChange callback}
-     */
-    addResource(resource: ItemResource): void;
-    /**
-     * @description
-     * Removes a resource from the transaction, preventing the {@link ItemResource.options.onChange the onChange callback} from being called.
-     * You should call this function when the resource is no longer needed
-     */
-    clearResource(resource: ItemResource): void;
     detectChanges(): boolean;
     /**
      * @description
@@ -82,8 +62,8 @@ export declare class TransactionItemHandler extends ItemHandlerBase {
      * The previous changes {@link FieldMap FieldMap}
      */
     processItemEntryChanges<ItemTypeType extends ItemType = any>(itemEntryChangesTuple: ChangesDeltaItemUpdateDelta<ItemTypeType>, forceOverwrite?: boolean, updateInitial?: boolean, isCalledAfterSocketUpdate?: boolean, createItemChangesIfNoneExist?: boolean): FieldMap<ItemTypeType> | null;
-    cloneItemEntries<ItemTypeType extends ItemType>(itemEntries: Array<ItemEntry<ItemTypeType>>, conversionMap?: ItemIdConversionMap, modifyFieldsCallback?: ModifyFieldsCallback): PromiseInterface<ChangesDeltaResult>;
-    cloneItemEntry<ItemTypeType extends ItemType>(changesDelta: ChangesDelta, sourceEntry: ItemEntry<ItemTypeType>, newFields?: FieldMap<ItemTypeType>, conversionMap?: ItemIdConversionMap, modifyFieldsCallback?: ModifyFieldsCallback): ItemId;
+    cloneItemEntries<ItemTypeType extends ItemType>(changesDelta: ChangesDelta, itemEntries: Array<ItemEntry<ItemTypeType>>, conversionMap?: ItemIdConversionMap, modifyFieldsCallback?: ModifyFieldsCallback): ItemId[];
+    cloneItemEntry<ItemTypeType extends ItemType>(changesDelta: ChangesDelta, sourceEntry: ItemEntry<ItemTypeType>, conversionMap?: ItemIdConversionMap, modifyFieldsCallback?: ModifyFieldsCallback): ItemId;
     fetchItemEntriesByQuery<ItemTypeType extends ItemType>(itemType: ItemTypeType, query: ApiQuery, entryOptions: ItemEntryOptions): PromiseInterface<Array<ItemEntry<ItemTypeType>>>;
     fetchItemEntry<ItemTypeType extends ItemType>(itemType: ItemTypeType, itemId: ItemId, options: ItemEntryOptions): PromiseInterface<ItemEntry<ItemTypeType>>;
     /**