@rentman/rm-core 8.2.0 → 8.2.2

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

@@ -1,319 +1,319 @@
-import { ApiEnumItemType, ApiFields, ItemId } from '@rentman/backend-types';
-import { AbstractCache, AbstractCacheDependencyInterface, ApiQuery, ApiRequestColumn, ApiRequestColumns, CachedQueryItem, CachedQueryItemTree, ChangesDelta, ChangesDeltaResult, ChildCollectionOptions, ChildCollectionResources, ChildCollectionResourcesNull, CollectionDefinition, CollectionOptionsInterface, CollectionQuery, CollectionResource, CollectionResourceParentIdMap, ConversionMap, CreateRequestParameterMap, DeregFunction, EntryParentNull, FieldChangeCallback, FieldMap, InternalChangesDelta, ItemEntry, ItemEntryOptions, ItemIdConversionMap, ItemOptionsInterface, ItemResource, ItemResourcesItemTypeMap, ItemTypeMap, LinkCollectionDefinition, ModuleChangesCompilationResult, OnAfterCreateCallback, ParentChangesDelta, ParentItemMap, PromiseInterface, RmCore, ServerCache, TransactionCacheCallbackCondition, TransactionCacheCallbackType, TransactionCachedQueryHandler, TransactionCollectionHandler, TransactionEventHandler, TransactionItemEntryChanges, TransactionItemHandler, TransactionOptions, TransactionValidatorFactory } from '../../../internal';
-declare type ItemResourceLinks<ItemTypeType extends ApiEnumItemType> = {
-    main: ItemResource<ItemTypeType>;
-    linked: ItemResourcesItemTypeMap;
-};
-export declare enum TransactionErrorLevel {
-    warning = "warning",
-    error = "error"
-}
-export declare type UndoFunction = () => PromiseInterface<ChangesDeltaResult>;
-/**
- * @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;
-            };
-        };
-    };
-    get 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 | 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 cachedQueryHandler: TransactionCachedQueryHandler;
-    readonly collectionHandler: TransactionCollectionHandler;
-    readonly eventHandler: TransactionEventHandler;
-    private readonly validator?;
-    private readonly options;
-    private _isValid;
-    private historyStep;
-    private undoDeltas;
-    private appliedDeltas;
-    constructor(dependencies: AbstractCacheDependencyInterface, core: RmCore, parent: AbstractCache, 
-    /**
-     * @description
-     * For debugging purposes
-     */
-    id?: string | undefined, validatorFactory?: TransactionValidatorFactory, options?: Partial<TransactionOptions>);
-    undo(): ReturnType<UndoFunction>;
-    redo(): ReturnType<TransactionCache['applyChangesDelta']>;
-    createChild(id?: string, validatorFactory?: TransactionValidatorFactory, options?: TransactionOptions): TransactionCache;
-    destroy(): void;
-    expandCollectionResource(collectionResource: CollectionResource, newColumns: ApiRequestColumns): PromiseInterface<void>;
-    /**
-     * @description
-     * Expands the collection with the new request columns, assumes that all collections have the same itemType
-     */
-    expandCollectionResources<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, collections: CollectionResourceParentIdMap<ItemTypeType>, newColumns: ApiRequestColumn[]): PromiseInterface<CollectionResourceParentIdMap>;
-    registerFieldChangeCallback<ItemTypeType extends ApiEnumItemType>(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
-     */
-    applyChangesFromParent(parentChangesDelta: ParentChangesDelta, isCalledAfterSocketUpdate?: boolean, conversionMap?: ItemIdConversionMap): PromiseInterface<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)
-     */
-    applyChangesDelta(changesDelta: ChangesDelta | InternalChangesDelta): 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 ApiEnumItemType = any>(itemEntry: ItemEntry<ItemTypeType>, fromInitial?: boolean, providedFields?: FieldMap<ItemTypeType>): EntryParentNull;
-    getCollectionChangesRecursively<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, parsedQuery: CollectionQuery): CachedQueryItem<ItemTypeType> | undefined;
-    /**
-     * @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 cached queries
-     */
-    clearCollectionResource(resource: CollectionResource): void;
-    /**
-     * @description
-     * Returns whether or not the {@link TransactionCache.rootItem rootItem} is uses locks
-     */
-    isLockable(): boolean;
-    /**
-     * @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>;
-    /**
-     * Rejects when another user is holding the lock, as opposed to {@link LockService.fetchLock}.
-     */
-    fetchLock(): PromiseInterface<void>;
-    detectChanges(force?: boolean): 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
-     * 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 ApiEnumItemType>(linkType: ApiEnumItemType, itemType: ItemTypeType, options: CollectionOptionsInterface<ItemTypeType>): PromiseInterface<CollectionResourceParentIdMap<ItemTypeType>>;
-    getLinkCollectionsFromDef<ItemTypeType extends ApiEnumItemType>(linkType: ApiEnumItemType, linkIdArray: ItemId[], definition: LinkCollectionDefinition<ItemTypeType>): PromiseInterface<CollectionResourceParentIdMap<ItemTypeType>>;
-    /**
-     * @deprecated Use the `children` collection option instead.
-     */
-    getLinkCollections<ItemTypeType extends ApiEnumItemType>(linkType: ApiEnumItemType, linkIdArray: ItemId[], itemType: ItemTypeType, options: CollectionOptionsInterface<ItemTypeType>): PromiseInterface<CollectionResourceParentIdMap<ItemTypeType>>;
-    getCollectionFromDef<ItemTypeType extends ApiEnumItemType>(definition: CollectionDefinition<ItemTypeType>): PromiseInterface<CollectionResource<ItemTypeType>>;
-    getCollection<ItemTypeType extends ApiEnumItemType, ColumnIds extends Array<keyof ApiFields[ItemTypeType]> = Array<keyof ApiFields[ItemTypeType]>>(itemType: ItemTypeType, options: CollectionOptionsInterface<ItemTypeType>): PromiseInterface<CollectionResource<ItemTypeType, ColumnIds>>;
-    getCollectionDef<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, options: CollectionOptionsInterface<ItemTypeType>): CollectionDefinition<ItemTypeType>;
-    getLinkCollectionsDef<ItemTypeType extends ApiEnumItemType>(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 ApiEnumItemType>(itemType: ItemTypeType, stateKey: ItemId | string, options?: ItemOptionsInterface, isRoot?: boolean): PromiseInterface<ItemResource<ItemTypeType>>;
-    getDuplicateById<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, duplicateId: ItemId, options: ItemOptionsInterface, returnLinks: true, isRoot?: boolean): PromiseInterface<ItemResourceLinks<ItemTypeType>>;
-    getDuplicateById<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, duplicateId: ItemId, options: ItemOptionsInterface, returnLinks?: boolean, isRoot?: boolean): PromiseInterface<ItemResource<ItemTypeType>>;
-    getNewResourceWithId<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, itemId: ItemId, options: Partial<ItemEntryOptions>, returnLinks: true, isRoot?: boolean): PromiseInterface<ItemResourceLinks<ItemTypeType>>;
-    getNewResourceWithId<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, itemId: ItemId, options: Partial<ItemEntryOptions>, returnLinks?: boolean, isRoot?: boolean): PromiseInterface<ItemResource<ItemTypeType>>;
-    getNewResource<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, options: ItemOptionsInterface, returnLinks: true, isRoot?: boolean): PromiseInterface<ItemResourceLinks<ItemTypeType>>;
-    getNewResource<ItemTypeType extends ApiEnumItemType>(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 ApiEnumItemType>(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 ApiEnumItemType>(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 ApiEnumItemType, ColumnIds extends Array<keyof ApiFields[ItemTypeType]> = Array<keyof ApiFields[ItemTypeType]>>(itemType: ItemTypeType, itemId: ItemId, options?: Partial<ItemEntryOptions>, isRoot?: boolean): PromiseInterface<ItemResource<ItemTypeType, ColumnIds>>;
-    /**
-     * @description
-     * Fetches the title of an item, does not create an {@link ItemResource ItemResource}
-     */
-    fetchTitle(itemType: ApiEnumItemType, 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: ApiEnumItemType, itemId: ItemEntry['itemId']): ItemEntry | 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 ApiEnumItemType>(itemEntry: ItemEntry<ItemTypeType>, childCollectionMap?: ChildCollectionResourcesNull, isNew?: boolean): ItemResource<ItemTypeType>;
-    createItemResources<ItemTypeType extends ApiEnumItemType, ColumnIds extends Array<keyof ApiFields[ItemTypeType]>>(itemEntries: Array<ItemEntry<ItemTypeType>>, childCollectionResourceMap?: ChildCollectionResourcesNull): Array<ItemResource<ItemTypeType, ColumnIds>>;
-    processLinkedItems<ItemTypeType extends ApiEnumItemType>(linkedEntries: ItemTypeMap<ItemEntry[]>): ItemResourcesItemTypeMap<ItemResource<ItemTypeType>>;
-    createCollectionResource<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, options: CollectionOptionsInterface<ItemTypeType>, initialEntries: Array<ItemEntry<ItemTypeType>>, childCollectionResourceMap?: ParentItemMap<CollectionResource> | null): CollectionResource<ItemTypeType>;
-    createChildCollectionResources(parentType: ApiEnumItemType, options: ChildCollectionOptions, cachedQueryItems: ParentItemMap<CachedQueryItemTree>): ChildCollectionResources;
-    private createChildCollectionResource;
-    getChangesFromItemChanges<ItemTypeType extends ApiEnumItemType = any>(changesObject: TransactionItemEntryChanges<FieldMap<ItemTypeType>>): FieldMap<ItemTypeType>;
-    /**
-     * @description
-     * Fetches all required columns to match/fit in collections
-     */
-    private expandItemsFromDelta;
-    private clearGlobalError;
-    clearItemError(itemEntryId?: ItemEntry['id'], columnId?: string, errorKey?: string): void;
-    private handleRemovedItemEntry;
-}
-export {};
+import { ApiEnumItemType, ApiFields, ItemId } from '@rentman/backend-types';
+import { AbstractCache, AbstractCacheDependencyInterface, ApiQuery, ApiRequestColumn, ApiRequestColumns, CachedQueryItem, CachedQueryItemTree, ChangesDelta, ChangesDeltaResult, ChildCollectionOptions, ChildCollectionResources, ChildCollectionResourcesNull, CollectionDefinition, CollectionOptionsInterface, CollectionQuery, CollectionResource, CollectionResourceParentIdMap, ConversionMap, CreateRequestParameterMap, DeregFunction, EntryParentNull, FieldChangeCallback, FieldMap, InternalChangesDelta, ItemEntry, ItemEntryOptions, ItemIdConversionMap, ItemOptionsInterface, ItemResource, ItemResourcesItemTypeMap, ItemTypeMap, LinkCollectionDefinition, ModuleChangesCompilationResult, OnAfterCreateCallback, ParentChangesDelta, ParentItemMap, PromiseInterface, RmCore, ServerCache, TransactionCacheCallbackCondition, TransactionCacheCallbackType, TransactionCachedQueryHandler, TransactionCollectionHandler, TransactionEventHandler, TransactionItemEntryChanges, TransactionItemHandler, TransactionOptions, TransactionValidatorFactory } from '../../../internal';
+declare type ItemResourceLinks<ItemTypeType extends ApiEnumItemType> = {
+    main: ItemResource<ItemTypeType>;
+    linked: ItemResourcesItemTypeMap;
+};
+export declare enum TransactionErrorLevel {
+    warning = "warning",
+    error = "error"
+}
+export declare type UndoFunction = () => PromiseInterface<ChangesDeltaResult>;
+/**
+ * @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;
+            };
+        };
+    };
+    get 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 | 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 cachedQueryHandler: TransactionCachedQueryHandler;
+    readonly collectionHandler: TransactionCollectionHandler;
+    readonly eventHandler: TransactionEventHandler;
+    private readonly validator?;
+    private readonly options;
+    private _isValid;
+    private historyStep;
+    private undoDeltas;
+    private appliedDeltas;
+    constructor(dependencies: AbstractCacheDependencyInterface, core: RmCore, parent: AbstractCache, 
+    /**
+     * @description
+     * For debugging purposes
+     */
+    id?: string | undefined, validatorFactory?: TransactionValidatorFactory, options?: Partial<TransactionOptions>);
+    undo(): ReturnType<UndoFunction>;
+    redo(): ReturnType<TransactionCache['applyChangesDelta']>;
+    createChild(id?: string, validatorFactory?: TransactionValidatorFactory, options?: TransactionOptions): TransactionCache;
+    destroy(): void;
+    expandCollectionResource(collectionResource: CollectionResource, newColumns: ApiRequestColumns): PromiseInterface<void>;
+    /**
+     * @description
+     * Expands the collection with the new request columns, assumes that all collections have the same itemType
+     */
+    expandCollectionResources<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, collections: CollectionResourceParentIdMap<ItemTypeType>, newColumns: ApiRequestColumn[]): PromiseInterface<CollectionResourceParentIdMap>;
+    registerFieldChangeCallback<ItemTypeType extends ApiEnumItemType>(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
+     */
+    applyChangesFromParent(parentChangesDelta: ParentChangesDelta, isCalledAfterSocketUpdate?: boolean, conversionMap?: ItemIdConversionMap): PromiseInterface<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)
+     */
+    applyChangesDelta(changesDelta: ChangesDelta | InternalChangesDelta): 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 ApiEnumItemType = any>(itemEntry: ItemEntry<ItemTypeType>, fromInitial?: boolean, providedFields?: FieldMap<ItemTypeType>): EntryParentNull;
+    getCollectionChangesRecursively<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, parsedQuery: CollectionQuery): CachedQueryItem<ItemTypeType> | undefined;
+    /**
+     * @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 cached queries
+     */
+    clearCollectionResource(resource: CollectionResource): void;
+    /**
+     * @description
+     * Returns whether or not the {@link TransactionCache.rootItem rootItem} is uses locks
+     */
+    isLockable(): boolean;
+    /**
+     * @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>;
+    /**
+     * Rejects when another user is holding the lock, as opposed to {@link LockService.fetchLock}.
+     */
+    fetchLock(): PromiseInterface<void>;
+    detectChanges(force?: boolean): 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
+     * 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 ApiEnumItemType>(linkType: ApiEnumItemType, itemType: ItemTypeType, options: CollectionOptionsInterface<ItemTypeType>): PromiseInterface<CollectionResourceParentIdMap<ItemTypeType>>;
+    getLinkCollectionsFromDef<ItemTypeType extends ApiEnumItemType>(linkType: ApiEnumItemType, linkIdArray: ItemId[], definition: LinkCollectionDefinition<ItemTypeType>): PromiseInterface<CollectionResourceParentIdMap<ItemTypeType>>;
+    /**
+     * @deprecated Use the `children` collection option instead.
+     */
+    getLinkCollections<ItemTypeType extends ApiEnumItemType>(linkType: ApiEnumItemType, linkIdArray: ItemId[], itemType: ItemTypeType, options: CollectionOptionsInterface<ItemTypeType>): PromiseInterface<CollectionResourceParentIdMap<ItemTypeType>>;
+    getCollectionFromDef<ItemTypeType extends ApiEnumItemType>(definition: CollectionDefinition<ItemTypeType>): PromiseInterface<CollectionResource<ItemTypeType>>;
+    getCollection<ItemTypeType extends ApiEnumItemType, ColumnIds extends Array<keyof ApiFields[ItemTypeType]> = Array<keyof ApiFields[ItemTypeType]>>(itemType: ItemTypeType, options: CollectionOptionsInterface<ItemTypeType>): PromiseInterface<CollectionResource<ItemTypeType, ColumnIds>>;
+    getCollectionDef<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, options: CollectionOptionsInterface<ItemTypeType>): CollectionDefinition<ItemTypeType>;
+    getLinkCollectionsDef<ItemTypeType extends ApiEnumItemType>(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 ApiEnumItemType>(itemType: ItemTypeType, stateKey: ItemId | string, options?: ItemOptionsInterface, isRoot?: boolean): PromiseInterface<ItemResource<ItemTypeType>>;
+    getDuplicateById<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, duplicateId: ItemId, options: ItemOptionsInterface, returnLinks: true, isRoot?: boolean): PromiseInterface<ItemResourceLinks<ItemTypeType>>;
+    getDuplicateById<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, duplicateId: ItemId, options: ItemOptionsInterface, returnLinks?: boolean, isRoot?: boolean): PromiseInterface<ItemResource<ItemTypeType>>;
+    getNewResourceWithId<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, itemId: ItemId, options: Partial<ItemEntryOptions>, returnLinks: true, isRoot?: boolean): PromiseInterface<ItemResourceLinks<ItemTypeType>>;
+    getNewResourceWithId<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, itemId: ItemId, options: Partial<ItemEntryOptions>, returnLinks?: boolean, isRoot?: boolean): PromiseInterface<ItemResource<ItemTypeType>>;
+    getNewResource<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, options: ItemOptionsInterface, returnLinks: true, isRoot?: boolean): PromiseInterface<ItemResourceLinks<ItemTypeType>>;
+    getNewResource<ItemTypeType extends ApiEnumItemType>(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 ApiEnumItemType>(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 ApiEnumItemType>(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 ApiEnumItemType, ColumnIds extends Array<keyof ApiFields[ItemTypeType]> = Array<keyof ApiFields[ItemTypeType]>>(itemType: ItemTypeType, itemId: ItemId, options?: Partial<ItemEntryOptions>, isRoot?: boolean): PromiseInterface<ItemResource<ItemTypeType, ColumnIds>>;
+    /**
+     * @description
+     * Fetches the title of an item, does not create an {@link ItemResource ItemResource}
+     */
+    fetchTitle(itemType: ApiEnumItemType, 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: ApiEnumItemType, itemId: ItemEntry['itemId']): ItemEntry | 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 ApiEnumItemType>(itemEntry: ItemEntry<ItemTypeType>, childCollectionMap?: ChildCollectionResourcesNull, isNew?: boolean): ItemResource<ItemTypeType>;
+    createItemResources<ItemTypeType extends ApiEnumItemType, ColumnIds extends Array<keyof ApiFields[ItemTypeType]>>(itemEntries: Array<ItemEntry<ItemTypeType>>, childCollectionResourceMap?: ChildCollectionResourcesNull): Array<ItemResource<ItemTypeType, ColumnIds>>;
+    processLinkedItems<ItemTypeType extends ApiEnumItemType>(linkedEntries: ItemTypeMap<ItemEntry[]>): ItemResourcesItemTypeMap<ItemResource<ItemTypeType>>;
+    createCollectionResource<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, options: CollectionOptionsInterface<ItemTypeType>, initialEntries: Array<ItemEntry<ItemTypeType>>, childCollectionResourceMap?: ParentItemMap<CollectionResource> | null): CollectionResource<ItemTypeType>;
+    createChildCollectionResources(parentType: ApiEnumItemType, options: ChildCollectionOptions, cachedQueryItems: ParentItemMap<CachedQueryItemTree>): ChildCollectionResources;
+    private createChildCollectionResource;
+    getChangesFromItemChanges<ItemTypeType extends ApiEnumItemType = any>(changesObject: TransactionItemEntryChanges<FieldMap<ItemTypeType>>): FieldMap<ItemTypeType>;
+    /**
+     * @description
+     * Fetches all required columns to match/fit in collections
+     */
+    private expandItemsFromDelta;
+    private clearGlobalError;
+    clearItemError(itemEntryId?: ItemEntry['id'], columnId?: string, errorKey?: string): void;
+    private handleRemovedItemEntry;
+}
+export {};