@rentman/rm-core 1.8.0 → 2.0.0

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

@@ -0,0 +1,423 @@
+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 { CollectionEditResource, CollectionEntry, CollectionResource, CollectionResourceOptionsInterface, CollectionViewResource, EditResource, ItemEntry, ItemResource, LocalViewResource, RemoteViewResource } from '../../../models';
+import { ApiQuery, CollectionDefinition, CollectionOptionsInterface, CollectionResourceParentIdMap, ConversionMap, CreateRequestParameterMap, EntryParentNull, 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, CollectionCache, ColumnCache, ItemCache, LockService, ModuleChangesCompilationResult, OnAfterCreateCallback, RequestBufferManager, TransactionCacheCallbackCondition, TransactionCacheCallbackType, TransactionCollectionHandler, TransactionItemEntryChanges, TransactionItemHandler } from '../../index';
+import { InternalChangesDelta } from '../../InternalChangesDelta';
+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';
+declare type EditResourceLinks<ItemTypeType extends ItemType> = {
+    main: EditResource<ItemTypeType>;
+    linked: ItemResourcesItemTypeMap;
+};
+/**
+ * @description
+ * The {@link TransactionCache TransactionCache} is responsible for keeping track of newly created {@link ItemEntry ItemEntries}
+ * and {@link CollectionEntry CollectionEntries}, and the changes of existing ItemEntries and CollectionEntries.
+ *
+ * The TransactionCache is also responsible for creating {@link ItemResource ItemResources}, which is a combination of an {@link ItemEntry ItemEntry} and the current transaction's changes on this ItemEntry
+ */
+export declare class TransactionCache extends AbstractCache {
+    /**
+     * @description
+     * For debugging purposes
+     */
+    id?: string | undefined;
+    /**
+     * @description
+     * Stores the 'root' {@link ItemEntry ItemEntry}, this {@link ItemEntry ItemEntry} can be used as request parent to store the whole transaction at once
+     */
+    rootItem: ItemEntry<any> | undefined;
+    /**
+     * @description
+     * Stores additional request parameters for when the transaction is stored to the server
+     */
+    tabRequestParameters: {};
+    /**
+     * @description
+     * Is true while the {@link TransactionCache TransactionCache} is applying changes to the parent (can either be through a merge or an Api save)
+     */
+    isSaving: boolean;
+    /**
+     * @description
+     * Is true when the current transaction has:
+     * - Newly created items
+     * - Removed items (from collections)
+     * - Changes on existing items
+     */
+    hasChanges: boolean;
+    /**
+     * @description
+     * The transaction's parent
+     */
+    readonly parent: AbstractCache;
+    readonly itemHandler: TransactionItemHandler;
+    readonly collectionHandler: TransactionCollectionHandler;
+    private readonly eventHandler;
+    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, parent: AbstractCache, 
+    /**
+     * @description
+     * For debugging purposes
+     */
+    id?: string | undefined);
+    destroy(): void;
+    createChangesDelta(): ChangesDelta;
+    /**
+     * @description
+     * Merges the passed changes from the parent Transaction into this Transaction's own changes and then propagates
+     * them to all child Transactions, this assumes that an action is already handled in a parent, so it does't handle created entries
+     * and removes entries that were in {@link TransactionItemHandler.deletedItems deletedItems} since they are already deleted
+     *
+     * ------------------
+     *
+     * The difference between {@link TransactionCache.applyChangesFromParent} and {@link TransactionCache.applyChangesDelta} is that applyChangesFromParent assumes
+     * the change has already been processed, and applyChangesDelta will process the changes once you save the transaction
+     *
+     * ------------------
+     * Use {@link TransactionCache.applyChangesDelta applyChangesDelta} if you want to apply changes from outside the core
+     *
+     * @param internalChangesDelta Changes to be applied
+     * @param isCalledAfterApiSave If 'isCalledAfterApiSave' is true local changes will always be overwritten (instead of only when there are no changes)
+     */
+    applyChangesFromParent(internalChangesDelta: InternalChangesDelta, isCalledAfterApiSave?: boolean): void;
+    /**
+     * @description
+     * Applies changes to this transaction and its children
+     *
+     * ------------------
+     *
+     * The difference between {@link TransactionCache.applyChangesFromParent} and {@link TransactionCache.applyChangesDelta} is that applyChangesFromParent assumes
+     * the change has already been processed, and applyChangesDelta will process the changes itself (result vs cause)
+     *
+     * ------------------
+     *
+     * Differs from {@link ServerCache.applyChangesDelta ServerCache.applyChangesDelta} in the handling of deleted entries and the applyChangesFromParent call
+     */
+    applyChangesDelta(changesDelta: ChangesDelta): PromiseInterface<ChangesDeltaResult>;
+    getServerCache(): ServerCache;
+    /**
+     * @description
+     * Gets the entry's parent from the closest transaction
+     *
+     * @param itemEntry The entry to get the parent from
+     * @param fromInitial If `true` the parent values will be read from {@link TransactionItemEntryChanges.initial initial} (Useful for when you've moved an entry)
+     */
+    getParent(itemEntry: ItemEntry, fromInitial?: boolean): EntryParentNull;
+    /**
+     * @description
+     * Traverses the transaction chain and returns the changes of the item on the first transaction
+     *
+     * @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.
+     * You should call this function when the resource is no longer needed
+     *
+     * @remark
+     * Does not remove changes
+     */
+    clearCollectionResource(resource: CollectionResource): void;
+    /**
+     * @description
+     * Returns whether or not the {@link TransactionCache.rootItem rootItem} is uses locks
+     */
+    isLockable(): boolean;
+    /**
+     * @description
+     * Disables the transaction's changes watcher, the transaction will no longer automatically detect changes on items
+     */
+    disableChangesWatcher(): void;
+    /**
+     * @description
+     * Enables the transaction's changes watcher, the transaction will now automatically detect changes on items
+     */
+    enableChangesWatcher(): void;
+    /**
+     * @description
+     * Saves the transaction, this has a different effect depending on the transaction's parent.
+     *
+     * - If the parent is another {@link TransactionCache TransactionCache} it will merge the changes of the child transaction in the the parent transaction
+     * - If the parent is the {@link ServerCache ServerCache} it will save the changes to the APi
+     */
+    save(closeTab?: boolean, parameters?: CreateRequestParameterMap, breakUpByParent?: boolean, onAfterCreateCallback?: OnAfterCreateCallback): PromiseInterface<void>;
+    detectChanges(): 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.
+     */
+    clearItem(itemResource: ItemResource<any>): void;
+    /**
+     * @description
+     * Removes an {@link ItemEntry ItemEntry} from the {@link TransactionCache TransactionCache} which means that changes on this entry will no longer be tracked.
+     */
+    clearItemEntry(itemEntry: ItemEntry<any>): void;
+    /**
+     * @description
+     * Removes a {@link CollectionEntry CollectionEntry} through a {@link CollectionResource CollectionResource} from the {@link TransactionCache TransactionCache} which means that changes on this collection will no longer be tracked.
+     */
+    clearCollection(collectionResource: CollectionResource<any>): void;
+    /**
+     * @description
+     * Adds a callback that will fire before the transaction is saved, rejecting this callback will prevent the transaction from saving
+     */
+    onBeforeSave(key: string, callback: TransactionCacheCallbackType['onBeforeSave'], condition?: TransactionCacheCallbackCondition, priority?: number): () => void;
+    /**
+     * @description
+     * Adds a callback that will fire when the transaction is saved successfully
+     */
+    onSaveSuccess(key: string, callback: TransactionCacheCallbackType['onSaveSuccess'], condition?: TransactionCacheCallbackCondition, priority?: number): () => void;
+    /**
+     * @description
+     * Returns a {@link ModuleChangesCompilationResult ModuleChangesCompilationResult} for the transaction
+     */
+    getModuleChanges(): ModuleChangesCompilationResult;
+    /**
+     * @description
+     * Updates the passed map with the new {@link ConversionMap CconversionMap} values
+     */
+    updateItemIdMap(collectionMap: {
+        [itemId: number]: any;
+    }, conversionMap: ConversionMap): void;
+    /**
+     * @description
+     * Returns the {@link TransactionCollectionHandler.entries CollectionCache} of the transaction
+     */
+    getCurrentCollectionEntryCache(): CollectionCache;
+    /**
+     * @description
+     * Returns the {@link TransactionItemHandler.entries ItemCache} of the transaction
+     */
+    getCurrentItemEntryCache(): ItemCache;
+    cloneCollection<ItemTypeType extends ItemType>(collectionResource: CollectionResource<ItemTypeType>, options: CollectionOptionsInterface<ItemTypeType> & {
+        editItems: true;
+        editCollection: true;
+    }, conversionMap: ItemIdConversionMap): CollectionEditResource<ItemTypeType, EditResource<ItemTypeType>>;
+    cloneCollection<ItemTypeType extends ItemType>(collectionResource: CollectionResource<ItemTypeType>, options: CollectionOptionsInterface<ItemTypeType> & {
+        remoteItems: true;
+        editCollection: true;
+    }, conversionMap: ItemIdConversionMap): CollectionEditResource<ItemTypeType, RemoteViewResource<ItemTypeType>>;
+    cloneCollection<ItemTypeType extends ItemType>(collectionResource: CollectionResource<ItemTypeType>, options: CollectionOptionsInterface<ItemTypeType> & {
+        editItems: true;
+    }, conversionMap: ItemIdConversionMap): CollectionViewResource<ItemTypeType, EditResource<ItemTypeType>>;
+    cloneCollection<ItemTypeType extends ItemType>(collectionResource: CollectionResource<ItemTypeType>, options: CollectionOptionsInterface<ItemTypeType> & {
+        remoteItems: true;
+    }, conversionMap: ItemIdConversionMap): CollectionViewResource<ItemTypeType, RemoteViewResource<ItemTypeType>>;
+    cloneCollection<ItemTypeType extends ItemType>(collectionResource: CollectionResource<ItemTypeType>, options: CollectionOptionsInterface<ItemTypeType> & {
+        editCollection: true;
+    }, conversionMap: ItemIdConversionMap): CollectionEditResource<ItemTypeType, LocalViewResource<ItemTypeType>>;
+    cloneCollection<ItemTypeType extends ItemType>(collectionResource: CollectionResource<ItemTypeType>, options: CollectionOptionsInterface<ItemTypeType>, conversionMap: ItemIdConversionMap): CollectionViewResource<ItemTypeType, LocalViewResource<ItemTypeType>>;
+    cloneItem<ItemTypeType extends ItemType>(itemResource: ItemResource<ItemTypeType>, options: ItemOptionsInterface & {
+        edit: true;
+    }): PromiseInterface<EditResource<ItemTypeType>>;
+    cloneItem<ItemTypeType extends ItemType>(itemResource: ItemResource<ItemTypeType>, options: ItemOptionsInterface & {
+        remote: true;
+    }): PromiseInterface<RemoteViewResource<ItemTypeType>>;
+    cloneItem<ItemTypeType extends ItemType>(itemResource: ItemResource<ItemTypeType>, options: ItemOptionsInterface): PromiseInterface<LocalViewResource<ItemTypeType>>;
+    getAllLinkCollections<ItemTypeType extends ItemType>(linkType: ItemType, itemType: ItemTypeType, options: CollectionOptionsInterface<ItemTypeType> & {
+        editItems: true;
+        editCollection: true;
+    }): PromiseInterface<CollectionResourceParentIdMap<CollectionEditResource<ItemTypeType, EditResource<ItemTypeType>>>>;
+    getAllLinkCollections<ItemTypeType extends ItemType>(linkType: ItemType, itemType: ItemTypeType, options: CollectionOptionsInterface<ItemTypeType> & {
+        remoteItems: true;
+        editCollection: true;
+    }): PromiseInterface<CollectionResourceParentIdMap<CollectionEditResource<ItemTypeType, RemoteViewResource<ItemTypeType>>>>;
+    getAllLinkCollections<ItemTypeType extends ItemType>(linkType: ItemType, itemType: ItemTypeType, options: CollectionOptionsInterface<ItemTypeType> & {
+        editCollection: true;
+    }): PromiseInterface<CollectionResourceParentIdMap<CollectionEditResource<ItemTypeType, LocalViewResource<ItemTypeType>>>>;
+    getAllLinkCollections<ItemTypeType extends ItemType>(linkType: ItemType, itemType: ItemTypeType, options: CollectionOptionsInterface<ItemTypeType> & {
+        editItems: true;
+    }): PromiseInterface<CollectionResourceParentIdMap<CollectionViewResource<ItemTypeType, EditResource<ItemTypeType>>>>;
+    getAllLinkCollections<ItemTypeType extends ItemType>(linkType: ItemType, itemType: ItemTypeType, options: CollectionOptionsInterface<ItemTypeType> & {
+        remoteItems: true;
+    }): PromiseInterface<CollectionResourceParentIdMap<CollectionViewResource<ItemTypeType, RemoteViewResource<ItemTypeType>>>>;
+    getAllLinkCollections<ItemTypeType extends ItemType>(linkType: ItemType, itemType: ItemTypeType, options: CollectionOptionsInterface<ItemTypeType>): PromiseInterface<CollectionResourceParentIdMap<CollectionViewResource<ItemTypeType, LocalViewResource<ItemTypeType>>>>;
+    getLinkCollectionsFromDef<ItemTypeType extends ItemType>(linkType: ItemType, linkIdArray: ItemId[], definition: LinkCollectionDefinition<ItemTypeType>): PromiseInterface<CollectionResourceParentIdMap<CollectionResource<ItemTypeType>>>;
+    getLinkCollections<ItemTypeType extends ItemType>(linkType: ItemType, linkIdArray: ItemId[], itemType: ItemTypeType, options: CollectionOptionsInterface<ItemTypeType> & {
+        editItems: true;
+        editCollection: true;
+    }): PromiseInterface<CollectionResourceParentIdMap<CollectionEditResource<ItemTypeType, EditResource<ItemTypeType>>>>;
+    getLinkCollections<ItemTypeType extends ItemType>(linkType: ItemType, linkIdArray: ItemId[], itemType: ItemTypeType, options: CollectionOptionsInterface<ItemTypeType> & {
+        remoteItems: true;
+        editCollection: true;
+    }): PromiseInterface<CollectionResourceParentIdMap<CollectionEditResource<ItemTypeType, RemoteViewResource<ItemTypeType>>>>;
+    getLinkCollections<ItemTypeType extends ItemType>(linkType: ItemType, linkIdArray: ItemId[], itemType: ItemTypeType, options: CollectionOptionsInterface<ItemTypeType> & {
+        editCollection: true;
+    }): PromiseInterface<CollectionResourceParentIdMap<CollectionEditResource<ItemTypeType, LocalViewResource<ItemTypeType>>>>;
+    getLinkCollections<ItemTypeType extends ItemType>(linkType: ItemType, linkIdArray: ItemId[], itemType: ItemTypeType, options: CollectionOptionsInterface<ItemTypeType> & {
+        editItems: true;
+    }): PromiseInterface<CollectionResourceParentIdMap<CollectionViewResource<ItemTypeType, EditResource<ItemTypeType>>>>;
+    getLinkCollections<ItemTypeType extends ItemType>(linkType: ItemType, linkIdArray: ItemId[], itemType: ItemTypeType, options: CollectionOptionsInterface<ItemTypeType> & {
+        remoteItems: true;
+    }): PromiseInterface<CollectionResourceParentIdMap<CollectionViewResource<ItemTypeType, RemoteViewResource<ItemTypeType>>>>;
+    getLinkCollections<ItemTypeType extends ItemType>(linkType: ItemType, linkIdArray: ItemId[], itemType: ItemTypeType, options: CollectionOptionsInterface<ItemTypeType>): PromiseInterface<CollectionResourceParentIdMap<CollectionViewResource<ItemTypeType, LocalViewResource<ItemTypeType>>>>;
+    getCollectionFromDef<ItemTypeType extends ItemType>(definition: CollectionDefinition<ItemTypeType>): PromiseInterface<CollectionResource<ItemTypeType>>;
+    getCollection<ItemTypeType extends ItemType>(itemType: ItemTypeType, options: CollectionOptionsInterface<ItemTypeType> & {
+        editCollection: true;
+        editItems: true;
+    }): PromiseInterface<CollectionEditResource<ItemTypeType, EditResource<ItemTypeType>>>;
+    getCollection<ItemTypeType extends ItemType>(itemType: ItemTypeType, options: CollectionOptionsInterface<ItemTypeType> & {
+        editItems: true;
+    }): PromiseInterface<CollectionViewResource<ItemTypeType, EditResource<ItemTypeType>>>;
+    getCollection<ItemTypeType extends ItemType>(itemType: ItemTypeType, options: CollectionOptionsInterface<ItemTypeType> & {
+        editCollection: true;
+        remoteItems: true;
+    }): PromiseInterface<CollectionEditResource<ItemTypeType, RemoteViewResource<ItemTypeType>>>;
+    getCollection<ItemTypeType extends ItemType>(itemType: ItemTypeType, options: CollectionOptionsInterface<ItemTypeType> & {
+        remoteItems: true;
+    }): PromiseInterface<CollectionViewResource<ItemTypeType, RemoteViewResource<ItemTypeType>>>;
+    getCollection<ItemTypeType extends ItemType>(itemType: ItemTypeType, options: CollectionOptionsInterface<ItemTypeType> & {
+        editCollection: true;
+    }): PromiseInterface<CollectionEditResource<ItemTypeType, LocalViewResource<ItemTypeType>>>;
+    getCollection<ItemTypeType extends ItemType>(itemType: ItemTypeType, options: CollectionOptionsInterface<ItemTypeType>): PromiseInterface<CollectionViewResource<ItemTypeType, LocalViewResource<ItemTypeType>>>;
+    getCollectionDef<ItemTypeType extends ItemType>(itemType: ItemTypeType, options: CollectionOptionsInterface<ItemTypeType>): CollectionDefinition<ItemTypeType>;
+    getLinkCollectionsDef<ItemTypeType extends ItemType>(itemType: ItemTypeType, linkField: string, options: CollectionOptionsInterface<ItemTypeType>): LinkCollectionDefinition<ItemTypeType>;
+    getItemByState<ItemTypeType extends ItemType>(itemType: ItemTypeType, stateKey: ItemId | string, options: ItemOptionsInterface & {
+        edit: true;
+    }, isRoot?: boolean): PromiseInterface<EditResource<ItemTypeType>>;
+    getItemByState<ItemTypeType extends ItemType>(itemType: ItemTypeType, stateKey: ItemId | string, options: ItemOptionsInterface & {
+        remote: true;
+    }, isRoot?: boolean): PromiseInterface<RemoteViewResource<ItemTypeType>>;
+    getItemByState<ItemTypeType extends ItemType>(itemType: ItemTypeType, stateKey: ItemId | string, options: ItemOptionsInterface, isRoot?: boolean): PromiseInterface<LocalViewResource<ItemTypeType>>;
+    getDuplicateById<ItemTypeType extends ItemType>(itemType: ItemTypeType, duplicateId: ItemId, options: ItemOptionsInterface, returnLinks: true, isRoot?: boolean): PromiseInterface<EditResourceLinks<ItemTypeType>>;
+    getDuplicateById<ItemTypeType extends ItemType>(itemType: ItemTypeType, duplicateId: ItemId, options: ItemOptionsInterface, returnLinks?: boolean, isRoot?: boolean): PromiseInterface<EditResource<ItemTypeType>>;
+    getNewResourceWithId<ItemTypeType extends ItemType>(itemType: ItemTypeType, itemId: ItemId, options: ItemOptionsInterface, returnLinks: true, isRoot?: boolean): PromiseInterface<EditResourceLinks<ItemTypeType>>;
+    getNewResourceWithId<ItemTypeType extends ItemType>(itemType: ItemTypeType, itemId: ItemId, options: ItemOptionsInterface, returnLinks?: boolean, isRoot?: boolean): PromiseInterface<EditResource<ItemTypeType>>;
+    getNewResource<ItemTypeType extends ItemType>(itemType: ItemTypeType, options: ItemOptionsInterface, returnLinks: true, isRoot?: boolean): PromiseInterface<EditResourceLinks<ItemTypeType>>;
+    getNewResource<ItemTypeType extends ItemType>(itemType: ItemTypeType, options: ItemOptionsInterface, returnLinks?: boolean, isRoot?: boolean): PromiseInterface<EditResource<ItemTypeType>>;
+    getItemsByQuery<ItemTypeType extends ItemType>(itemType: ItemTypeType, query: ApiQuery, options: ItemOptionsInterface & {
+        edit: true;
+    }): PromiseInterface<Array<EditResource<ItemTypeType>>>;
+    getItemsByQuery<ItemTypeType extends ItemType>(itemType: ItemTypeType, query: ApiQuery, options: ItemOptionsInterface & {
+        remote: true;
+    }): PromiseInterface<Array<RemoteViewResource<ItemTypeType>>>;
+    getItemsByQuery<ItemTypeType extends ItemType>(itemType: ItemTypeType, query: ApiQuery, options: ItemOptionsInterface): PromiseInterface<Array<LocalViewResource<ItemTypeType>>>;
+    getItemsById<ItemTypeType extends ItemType>(itemType: ItemTypeType, itemIds: ItemId[], options: ItemOptionsInterface & {
+        edit: true;
+    }): PromiseInterface<Array<EditResource<ItemTypeType>>>;
+    getItemsById<ItemTypeType extends ItemType>(itemType: ItemTypeType, itemIds: ItemId[], options: ItemOptionsInterface & {
+        remote: true;
+    }): PromiseInterface<Array<RemoteViewResource<ItemTypeType>>>;
+    getItemsById<ItemTypeType extends ItemType>(itemType: ItemTypeType, itemIds: ItemId[], options: ItemOptionsInterface): PromiseInterface<Array<LocalViewResource<ItemTypeType>>>;
+    getItemById<ItemTypeType extends ItemType>(itemType: ItemTypeType, itemId: ItemId, options: ItemOptionsInterface & {
+        edit: true;
+    }, isRoot?: boolean): PromiseInterface<EditResource<ItemTypeType>>;
+    getItemById<ItemTypeType extends ItemType>(itemType: ItemTypeType, itemId: ItemId, options: ItemOptionsInterface & {
+        remote: true;
+    }, isRoot?: boolean): PromiseInterface<RemoteViewResource<ItemTypeType>>;
+    getItemById<ItemTypeType extends ItemType>(itemType: ItemTypeType, itemId: ItemId, options: ItemOptionsInterface, isRoot?: boolean): PromiseInterface<LocalViewResource<ItemTypeType>>;
+    /**
+     * @description
+     * Fetches the title of an item, does not create an {@link ItemResource ItemResource}
+     */
+    fetchTitle(itemType: ItemType, itemId: ItemId): PromiseInterface<string>;
+    /**
+     * @description
+     * Merges the passed child Transaction into this transaction and then propagates them to the other child transactions
+     */
+    applyChangesFromChild(childTransaction: TransactionCache, _breakUpByParent?: boolean, _onAfterCreateCallback?: OnAfterCreateCallback): PromiseInterface<ItemIdConversionMap>;
+    /**
+     * @description
+     * Gets an already cached {@link ItemEntry ItemEntry} and the changes of this specific transaction for that entry
+     */
+    getLocalItemEntryChangesTuple(itemEntryId: ItemEntry['id']): {
+        entry: ItemEntry;
+        changes: TransactionItemEntryChanges;
+    };
+    /**
+     * @description
+     * Gets an ItemEntry from the cache, doesn't do a API request, used for saving
+     */
+    getLocalItemEntry(itemEntryId: ItemEntry['id']): ItemEntry | undefined;
+    /**
+     * @description
+     * Gets an ItemEntry from the cache by ItemId
+     */
+    getLocalItemEntryByItemId(itemType: ItemType, itemId: ItemEntry['itemId']): ItemEntry | undefined;
+    /**
+     * @description
+     * Gets an CollectionEntry from the cache, doesn't do a API request, used for saving
+     */
+    getLocalCollectionEntry(collectionEntryId: CollectionEntry['id']): CollectionEntry | undefined;
+    /**
+     * @description
+     * Returns the complete {@link InternalChangesDelta InternalChangesDelta} of the TransactionCache, this only takes into account the end result (initial is compared to changes), so changing something and reverting it
+     * won't be included
+     */
+    getDelta(): InternalChangesDelta;
+    createItemResource<ItemTypeType extends ItemType>(itemEntry: ItemEntry<ItemTypeType>, options: ItemOptionsInterface & {
+        edit: true;
+    }, isRoot?: boolean, isNew?: boolean): EditResource<ItemTypeType>;
+    createItemResource<ItemTypeType extends ItemType>(itemEntry: ItemEntry<ItemTypeType>, options: ItemOptionsInterface & {
+        remote: true;
+    }, isRoot?: boolean, isNew?: boolean): RemoteViewResource<ItemTypeType>;
+    createItemResource<ItemTypeType extends ItemType>(itemEntry: ItemEntry<ItemTypeType>, options: ItemOptionsInterface, isRoot?: boolean, isNew?: boolean): LocalViewResource<ItemTypeType>;
+    createItemResources<ItemTypeType extends ItemType>(itemEntries: Array<ItemEntry<ItemTypeType>>, options: ItemOptionsInterface & {
+        edit: true;
+    }): Array<EditResource<ItemTypeType>>;
+    createItemResources<ItemTypeType extends ItemType>(itemEntries: Array<ItemEntry<ItemTypeType>>, options: ItemOptionsInterface & {
+        remote: true;
+    }): Array<RemoteViewResource<ItemTypeType>>;
+    createItemResources<ItemTypeType extends ItemType>(itemEntries: Array<ItemEntry<ItemTypeType>>, options: ItemOptionsInterface): Array<LocalViewResource<ItemTypeType>>;
+    processLinkedItems<ItemTypeType extends ItemType>(linkedEntries: ItemTypeMap<ItemEntry[]>, options: ItemOptionsInterface & {
+        edit: true;
+    }): ItemResourcesItemTypeMap<EditResource<ItemTypeType>>;
+    processLinkedItems<ItemTypeType extends ItemType>(linkedEntries: ItemTypeMap<ItemEntry[]>, options: ItemOptionsInterface & {
+        remote: true;
+    }): ItemResourcesItemTypeMap<RemoteViewResource<ItemTypeType>>;
+    processLinkedItems<ItemTypeType extends ItemType>(linkedEntries: ItemTypeMap<ItemEntry[]>, options: ItemOptionsInterface): ItemResourcesItemTypeMap<LocalViewResource<ItemTypeType>>;
+    private createCollectionResources;
+    createCollectionResource<ItemTypeType extends ItemType>(collectionEntry: CollectionEntry<ItemTypeType>, resourceOptions: CollectionResourceOptionsInterface<ItemTypeType> & {
+        editItems: true;
+        editCollection: true;
+    }): CollectionEditResource<ItemTypeType, EditResource<ItemTypeType>>;
+    createCollectionResource<ItemTypeType extends ItemType>(collectionEntry: CollectionEntry<ItemTypeType>, resourceOptions: CollectionResourceOptionsInterface<ItemTypeType> & {
+        remoteItems: true;
+        editCollection: true;
+    }): CollectionEditResource<ItemTypeType, RemoteViewResource<ItemTypeType>>;
+    createCollectionResource<ItemTypeType extends ItemType>(collectionEntry: CollectionEntry<ItemTypeType>, resourceOptions: CollectionResourceOptionsInterface<ItemTypeType> & {
+        editCollection: true;
+    }): CollectionEditResource<ItemTypeType, LocalViewResource<ItemTypeType>>;
+    createCollectionResource<ItemTypeType extends ItemType>(collectionEntry: CollectionEntry<ItemTypeType>, resourceOptions: CollectionResourceOptionsInterface<ItemTypeType> & {
+        editItems: true;
+    }): CollectionViewResource<ItemTypeType, EditResource<ItemTypeType>>;
+    createCollectionResource<ItemTypeType extends ItemType>(collectionEntry: CollectionEntry<ItemTypeType>, resourceOptions: CollectionResourceOptionsInterface<ItemTypeType> & {
+        remoteItems: true;
+    }): CollectionViewResource<ItemTypeType, RemoteViewResource<ItemTypeType>>;
+    createCollectionResource<ItemTypeType extends ItemType>(collectionEntry: CollectionEntry<ItemTypeType>, resourceOptions: CollectionResourceOptionsInterface<ItemTypeType>): CollectionViewResource<ItemTypeType, LocalViewResource<ItemTypeType>>;
+    /**
+     * @description
+     * Returns this transaction and all parents
+     */
+    getTransactionChain(): AbstractCache[];
+    /**
+     * @description
+     * Fetches all required columns to match/fit in collections
+     */
+    private expandItemsFromDelta;
+    getChangesFromItemChanges<ItemTypeType extends ItemType = any>(changesObject: TransactionItemEntryChanges<ItemTypeType>): FieldMap<ItemTypeType>;
+}
+export {};

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

@@ -0,0 +1,72 @@
+import { CollectionCacheFactory, CollectionMatcherFactory, ColumnExpansionFactory, ColumnSubsetCacheFactory, RequestColumnExpansionFactory } from '../../../factories';
+import { ChangesDeltaFactory } from '../../../factories/ChangesDeltaFactory';
+import { ApiRequestColumns, ChangesDelta, CollectionEntryOptions, CollectionResource, ColumnUtil, ConversionMap, EntryParent, ExceptionHandlerInterface, ItemIdConversionMap, PromiseInterface } from '../../../index';
+import { ErrorHandlerInterface, PromiseLibraryInterface } from '../../../interfaces';
+import { CollectionEntry, ItemEntry } from '../../../models';
+import { ApiRequestColumn, CollectionEntryParentIdMap, CollectionResourceParentIdMap, ItemId, ItemType, QueryCallback } from '../../../types';
+import { CollectionEntryService, CollectionMatcher, ColumnHandler, KeyService, TransactionItemHandler } 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 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);
+    getAllCollectionsByItemType<ItemTypeType extends ItemType>(itemType: ItemTypeType): Array<CollectionEntry<ItemTypeType>>;
+    createCollectionEntry<ItemTypeType extends ItemType>(itemType: ItemTypeType, options: CollectionEntryOptions): CollectionEntry<ItemTypeType>;
+    /**
+     * @description
+     * Calls the {@link CollectionResourceOptions.onItemsCreated onItemsCreated} callback whenever a create request is done on {@link ItemEntry ItemEntries} that fit in the collection
+     * 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
+     */
+    onItemEntriesCreated(collectionEntry: CollectionEntry, conversionMap: ConversionMap): void;
+    clearEntry(entry: CollectionEntry): void;
+    addResource(resource: CollectionResource): void;
+    clearResource(resource: CollectionResource): void;
+    /**
+     * @description
+     * Updates the parents of the passed {@link ItemEntry ItemEntries}, returns `void` because you should use the {@link CollectionResourceOptions.onAdd onAdd} and {@link CollectionResourceOptions.onRemove onRemove} callbacks
+     */
+    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']>;
+    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>>;
+    expandCollectionEntries<ItemTypeType extends ItemType>(parentType: ItemType, itemType: ItemTypeType, collections: CollectionResourceParentIdMap, newColumns: ApiRequestColumn[]): PromiseInterface<CollectionResourceParentIdMap>;
+    extendCollectionEntries<T extends CollectionResourceParentIdMap>(parentType: ItemType, itemType: ItemType, options: CollectionEntryOptions, queryCallback: QueryCallback, collections: T): PromiseInterface<void>;
+    addItemEntriesToCollectionChanges<CollectionEntryType extends CollectionEntry>(collectionEntry: CollectionEntryType, itemEntries: Array<ItemEntry<CollectionEntryType['itemType']>>): void;
+    isLocal(options: CollectionEntryOptions): boolean;
+    expandCollectionEntry<CollectionEntryType extends CollectionEntry>(changesDelta: ChangesDelta, collectionEntry: CollectionEntryType, newColumns: ApiRequestColumns): PromiseInterface<CollectionEntryType>;
+    /**
+     * @description
+     * When {@link ItemEntry ItemEntries} are added to the changes of a {@link CollectionEntry CollectionEntry} all {@link CollectionResource CollectionResources}
+     * should get new {@link ItemResource ItemResources} for the newly added entries
+     */
+    protected handleAddedItemEntriesCallback<CollectionEntryType extends CollectionEntry>(collectionEntry: CollectionEntryType, addedEntries: Array<ItemEntry<CollectionEntryType['itemType']>>): void;
+    /**
+     * @description
+     * When {@link ItemEntry ItemEntries} are removed from the changes of a {@link CollectionEntry CollectionEntry} the {@link ItemResource ItemResources} of the ItemEntries should be removed from all {@link CollectionResource CollectionResources}
+     */
+    protected handleRemovedItemEntriesCallback<CollectionEntryType extends CollectionEntry>(collectionEntry: CollectionEntryType, removedItemEntries: Array<ItemEntry<CollectionEntryType['itemType']>>): void;
+    private fetchCollectionData;
+    /**
+     * @description
+     * Fetches {@link CollectionEntry CollectionEntries} of which the parents are local
+     */
+    private fetchLinkedLocalCollectionEntries;
+}

package/dist/src/classes/cache/transaction/TransactionEventHandler.d.ts

@@ -0,0 +1,19 @@
+import { ErrorHandlerInterface, ExceptionHandlerInterface, PromiseLibraryInterface } from '../../../interfaces';
+import { ItemIdConversionMap, PromiseInterface } from '../../../types';
+import { TransactionCache } from './TransactionCache';
+export declare type TransactionCacheCallbackCondition = 'always' | 'onClose' | 'skipOnClose';
+export declare type TransactionCacheCallbackType = {
+    onBeforeSave: (transaction: TransactionCache) => any;
+    onSaveSuccess: (transaction: TransactionCache, conversionMap: ItemIdConversionMap) => any;
+};
+export declare class TransactionEventHandler {
+    private errorHandler;
+    private exceptionHandler;
+    private promiseService;
+    private callbacks;
+    constructor(errorHandler: ErrorHandlerInterface, exceptionHandler: ExceptionHandlerInterface, promiseService: PromiseLibraryInterface);
+    registerCallback<T extends keyof TransactionCacheCallbackType>(type: T, key: string, callback: TransactionCacheCallbackType[T], condition?: TransactionCacheCallbackCondition, priority?: number): () => void;
+    executeCallbacks<T extends keyof TransactionCacheCallbackType>(type: T, execute: (callback: TransactionCacheCallbackType[T]) => any, closeTab: boolean): PromiseInterface<any>;
+    private getPriorityLevel;
+    private executeCallbacksPriorityLevel;
+}

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

@@ -0,0 +1,113 @@
+import { ChangesDeltaFactory, ColumnExpansionFactory, ColumnSetFactory, ColumnSubsetCacheFactory, ItemCacheFactory, ItemEntryFactory } from '../../../factories';
+import { ErrorHandlerInterface, ExceptionHandlerInterface, PromiseLibraryInterface } from '../../../interfaces';
+import { ItemEntry, ItemEntryOptions, ItemResource, Template } from '../../../models';
+import { ApiQuery, ApiRequestColumns, EntryParentNull, FieldMap, ItemId, ItemIdConversionMap, ItemType, ItemTypeMap, PromiseInterface, ResponseColumnItemTypeMap } from '../../../types';
+import { ChangesDelta, ChangesDeltaItemCreateDelta } from '../../ChangesDelta';
+import { ChangesDeltaBase, ChangesDeltaItemUpdateDelta, ChangesDeltaResult } from '../../ChangesDeltaBase';
+import { ApiFormatter, ColumnHandler, ColumnInfo, ColumnSubsetCache, ColumnUtil, ItemEntryService, KeyService } from '../../index';
+import { TemplateCache } from '../../TemplateCache';
+import { ItemHandlerBase } from '../ItemHandlerBase';
+import { TransactionCache } from './TransactionCache';
+export declare type TransactionItemEntryChanges<ItemTypeType extends ItemType = any> = {
+    initial: FieldMap<ItemTypeType>;
+    changes: FieldMap<ItemTypeType>;
+};
+/**
+ * @description
+ * In a {@link TransactionCache Transaction} only local items can be stored, so all entries in {@link TransactionItemHandler.entries this.entries} are local
+ * 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 columnSetFactory;
+    private columnSubsetCacheFactory;
+    private itemEntryService;
+    private keyService;
+    protected transaction: TransactionCache;
+    deletedItems: ItemTypeMap<ItemEntry[]>;
+    itemChanges: {
+        [itemEntryId: number]: TransactionItemEntryChanges;
+    };
+    itemResources: {
+        [itemEntryId: number]: ItemResource[];
+    };
+    constructor(changesDeltaFactory: ChangesDeltaFactory, exceptionHandler: ExceptionHandlerInterface, templateCache: TemplateCache, columnExpansionFactory: ColumnExpansionFactory, columnHandler: ColumnHandler, columnSetFactory: ColumnSetFactory, columnSubsetCacheFactory: ColumnSubsetCacheFactory, errorHandler: ErrorHandlerInterface, itemEntryService: ItemEntryService, keyService: KeyService, promiseService: PromiseLibraryInterface, columnUtil: ColumnUtil, apiFormatter: ApiFormatter, itemEntryFactory: ItemEntryFactory, itemCacheFactory: ItemCacheFactory, transaction: TransactionCache);
+    createItemEntry(createTuple: ChangesDeltaItemCreateDelta): ItemEntry;
+    /**
+     * @description
+     * 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']>;
+    /**
+     * @description
+     * Fetches a new {@link Template template} and creates new {@link ItemEntry itemEntries} with the passed values
+     */
+    createItems<ItemTypeType extends ItemType>(itemType: ItemTypeType, valuesArray: Array<FieldMap<ItemTypeType>>, parent: EntryParentNull): PromiseInterface<ChangesDeltaResult>;
+    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
+     * Checks if the transaction has changes for the passed {@link ItemEntry.id ItemEntryId}
+     *
+     * -----
+     * @remarks
+     * Compares every field (of the entry) in {@link TransactionItemHandler.itemChanges itemChanges} with the initial fields, because fields are copied over when creating a resource having something in itemChanges doesn't actually mean that there are changes (just that a resource has been made)
+     */
+    detectEntryChanges(itemEntryId: ItemEntry['id']): boolean;
+    /**
+     * @description
+     * Processes on a cached entry, if there are no {@link TransactionItemHandler.itemChanges itemChanges} the new values will not be processed, unless forceOverwrite is set
+     *
+     * @param itemEntryChangesTuple The changes tuple
+     * @param forceOverwrite Instead of calling {@link ApiFormatter.mergeCopyFields mergeCopyFields}, {@link ApiFormatter.copyFields copyFields} will be used (because API values are always right)
+     * @param updateInitial Should be `true` if called by applyChangesFromParent
+     *
+     * @returns
+     * The previous changes {@link FieldMap FieldMap}
+     */
+    processItemEntryChanges<ItemTypeType extends ItemType = any>(itemEntryChangesTuple: ChangesDeltaItemUpdateDelta<ItemTypeType>, forceOverwrite?: boolean, updateInitial?: boolean): FieldMap<ItemTypeType>;
+    cloneItemEntries<ItemTypeType extends ItemType>(itemEntries: Array<ItemEntry<ItemTypeType>>, conversionMap?: ItemIdConversionMap, modifyFieldsCallback?: (sourceEntry: ItemEntry<ItemTypeType>, fields: FieldMap<ItemTypeType>) => void): PromiseInterface<ChangesDeltaResult>;
+    cloneItemEntry<ItemTypeType extends ItemType>(changesDelta: ChangesDelta, sourceEntry: ItemEntry<ItemTypeType>, newFields?: FieldMap<ItemTypeType>, conversionMap?: ItemIdConversionMap, modifyFieldsCallback?: (sourceEntry: ItemEntry<ItemTypeType>, fields: FieldMap<ItemTypeType>) => void): 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>>;
+    /**
+     * @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 ItemType>(itemType: ItemTypeType, itemId: ItemId, options: ItemEntryOptions): PromiseInterface<ChangesDeltaResult>;
+    fetchItemEntries<ItemTypeType extends ItemType>(itemType: ItemTypeType, itemIds: ItemId[], options: ItemEntryOptions): PromiseInterface<Array<ItemEntry<ItemTypeType>>>;
+    fetchTitle(itemType: ItemType, itemId: ItemId): PromiseInterface<string>;
+    resolveLocalItemEntry<ItemTypeType extends ItemType>(changesDelta: ChangesDelta, itemEntry: ItemEntry<ItemTypeType>, columnSubsetCache: ColumnSubsetCache<ItemTypeType>, options: ItemEntryOptions): PromiseInterface<ItemEntry<ItemTypeType>>;
+    private getColumnDifference;
+    private resolveLocal;
+    createLocalEntries(changesDelta: ChangesDelta, parentType: ItemType, localParentId: ItemId, template: Template<ItemType>, itemIdConversion: ItemIdConversionMap, filterItemEntry?: <ItemTypeType extends ItemType>(itemType: ItemTypeType, fields: FieldMap<ItemTypeType>) => boolean, // return true to include item
+    modifyFieldsCallback?: <ItemTypeType extends ItemType>(itemType: ItemTypeType, fields: FieldMap<ItemTypeType>, itemIdConversionMap: ItemIdConversionMap) => void): void;
+    expandLocalItemEntries<ItemTypeType extends ItemType>(changesDelta: ChangesDeltaBase, itemType: ItemTypeType, itemEntries: Array<ItemEntry<ItemTypeType>>, requestColumns: ApiRequestColumns, responseColumns: ResponseColumnItemTypeMap): PromiseInterface<Array<ItemEntry<ItemTypeType>>>;
+    updateItemValues<ItemTypeType extends ItemType>(changes: FieldMap<ItemTypeType>, parent: EntryParentNull, itemColumns: Array<ColumnInfo<ItemTypeType>>, conversionMap: ItemIdConversionMap): FieldMap<ItemTypeType>;
+    /**
+     * @description
+     * Fetches the data for the passed ItemType/ItemId/columns, is able to fetchCollectionEntry non-local derived values.
+     *
+     * @remark
+     * Assumes the the ItemEntry with the given ItemType-ItemId is already cached
+     */
+    fetchLocalItemEntryData<ItemTypeType extends ItemType>(changesDelta: ChangesDelta, itemType: ItemTypeType, itemId: ItemId, columnSubsetCache: ColumnSubsetCache<ItemTypeType>, options: ItemEntryOptions): PromiseInterface<any>;
+    fetchLocalItemEntries<ItemTypeType extends ItemType>(itemType: ItemTypeType, itemIds: ItemId[], options: ItemEntryOptions): PromiseInterface<Array<ItemEntry<ItemTypeType>>>;
+    private expandLocalItemEntry;
+    private getLocalValues;
+}