@rentman/rm-core 12.1.0 → 12.1.2

package/dist/types/src/classes/CacheSyncer.d.ts

@@ -1,71 +1,71 @@
-import { ApiEnumItemType } from '@rentman/backend-types';
-import { AbstractCache, ApiRequestService, CachedQueryItem, ChangesDeltaBase, CollectionQuery, CollectionResource, FieldMap, ItemEntry, ItemTypeMap, ParentChangesDelta, PromiseInterface, PromiseLibraryInterface, QueryMatcherFactory, QueryService } from '../internal';
-export declare type CacheSyncerQueryMap = ItemTypeMap<CacheSyncerQueryMapEntry>;
-export declare type CacheSyncerQueryMapEntry = {
-    [cachedQueryString: string]: {
-        cachedQueryItems: CachedQueryItem[];
-        collectionResources: CollectionResource[];
-    };
-};
-declare type CacheSyncerMatchesMapEntry = {
-    query: CollectionQuery;
-    items: ItemEntry[];
-};
-declare type CacheSyncerMatchesMap = ItemTypeMap<{
-    [cachedQueryString: string]: CacheSyncerMatchesMapEntry;
-}>;
-export declare class CacheSyncer {
-    private queryService;
-    private queryMatcherFactory;
-    private apiRequestService;
-    private promiseService;
-    private transaction;
-    private cachedQueryMap;
-    matches: {
-        true: CacheSyncerMatchesMap;
-        false: CacheSyncerMatchesMap;
-        maybe: CacheSyncerMatchesMap;
-    };
-    constructor(queryService: QueryService, queryMatcherFactory: QueryMatcherFactory, apiRequestService: ApiRequestService, promiseService: PromiseLibraryInterface, transaction: AbstractCache, cachedQueryMap: CacheSyncerQueryMap);
-    getMatches<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, queryString: string, type: 'true' | 'false' | 'maybe'): ItemEntry<ItemTypeType>[];
-    /**
-     * Syncing of collections always runs in 3 phases:
-     * - Remove items from collections
-     * - Add items to collections
-     * - Process MAYBE matches
-     * -- Remove MAYBE items from collections
-     * -- Add MAYBE items to collections
-     *
-     * @param isCalledAfterSocketUpdate
-     * @param changesDelta
-     */
-    syncCollections(isCalledAfterSocketUpdate?: boolean, changesDelta?: ChangesDeltaBase): PromiseInterface<void>;
-    /**
-     * Syncing of cached queries runs in 3 phases:
-     * - Remove items from collections
-     * - Add items to collections
-     * - Process MAYBE matches
-     * -- Remove MAYBE items from collections
-     * -- Add MAYBE items to collections
-     *
-     * @param _isCalledAfterSocketUpdate
-     * @param changesDelta
-     */
-    syncCachedQueries(_isCalledAfterSocketUpdate?: boolean, changesDelta?: ChangesDeltaBase): PromiseInterface<void[]>;
-    expand<ItemEntryType extends ItemEntry>(itemEntry: ItemEntryType, fields: FieldMap<ItemEntryType['itemType']>): this;
-    processDelta(parentChangesDelta: ParentChangesDelta): this;
-    _expand<ItemTypeType extends ApiEnumItemType = any>(itemEntry: ItemEntry<ItemTypeType>, matchFunction: (itemType: ItemTypeType, parsedQuery: CollectionQuery) => boolean | 'maybe'): this;
-    /**
-     * Unlike the functions that use a promise accumulator, this function *can* result in a rejection. It should be handled
-     * by the caller.
-     */
-    protected processMaybeMatches<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, query: CollectionQuery, maybeItemEntries: ItemEntry<ItemTypeType>[], changesDelta: ChangesDeltaBase | undefined): PromiseInterface<ItemEntry<ItemTypeType>[]>;
-    /**
-     * Returns null if none of the promises resulted in an exception, or the exception otherwise.
-     */
-    private resolveAll;
-    private addMatchedEntriesToCollections;
-    private processCollectionMaybe;
-    private processCachedQueryMaybe;
-}
-export {};
+import { ApiEnumItemType } from '@rentman/backend-types';
+import { AbstractCache, ApiRequestService, CachedQueryItem, ChangesDeltaBase, CollectionQuery, CollectionResource, FieldMap, ItemEntry, ItemTypeMap, ParentChangesDelta, PromiseInterface, PromiseLibraryInterface, QueryMatcherFactory, QueryService } from '../internal';
+export declare type CacheSyncerQueryMap = ItemTypeMap<CacheSyncerQueryMapEntry>;
+export declare type CacheSyncerQueryMapEntry = {
+    [cachedQueryString: string]: {
+        cachedQueryItems: CachedQueryItem[];
+        collectionResources: CollectionResource[];
+    };
+};
+declare type CacheSyncerMatchesMapEntry = {
+    query: CollectionQuery;
+    items: ItemEntry[];
+};
+declare type CacheSyncerMatchesMap = ItemTypeMap<{
+    [cachedQueryString: string]: CacheSyncerMatchesMapEntry;
+}>;
+export declare class CacheSyncer {
+    private queryService;
+    private queryMatcherFactory;
+    private apiRequestService;
+    private promiseService;
+    private transaction;
+    private cachedQueryMap;
+    matches: {
+        true: CacheSyncerMatchesMap;
+        false: CacheSyncerMatchesMap;
+        maybe: CacheSyncerMatchesMap;
+    };
+    constructor(queryService: QueryService, queryMatcherFactory: QueryMatcherFactory, apiRequestService: ApiRequestService, promiseService: PromiseLibraryInterface, transaction: AbstractCache, cachedQueryMap: CacheSyncerQueryMap);
+    getMatches<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, queryString: string, type: 'true' | 'false' | 'maybe'): ItemEntry<ItemTypeType>[];
+    /**
+     * Syncing of collections always runs in 3 phases:
+     * - Remove items from collections
+     * - Add items to collections
+     * - Process MAYBE matches
+     * -- Remove MAYBE items from collections
+     * -- Add MAYBE items to collections
+     *
+     * @param isCalledAfterSocketUpdate
+     * @param changesDelta
+     */
+    syncCollections(isCalledAfterSocketUpdate?: boolean, changesDelta?: ChangesDeltaBase): PromiseInterface<void>;
+    /**
+     * Syncing of cached queries runs in 3 phases:
+     * - Remove items from collections
+     * - Add items to collections
+     * - Process MAYBE matches
+     * -- Remove MAYBE items from collections
+     * -- Add MAYBE items to collections
+     *
+     * @param _isCalledAfterSocketUpdate
+     * @param changesDelta
+     */
+    syncCachedQueries(_isCalledAfterSocketUpdate?: boolean, changesDelta?: ChangesDeltaBase): PromiseInterface<void[]>;
+    expand<ItemEntryType extends ItemEntry>(itemEntry: ItemEntryType, fields: FieldMap<ItemEntryType['itemType']>): this;
+    processDelta(parentChangesDelta: ParentChangesDelta): this;
+    _expand<ItemTypeType extends ApiEnumItemType = any>(itemEntry: ItemEntry<ItemTypeType>, matchFunction: (itemType: ItemTypeType, parsedQuery: CollectionQuery) => boolean | 'maybe'): this;
+    /**
+     * Unlike the functions that use a promise accumulator, this function *can* result in a rejection. It should be handled
+     * by the caller.
+     */
+    protected processMaybeMatches<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, query: CollectionQuery, maybeItemEntries: ItemEntry<ItemTypeType>[], changesDelta: ChangesDeltaBase | undefined): PromiseInterface<ItemEntry<ItemTypeType>[]>;
+    /**
+     * Returns null if none of the promises resulted in an exception, or the exception otherwise.
+     */
+    private resolveAll;
+    private addMatchedEntriesToCollections;
+    private processCollectionMaybe;
+    private processCachedQueryMaybe;
+}
+export {};

package/dist/types/src/classes/ChangesCompilation.d.ts

@@ -1,33 +1,33 @@
-import { ApiEnumItemType } from '@rentman/backend-types';
-import { InternalCreateDelta, ItemEntry, ItemEntryMap, ItemMap, TransactionCache } from '../internal';
-export declare type CreateRequestCompilationParent = ApiEnumItemType | 'Void';
-export declare type CreateCompilation = {
-    [parentType: string]: {
-        [parentId: number]: ItemMap<InternalCreateDelta>;
-    };
-};
-export declare type DeleteCompilation = {
-    [itemType: string]: ItemEntry[];
-};
-export declare type UpdateCompilation = ItemEntryMap;
-export declare type MoveCompilation = {
-    [parentType: string]: {
-        [parentId: number]: ItemEntry[];
-    };
-};
-export declare class ChangesCompilation {
-    private transaction;
-    compilation: {
-        create: CreateCompilation;
-        delete: DeleteCompilation;
-        update: UpdateCompilation;
-        move: MoveCompilation;
-    };
-    constructor(transaction: TransactionCache);
-    private processDelta;
-    private getDefaultParent;
-    private addMoveEntry;
-    private addDeleteEntry;
-    private addUpdateEntry;
-    private addCreateEntry;
-}
+import { ApiEnumItemType } from '@rentman/backend-types';
+import { InternalCreateDelta, ItemEntry, ItemEntryMap, ItemMap, TransactionCache } from '../internal';
+export declare type CreateRequestCompilationParent = ApiEnumItemType | 'Void';
+export declare type CreateCompilation = {
+    [parentType: string]: {
+        [parentId: number]: ItemMap<InternalCreateDelta>;
+    };
+};
+export declare type DeleteCompilation = {
+    [itemType: string]: ItemEntry[];
+};
+export declare type UpdateCompilation = ItemEntryMap;
+export declare type MoveCompilation = {
+    [parentType: string]: {
+        [parentId: number]: ItemEntry[];
+    };
+};
+export declare class ChangesCompilation {
+    private transaction;
+    compilation: {
+        create: CreateCompilation;
+        delete: DeleteCompilation;
+        update: UpdateCompilation;
+        move: MoveCompilation;
+    };
+    constructor(transaction: TransactionCache);
+    private processDelta;
+    private getDefaultParent;
+    private addMoveEntry;
+    private addDeleteEntry;
+    private addUpdateEntry;
+    private addCreateEntry;
+}

package/dist/types/src/classes/ChangesDelta.d.ts

@@ -1,65 +1,65 @@
-import { ApiEnumItemType, ApiFields, ItemId } from '@rentman/backend-types';
-import { ApiFormatter, ChangesDeltaBase, ChangesDeltaItemUpdateMode, ColumnExpansionResult, ColumnSet, CreatedChangesDelta, EntryParent, EntryParentNull, ErrorHandlerInterface, FieldMap, ItemCreateService, ItemEntry, ItemEntryService, PromiseInterface } from '../internal';
-export declare type ChangesDeltaItemDeleteDelta = ItemEntry;
-/**
- * @description
- * ChangesDelta used to apply changes from outside of the core to a transaction
- *
- * ----------
- *
- * The difference between {@link InternalChangesDelta InternalChangesDelta} and {@link ChangesDelta ChangesDelta} is that the ChangesDelta
- * assumes 'created' values have no itemEntries yet.
- *
- * Use this when calling {@link TransactionCache.applyChangesDelta applyChangesDelta}
- */
-export declare class ChangesDelta extends ChangesDeltaBase {
-    private errorHandler;
-    private itemCreateService;
-    created: CreatedChangesDelta;
-    deleted: {
-        [itemType: string]: {
-            [entryId: string]: ChangesDeltaItemDeleteDelta;
-        };
-    };
-    constructor(errorHandler: ErrorHandlerInterface, itemCreateService: ItemCreateService, itemEntryService: ItemEntryService, apiFormatter: ApiFormatter);
-    merge(otherChangesDelta: ChangesDelta): ChangesDelta;
-    /**
-     * @description
-     * Fetches a template for the passed itemType and processes the passed values and sets the item to be created when the delta is applied
-     *
-     * @remark
-     * - If the values don't contain an `id` a new one will be generated
-     * - If you want to set a parent set the proper field, you can't pass it as a separate object
-     */
-    setItemCreated<ItemTypeType extends ApiEnumItemType, Fields extends Partial<FieldMap<ItemTypeType>>>(itemType: ItemTypeType, values: Fields): PromiseInterface<this>;
-    setItemUpdated<ItemTypeType extends ApiEnumItemType>(entry: ItemEntry<ItemTypeType>, fields: Partial<FieldMap<ItemTypeType>>, columnExpansionResult?: ColumnExpansionResult<ItemTypeType> | null, parent?: EntryParentNull, mode?: ChangesDeltaItemUpdateMode, didChangeAnyFieldOnParentTransaction?: boolean, previous?: FieldMap<ItemTypeType> | null): this;
-    setItemDeleted(deleted: ChangesDeltaItemDeleteDelta): this;
-    setItemsDeleted(deleted: ChangesDeltaItemDeleteDelta[]): this;
-    /**
-     * @description
-     * Fetches a template for the passed itemType and processes the passed values and sets the items to be created when the delta is applied
-     *
-     * @remark
-     * - If the values don't contain an `id` a new one will be generated
-     * - If you want to set a parent set the proper field, you can't pass it as a separate object
-     */
-    setItemsCreated<ItemTypeType extends ApiEnumItemType, ColumnIds extends (keyof ApiFields[ItemTypeType])[] = (keyof ApiFields[ItemTypeType])[]>(itemType: ItemTypeType, valuesArray: Partial<FieldMap<ItemTypeType, ColumnIds>>[]): PromiseInterface<this>;
-    /**
-     * @description
-     * Will create an {@link ItemEntry ItemEntry} when the delta is applied
-     * Does not always mean the item is local, just that it isn't cached yet
-     *
-     * @remark
-     * If you're calling this from the frontend you probably want to call `setItemCreated`, which will fetch a template and process the values for you
-     * If you don't, you have to make sure the values are all correct and all template items are processed
-     *
-     * @internal
-     */
-    _setItemCreated<ItemTypeType extends ApiEnumItemType, Fields extends FieldMap<ItemTypeType>>(itemId: ItemId, fields: Fields, columns: ColumnSet<ItemTypeType>, parent?: EntryParentNull, isRoot?: boolean, isApiResponse?: boolean): this;
-    /**
-     * @description
-     * Convenience function to assign the proper parent fields, will call {@link ChangesDeltaBase.setItemUpdated setItemUpdated} internally
-     */
-    setItemMoved(entry: ItemEntry, to: EntryParent, mode?: ChangesDeltaItemUpdateMode): this;
-    isEmpty(): boolean;
-}
+import { ApiEnumItemType, ApiFields, ItemId } from '@rentman/backend-types';
+import { ApiFormatter, ChangesDeltaBase, ChangesDeltaItemUpdateMode, ColumnExpansionResult, ColumnSet, CreatedChangesDelta, EntryParent, EntryParentNull, ErrorHandlerInterface, FieldMap, ItemCreateService, ItemEntry, ItemEntryService, PromiseInterface } from '../internal';
+export declare type ChangesDeltaItemDeleteDelta = ItemEntry;
+/**
+ * @description
+ * ChangesDelta used to apply changes from outside of the core to a transaction
+ *
+ * ----------
+ *
+ * The difference between {@link InternalChangesDelta InternalChangesDelta} and {@link ChangesDelta ChangesDelta} is that the ChangesDelta
+ * assumes 'created' values have no itemEntries yet.
+ *
+ * Use this when calling {@link TransactionCache.applyChangesDelta applyChangesDelta}
+ */
+export declare class ChangesDelta extends ChangesDeltaBase {
+    private errorHandler;
+    private itemCreateService;
+    created: CreatedChangesDelta;
+    deleted: {
+        [itemType: string]: {
+            [entryId: string]: ChangesDeltaItemDeleteDelta;
+        };
+    };
+    constructor(errorHandler: ErrorHandlerInterface, itemCreateService: ItemCreateService, itemEntryService: ItemEntryService, apiFormatter: ApiFormatter);
+    merge(otherChangesDelta: ChangesDelta): ChangesDelta;
+    /**
+     * @description
+     * Fetches a template for the passed itemType and processes the passed values and sets the item to be created when the delta is applied
+     *
+     * @remark
+     * - If the values don't contain an `id` a new one will be generated
+     * - If you want to set a parent set the proper field, you can't pass it as a separate object
+     */
+    setItemCreated<ItemTypeType extends ApiEnumItemType, Fields extends Partial<FieldMap<ItemTypeType>>>(itemType: ItemTypeType, values: Fields): PromiseInterface<this>;
+    setItemUpdated<ItemTypeType extends ApiEnumItemType>(entry: ItemEntry<ItemTypeType>, fields: Partial<FieldMap<ItemTypeType>>, columnExpansionResult?: ColumnExpansionResult<ItemTypeType> | null, parent?: EntryParentNull, mode?: ChangesDeltaItemUpdateMode, didChangeAnyFieldOnParentTransaction?: boolean, previous?: FieldMap<ItemTypeType> | null): this;
+    setItemDeleted(deleted: ChangesDeltaItemDeleteDelta): this;
+    setItemsDeleted(deleted: ChangesDeltaItemDeleteDelta[]): this;
+    /**
+     * @description
+     * Fetches a template for the passed itemType and processes the passed values and sets the items to be created when the delta is applied
+     *
+     * @remark
+     * - If the values don't contain an `id` a new one will be generated
+     * - If you want to set a parent set the proper field, you can't pass it as a separate object
+     */
+    setItemsCreated<ItemTypeType extends ApiEnumItemType, ColumnIds extends (keyof ApiFields[ItemTypeType])[] = (keyof ApiFields[ItemTypeType])[]>(itemType: ItemTypeType, valuesArray: Partial<FieldMap<ItemTypeType, ColumnIds>>[]): PromiseInterface<this>;
+    /**
+     * @description
+     * Will create an {@link ItemEntry ItemEntry} when the delta is applied
+     * Does not always mean the item is local, just that it isn't cached yet
+     *
+     * @remark
+     * If you're calling this from the frontend you probably want to call `setItemCreated`, which will fetch a template and process the values for you
+     * If you don't, you have to make sure the values are all correct and all template items are processed
+     *
+     * @internal
+     */
+    _setItemCreated<ItemTypeType extends ApiEnumItemType, Fields extends FieldMap<ItemTypeType>>(itemId: ItemId, fields: Fields, columns: ColumnSet<ItemTypeType>, parent?: EntryParentNull, isRoot?: boolean, isApiResponse?: boolean): this;
+    /**
+     * @description
+     * Convenience function to assign the proper parent fields, will call {@link ChangesDeltaBase.setItemUpdated setItemUpdated} internally
+     */
+    setItemMoved(entry: ItemEntry, to: EntryParent, mode?: ChangesDeltaItemUpdateMode): this;
+    isEmpty(): boolean;
+}

package/dist/types/src/classes/ChangesDeltaBase.d.ts

@@ -1,88 +1,88 @@
-import { ApiEnumItemType, ItemId } from '@rentman/backend-types';
-import { ApiFormatter, ColumnExpansionResult, EntryParentNull, FieldMap, ItemEntry, ItemEntryChangesTuple, ItemEntryService, ItemIdConversionMap, ItemTypeColumnId } from '../internal';
-export declare type ChangesDeltaResult = {
-    itemIdConversionMap: ItemIdConversionMap;
-    created: ItemEntry[];
-};
-export declare enum ChangesDeltaItemUpdateMode {
-    CLEAR_ALWAYS = "overwrite",
-    CLEAR_WHEN_SAME = "same",
-    KEEP_WHEN_DIFFERENT = "different",
-    APPEND = "append",
-    QUERY = "query"
-}
-/**
- * @remark
- * We explicitly keep track of the new parent, so we can set an item to moved if it isn't null (Needed for linkTo request)
- */
-export declare type ChangesDeltaItemUpdateDelta<ItemTypeType extends ApiEnumItemType = any> = {
-    entry: ItemEntry<ItemTypeType>;
-    changes: {
-        expandedColumns: ColumnExpansionResult<ItemTypeType> | null;
-        fields: FieldMap<ItemTypeType>;
-        parent: EntryParentNull;
-    };
-    previous: FieldMap<ItemTypeType> | null;
-    mode: ChangesDeltaItemUpdateMode;
-    didChangeAnyField: boolean;
-};
-export declare abstract class ChangesDeltaBase {
-    protected itemEntryService: ItemEntryService;
-    protected apiFormatter: ApiFormatter;
-    updated: {
-        [itemEntryId: number]: ChangesDeltaItemUpdateDelta;
-    };
-    itemIdConversionMap: ItemIdConversionMap;
-    /**
-     * Only contains remote items, when rolling back local items the whole entries are deleted.
-     */
-    restored: {
-        [itemEntryId: number]: ItemEntryChangesTuple<any>;
-    };
-    /**
-     * @private
-     * @warning
-     * Do not set in frontend
-     */
-    __isUndo: boolean;
-    /**
-     * @private
-     * @warning
-     * Do not set in frontend
-     */
-    __isRedo: boolean;
-    /**
-     * @private
-     */
-    _queryResults: {
-        [itemType: string]: {
-            [queryString: string]: {
-                [itemId: string]: true;
-            };
-        };
-    };
-    /**
-     * @private
-     * When set, only collections of this item type will be matched.
-     */
-    _queryItemType?: ApiEnumItemType;
-    protected constructor(itemEntryService: ItemEntryService, apiFormatter: ApiFormatter);
-    getUpdatedValue<ItemTypeType extends ApiEnumItemType, ColumnId extends ItemTypeColumnId<ItemTypeType> = any>(itemEntry: ItemEntry<ItemTypeType>, columnId: ColumnId): FieldMap<ItemTypeType>[ColumnId] | undefined;
-    /**
-     * @private
-     */
-    _setQueryItemType(itemType?: ApiEnumItemType): this;
-    /**
-     * @description
-     * Adds a hint for the {@link CollectionMatcherBase CacheSyncer] to the ChangesDelta, when the CollectionMatcher encounters a collection
-     * with the exact query, it will use the hint instead of running the matcher
-     *
-     * @private
-     */
-    _setQueryResult(itemType: ApiEnumItemType, queryString: string, itemIds: ItemId[] | {
-        [itemId: string]: true;
-    }): this;
-    setItemUpdated<ItemTypeType extends ApiEnumItemType>(entry: ItemEntry<ItemTypeType>, fields: Partial<FieldMap<ItemTypeType>>, columnExpansionResult?: ColumnExpansionResult<ItemTypeType> | null, parent?: EntryParentNull, mode?: ChangesDeltaItemUpdateMode, didChangeAnyFieldOnParentTransaction?: boolean, previous?: FieldMap<ItemTypeType> | null): this;
-    setItemRestored<ItemTypeType extends ApiEnumItemType>(itemEntry: ItemEntry<ItemTypeType>, transactionItemEntryChanges: FieldMap<ItemTypeType>): void;
-    isEmpty(): boolean;
-}
+import { ApiEnumItemType, ItemId } from '@rentman/backend-types';
+import { ApiFormatter, ColumnExpansionResult, EntryParentNull, FieldMap, ItemEntry, ItemEntryChangesTuple, ItemEntryService, ItemIdConversionMap, ItemTypeColumnId } from '../internal';
+export declare type ChangesDeltaResult = {
+    itemIdConversionMap: ItemIdConversionMap;
+    created: ItemEntry[];
+};
+export declare enum ChangesDeltaItemUpdateMode {
+    CLEAR_ALWAYS = "overwrite",
+    CLEAR_WHEN_SAME = "same",
+    KEEP_WHEN_DIFFERENT = "different",
+    APPEND = "append",
+    QUERY = "query"
+}
+/**
+ * @remark
+ * We explicitly keep track of the new parent, so we can set an item to moved if it isn't null (Needed for linkTo request)
+ */
+export declare type ChangesDeltaItemUpdateDelta<ItemTypeType extends ApiEnumItemType = any> = {
+    entry: ItemEntry<ItemTypeType>;
+    changes: {
+        expandedColumns: ColumnExpansionResult<ItemTypeType> | null;
+        fields: FieldMap<ItemTypeType>;
+        parent: EntryParentNull;
+    };
+    previous: FieldMap<ItemTypeType> | null;
+    mode: ChangesDeltaItemUpdateMode;
+    didChangeAnyField: boolean;
+};
+export declare abstract class ChangesDeltaBase {
+    protected itemEntryService: ItemEntryService;
+    protected apiFormatter: ApiFormatter;
+    updated: {
+        [itemEntryId: number]: ChangesDeltaItemUpdateDelta;
+    };
+    itemIdConversionMap: ItemIdConversionMap;
+    /**
+     * Only contains remote items, when rolling back local items the whole entries are deleted.
+     */
+    restored: {
+        [itemEntryId: number]: ItemEntryChangesTuple<any>;
+    };
+    /**
+     * @private
+     * @warning
+     * Do not set in frontend
+     */
+    __isUndo: boolean;
+    /**
+     * @private
+     * @warning
+     * Do not set in frontend
+     */
+    __isRedo: boolean;
+    /**
+     * @private
+     */
+    _queryResults: {
+        [itemType: string]: {
+            [queryString: string]: {
+                [itemId: string]: true;
+            };
+        };
+    };
+    /**
+     * @private
+     * When set, only collections of this item type will be matched.
+     */
+    _queryItemType?: ApiEnumItemType;
+    protected constructor(itemEntryService: ItemEntryService, apiFormatter: ApiFormatter);
+    getUpdatedValue<ItemTypeType extends ApiEnumItemType, ColumnId extends ItemTypeColumnId<ItemTypeType> = any>(itemEntry: ItemEntry<ItemTypeType>, columnId: ColumnId): FieldMap<ItemTypeType>[ColumnId] | undefined;
+    /**
+     * @private
+     */
+    _setQueryItemType(itemType?: ApiEnumItemType): this;
+    /**
+     * @description
+     * Adds a hint for the {@link CollectionMatcherBase CacheSyncer] to the ChangesDelta, when the CollectionMatcher encounters a collection
+     * with the exact query, it will use the hint instead of running the matcher
+     *
+     * @private
+     */
+    _setQueryResult(itemType: ApiEnumItemType, queryString: string, itemIds: ItemId[] | {
+        [itemId: string]: true;
+    }): this;
+    setItemUpdated<ItemTypeType extends ApiEnumItemType>(entry: ItemEntry<ItemTypeType>, fields: Partial<FieldMap<ItemTypeType>>, columnExpansionResult?: ColumnExpansionResult<ItemTypeType> | null, parent?: EntryParentNull, mode?: ChangesDeltaItemUpdateMode, didChangeAnyFieldOnParentTransaction?: boolean, previous?: FieldMap<ItemTypeType> | null): this;
+    setItemRestored<ItemTypeType extends ApiEnumItemType>(itemEntry: ItemEntry<ItemTypeType>, transactionItemEntryChanges: FieldMap<ItemTypeType>): void;
+    isEmpty(): boolean;
+}

package/dist/types/src/classes/ChangesProcessor.d.ts

@@ -1,40 +1,40 @@
-import { ApiRequestService, ChangesCompilationFactory, ChangesDeltaFactory, CreateRequestFactory, ErrorHandlerInterface, ItemEntryService, ItemIdConversionMap, PromiseInterface, PromiseLibraryInterface, RequestColumnExpansionFactory, TransactionCache } from '../internal';
-export declare type OnAfterCreateCallback = (conversionMap: ItemIdConversionMap) => void;
-/**
- * @description
- * Executes the changes from a specific {@link TransactionCache transaction} and returns a {@link ChangesDelta ChangesDelta}
- */
-export declare class ChangesProcessor {
-    private changesDeltaFactory;
-    private apiRequestService;
-    private changesCompilationFactory;
-    private createRequestFactory;
-    private errorHandler;
-    private promiseService;
-    private requestColumnExpansionFactory;
-    private itemEntryService;
-    private transaction;
-    private breakUpByParent?;
-    private onAfterCreateCallback?;
-    private itemIdConversionMap;
-    private serverCache;
-    constructor(changesDeltaFactory: ChangesDeltaFactory, apiRequestService: ApiRequestService, changesCompilationFactory: ChangesCompilationFactory, createRequestFactory: CreateRequestFactory, errorHandler: ErrorHandlerInterface, promiseService: PromiseLibraryInterface, requestColumnExpansionFactory: RequestColumnExpansionFactory, itemEntryService: ItemEntryService, transaction: TransactionCache, breakUpByParent?: boolean | undefined, onAfterCreateCallback?: OnAfterCreateCallback | undefined);
-    /**
-     * @description
-     * Executes the requests in the order of:
-     * 1. create
-     * 2. move
-     * 3. delete
-     * 4. update
-     */
-    execute(): PromiseInterface<ItemIdConversionMap>;
-    private buildMoveRequest;
-    private getMapValue;
-    private executeCreateRequests;
-    private executeCreateRequest;
-    private executeUpdateRequests;
-    private executeUpdateRequest;
-    private executeDeleteRequests;
-    private executeDeleteRequest;
-    private executeMoveRequests;
-}
+import { ApiRequestService, ChangesCompilationFactory, ChangesDeltaFactory, CreateRequestFactory, ErrorHandlerInterface, ItemEntryService, ItemIdConversionMap, PromiseInterface, PromiseLibraryInterface, RequestColumnExpansionFactory, TransactionCache } from '../internal';
+export declare type OnAfterCreateCallback = (conversionMap: ItemIdConversionMap) => void;
+/**
+ * @description
+ * Executes the changes from a specific {@link TransactionCache transaction} and returns a {@link ChangesDelta ChangesDelta}
+ */
+export declare class ChangesProcessor {
+    private changesDeltaFactory;
+    private apiRequestService;
+    private changesCompilationFactory;
+    private createRequestFactory;
+    private errorHandler;
+    private promiseService;
+    private requestColumnExpansionFactory;
+    private itemEntryService;
+    private transaction;
+    private breakUpByParent?;
+    private onAfterCreateCallback?;
+    private itemIdConversionMap;
+    private serverCache;
+    constructor(changesDeltaFactory: ChangesDeltaFactory, apiRequestService: ApiRequestService, changesCompilationFactory: ChangesCompilationFactory, createRequestFactory: CreateRequestFactory, errorHandler: ErrorHandlerInterface, promiseService: PromiseLibraryInterface, requestColumnExpansionFactory: RequestColumnExpansionFactory, itemEntryService: ItemEntryService, transaction: TransactionCache, breakUpByParent?: boolean | undefined, onAfterCreateCallback?: OnAfterCreateCallback | undefined);
+    /**
+     * @description
+     * Executes the requests in the order of:
+     * 1. create
+     * 2. move
+     * 3. delete
+     * 4. update
+     */
+    execute(): PromiseInterface<ItemIdConversionMap>;
+    private buildMoveRequest;
+    private getMapValue;
+    private executeCreateRequests;
+    private executeCreateRequest;
+    private executeUpdateRequests;
+    private executeUpdateRequest;
+    private executeDeleteRequests;
+    private executeDeleteRequest;
+    private executeMoveRequests;
+}