@rentman/rm-core 8.0.0 → 8.0.1-2

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

@@ -1,23 +1,23 @@
-import { ApiEnumItemType, ItemId } from '@rentman/backend-types';
-import { ApiQuery, ApiRequestColumns, CollectionQuery, ColumnSubsetCache, ItemEntryOptions, ParentIdMap, PromiseInterface, TransactionCollectionHandlerDependencyInterface, TransactionItemHandler } from '../../../index';
-import { ItemEntry } from '../../../models';
-import { CollectionOptions } from '../../../models/CollectionOptions';
-import { CachedQueryHandlerBase, CachedQueryItem } from '../CachedQueryHandlerBase';
-import { TransactionCache } from './TransactionCache';
-export declare class TransactionCachedQueryHandler extends CachedQueryHandlerBase {
-    private dependencies;
-    private itemHandler;
-    protected transaction: TransactionCache;
-    constructor(dependencies: TransactionCollectionHandlerDependencyInterface, itemHandler: TransactionItemHandler, transaction: TransactionCache);
-    __fetchCachedQueryItem<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, options: CollectionOptions): PromiseInterface<CachedQueryItem<ItemTypeType>>;
-    __expandCachedQuery<ItemTypeType extends ApiEnumItemType>(cachedQuery: CachedQueryItem<ItemTypeType>, newColumns: ApiRequestColumns, force?: boolean): PromiseInterface<CachedQueryItem<ItemTypeType>>;
-    __addItemEntriesToCachedQueries<ItemTypeType extends ApiEnumItemType = any>(itemType: ItemTypeType, parsedQuery: CollectionQuery, itemEntries: Array<ItemEntry<ItemTypeType>>): void;
-    /**
-     * @remark
-     * todo not only linkedTo should be checked, but it should check if there's a local ID anywhere in the query
-     * ({<field>: <localId>}) is also a local query
-     */
-    isLocal(options: CollectionOptions | ItemEntryOptions, query: ApiQuery): boolean;
-    __fetchItemEntriesByQueryData<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, options: CollectionOptions<ItemTypeType>, columnSubsetCache: ColumnSubsetCache<ItemTypeType>, collectionQuery: CollectionQuery): PromiseInterface<CachedQueryItem<ItemTypeType>>;
-    __fetchLinkedCachedQueryItems<ItemTypeType extends ApiEnumItemType>(parentType: ApiEnumItemType, parentIdArray: ItemId[] | (() => ItemId[]), itemType: ItemTypeType, options: CollectionOptions): PromiseInterface<ParentIdMap<CachedQueryItem<ItemTypeType>>>;
-}
+import { ApiEnumItemType, ItemId } from '@rentman/backend-types';
+import { ApiQuery, ApiRequestColumns, CollectionQuery, ColumnSubsetCache, ItemEntryOptions, ParentIdMap, PromiseInterface, TransactionCollectionHandlerDependencyInterface, TransactionItemHandler } from '../../../index';
+import { ItemEntry } from '../../../models';
+import { CollectionOptions } from '../../../models/CollectionOptions';
+import { CachedQueryHandlerBase, CachedQueryItem } from '../CachedQueryHandlerBase';
+import { TransactionCache } from './TransactionCache';
+export declare class TransactionCachedQueryHandler extends CachedQueryHandlerBase {
+    private dependencies;
+    private itemHandler;
+    protected transaction: TransactionCache;
+    constructor(dependencies: TransactionCollectionHandlerDependencyInterface, itemHandler: TransactionItemHandler, transaction: TransactionCache);
+    __fetchCachedQueryItem<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, options: CollectionOptions): PromiseInterface<CachedQueryItem<ItemTypeType>>;
+    __expandCachedQuery<ItemTypeType extends ApiEnumItemType>(cachedQuery: CachedQueryItem<ItemTypeType>, newColumns: ApiRequestColumns, force?: boolean): PromiseInterface<CachedQueryItem<ItemTypeType>>;
+    __addItemEntriesToCachedQueries<ItemTypeType extends ApiEnumItemType = any>(itemType: ItemTypeType, parsedQuery: CollectionQuery, itemEntries: Array<ItemEntry<ItemTypeType>>): void;
+    /**
+     * @remark
+     * todo not only linkedTo should be checked, but it should check if there's a local ID anywhere in the query
+     * ({<field>: <localId>}) is also a local query
+     */
+    isLocal(options: CollectionOptions | ItemEntryOptions, query: ApiQuery): boolean;
+    __fetchItemEntriesByQueryData<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, options: CollectionOptions<ItemTypeType>, columnSubsetCache: ColumnSubsetCache<ItemTypeType>, collectionQuery: CollectionQuery): PromiseInterface<CachedQueryItem<ItemTypeType>>;
+    __fetchLinkedCachedQueryItems<ItemTypeType extends ApiEnumItemType>(parentType: ApiEnumItemType, parentIdArray: ItemId[] | (() => ItemId[]), itemType: ItemTypeType, options: CollectionOptions): PromiseInterface<ParentIdMap<CachedQueryItem<ItemTypeType>>>;
+}

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

@@ -1,29 +1,29 @@
-import { ApiEnumItemType } from '@rentman/backend-types';
-import { TransactionCollectionHandlerDependencyInterface } from '../../../interfaces/TransactionCollectionHandlerDependencyInterface';
-import { CollectionEntry, CollectionResource, ItemEntry } from '../../../models';
-import { ApiRequestColumns, ItemIdConversionMap, ModifyFieldsCallback, PromiseInterface } from '../../../types';
-import { ChangesDelta } from '../../ChangesDelta';
-import { TransactionCache } from './TransactionCache';
-import { TransactionCachedQueryHandler } from './TransactionCachedQueryHandler';
-import { TransactionItemHandler } from './TransactionItemHandler';
-export declare class TransactionCollectionHandler {
-    protected itemHandler: TransactionItemHandler;
-    protected cachedQueryHandler: TransactionCachedQueryHandler;
-    private dependencies;
-    private transaction;
-    collectionResources: {
-        [itemType: string]: {
-            [queryString: string]: CollectionResource[];
-        };
-    };
-    constructor(itemHandler: TransactionItemHandler, cachedQueryHandler: TransactionCachedQueryHandler, dependencies: TransactionCollectionHandlerDependencyInterface, transaction: TransactionCache);
-    expandCollectionResource<ItemTypeType extends ApiEnumItemType = any>(collectionResource: CollectionResource<ItemTypeType>, newColumns: ApiRequestColumns): PromiseInterface<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;
-    cloneCollectionEntry<CollectionEntryType extends CollectionEntry>(changesDelta: ChangesDelta, sourceEntry: CollectionEntryType, conversionMap?: ItemIdConversionMap, modifyFieldsCallback?: ModifyFieldsCallback): void;
-}
+import { ApiEnumItemType } from '@rentman/backend-types';
+import { TransactionCollectionHandlerDependencyInterface } from '../../../interfaces/TransactionCollectionHandlerDependencyInterface';
+import { CollectionEntry, CollectionResource, ItemEntry } from '../../../models';
+import { ApiRequestColumns, ItemIdConversionMap, ModifyFieldsCallback, PromiseInterface } from '../../../types';
+import { ChangesDelta } from '../../ChangesDelta';
+import { TransactionCache } from './TransactionCache';
+import { TransactionCachedQueryHandler } from './TransactionCachedQueryHandler';
+import { TransactionItemHandler } from './TransactionItemHandler';
+export declare class TransactionCollectionHandler {
+    protected itemHandler: TransactionItemHandler;
+    protected cachedQueryHandler: TransactionCachedQueryHandler;
+    private dependencies;
+    private transaction;
+    collectionResources: {
+        [itemType: string]: {
+            [queryString: string]: CollectionResource[];
+        };
+    };
+    constructor(itemHandler: TransactionItemHandler, cachedQueryHandler: TransactionCachedQueryHandler, dependencies: TransactionCollectionHandlerDependencyInterface, transaction: TransactionCache);
+    expandCollectionResource<ItemTypeType extends ApiEnumItemType = any>(collectionResource: CollectionResource<ItemTypeType>, newColumns: ApiRequestColumns): PromiseInterface<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;
+    cloneCollectionEntry<CollectionEntryType extends CollectionEntry>(changesDelta: ChangesDelta, sourceEntry: CollectionEntryType, conversionMap?: ItemIdConversionMap, modifyFieldsCallback?: ModifyFieldsCallback): void;
+}

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

@@ -1,24 +1,24 @@
-import { ErrorHandlerInterface, ExceptionHandlerInterface, PromiseLibraryInterface } from '../../../interfaces';
-import { ItemEntry } from '../../../models';
-import { ItemIdConversionMap, PromiseInterface } from '../../../types';
-import { TransactionCache, TransactionErrorLevel } from './TransactionCache';
-export declare type TransactionCacheCallbackCondition = 'always' | 'onClose' | 'skipOnClose';
-export declare type TransactionCacheCallbackType = {
-    onBeforeSave: (transaction: TransactionCache) => any;
-    onSaveSuccess: (transaction: TransactionCache, conversionMap: ItemIdConversionMap) => any;
-    onSetItemError: (itemEntryId: ItemEntry['id'], columnId: string, key: string) => void;
-    onClearItemError: (itemEntryId: ItemEntry['id'], columnId: string, key: string) => void;
-    onSetGlobalError: (key: string, level: TransactionErrorLevel) => void;
-    onClearGlobalError: (key: string) => void;
-};
-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;
-}
+import { ErrorHandlerInterface, ExceptionHandlerInterface, PromiseLibraryInterface } from '../../../interfaces';
+import { ItemEntry } from '../../../models';
+import { ItemIdConversionMap, PromiseInterface } from '../../../types';
+import { TransactionCache, TransactionErrorLevel } from './TransactionCache';
+export declare type TransactionCacheCallbackCondition = 'always' | 'onClose' | 'skipOnClose';
+export declare type TransactionCacheCallbackType = {
+    onBeforeSave: (transaction: TransactionCache) => any;
+    onSaveSuccess: (transaction: TransactionCache, conversionMap: ItemIdConversionMap) => any;
+    onSetItemError: (itemEntryId: ItemEntry['id'], columnId: string, key: string) => void;
+    onClearItemError: (itemEntryId: ItemEntry['id'], columnId: string, key: string) => void;
+    onSetGlobalError: (key: string, level: TransactionErrorLevel) => void;
+    onClearGlobalError: (key: string) => void;
+};
+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/types/classes/cache/transaction/TransactionItemHandler.d.ts

@@ -1,94 +1,94 @@
-import { ApiEnumItemType, ItemId } from '@rentman/backend-types';
-import { TransactionItemHandlerDependencyInterface } from '../../../interfaces';
-import { ItemEntry, ItemEntryOptions } from '../../../models';
-import { ApiQuery, ApiRequestColumns, DeregFunction, FieldChangeCallback, FieldMap, ItemIdConversionMap, ItemTypeMap, ModifyFieldsCallback, PromiseInterface, ResponseColumnItemTypeMap } from '../../../types';
-import { ChangesDelta } from '../../ChangesDelta';
-import { ChangesDeltaBase, ChangesDeltaItemUpdateDelta, ChangesDeltaResult } from '../../ChangesDeltaBase';
-import { ChangesDeltaItemCreateDelta, ColumnSubsetCache } from '../../index';
-import { ItemHandlerBase, ProcessItemEntryChangesResult } from '../ItemHandlerBase';
-import { TransactionCache } from './TransactionCache';
-import { TransactionValidator } from './TransactionValidator';
-export declare type TransactionItemEntryChanges<Fields extends FieldMap = FieldMap> = {
-    initial: Fields;
-    changes: Fields;
-};
-/**
- * @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 __fetchCachedQueryItem the entry from the server
- */
-export declare class TransactionItemHandler extends ItemHandlerBase {
-    private dependencies;
-    protected transaction: TransactionCache;
-    private validator?;
-    deletedItems: ItemTypeMap<ItemEntry[]>;
-    itemChanges: {
-        [itemEntryId: number]: TransactionItemEntryChanges;
-    };
-    fieldChangeCallbacks: {
-        [itemType: string]: {
-            [itemId: string]: FieldChangeCallback[];
-        };
-    };
-    constructor(dependencies: TransactionItemHandlerDependencyInterface, transaction: TransactionCache, validator?: TransactionValidator | undefined);
-    registerFieldChangeCallback<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, itemId: ItemId, callback: FieldChangeCallback<ItemTypeType>): DeregFunction;
-    copyTransactionItemEntryChanges(itemEntryChanges: TransactionItemEntryChanges, entry: ItemEntry): TransactionItemEntryChanges;
-    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): {
-        [columnId: string]: any;
-    };
-    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
-     * @param isCalledAfterSocketUpdate Indicates that the change is done by a different user
-     * @param createItemChangesIfNoneExist Is `true` when called from `applyChangesDelta`, we can assume that when you call `applyChangesDelta` with updates that aren't on the transaction yet you want to add those
-     *
-     * @returns
-     * The previous changes {@link FieldMap FieldMap}, returns `null` when the item was not cached or no fields were changed.
-     */
-    processItemEntryChanges<ItemTypeType extends ApiEnumItemType = any>(itemEntryChangesTuple: ChangesDeltaItemUpdateDelta<ItemTypeType>, forceOverwrite?: boolean, updateInitial?: boolean, isCalledAfterSocketUpdate?: boolean, createItemChangesIfNoneExist?: boolean): ProcessItemEntryChangesResult<ItemTypeType>;
-    cloneItemEntries<ItemTypeType extends ApiEnumItemType>(changesDelta: ChangesDelta, itemEntries: Array<ItemEntry<ItemTypeType>>, conversionMap?: ItemIdConversionMap, modifyFieldsCallback?: ModifyFieldsCallback): ItemId[];
-    cloneItemEntry<ItemTypeType extends ApiEnumItemType>(changesDelta: ChangesDelta, sourceEntry: ItemEntry<ItemTypeType>, conversionMap?: ItemIdConversionMap, modifyFieldsCallback?: ModifyFieldsCallback): ItemId;
-    fetchItemEntriesByQuery<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, query: ApiQuery, entryOptions: ItemEntryOptions): PromiseInterface<Array<ItemEntry<ItemTypeType>>>;
-    fetchItemEntry<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, itemId: ItemId, options: ItemEntryOptions): PromiseInterface<ItemEntry<ItemTypeType>>;
-    /**
-     * @description
-     * Fetches a template and creates a new {@link ItemEntry ItemEntry}, will error if the ItemEntry with the given ItemId already exists
-     */
-    fetchNewItemEntry<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, itemId: ItemId, options: ItemEntryOptions): PromiseInterface<ChangesDeltaResult>;
-    fetchItemEntries<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, itemIds: ItemId[], options: ItemEntryOptions): PromiseInterface<Array<ItemEntry<ItemTypeType>>>;
-    fetchTitle(itemType: ApiEnumItemType, itemId: ItemId): PromiseInterface<string>;
-    resolveLocalItemEntry<ItemTypeType extends ApiEnumItemType>(changesDelta: ChangesDelta, itemEntry: ItemEntry<ItemTypeType>, columnSubsetCache: ColumnSubsetCache<ItemTypeType>, options: ItemEntryOptions): PromiseInterface<ItemEntry<ItemTypeType>>;
-    expandLocalItemEntries<ItemTypeType extends ApiEnumItemType>(changesDelta: ChangesDeltaBase, itemType: ItemTypeType, itemEntries: Array<ItemEntry<ItemTypeType>>, requestColumns: ApiRequestColumns, responseColumns: ResponseColumnItemTypeMap): PromiseInterface<Array<ItemEntry<ItemTypeType>>>;
-    /**
-     * @description
-     * Fetches the data for the passed ItemType/ItemId/columns, is able to __fetchCachedQueryItem non-local derived values.
-     *
-     * @remark
-     * Assumes the the ItemEntry with the given ItemType-ItemId is already cached
-     */
-    fetchLocalItemEntryData<ItemTypeType extends ApiEnumItemType>(changesDelta: ChangesDelta, itemType: ItemTypeType, itemId: ItemId, columnSubsetCache: ColumnSubsetCache<ItemTypeType>, options: ItemEntryOptions): PromiseInterface<any>;
-    fetchLocalItemEntries<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, itemIds: ItemId[], options: ItemEntryOptions): PromiseInterface<Array<ItemEntry<ItemTypeType>>>;
-    private getColumnDifference;
-    private expandLocalItemEntry;
-    private getLocalValues;
-    private updateLocalItemIdReferences;
-}
+import { ApiEnumItemType, ItemId } from '@rentman/backend-types';
+import { TransactionItemHandlerDependencyInterface } from '../../../interfaces';
+import { ItemEntry, ItemEntryOptions } from '../../../models';
+import { ApiQuery, ApiRequestColumns, DeregFunction, FieldChangeCallback, FieldMap, ItemIdConversionMap, ItemTypeMap, ModifyFieldsCallback, PromiseInterface, ResponseColumnItemTypeMap } from '../../../types';
+import { ChangesDelta } from '../../ChangesDelta';
+import { ChangesDeltaBase, ChangesDeltaItemUpdateDelta, ChangesDeltaResult } from '../../ChangesDeltaBase';
+import { ChangesDeltaItemCreateDelta, ColumnSubsetCache } from '../../index';
+import { ItemHandlerBase, ProcessItemEntryChangesResult } from '../ItemHandlerBase';
+import { TransactionCache } from './TransactionCache';
+import { TransactionValidator } from './TransactionValidator';
+export declare type TransactionItemEntryChanges<Fields extends FieldMap = FieldMap> = {
+    initial: Fields;
+    changes: Fields;
+};
+/**
+ * @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 __fetchCachedQueryItem the entry from the server
+ */
+export declare class TransactionItemHandler extends ItemHandlerBase {
+    private dependencies;
+    protected transaction: TransactionCache;
+    private validator?;
+    deletedItems: ItemTypeMap<ItemEntry[]>;
+    itemChanges: {
+        [itemEntryId: number]: TransactionItemEntryChanges;
+    };
+    fieldChangeCallbacks: {
+        [itemType: string]: {
+            [itemId: string]: FieldChangeCallback[];
+        };
+    };
+    constructor(dependencies: TransactionItemHandlerDependencyInterface, transaction: TransactionCache, validator?: TransactionValidator | undefined);
+    registerFieldChangeCallback<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, itemId: ItemId, callback: FieldChangeCallback<ItemTypeType>): DeregFunction;
+    copyTransactionItemEntryChanges(itemEntryChanges: TransactionItemEntryChanges, entry: ItemEntry): TransactionItemEntryChanges;
+    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): {
+        [columnId: string]: any;
+    };
+    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
+     * @param isCalledAfterSocketUpdate Indicates that the change is done by a different user
+     * @param createItemChangesIfNoneExist Is `true` when called from `applyChangesDelta`, we can assume that when you call `applyChangesDelta` with updates that aren't on the transaction yet you want to add those
+     *
+     * @returns
+     * The previous changes {@link FieldMap FieldMap}, returns `null` when the item was not cached or no fields were changed.
+     */
+    processItemEntryChanges<ItemTypeType extends ApiEnumItemType = any>(itemEntryChangesTuple: ChangesDeltaItemUpdateDelta<ItemTypeType>, forceOverwrite?: boolean, updateInitial?: boolean, isCalledAfterSocketUpdate?: boolean, createItemChangesIfNoneExist?: boolean): ProcessItemEntryChangesResult<ItemTypeType>;
+    cloneItemEntries<ItemTypeType extends ApiEnumItemType>(changesDelta: ChangesDelta, itemEntries: Array<ItemEntry<ItemTypeType>>, conversionMap?: ItemIdConversionMap, modifyFieldsCallback?: ModifyFieldsCallback): ItemId[];
+    cloneItemEntry<ItemTypeType extends ApiEnumItemType>(changesDelta: ChangesDelta, sourceEntry: ItemEntry<ItemTypeType>, conversionMap?: ItemIdConversionMap, modifyFieldsCallback?: ModifyFieldsCallback): ItemId;
+    fetchItemEntriesByQuery<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, query: ApiQuery, entryOptions: ItemEntryOptions): PromiseInterface<Array<ItemEntry<ItemTypeType>>>;
+    fetchItemEntry<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, itemId: ItemId, options: ItemEntryOptions): PromiseInterface<ItemEntry<ItemTypeType>>;
+    /**
+     * @description
+     * Fetches a template and creates a new {@link ItemEntry ItemEntry}, will error if the ItemEntry with the given ItemId already exists
+     */
+    fetchNewItemEntry<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, itemId: ItemId, options: ItemEntryOptions): PromiseInterface<ChangesDeltaResult>;
+    fetchItemEntries<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, itemIds: ItemId[], options: ItemEntryOptions): PromiseInterface<Array<ItemEntry<ItemTypeType>>>;
+    fetchTitle(itemType: ApiEnumItemType, itemId: ItemId): PromiseInterface<string>;
+    resolveLocalItemEntry<ItemTypeType extends ApiEnumItemType>(changesDelta: ChangesDelta, itemEntry: ItemEntry<ItemTypeType>, columnSubsetCache: ColumnSubsetCache<ItemTypeType>, options: ItemEntryOptions): PromiseInterface<ItemEntry<ItemTypeType>>;
+    expandLocalItemEntries<ItemTypeType extends ApiEnumItemType>(changesDelta: ChangesDeltaBase, itemType: ItemTypeType, itemEntries: Array<ItemEntry<ItemTypeType>>, requestColumns: ApiRequestColumns, responseColumns: ResponseColumnItemTypeMap): PromiseInterface<Array<ItemEntry<ItemTypeType>>>;
+    /**
+     * @description
+     * Fetches the data for the passed ItemType/ItemId/columns, is able to __fetchCachedQueryItem non-local derived values.
+     *
+     * @remark
+     * Assumes the the ItemEntry with the given ItemType-ItemId is already cached
+     */
+    fetchLocalItemEntryData<ItemTypeType extends ApiEnumItemType>(changesDelta: ChangesDelta, itemType: ItemTypeType, itemId: ItemId, columnSubsetCache: ColumnSubsetCache<ItemTypeType>, options: ItemEntryOptions): PromiseInterface<any>;
+    fetchLocalItemEntries<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, itemIds: ItemId[], options: ItemEntryOptions): PromiseInterface<Array<ItemEntry<ItemTypeType>>>;
+    private getColumnDifference;
+    private expandLocalItemEntry;
+    private getLocalValues;
+    private updateLocalItemIdReferences;
+}

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

@@ -1,35 +1,35 @@
-import { ApiEnumItemType } from '@rentman/backend-types';
-import { ItemEntry } from '../../../models/index';
-import { FieldMap, PromiseInterface } from '../../../types/index';
-import { TransactionCache, TransactionErrorLevel } from './TransactionCache';
-export interface TransactionValidatorFactory {
-    construct(transaction: TransactionCache): TransactionValidator;
-}
-export declare abstract class TransactionValidator {
-    protected transaction: TransactionCache;
-    private lastCallIdMap;
-    private _lastCallId;
-    protected constructor(transaction: TransactionCache);
-    /**
-     * @description
-     * Will return `true` if there are any validators pending
-     */
-    isPending(): boolean;
-    /**
-     * @description
-     * Will be called after {@link TransactionCache.applyChangesFromParent applyChangesFromParent}, {@link TransactionCache.applyChangesFromChild applyChangesFromChild} or {@link TransactionCache.applyChangesDelta applyChangesDelta} is called
-     * Allows you to set {@link TransactionCache.errors global errors}
-     */
-    abstract validateTransaction(): void;
-    /**
-     * @description
-     * Will be called whenever an item is changed, allows you to set errors on the transaction
-     * @param itemEntry
-     * @param fields
-     * @param previous
-     */
-    abstract validateItem<ItemTypeType extends ApiEnumItemType>(itemEntry: ItemEntry<ItemTypeType>, fields: FieldMap<ItemTypeType>, previous: FieldMap<ItemTypeType>): void;
-    protected setGlobalError(key: string, isInvalid: boolean | PromiseInterface<boolean>, saveButtonErrorTranslationFn: () => string, level: TransactionErrorLevel): void;
-    protected setItemError(itemEntryId: ItemEntry['id'], columnId: string, errorKey: string, isInvalid: boolean | PromiseInterface<boolean>, fieldErrorTranslationFn: () => string, saveButtonErrorTranslationFn: () => string, level: TransactionErrorLevel): void;
-    private getHash;
-}
+import { ApiEnumItemType } from '@rentman/backend-types';
+import { ItemEntry } from '../../../models/index';
+import { FieldMap, PromiseInterface } from '../../../types/index';
+import { TransactionCache, TransactionErrorLevel } from './TransactionCache';
+export interface TransactionValidatorFactory {
+    construct(transaction: TransactionCache): TransactionValidator;
+}
+export declare abstract class TransactionValidator {
+    protected transaction: TransactionCache;
+    private lastCallIdMap;
+    private _lastCallId;
+    protected constructor(transaction: TransactionCache);
+    /**
+     * @description
+     * Will return `true` if there are any validators pending
+     */
+    isPending(): boolean;
+    /**
+     * @description
+     * Will be called after {@link TransactionCache.applyChangesFromParent applyChangesFromParent}, {@link TransactionCache.applyChangesFromChild applyChangesFromChild} or {@link TransactionCache.applyChangesDelta applyChangesDelta} is called
+     * Allows you to set {@link TransactionCache.errors global errors}
+     */
+    abstract validateTransaction(): void;
+    /**
+     * @description
+     * Will be called whenever an item is changed, allows you to set errors on the transaction
+     * @param itemEntry
+     * @param fields
+     * @param previous
+     */
+    abstract validateItem<ItemTypeType extends ApiEnumItemType>(itemEntry: ItemEntry<ItemTypeType>, fields: FieldMap<ItemTypeType>, previous: FieldMap<ItemTypeType>): void;
+    protected setGlobalError(key: string, isInvalid: boolean | PromiseInterface<boolean>, saveButtonErrorTranslationFn: () => string, level: TransactionErrorLevel): void;
+    protected setItemError(itemEntryId: ItemEntry['id'], columnId: string, errorKey: string, isInvalid: boolean | PromiseInterface<boolean>, fieldErrorTranslationFn: () => string, saveButtonErrorTranslationFn: () => string, level: TransactionErrorLevel): void;
+    private getHash;
+}

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

@@ -1,46 +1,46 @@
-export * from './ApiFormatter';
-export * from './ApiRequestService';
-export * from './ApiResponseProcessor';
-export * from './ChangesCompilation';
-export * from './ChangesProcessor';
-export * from './CollectionEntryService';
-export * from './CollectionMatcherCachedCollectionProcessor';
-export * from './CollectionResourceService';
-export * from './ColumnCache';
-export * from './ColumnExpansion';
-export * from './ColumnHandler';
-export * from './ColumnInfo';
-export * from './ColumnSet';
-export * from './ColumnSubsetCache';
-export * from './ColumnUtil';
-export * from './ConversionMapService';
-export * from './CreateRequest';
-export * from './ItemCache';
-export * from './ItemEntryService';
-export * from './KeyService';
-export * from './cache/transaction/TransactionEventHandler';
-export * from './LockService';
-export * from './ModuleChangesCompilation';
-export * from './QueryMatcher';
-export * from './QueryParser';
-export * from './QueryService';
-export * from './RequestColumnExpansion';
-export * from './SocketMessageHandler';
-export * from './Util';
-export * from './cache/AbstractCache';
-export * from './cache/server/ServerCache';
-export * from './cache/server/ServerItemHandler';
-export * from './cache/server/ServerCachedQueryHandler';
-export * from './cache/transaction/TransactionCache';
-export * from './cache/transaction/TransactionItemHandler';
-export * from './cache/transaction/TransactionCachedQueryHandler';
-export * from './cache/transaction/TransactionCollectionHandler';
-export * from './cache/transaction/TransactionEventHandler';
-export * from './cache/transaction/TransactionValidator';
-export * from './ChangesDeltaBase';
-export * from './ChangesDelta';
-export * from './InternalChangesDelta';
-export * from './RequestBufferManager';
-export * from './RequestBuffer';
-export * from './ItemCreateService';
-export * from './CreatedChangesDelta';
+export * from './ApiFormatter';
+export * from './ApiRequestService';
+export * from './ApiResponseProcessor';
+export * from './ChangesCompilation';
+export * from './ChangesProcessor';
+export * from './CollectionEntryService';
+export * from './CollectionMatcherCachedCollectionProcessor';
+export * from './CollectionResourceService';
+export * from './ColumnCache';
+export * from './ColumnExpansion';
+export * from './ColumnHandler';
+export * from './ColumnInfo';
+export * from './ColumnSet';
+export * from './ColumnSubsetCache';
+export * from './ColumnUtil';
+export * from './ConversionMapService';
+export * from './CreateRequest';
+export * from './ItemCache';
+export * from './ItemEntryService';
+export * from './KeyService';
+export * from './cache/transaction/TransactionEventHandler';
+export * from './LockService';
+export * from './ModuleChangesCompilation';
+export * from './QueryMatcher';
+export * from './QueryParser';
+export * from './QueryService';
+export * from './RequestColumnExpansion';
+export * from './SocketMessageHandler';
+export * from './Util';
+export * from './cache/AbstractCache';
+export * from './cache/server/ServerCache';
+export * from './cache/server/ServerItemHandler';
+export * from './cache/server/ServerCachedQueryHandler';
+export * from './cache/transaction/TransactionCache';
+export * from './cache/transaction/TransactionItemHandler';
+export * from './cache/transaction/TransactionCachedQueryHandler';
+export * from './cache/transaction/TransactionCollectionHandler';
+export * from './cache/transaction/TransactionEventHandler';
+export * from './cache/transaction/TransactionValidator';
+export * from './ChangesDeltaBase';
+export * from './ChangesDelta';
+export * from './InternalChangesDelta';
+export * from './RequestBufferManager';
+export * from './RequestBuffer';
+export * from './ItemCreateService';
+export * from './CreatedChangesDelta';

package/dist/types/constants.d.ts

@@ -1,7 +1,7 @@
-export declare const ALL_PERMISSIONS = 7;
-export declare const COLUMN_SEPERATOR = ">";
-export declare const RENDER_AS_SEPERATOR = ":";
-export declare const NEW_PREFIX: string;
-export declare const DUPLICATE_PREFIX: string;
-export declare const NEW_KEYWORD: string;
-export declare const DUPLICATE_KEYWORD: string;
+export declare const ALL_PERMISSIONS = 7;
+export declare const COLUMN_SEPERATOR = ">";
+export declare const RENDER_AS_SEPERATOR = ":";
+export declare const NEW_PREFIX: string;
+export declare const DUPLICATE_PREFIX: string;
+export declare const NEW_KEYWORD: string;
+export declare const DUPLICATE_KEYWORD: string;