@rentman/rm-core 3.1.0 → 4.0.1

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

@@ -1,344 +1,336 @@
-import { RmCore } from '../../../core';
-import { TransactionCacheDependencyInterface } from '../../../interfaces/TransactionCacheDependencyInterface';
-import { CollectionEntry, CollectionResource, CollectionResourceOptionsInterface, ItemEntry, ItemResource, ItemResourceOptionsInterface } 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 { ModuleChangesCompilationResult, OnAfterCreateCallback, TransactionCacheCallbackCondition, TransactionCacheCallbackType, TransactionCollectionHandler, TransactionItemEntryChanges, TransactionItemHandler, TransactionValidatorFactory } from '../../index';
-import { InternalChangesDelta } from '../../InternalChangesDelta';
-import { AbstractCache } from '../AbstractCache';
-import { ServerCache } from '../server/ServerCache';
-import { TransactionEventHandler } from './TransactionEventHandler';
-declare type ItemResourceLinks<ItemTypeType extends ItemType> = {
-    main: ItemResource<ItemTypeType>;
-    linked: ItemResourcesItemTypeMap;
-};
-export declare enum TransactionErrorLevel {
-    warning = "warning",
-    error = "error"
-}
-/**
- * @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
-     * A map of all item errors, can be populated using {@link TransactionValidator.setGlobalError TransactionValidator.setGlobalError} and {@link TransactionValidator.setItemError TransactionValidator.setItemError}.
-     * Contains a translation and level for every error
-     */
-    errors: {
-        item: {
-            [itemEntryId: string]: {
-                [columnId: string]: {
-                    [errorKey: string]: {
-                        fieldString: string;
-                        string: string;
-                        level: TransactionErrorLevel;
-                    };
-                };
-            };
-        };
-        global: {
-            [key: string]: {
-                string: string;
-                level: TransactionErrorLevel;
-            };
-        };
-    };
-    isValid: boolean;
-    /**
-     * @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;
-    readonly eventHandler: TransactionEventHandler;
-    private readonly validator?;
-    private changesInterval;
-    constructor(dependencies: TransactionCacheDependencyInterface, core: RmCore, parent: AbstractCache, 
-    /**
-     * @description
-     * For debugging purposes
-     */
-    id?: string | undefined, validatorFactory?: TransactionValidatorFactory);
-    destroy(): void;
-    createChangesDelta(): ChangesDelta;
-    getFirstErrorString(): undefined | string;
-    /**
-     * @description
-     * Should only be called by {@link TransactionValidator TransactionValidator}
-     * @internal
-     */
-    _setGlobalError(key: string, isInvalid: boolean, saveButtonErrorTranslationFn: () => string, level: TransactionErrorLevel): void;
-    /**
-     * @description
-     * Should only be called by {@link TransactionValidator TransactionValidator}
-     * @internal
-     */
-    _setItemError(itemEntryId: ItemEntry['id'], columnId: string, errorKey: string, isInvalid: boolean, fieldErrorTranslationFn: () => string, saveButtonErrorTranslationFn: () => string, level: TransactionErrorLevel): void;
-    /**
-     * @internal
-     */
-    _setIsValid(): void;
-    /**
-     * @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, isCalledAfterSocketUpdate?: 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)
-     * @param providedFields Use the provided fields instead of the cached fields, used by {@link CollectionResource.getParent CollectionResource.getParent}
-     *
-     * @remark
-     * Use {@link CollectionResource.getParent CollectionResource.getParent} instead of {@link TransactionCache.getParent TransactionCache.getParent} if you're getting the parent in the onRemove callback
-     */
-    getParent<ItemTypeType extends ItemType = any>(itemEntry: ItemEntry<ItemTypeType>, fromInitial?: boolean, providedFields?: FieldMap<ItemTypeType>): EntryParentNull;
-    getCollectionChangesRecursively(collectionEntryId: CollectionEntry['id']): ItemEntry[];
-    /**
-     * @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;
-    getAllLinkCollections<ItemTypeType extends ItemType>(linkType: ItemType, itemType: ItemTypeType, options: CollectionOptionsInterface<ItemTypeType>): PromiseInterface<CollectionResourceParentIdMap<ItemTypeType>>;
-    getLinkCollectionsFromDef<ItemTypeType extends ItemType>(linkType: ItemType, linkIdArray: ItemId[], definition: LinkCollectionDefinition<ItemTypeType>): PromiseInterface<CollectionResourceParentIdMap<ItemTypeType>>;
-    getLinkCollections<ItemTypeType extends ItemType>(linkType: ItemType, linkIdArray: ItemId[], itemType: ItemTypeType, options: CollectionOptionsInterface<ItemTypeType>): PromiseInterface<CollectionResourceParentIdMap<ItemTypeType>>;
-    getCollectionFromDef<ItemTypeType extends ItemType>(definition: CollectionDefinition<ItemTypeType>): PromiseInterface<CollectionResource<ItemTypeType>>;
-    getCollection<ItemTypeType extends ItemType>(itemType: ItemTypeType, options: CollectionOptionsInterface<ItemTypeType>): PromiseInterface<CollectionResource<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>;
-    /**
-     * @deprecated
-     * Use getItemById/getNewResourceWithId
-     *
-     * @remarks
-     * stateKey can be a keyword or a local id (in case of a refresh)
-     */
-    getItemByState<ItemTypeType extends ItemType>(itemType: ItemTypeType, stateKey: ItemId | string, options?: ItemOptionsInterface, isRoot?: boolean): PromiseInterface<ItemResource<ItemTypeType>>;
-    getDuplicateById<ItemTypeType extends ItemType>(itemType: ItemTypeType, duplicateId: ItemId, options: ItemOptionsInterface, returnLinks: true, isRoot?: boolean): PromiseInterface<ItemResourceLinks<ItemTypeType>>;
-    getDuplicateById<ItemTypeType extends ItemType>(itemType: ItemTypeType, duplicateId: ItemId, options: ItemOptionsInterface, returnLinks?: boolean, isRoot?: boolean): PromiseInterface<ItemResource<ItemTypeType>>;
-    getNewResourceWithId<ItemTypeType extends ItemType>(itemType: ItemTypeType, itemId: ItemId, options: ItemOptionsInterface, returnLinks: true, isRoot?: boolean): PromiseInterface<ItemResourceLinks<ItemTypeType>>;
-    getNewResourceWithId<ItemTypeType extends ItemType>(itemType: ItemTypeType, itemId: ItemId, options: ItemOptionsInterface, returnLinks?: boolean, isRoot?: boolean): PromiseInterface<ItemResource<ItemTypeType>>;
-    getNewResource<ItemTypeType extends ItemType>(itemType: ItemTypeType, options: ItemOptionsInterface, returnLinks: true, isRoot?: boolean): PromiseInterface<ItemResourceLinks<ItemTypeType>>;
-    getNewResource<ItemTypeType extends ItemType>(itemType: ItemTypeType, options: ItemOptionsInterface, returnLinks?: boolean, isRoot?: boolean): PromiseInterface<ItemResource<ItemTypeType>>;
-    /**
-     * @description
-     * Fetches multiple items with their respective changes of the current {@link TransactionCache transaction}
-     */
-    getItemsByQuery<ItemTypeType extends ItemType>(itemType: ItemTypeType, query: ApiQuery, options?: ItemOptionsInterface): PromiseInterface<Array<ItemResource<ItemTypeType>>>;
-    /**
-     * @description
-     * Fetches multiple items with their respective changes of the current {@link TransactionCache transaction}
-     */
-    getItemsById<ItemTypeType extends ItemType>(itemType: ItemTypeType, itemIds: ItemId[], options?: ItemOptionsInterface): PromiseInterface<Array<ItemResource<ItemTypeType>>>;
-    /**
-     * @description
-     * Fetches the item with the changes of the current {@link TransactionCache transaction}
-     *
-     * @param isRoot Sets the item as the root item of the transaction, new items will be linked to this item (if there's a connection in the LinkTree)
-     */
-    getItemById<ItemTypeType extends ItemType>(itemType: ItemTypeType, itemId: ItemId, options?: ItemOptionsInterface, isRoot?: boolean): PromiseInterface<ItemResource<ItemTypeType>>;
-    /**
-     * @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
-     */
-    getLocalCollectionEntryByQueryString(itemType: ItemType, queryString: string): CollectionEntry | 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: ItemResourceOptionsInterface, isRoot?: boolean, isNew?: boolean): ItemResource<ItemTypeType>;
-    createItemResources<ItemTypeType extends ItemType>(itemEntries: Array<ItemEntry<ItemTypeType>>, options: ItemResourceOptionsInterface): Array<ItemResource<ItemTypeType>>;
-    processLinkedItems<ItemTypeType extends ItemType>(linkedEntries: ItemTypeMap<ItemEntry[]>, options: ItemOptionsInterface): ItemResourcesItemTypeMap<ItemResource<ItemTypeType>>;
-    createCollectionResource<ItemTypeType extends ItemType>(collectionEntry: CollectionEntry<ItemTypeType>, resourceOptions: CollectionResourceOptionsInterface<ItemTypeType>): CollectionResource<ItemTypeType>;
-    getChangesFromItemChanges<ItemTypeType extends ItemType = any>(changesObject: TransactionItemEntryChanges<ItemTypeType>): FieldMap<ItemTypeType>;
-    private createCollectionResources;
-    /**
-     * @description
-     * Fetches all required columns to match/fit in collections
-     */
-    private expandItemsFromDelta;
-    private clearGlobalError;
-    private clearItemError;
-}
-export {};
+import { RmCore } from '../../../core';
+import { AbstractCacheDependencyInterface } from '../../../interfaces/AbstractCacheDependencyInterface';
+import { CollectionEntry, CollectionResource, CollectionResourceOptionsInterface, ItemEntry, ItemEntryOptions, ItemResource } from '../../../models';
+import { ApiQuery, CollectionDefinition, CollectionOptionsInterface, CollectionResourceParentIdMap, ConversionMap, CreateRequestParameterMap, DeregFunction, EntryParentNull, FieldChangeCallback, FieldMap, ItemId, ItemIdConversionMap, ItemOptionsInterface, ItemResourcesItemTypeMap, ItemType, ItemTypeMap, LinkCollectionDefinition, PromiseInterface } from '../../../types';
+import { ChangesDelta } from '../../ChangesDelta';
+import { ChangesDeltaResult } from '../../ChangesDeltaBase';
+import { ModuleChangesCompilationResult, OnAfterCreateCallback, TransactionCacheCallbackCondition, TransactionCacheCallbackType, TransactionCollectionHandler, TransactionItemEntryChanges, TransactionItemHandler, TransactionValidatorFactory } from '../../index';
+import { InternalChangesDelta } from '../../InternalChangesDelta';
+import { AbstractCache } from '../AbstractCache';
+import { ServerCache } from '../server/ServerCache';
+import { TransactionEventHandler } from './TransactionEventHandler';
+declare type ItemResourceLinks<ItemTypeType extends ItemType> = {
+    main: ItemResource<ItemTypeType>;
+    linked: ItemResourcesItemTypeMap;
+};
+export declare enum TransactionErrorLevel {
+    warning = "warning",
+    error = "error"
+}
+/**
+ * @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
+     * A map of all item errors, can be populated using {@link TransactionValidator.setGlobalError TransactionValidator.setGlobalError} and {@link TransactionValidator.setItemError TransactionValidator.setItemError}.
+     * Contains a translation and level for every error
+     */
+    errors: {
+        item: {
+            [itemEntryId: string]: {
+                [columnId: string]: {
+                    [errorKey: string]: {
+                        fieldString: string;
+                        string: string;
+                        level: TransactionErrorLevel;
+                    };
+                };
+            };
+        };
+        global: {
+            [key: string]: {
+                string: string;
+                level: TransactionErrorLevel;
+            };
+        };
+    };
+    isValid: boolean;
+    /**
+     * @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;
+    readonly eventHandler: TransactionEventHandler;
+    private readonly validator?;
+    private changesInterval;
+    constructor(dependencies: AbstractCacheDependencyInterface, core: RmCore, parent: AbstractCache, 
+    /**
+     * @description
+     * For debugging purposes
+     */
+    id?: string | undefined, validatorFactory?: TransactionValidatorFactory);
+    destroy(): void;
+    registerFieldChangeCallback<ItemTypeType extends ItemType>(itemType: ItemTypeType, itemId: ItemId, callback: FieldChangeCallback<ItemTypeType>): DeregFunction;
+    createChangesDelta(): ChangesDelta;
+    getFirstErrorString(): undefined | string;
+    /**
+     * @description
+     * Should only be called by {@link TransactionValidator TransactionValidator}
+     * @internal
+     */
+    _setGlobalError(key: string, isInvalid: boolean, saveButtonErrorTranslationFn: () => string, level: TransactionErrorLevel): void;
+    /**
+     * @description
+     * Should only be called by {@link TransactionValidator TransactionValidator}
+     * @internal
+     */
+    _setItemError(itemEntryId: ItemEntry['id'], columnId: string, errorKey: string, isInvalid: boolean, fieldErrorTranslationFn: () => string, saveButtonErrorTranslationFn: () => string, level: TransactionErrorLevel): void;
+    /**
+     * @internal
+     */
+    _setIsValid(): void;
+    /**
+     * @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, isCalledAfterSocketUpdate?: 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)
+     * @param providedFields Use the provided fields instead of the cached fields, used by {@link CollectionResource.getParent CollectionResource.getParent}
+     *
+     * @remark
+     * Use {@link CollectionResource.getParent CollectionResource.getParent} instead of {@link TransactionCache.getParent TransactionCache.getParent} if you're getting the parent in the onRemove callback
+     */
+    getParent<ItemTypeType extends ItemType = any>(itemEntry: ItemEntry<ItemTypeType>, fromInitial?: boolean, providedFields?: FieldMap<ItemTypeType>): EntryParentNull;
+    getCollectionChangesRecursively(collectionEntryId: CollectionEntry['id']): ItemEntry[];
+    /**
+     * @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 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;
+    getAllLinkCollections<ItemTypeType extends ItemType>(linkType: ItemType, itemType: ItemTypeType, options: CollectionOptionsInterface<ItemTypeType>): PromiseInterface<CollectionResourceParentIdMap<ItemTypeType>>;
+    getLinkCollectionsFromDef<ItemTypeType extends ItemType>(linkType: ItemType, linkIdArray: ItemId[], definition: LinkCollectionDefinition<ItemTypeType>): PromiseInterface<CollectionResourceParentIdMap<ItemTypeType>>;
+    getLinkCollections<ItemTypeType extends ItemType>(linkType: ItemType, linkIdArray: ItemId[], itemType: ItemTypeType, options: CollectionOptionsInterface<ItemTypeType>): PromiseInterface<CollectionResourceParentIdMap<ItemTypeType>>;
+    getCollectionFromDef<ItemTypeType extends ItemType>(definition: CollectionDefinition<ItemTypeType>): PromiseInterface<CollectionResource<ItemTypeType>>;
+    getCollection<ItemTypeType extends ItemType>(itemType: ItemTypeType, options: CollectionOptionsInterface<ItemTypeType>): PromiseInterface<CollectionResource<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>;
+    /**
+     * @deprecated
+     * Use getItemById/getNewResourceWithId
+     *
+     * @remarks
+     * stateKey can be a keyword or a local id (in case of a refresh)
+     */
+    getItemByState<ItemTypeType extends ItemType>(itemType: ItemTypeType, stateKey: ItemId | string, options?: ItemOptionsInterface, isRoot?: boolean): PromiseInterface<ItemResource<ItemTypeType>>;
+    getDuplicateById<ItemTypeType extends ItemType>(itemType: ItemTypeType, duplicateId: ItemId, options: ItemOptionsInterface, returnLinks: true, isRoot?: boolean): PromiseInterface<ItemResourceLinks<ItemTypeType>>;
+    getDuplicateById<ItemTypeType extends ItemType>(itemType: ItemTypeType, duplicateId: ItemId, options: ItemOptionsInterface, returnLinks?: boolean, isRoot?: boolean): PromiseInterface<ItemResource<ItemTypeType>>;
+    getNewResourceWithId<ItemTypeType extends ItemType>(itemType: ItemTypeType, itemId: ItemId, options: Partial<ItemEntryOptions>, returnLinks: true, isRoot?: boolean): PromiseInterface<ItemResourceLinks<ItemTypeType>>;
+    getNewResourceWithId<ItemTypeType extends ItemType>(itemType: ItemTypeType, itemId: ItemId, options: Partial<ItemEntryOptions>, returnLinks?: boolean, isRoot?: boolean): PromiseInterface<ItemResource<ItemTypeType>>;
+    getNewResource<ItemTypeType extends ItemType>(itemType: ItemTypeType, options: ItemOptionsInterface, returnLinks: true, isRoot?: boolean): PromiseInterface<ItemResourceLinks<ItemTypeType>>;
+    getNewResource<ItemTypeType extends ItemType>(itemType: ItemTypeType, options: ItemOptionsInterface, returnLinks?: boolean, isRoot?: boolean): PromiseInterface<ItemResource<ItemTypeType>>;
+    /**
+     * @description
+     * Fetches multiple items with their respective changes of the current {@link TransactionCache transaction}
+     */
+    getItemsByQuery<ItemTypeType extends ItemType>(itemType: ItemTypeType, query: ApiQuery, options?: Partial<ItemEntryOptions>): PromiseInterface<Array<ItemResource<ItemTypeType>>>;
+    /**
+     * @description
+     * Fetches multiple items with their respective changes of the current {@link TransactionCache transaction}
+     */
+    getItemsById<ItemTypeType extends ItemType>(itemType: ItemTypeType, itemIds: ItemId[], options?: Partial<ItemEntryOptions>): PromiseInterface<Array<ItemResource<ItemTypeType>>>;
+    /**
+     * @description
+     * Fetches the item with the changes of the current {@link TransactionCache transaction}
+     *
+     * @param isRoot Sets the item as the root item of the transaction, new items will be linked to this item (if there's a connection in the LinkTree)
+     */
+    getItemById<ItemTypeType extends ItemType>(itemType: ItemTypeType, itemId: ItemId, options?: Partial<ItemEntryOptions>, isRoot?: boolean): PromiseInterface<ItemResource<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
+     */
+    getLocalCollectionEntryByQueryString(itemType: ItemType, queryString: string): CollectionEntry | 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>, isRoot?: boolean, isNew?: boolean): ItemResource<ItemTypeType>;
+    createItemResources<ItemTypeType extends ItemType>(itemEntries: Array<ItemEntry<ItemTypeType>>): Array<ItemResource<ItemTypeType>>;
+    processLinkedItems<ItemTypeType extends ItemType>(linkedEntries: ItemTypeMap<ItemEntry[]>): ItemResourcesItemTypeMap<ItemResource<ItemTypeType>>;
+    createCollectionResource<ItemTypeType extends ItemType>(collectionEntry: CollectionEntry<ItemTypeType>, resourceOptions: CollectionResourceOptionsInterface<ItemTypeType>): CollectionResource<ItemTypeType>;
+    getChangesFromItemChanges<ItemTypeType extends ItemType = any>(changesObject: TransactionItemEntryChanges<ItemTypeType>): FieldMap<ItemTypeType>;
+    private createCollectionResources;
+    /**
+     * @description
+     * Fetches all required columns to match/fit in collections
+     */
+    private expandItemsFromDelta;
+    private clearGlobalError;
+    private clearItemError;
+}
+export {};