@rentman/rm-core 8.2.0 → 8.2.2

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

@@ -1,31 +1,31 @@
-import { ApiEnumItemType, ItemId } from '@rentman/backend-types';
-import { ApiQuery, ApiRequestColumns, CachedQueryHandlerBase, CachedQueryItem, CachedQueryItemTree, ChildCollectionOptions, CollectionOptions, CollectionQuery, ColumnSubsetCache, ItemEntry, ItemEntryOptions, ItemIdConversionMap, ParentIdMap, ParentItemMap, PromiseInterface, TransactionCache, TransactionCollectionHandlerDependencyInterface, TransactionItemHandler } from '../../../internal';
-export declare class TransactionCachedQueryHandler extends CachedQueryHandlerBase {
-    private dependencies;
-    private itemHandler;
-    protected transaction: TransactionCache;
-    constructor(dependencies: TransactionCollectionHandlerDependencyInterface, itemHandler: TransactionItemHandler, transaction: TransactionCache);
-    /**
-     * @description
-     * Updates all cached queries which references one of the updated IDs in the conversionMap
-     *
-     * @param conversionMap ConversionMap with the updated IDs
-     */
-    updateLocalItemIdReferences(conversionMap: ItemIdConversionMap): void;
-    __fetchCachedQueryItem<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, options: CollectionOptions): PromiseInterface<CachedQueryItem<ItemTypeType>>;
-    __expandCachedQuery<ItemTypeType extends ApiEnumItemType>(cachedQuery: CachedQueryItem<ItemTypeType>, newColumns: ApiRequestColumns, force?: boolean): PromiseInterface<CachedQueryItem<ItemTypeType>>;
-    __addItemEntriesToCachedQueries<ItemTypeType extends ApiEnumItemType = any>(itemType: ItemTypeType, parsedQuery: CollectionQuery, itemEntries: Array<ItemEntry<ItemTypeType>>): void;
-    /**
-     * @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>>;
-    private resolveLocalCachedQueryItem;
-    private expandCachedQueryItemEntries;
-    private syncCachedQueryWithLocalItems;
-    __fetchLinkedCachedQueryItems<ItemTypeType extends ApiEnumItemType>(parentType: ApiEnumItemType, parentIdArray: ItemId[] | (() => ItemId[]), itemType: ItemTypeType, options: CollectionOptions): PromiseInterface<ParentIdMap<CachedQueryItem<ItemTypeType>>>;
-    __fetchParentCachedQueryItem<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, options: CollectionOptions): PromiseInterface<CachedQueryItemTree<ItemTypeType>>;
-    __fetchChildCachedQueryItems(parentType: ApiEnumItemType, parentIds: ItemId[], childCollectionOptions: ChildCollectionOptions): PromiseInterface<ParentItemMap<CachedQueryItemTree>>;
-}
+import { ApiEnumItemType, ItemId } from '@rentman/backend-types';
+import { ApiQuery, ApiRequestColumns, CachedQueryHandlerBase, CachedQueryItem, CachedQueryItemTree, ChildCollectionOptions, CollectionOptions, CollectionQuery, ColumnSubsetCache, ItemEntry, ItemEntryOptions, ItemIdConversionMap, ParentIdMap, ParentItemMap, PromiseInterface, TransactionCache, TransactionCollectionHandlerDependencyInterface, TransactionItemHandler } from '../../../internal';
+export declare class TransactionCachedQueryHandler extends CachedQueryHandlerBase {
+    private dependencies;
+    private itemHandler;
+    protected transaction: TransactionCache;
+    constructor(dependencies: TransactionCollectionHandlerDependencyInterface, itemHandler: TransactionItemHandler, transaction: TransactionCache);
+    /**
+     * @description
+     * Updates all cached queries which references one of the updated IDs in the conversionMap
+     *
+     * @param conversionMap ConversionMap with the updated IDs
+     */
+    updateLocalItemIdReferences(conversionMap: ItemIdConversionMap): void;
+    __fetchCachedQueryItem<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, options: CollectionOptions): PromiseInterface<CachedQueryItem<ItemTypeType>>;
+    __expandCachedQuery<ItemTypeType extends ApiEnumItemType>(cachedQuery: CachedQueryItem<ItemTypeType>, newColumns: ApiRequestColumns, force?: boolean): PromiseInterface<CachedQueryItem<ItemTypeType>>;
+    __addItemEntriesToCachedQueries<ItemTypeType extends ApiEnumItemType = any>(itemType: ItemTypeType, parsedQuery: CollectionQuery, itemEntries: Array<ItemEntry<ItemTypeType>>): void;
+    /**
+     * @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>>;
+    private resolveLocalCachedQueryItem;
+    private expandCachedQueryItemEntries;
+    private syncCachedQueryWithLocalItems;
+    __fetchLinkedCachedQueryItems<ItemTypeType extends ApiEnumItemType>(parentType: ApiEnumItemType, parentIdArray: ItemId[] | (() => ItemId[]), itemType: ItemTypeType, options: CollectionOptions): PromiseInterface<ParentIdMap<CachedQueryItem<ItemTypeType>>>;
+    __fetchParentCachedQueryItem<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, options: CollectionOptions): PromiseInterface<CachedQueryItemTree<ItemTypeType>>;
+    __fetchChildCachedQueryItems(parentType: ApiEnumItemType, parentIds: ItemId[], childCollectionOptions: ChildCollectionOptions): PromiseInterface<ParentItemMap<CachedQueryItemTree>>;
+}

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

@@ -1,24 +1,24 @@
-import { ApiEnumItemType } from '@rentman/backend-types';
-import { ApiRequestColumns, ChangesDelta, CollectionEntry, CollectionResource, ItemEntry, ItemIdConversionMap, ModifyFieldsCallback, PromiseInterface, TransactionCache, TransactionCachedQueryHandler, TransactionCollectionHandlerDependencyInterface, TransactionItemHandler } from '../../../internal';
-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);
-    updateLocalItemIdReferences(conversionMap: ItemIdConversionMap): void;
-    expandCollectionResource<ItemTypeType extends ApiEnumItemType = any>(collectionResource: CollectionResource<ItemTypeType>, newColumns: ApiRequestColumns): PromiseInterface<void>;
-    addResource(resource: CollectionResource): CollectionResource;
-    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 { ApiRequestColumns, ChangesDelta, CollectionEntry, CollectionResource, ItemEntry, ItemIdConversionMap, ModifyFieldsCallback, PromiseInterface, TransactionCache, TransactionCachedQueryHandler, TransactionCollectionHandlerDependencyInterface, TransactionItemHandler } from '../../../internal';
+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);
+    updateLocalItemIdReferences(conversionMap: ItemIdConversionMap): void;
+    expandCollectionResource<ItemTypeType extends ApiEnumItemType = any>(collectionResource: CollectionResource<ItemTypeType>, newColumns: ApiRequestColumns): PromiseInterface<void>;
+    addResource(resource: CollectionResource): CollectionResource;
+    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,21 +1,21 @@
-import { ErrorHandlerInterface, ExceptionHandlerInterface, ItemEntry, ItemIdConversionMap, PromiseInterface, PromiseLibraryInterface, TransactionCache, TransactionErrorLevel } from '../../../internal';
-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, ItemEntry, ItemIdConversionMap, PromiseInterface, PromiseLibraryInterface, TransactionCache, TransactionErrorLevel } from '../../../internal';
+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,89 +1,89 @@
-import { ApiEnumItemType, ItemId } from '@rentman/backend-types';
-import { ApiQuery, ApiRequestColumns, ChangesDelta, ChangesDeltaBase, ChangesDeltaItemCreateDelta, ChangesDeltaItemUpdateDelta, ChangesDeltaResult, ColumnSubsetCache, DeregFunction, FieldChangeCallback, FieldMap, ItemEntry, ItemEntryOptions, ItemHandlerBase, ItemIdConversionMap, ItemTypeMap, ModifyFieldsCallback, ProcessItemEntryChangesResult, PromiseInterface, ResponseColumnItemTypeMap, TransactionCache, TransactionItemHandlerDependencyInterface, TransactionValidator } from '../../../internal';
-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?;
-    /**
-     * @warning
-     * Can contain both local and non-local {@link ItemEntry itemEntries}
-     */
-    deletedItems: ItemTypeMap<ItemEntry[]>;
-    itemChanges: {
-        [itemEntryId: number]: TransactionItemEntryChanges;
-    };
-    fieldChangeCallbacks: {
-        [itemType: string]: {
-            [itemId: string]: FieldChangeCallback[];
-        };
-    };
-    constructor(dependencies: TransactionItemHandlerDependencyInterface, transaction: TransactionCache, validator?: TransactionValidator | undefined);
-    updateLocalItemIdReferences(itemType: ApiEnumItemType, oldItemId: ItemId, newItemId: ItemId, changesDelta?: ChangesDeltaBase): void;
-    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 `createItemChangesIfNoneExist` is set
-     *
-     * @param itemEntryChangesTuple The changes tuple
-     * @param isCalledAfterSocketUpdate Indicates that the change is done by a different user
-     * @param createItemChangesIfNoneExist Is `true` when called from `applyChangesDelta`, we can assume that when you call `applyChangesDelta` with updates that aren't on the transaction yet you want to add those
-     * @param changesDelta Will be used to check which items should/shouldn't be updated when updating local ID references
-     *
-     * @returns
-     * The previous changes {@link FieldMap FieldMap}, returns `null` when the item was not cached or no fields were changed.
-     */
-    processItemEntryChanges<ItemTypeType extends ApiEnumItemType = any>(itemEntryChangesTuple: ChangesDeltaItemUpdateDelta<ItemTypeType>, 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, isRoot?: boolean): PromiseInterface<ItemEntry<ItemTypeType>>;
-    /**
-     * @description
-     * Fetches a template and creates a new {@link ItemEntry ItemEntry}, will error if the ItemEntry with the given ItemId already exists
-     */
-    fetchNewItemEntry<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, itemId: ItemId, options: ItemEntryOptions, isRoot?: boolean): PromiseInterface<ChangesDeltaResult>;
-    fetchItemEntries<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, itemIds: ItemId[], options: ItemEntryOptions): PromiseInterface<Array<ItemEntry<ItemTypeType>>>;
-    fetchTitle(itemType: ApiEnumItemType, itemId: ItemId): PromiseInterface<string>;
-    resolveLocalItemEntry<ItemTypeType extends ApiEnumItemType>(changesDelta: ChangesDelta, itemEntry: ItemEntry<ItemTypeType>, columnSubsetCache: ColumnSubsetCache<ItemTypeType>, options: ItemEntryOptions): PromiseInterface<ItemEntry<ItemTypeType>>;
-    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;
-}
+import { ApiEnumItemType, ItemId } from '@rentman/backend-types';
+import { ApiQuery, ApiRequestColumns, ChangesDelta, ChangesDeltaBase, ChangesDeltaItemCreateDelta, ChangesDeltaItemUpdateDelta, ChangesDeltaResult, ColumnSubsetCache, DeregFunction, FieldChangeCallback, FieldMap, ItemEntry, ItemEntryOptions, ItemHandlerBase, ItemIdConversionMap, ItemTypeMap, ModifyFieldsCallback, ProcessItemEntryChangesResult, PromiseInterface, ResponseColumnItemTypeMap, TransactionCache, TransactionItemHandlerDependencyInterface, TransactionValidator } from '../../../internal';
+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?;
+    /**
+     * @warning
+     * Can contain both local and non-local {@link ItemEntry itemEntries}
+     */
+    deletedItems: ItemTypeMap<ItemEntry[]>;
+    itemChanges: {
+        [itemEntryId: number]: TransactionItemEntryChanges;
+    };
+    fieldChangeCallbacks: {
+        [itemType: string]: {
+            [itemId: string]: FieldChangeCallback[];
+        };
+    };
+    constructor(dependencies: TransactionItemHandlerDependencyInterface, transaction: TransactionCache, validator?: TransactionValidator | undefined);
+    updateLocalItemIdReferences(itemType: ApiEnumItemType, oldItemId: ItemId, newItemId: ItemId, changesDelta?: ChangesDeltaBase): void;
+    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 `createItemChangesIfNoneExist` is set
+     *
+     * @param itemEntryChangesTuple The changes tuple
+     * @param isCalledAfterSocketUpdate Indicates that the change is done by a different user
+     * @param createItemChangesIfNoneExist Is `true` when called from `applyChangesDelta`, we can assume that when you call `applyChangesDelta` with updates that aren't on the transaction yet you want to add those
+     * @param changesDelta Will be used to check which items should/shouldn't be updated when updating local ID references
+     *
+     * @returns
+     * The previous changes {@link FieldMap FieldMap}, returns `null` when the item was not cached or no fields were changed.
+     */
+    processItemEntryChanges<ItemTypeType extends ApiEnumItemType = any>(itemEntryChangesTuple: ChangesDeltaItemUpdateDelta<ItemTypeType>, 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, isRoot?: boolean): PromiseInterface<ItemEntry<ItemTypeType>>;
+    /**
+     * @description
+     * Fetches a template and creates a new {@link ItemEntry ItemEntry}, will error if the ItemEntry with the given ItemId already exists
+     */
+    fetchNewItemEntry<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, itemId: ItemId, options: ItemEntryOptions, isRoot?: boolean): PromiseInterface<ChangesDeltaResult>;
+    fetchItemEntries<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, itemIds: ItemId[], options: ItemEntryOptions): PromiseInterface<Array<ItemEntry<ItemTypeType>>>;
+    fetchTitle(itemType: ApiEnumItemType, itemId: ItemId): PromiseInterface<string>;
+    resolveLocalItemEntry<ItemTypeType extends ApiEnumItemType>(changesDelta: ChangesDelta, itemEntry: ItemEntry<ItemTypeType>, columnSubsetCache: ColumnSubsetCache<ItemTypeType>, options: ItemEntryOptions): PromiseInterface<ItemEntry<ItemTypeType>>;
+    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;
+}

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

@@ -1,33 +1,33 @@
-import { ApiEnumItemType } from '@rentman/backend-types';
-import { FieldMap, ItemEntry, PromiseInterface, TransactionCache, TransactionErrorLevel } from '../../../internal';
-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 { FieldMap, ItemEntry, PromiseInterface, TransactionCache, TransactionErrorLevel } from '../../../internal';
+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/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;

package/dist/types/core.d.ts

@@ -1,45 +1,45 @@
-import { ApiFormatter, ApiRequestService, ApiRequestServiceInterface, ApiResponseProcessorFactory, AuthInterface, CacheSyncerFactory, ChangesCompilationFactory, ChangesDeltaFactory, ChangesProcessorFactory, CollectionEntryFactory, CollectionEntryService, CollectionResourceFactory, CollectionResourceService, ColumnCache, ColumnExpansionFactory, ColumnHandler, ColumnInfoFactory, ColumnSetFactory, ColumnSubsetCacheFactory, ColumnUtil, ConversionMapService, CreateRequestFactory, ErrorHandlerInterface, ExceptionHandlerInterface, ItemCacheFactory, ItemCreateService, ItemEntryFactory, ItemEntryService, ItemResourceFactory, KeyService, LinkTreeServiceInterface, LockService, ModuleChangesCompilationFactory, PromiseLibraryInterface, QueryMatcherFactory, QueryParserFactory, QueryService, RequestColumnExpansionFactory, SocketMessageHandler, TemplateCache, TemplateFactory, TransactionCacheFactory } from './internal';
-export declare class RmCore {
-    version: string;
-    noop: typeof noop;
-    apiFormatter: ApiFormatter;
-    apiRequestService: ApiRequestService;
-    apiResponseProcessorFactory: ApiResponseProcessorFactory;
-    changesCompilationFactory: ChangesCompilationFactory;
-    changesDeltaFactory: ChangesDeltaFactory;
-    changesProcessorFactory: ChangesProcessorFactory;
-    collectionEntryFactory: CollectionEntryFactory;
-    collectionEntryService: CollectionEntryService;
-    collectionMatcherFactory: CacheSyncerFactory;
-    collectionResourceFactory: CollectionResourceFactory;
-    collectionResourceService: CollectionResourceService;
-    columnCache: ColumnCache;
-    columnExpansionFactory: ColumnExpansionFactory;
-    columnHandler: ColumnHandler;
-    columnInfoFactory: ColumnInfoFactory;
-    columnSetFactory: ColumnSetFactory;
-    columnSubsetCacheFactory: ColumnSubsetCacheFactory;
-    columnUtil: ColumnUtil;
-    conversionMapService: ConversionMapService;
-    createRequestFactory: CreateRequestFactory;
-    itemCacheFactory: ItemCacheFactory;
-    itemCreateService: ItemCreateService;
-    itemEntryFactory: ItemEntryFactory;
-    itemEntryService: ItemEntryService;
-    itemResourceFactory: ItemResourceFactory;
-    keyService: KeyService;
-    lockService: LockService;
-    moduleChangesCompilationFactory: ModuleChangesCompilationFactory;
-    queryMatcherFactory: QueryMatcherFactory;
-    queryParserFactory: QueryParserFactory;
-    queryService: QueryService;
-    requestColumnExpansionFactory: RequestColumnExpansionFactory;
-    socketMessageHandler: SocketMessageHandler;
-    templateCache: TemplateCache;
-    templateFactory: TemplateFactory;
-    transactionCacheFactory: TransactionCacheFactory;
-    constructor(_apiRequestService: ApiRequestServiceInterface, authInterface: AuthInterface, errorHandler: ErrorHandlerInterface, exceptionHandler: ExceptionHandlerInterface, promiseLibrary: PromiseLibraryInterface, linkTreeService: LinkTreeServiceInterface);
-}
-export declare function noop(): void;
-export declare function identity(value: any): any;
-export declare function nullFunction(): null;
+import { ApiFormatter, ApiRequestService, ApiRequestServiceInterface, ApiResponseProcessorFactory, AuthInterface, CacheSyncerFactory, ChangesCompilationFactory, ChangesDeltaFactory, ChangesProcessorFactory, CollectionEntryFactory, CollectionEntryService, CollectionResourceFactory, CollectionResourceService, ColumnCache, ColumnExpansionFactory, ColumnHandler, ColumnInfoFactory, ColumnSetFactory, ColumnSubsetCacheFactory, ColumnUtil, ConversionMapService, CreateRequestFactory, ErrorHandlerInterface, ExceptionHandlerInterface, ItemCacheFactory, ItemCreateService, ItemEntryFactory, ItemEntryService, ItemResourceFactory, KeyService, LinkTreeServiceInterface, LockService, ModuleChangesCompilationFactory, PromiseLibraryInterface, QueryMatcherFactory, QueryParserFactory, QueryService, RequestColumnExpansionFactory, SocketMessageHandler, TemplateCache, TemplateFactory, TransactionCacheFactory } from './internal';
+export declare class RmCore {
+    version: string;
+    noop: typeof noop;
+    apiFormatter: ApiFormatter;
+    apiRequestService: ApiRequestService;
+    apiResponseProcessorFactory: ApiResponseProcessorFactory;
+    changesCompilationFactory: ChangesCompilationFactory;
+    changesDeltaFactory: ChangesDeltaFactory;
+    changesProcessorFactory: ChangesProcessorFactory;
+    collectionEntryFactory: CollectionEntryFactory;
+    collectionEntryService: CollectionEntryService;
+    collectionMatcherFactory: CacheSyncerFactory;
+    collectionResourceFactory: CollectionResourceFactory;
+    collectionResourceService: CollectionResourceService;
+    columnCache: ColumnCache;
+    columnExpansionFactory: ColumnExpansionFactory;
+    columnHandler: ColumnHandler;
+    columnInfoFactory: ColumnInfoFactory;
+    columnSetFactory: ColumnSetFactory;
+    columnSubsetCacheFactory: ColumnSubsetCacheFactory;
+    columnUtil: ColumnUtil;
+    conversionMapService: ConversionMapService;
+    createRequestFactory: CreateRequestFactory;
+    itemCacheFactory: ItemCacheFactory;
+    itemCreateService: ItemCreateService;
+    itemEntryFactory: ItemEntryFactory;
+    itemEntryService: ItemEntryService;
+    itemResourceFactory: ItemResourceFactory;
+    keyService: KeyService;
+    lockService: LockService;
+    moduleChangesCompilationFactory: ModuleChangesCompilationFactory;
+    queryMatcherFactory: QueryMatcherFactory;
+    queryParserFactory: QueryParserFactory;
+    queryService: QueryService;
+    requestColumnExpansionFactory: RequestColumnExpansionFactory;
+    socketMessageHandler: SocketMessageHandler;
+    templateCache: TemplateCache;
+    templateFactory: TemplateFactory;
+    transactionCacheFactory: TransactionCacheFactory;
+    constructor(_apiRequestService: ApiRequestServiceInterface, authInterface: AuthInterface, errorHandler: ErrorHandlerInterface, exceptionHandler: ExceptionHandlerInterface, promiseLibrary: PromiseLibraryInterface, linkTreeService: LinkTreeServiceInterface);
+}
+export declare function noop(): void;
+export declare function identity(value: any): any;
+export declare function nullFunction(): null;

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

@@ -1,6 +1,6 @@
-import { ApiFormatter, ApiResponseProcessor } from '../internal';
-export declare class ApiResponseProcessorFactory {
-    private apiFormatter;
-    constructor(apiFormatter: ApiFormatter);
-    construct(response: any): ApiResponseProcessor;
-}
+import { ApiFormatter, ApiResponseProcessor } from '../internal';
+export declare class ApiResponseProcessorFactory {
+    private apiFormatter;
+    constructor(apiFormatter: ApiFormatter);
+    construct(response: any): ApiResponseProcessor;
+}

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

@@ -1,10 +1,10 @@
-import { AbstractCache, ApiRequestService, CacheSyncer, CacheSyncerQueryMap, PromiseLibraryInterface, QueryMatcherFactory, QueryService } from '../internal';
-export declare class CacheSyncerFactory {
-    private queryMatcherFactory;
-    private queryService;
-    private apiRequestService;
-    private promiseService;
-    constructor(queryMatcherFactory: QueryMatcherFactory, queryService: QueryService, apiRequestService: ApiRequestService, promiseService: PromiseLibraryInterface);
-    construct(transaction: AbstractCache, queryStringMap?: CacheSyncerQueryMap): CacheSyncer;
-    private collectQueries;
-}
+import { AbstractCache, ApiRequestService, CacheSyncer, CacheSyncerQueryMap, PromiseLibraryInterface, QueryMatcherFactory, QueryService } from '../internal';
+export declare class CacheSyncerFactory {
+    private queryMatcherFactory;
+    private queryService;
+    private apiRequestService;
+    private promiseService;
+    constructor(queryMatcherFactory: QueryMatcherFactory, queryService: QueryService, apiRequestService: ApiRequestService, promiseService: PromiseLibraryInterface);
+    construct(transaction: AbstractCache, queryStringMap?: CacheSyncerQueryMap): CacheSyncer;
+    private collectQueries;
+}

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

@@ -1,5 +1,5 @@
-import { ChangesCompilation, TransactionCache } from '../internal';
-export declare class ChangesCompilationFactory {
-    constructor();
-    construct(transaction: TransactionCache): ChangesCompilation;
-}
+import { ChangesCompilation, TransactionCache } from '../internal';
+export declare class ChangesCompilationFactory {
+    constructor();
+    construct(transaction: TransactionCache): ChangesCompilation;
+}

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

@@ -1,13 +1,13 @@
-import { ApiFormatter, ChangesDelta, ConversionMapService, ErrorHandlerInterface, InternalChangesDelta, ItemCreateService, ItemEntryService, ParentChangesDelta } from '../internal';
-export declare class ChangesDeltaFactory {
-    private apiFormatter;
-    private conversionMapService;
-    private errorHandler;
-    private itemCreateService;
-    private itemEntryService;
-    constructor(apiFormatter: ApiFormatter, conversionMapService: ConversionMapService, errorHandler: ErrorHandlerInterface, itemCreateService: ItemCreateService, itemEntryService: ItemEntryService);
-    construct(): ChangesDelta;
-    cloneCreatedChanges(sourceChangesDelta: ChangesDelta, destinationChangesDelta?: ChangesDelta): ChangesDelta;
-    constructInternalDelta(): InternalChangesDelta;
-    constructParentDelta(): ParentChangesDelta;
-}
+import { ApiFormatter, ChangesDelta, ConversionMapService, ErrorHandlerInterface, InternalChangesDelta, ItemCreateService, ItemEntryService, ParentChangesDelta } from '../internal';
+export declare class ChangesDeltaFactory {
+    private apiFormatter;
+    private conversionMapService;
+    private errorHandler;
+    private itemCreateService;
+    private itemEntryService;
+    constructor(apiFormatter: ApiFormatter, conversionMapService: ConversionMapService, errorHandler: ErrorHandlerInterface, itemCreateService: ItemCreateService, itemEntryService: ItemEntryService);
+    construct(): ChangesDelta;
+    cloneCreatedChanges(sourceChangesDelta: ChangesDelta, destinationChangesDelta?: ChangesDelta): ChangesDelta;
+    constructInternalDelta(): InternalChangesDelta;
+    constructParentDelta(): ParentChangesDelta;
+}