@rentman/rm-core 11.0.4 → 12.0.0

package/dist/types/src/FieldLookupProxy.d.ts

@@ -0,0 +1,4 @@
+import { ApiEnumItemType } from '@rentman/backend-types';
+import { AbstractCache } from './classes/cache/AbstractCache';
+import { ItemEntry } from './models/ItemEntry';
+export declare const FieldLookupProxy: <ItemTypeType extends ApiEnumItemType>(transaction: AbstractCache, itemEntry: ItemEntry<ItemTypeType>, fromInitial?: boolean) => {};

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

@@ -40,15 +40,12 @@ export declare class ApiFormatter {
      * Note: parentChanges can be undefined for local items
      */
     mergeCopyFields<ItemTypeType extends ApiEnumItemType, ColumnIds extends ItemTypeColumnIds<ItemTypeType> = any>(parentChanges: FieldMap<ItemTypeType, ColumnIds> | undefined, changes: FieldMap<ItemTypeType, ColumnIds>, initial: FieldMap<ItemTypeType, ColumnIds>, newInitial: FieldMap<ItemTypeType, ColumnIds>, columns: ColumnInfo<ItemTypeType>[]): FieldMap<ItemTypeType, ColumnIds>;
-    formatRequest<ItemTypeType extends ApiEnumItemType>(initial: FieldMap<ItemTypeType>, modified: FieldMap<ItemTypeType>, columns: ColumnInfo<ItemTypeType>[]): {
-        [columnId: string]: any;
-    };
     formatRequestLocal<ItemTypeType extends ApiEnumItemType>(fields: FieldMap<ItemTypeType>, columns: ColumnInfo<ItemTypeType>[]): {
         [columnId: string]: any;
     };
     hasChanges<ItemTypeType extends ApiEnumItemType>(initial: FieldMap<ItemTypeType>, modified: FieldMap<ItemTypeType>, columns: ColumnInfo<ItemTypeType>[], includeReadOnlyColumns?: boolean, forceCompare?: boolean): boolean;
     getChanges<ItemTypeType extends ApiEnumItemType = any, ColumnIds extends ItemTypeColumnIds<ItemTypeType> = any>(initial: FieldMap<ItemTypeType, ColumnIds>, modified: FieldMap<ItemTypeType, ColumnIds>, columns: ColumnInfo<ItemTypeType, ColumnIds[number]>[]): GetChangesResult<ItemTypeType, ColumnIds[number]>[];
-    copyFields<ItemTypeType extends ApiEnumItemType = any, ColumnIds extends ItemTypeColumnIds<ItemTypeType> = any>(source: FieldMap<ItemTypeType, ColumnIds>, destination: Partial<FieldMap<ItemTypeType>>, columns: ColumnInfo<ItemTypeType, ColumnIds[number]>[]): FieldMap<ItemTypeType, ColumnIds>;
+    copyFields<ItemTypeType extends ApiEnumItemType = any, ColumnIds extends ItemTypeColumnIds<ItemTypeType> = any>(source: Partial<FieldMap<ItemTypeType, ColumnIds>>, destination: Partial<FieldMap<ItemTypeType>>, columns: ColumnInfo<ItemTypeType, ColumnIds[number]>[]): FieldMap<ItemTypeType, ColumnIds>;
     shallowCopyFields<ItemTypeType extends ApiEnumItemType>(shallowSource: FieldMap<ItemTypeType>, deepSource: FieldMap<ItemTypeType>, destination: FieldMap<ItemTypeType>, columns: ColumnInfo<ItemTypeType>[]): FieldMap<ItemTypeType>;
     setDefaultValues<ItemTypeType extends ApiEnumItemType = any>(destination: FieldMap<ItemTypeType>, columns: ColumnInfo<ItemTypeType>[]): FieldMap<ItemTypeType>;
     /**

package/dist/types/src/classes/BusinessLogicManager/BusinessLogicRule.d.ts

@@ -3,7 +3,6 @@ import { ItemEntry } from '../../models/ItemEntry';
 import { FieldMap, GetFieldValueType, ItemTypeColumnId } from '../../types/ItemTypesCollection';
 import { ApiFormatter } from '../ApiFormatter';
 import { TransactionCache } from '../cache/transaction/TransactionCache';
-import { TransactionItemHandler } from '../cache/transaction/TransactionItemHandler';
 import { ChangesDelta } from '../ChangesDelta';
 import { ChangesDeltaItemUpdateDelta } from '../ChangesDeltaBase';
 export declare type BusinessLogicRuleConfirmFn<ConditionResult = any> = (conditionResult: ConditionResult, changesDelta: ChangesDelta) => Promise<boolean>;
@@ -31,10 +30,10 @@ export declare abstract class BusinessLogicRule<ConditionResult extends any = an
      * @description
      * Checks if the business rule should run. It will first check if there's any item in the changesDelta this rule applies to. If this is the case it will check if the rule has a {@link BusinessLogicRule.confirmFn confirmFn} and show it if there is one.
      *
+     * @param transaction
      * @param changesDelta The changesDelta that is being applied
-     * @param itemChanges The transaction's item changes
      */
-    checkCondition(changesDelta: ChangesDelta, itemChanges: TransactionItemHandler['itemChanges']): Promise<ConditionResult | undefined>;
+    checkCondition(transaction: TransactionCache, changesDelta: ChangesDelta): Promise<ConditionResult | undefined>;
     /**
      * @description
      * The {@link BusinessLogicRule.dependency `dependency`} function gets the result of the {@link BusinessLogicRule.condition `condition`} function and has to ensure that
@@ -64,31 +63,31 @@ export declare abstract class BusinessLogicRule<ConditionResult extends any = an
      * The {@link BusinessLogicRule.condition `condition`} function should extract the items from the {@link ChangesDelta `ChangesDelta`} so that the {@link BusinessLogicRule.dependency `dependency`} function can fetch the required data for the business rule.
      * This function can return `undefined` if the rule does not apply to the items in the given ChangesDelta.
      *
+     * @param transaction
      * @param changesDelta The source changesDelta that triggered the business rule
-     * @param itemChanges The {@link TransactionItemHandler.itemChanges ItemChanges} of the transaction
      * @protected
      */
-    protected abstract condition(changesDelta: ChangesDelta, itemChanges: TransactionItemHandler['itemChanges']): ConditionResult | undefined;
+    protected abstract condition(changesDelta: ChangesDelta, transaction: TransactionCache): ConditionResult | undefined;
     /**
      * @description
      * This function is a utility function that will return the {@link ItemId ItemIds} of updated items in the {@link ChangesDelta ChangesDelta} which match the {@link ApiEnumItemType ItemType} and of which the provided column's field has changed
      *
+     * @param transaction
      * @param changesDelta The source changesDelta that triggered the business rule
-     * @param itemChanges The {@link TransactionItemHandler.itemChanges ItemChanges} of the transaction
      * @param itemType The ItemType of the item you want to compare a field from
      * @param columnId The columnId of the field that should've been changed for the ID to be included
      * @protected
      */
-    protected getItemIdsWithUpdatedField<ItemTypeType extends ApiEnumItemType>(changesDelta: ChangesDelta, itemChanges: TransactionItemHandler['itemChanges'], itemType: ItemTypeType, columnId: keyof FieldMap<ItemTypeType>): ItemId[] | undefined;
+    protected getItemIdsWithUpdatedField<ItemTypeType extends ApiEnumItemType>(transaction: TransactionCache, changesDelta: ChangesDelta, itemType: ItemTypeType, columnId: keyof FieldMap<ItemTypeType>): ItemId[] | undefined;
     /**
      * @description
      * This function will compare the stored changes with the given changes, and return a {@link BusinessLogicConditionResult} if the fields have been changed, null otherwise.
      * If either the source or changed field is `undefined` it will always return `null` (not changed)
      *
-     * @param itemChanges The {@link TransactionItemHandler.itemChanges ItemChanges} of the transaction
+     * @param transaction
      * @param tuple The {@link ChangesDelta.updated update tuple} from a ChangesDelta
      * @param columnId The columnId of the field that should've been changed for the ID to be included
      * @protected
      */
-    protected fieldChanged<ItemTypeType extends ApiEnumItemType, ColumnId extends ItemTypeColumnId<ItemTypeType>>(itemChanges: TransactionItemHandler['itemChanges'], tuple: ChangesDeltaItemUpdateDelta<ItemTypeType>, columnId: ColumnId): null | BusinessLogicConditionResult<ItemTypeType, ColumnId>;
+    protected fieldChanged<ItemTypeType extends ApiEnumItemType, ColumnId extends ItemTypeColumnId<ItemTypeType>>(transaction: TransactionCache, tuple: ChangesDeltaItemUpdateDelta<ItemTypeType>, columnId: ColumnId): null | BusinessLogicConditionResult<ItemTypeType, ColumnId>;
 }

package/dist/types/src/classes/BusinessLogicManager/Customfield/CustomFieldTypeBusinessLogicRule.d.ts

@@ -1,7 +1,6 @@
 import { ApiEnumItemType, ItemId } from '@rentman/backend-types';
 import { ItemResource } from '../../../models/ItemResource';
 import { TransactionCache } from '../../cache/transaction/TransactionCache';
-import { TransactionItemHandler } from '../../cache/transaction/TransactionItemHandler';
 import { ChangesDelta } from '../../ChangesDelta';
 import { BusinessLogicRule } from '../BusinessLogicRule';
 declare type ConditionResult = ItemId[];
@@ -11,7 +10,7 @@ declare type Dependency = ItemResource<ApiEnumItemType.Customfield, ['defaultval
  * If the 'type' field changes we reset the 'defaultvalue' and 'attribute' fields so that they do not contain invalid values
  */
 export declare class CustomFieldTypeBusinessLogicRule extends BusinessLogicRule<ConditionResult, Dependency> {
-    condition(changesDelta: ChangesDelta, itemChanges: TransactionItemHandler['itemChanges']): ConditionResult | undefined;
+    condition(changesDelta: ChangesDelta, transaction: TransactionCache): ConditionResult | undefined;
     dependency(transaction: TransactionCache, functionIds: ConditionResult): Promise<Dependency>;
     apply(changesDelta: ChangesDelta, destinationChangesDelta: ChangesDelta, customFieldResources: Dependency): void;
 }

package/dist/types/src/classes/BusinessLogicManager/Documents/DocumentTemplateBusinessLogicRule.d.ts

@@ -3,7 +3,6 @@ import { PromiseLibraryInterface } from '../../../interfaces/PromiseLibraryInter
 import { ItemResource } from '../../../models/ItemResource';
 import { ApiFormatter } from '../../ApiFormatter';
 import { TransactionCache } from '../../cache/transaction/TransactionCache';
-import { TransactionItemHandler } from '../../cache/transaction/TransactionItemHandler';
 import { ChangesDelta } from '../../ChangesDelta';
 import { BusinessLogicRule } from '../BusinessLogicRule';
 declare type DocumentTypes = ApiEnumItemType.Factuur | ApiEnumItemType.Offerte | ApiEnumItemType.Contract | ApiEnumItemType.Bon | ApiEnumItemType.Inhuurbon | ApiEnumItemType.Materiaalbon | ApiEnumItemType.Medewerkerbon | ApiEnumItemType.Aanmaning | ApiEnumItemType.Reparatiebon | ApiEnumItemType.Voertuigbon;
@@ -17,7 +16,7 @@ export declare class DocumentTemplateBusinessLogicRule extends BusinessLogicRule
     protected apiFormatter: ApiFormatter;
     private promiseLibrary;
     constructor(apiFormatter: ApiFormatter, promiseLibrary: PromiseLibraryInterface);
-    condition(changesDelta: ChangesDelta, itemChanges: TransactionItemHandler['itemChanges']): ConditionResult | undefined;
+    condition(changesDelta: ChangesDelta, transaction: TransactionCache): ConditionResult | undefined;
     dependency(transaction: TransactionCache, itemIdMap: ConditionResult): Promise<Dependency>;
     apply(_changesDelta: ChangesDelta, destinationChangesDelta: ChangesDelta, items: Dependency): void;
     private isDocumentType;

package/dist/types/src/classes/BusinessLogicManager/Exemplaar/ExemplaarAanschafdatumBusinessLogicRule.d.ts

@@ -1,13 +1,12 @@
 import { ApiEnumItemType, ItemId } from '@rentman/backend-types';
 import { ItemResource } from '../../../models/ItemResource';
 import { TransactionCache } from '../../cache/transaction/TransactionCache';
-import { TransactionItemHandler } from '../../cache/transaction/TransactionItemHandler';
 import { ChangesDelta } from '../../ChangesDelta';
 import { BusinessLogicRule } from '../BusinessLogicRule';
 declare type ConditionResult = ItemId[];
 declare type Dependency = ItemResource<ApiEnumItemType.Exemplaar, ['actief']>[];
 export declare class ExemplaarAanschafdatumBusinessLogicRule extends BusinessLogicRule<ConditionResult, Dependency> {
-    condition(changesDelta: ChangesDelta, _itemChanges: TransactionItemHandler['itemChanges']): ConditionResult | undefined;
+    condition(changesDelta: ChangesDelta): ConditionResult | undefined;
     dependency(transaction: TransactionCache, exemplaarIds: ConditionResult): Promise<Dependency>;
     apply(_changesDelta: ChangesDelta, destinationChangesDelta: ChangesDelta, exemplaarResources: Dependency): void;
 }

package/dist/types/src/classes/BusinessLogicManager/Factuur/FactuurBetalingsconditieBusinessLogicRule.d.ts

@@ -1,7 +1,6 @@
 import { ApiEnumItemType, ItemId } from '@rentman/backend-types';
 import { ItemResource } from '../../../models/ItemResource';
 import { TransactionCache } from '../../cache/transaction/TransactionCache';
-import { TransactionItemHandler } from '../../cache/transaction/TransactionItemHandler';
 import { ChangesDelta } from '../../ChangesDelta';
 import { BusinessLogicConditionResult, BusinessLogicRule } from '../BusinessLogicRule';
 declare type ConditionResult = BusinessLogicConditionResult<ApiEnumItemType.Factuur, 'betalingsconditie'>[];
@@ -13,7 +12,7 @@ declare type Dependency = {
     defaultPaymentConditionId: ItemId | null;
 };
 export declare class FactuurBetalingsconditieBusinessLogicRule extends BusinessLogicRule<ConditionResult, Dependency> {
-    condition(changesDelta: ChangesDelta, itemChanges: TransactionItemHandler['itemChanges']): ConditionResult | undefined;
+    condition(changesDelta: ChangesDelta, transaction: TransactionCache): ConditionResult | undefined;
     dependency(transaction: TransactionCache, result: ConditionResult, changesDelta: ChangesDelta): Promise<Dependency>;
     apply(changesDelta: ChangesDelta, destinationChangesDelta: ChangesDelta, deps: Dependency): void;
 }

package/dist/types/src/classes/BusinessLogicManager/Factuur/FactuurDatumBusinessLogicRule.d.ts

@@ -1,7 +1,6 @@
 import { ApiEnumItemType, ItemId } from '@rentman/backend-types';
 import { ItemResource } from '../../../models/ItemResource';
 import { TransactionCache } from '../../cache/transaction/TransactionCache';
-import { TransactionItemHandler } from '../../cache/transaction/TransactionItemHandler';
 import { ChangesDelta } from '../../ChangesDelta';
 import { BusinessLogicRule } from '../BusinessLogicRule';
 declare type ConditionResult = ItemId[];
@@ -12,7 +11,7 @@ declare type Dependency = {
     };
 };
 export declare class FactuurDatumBusinessLogicRule extends BusinessLogicRule<ConditionResult, Dependency> {
-    condition(changesDelta: ChangesDelta, itemChanges: TransactionItemHandler['itemChanges']): ConditionResult | undefined;
+    condition(changesDelta: ChangesDelta, transaction: TransactionCache): ConditionResult | undefined;
     dependency(transaction: TransactionCache, factuurIds: ConditionResult, _changesDelta: ChangesDelta): Promise<Dependency>;
     apply(changesDelta: ChangesDelta, destinationChangesDelta: ChangesDelta, deps: Dependency): void;
 }

package/dist/types/src/classes/BusinessLogicManager/Factuur/FactuurNumberseriesBusinessLogicRule.d.ts

@@ -1,13 +1,12 @@
 import { ApiEnumItemType, ItemId } from '@rentman/backend-types';
 import { ItemResource } from '../../../models/ItemResource';
 import { TransactionCache } from '../../cache/transaction/TransactionCache';
-import { TransactionItemHandler } from '../../cache/transaction/TransactionItemHandler';
 import { ChangesDelta } from '../../ChangesDelta';
 import { BusinessLogicRule } from '../BusinessLogicRule';
 declare type ConditionResult = ItemId[];
 declare type Dependency = ItemResource<ApiEnumItemType.Factuur, ['nummer']>[];
 export declare class FactuurNumberseriesBusinessLogicRule extends BusinessLogicRule<ConditionResult, Dependency> {
-    condition(changesDelta: ChangesDelta, itemChanges: TransactionItemHandler['itemChanges']): ConditionResult | undefined;
+    condition(changesDelta: ChangesDelta, transaction: TransactionCache): ConditionResult | undefined;
     dependency(transaction: TransactionCache, factuurIds: ConditionResult): Promise<Dependency>;
     apply(_changesDelta: ChangesDelta, destinationChangesDelta: ChangesDelta, factuurResources: Dependency): void;
 }

package/dist/types/src/classes/BusinessLogicManager/Functie/FunctieNaaminternBusinessLogicRule.d.ts

@@ -1,7 +1,6 @@
 import { ApiEnumItemType, ItemId } from '@rentman/backend-types';
 import { ItemResource } from '../../../models/ItemResource';
 import { TransactionCache } from '../../cache/transaction/TransactionCache';
-import { TransactionItemHandler } from '../../cache/transaction/TransactionItemHandler';
 import { ChangesDelta } from '../../ChangesDelta';
 import { BusinessLogicRule } from '../BusinessLogicRule';
 declare type ConditionResult = ItemId[];
@@ -11,7 +10,7 @@ declare type Dependency = ItemResource<ApiEnumItemType.Functie, ['naamintern']>[
  * If the `naamofferte` is set and the user hasn't filled in a `naamintern` we sync the fields
  */
 export declare class FunctieNaaminternBusinessLogicRule extends BusinessLogicRule<ConditionResult, Dependency> {
-    condition(changesDelta: ChangesDelta, itemChanges: TransactionItemHandler['itemChanges']): ConditionResult | undefined;
+    condition(changesDelta: ChangesDelta, transaction: TransactionCache): ConditionResult | undefined;
     dependency(transaction: TransactionCache, functionIds: ConditionResult): Promise<Dependency>;
     apply(changesDelta: ChangesDelta, destinationChangesDelta: ChangesDelta, functionResources: Dependency): void;
 }

package/dist/types/src/classes/BusinessLogicManager/Functie/FunctieTwowayBusinessLogicRule.d.ts

@@ -1,13 +1,12 @@
 import { ApiEnumItemType, ItemId } from '@rentman/backend-types';
 import { ItemResource } from '../../../models/ItemResource';
 import { TransactionCache } from '../../cache/transaction/TransactionCache';
-import { TransactionItemHandler } from '../../cache/transaction/TransactionItemHandler';
 import { ChangesDelta } from '../../ChangesDelta';
 import { BusinessLogicRule } from '../BusinessLogicRule';
 declare type ConditionResult = ItemId[];
 declare type Dependency = ItemResource<ApiEnumItemType.Functie, ['afstand']>[];
 export declare class FunctieTwowayBusinessLogicRule extends BusinessLogicRule<ConditionResult, Dependency> {
-    condition(changesDelta: ChangesDelta, itemChanges: TransactionItemHandler['itemChanges']): ConditionResult | undefined;
+    condition(changesDelta: ChangesDelta, transaction: TransactionCache): ConditionResult | undefined;
     dependency(transaction: TransactionCache, functionIds: ConditionResult): Promise<Dependency>;
     apply(changesDelta: ChangesDelta, destinationChangesDelta: ChangesDelta, functionResources: Dependency): void;
 }

package/dist/types/src/classes/BusinessLogicManager/Materiaal/MateriaalTypeBusinessLogicRule.d.ts

@@ -1,7 +1,6 @@
 import { ApiEnumItemType, ItemId } from '@rentman/backend-types';
 import { ItemResource } from '../../../models/ItemResource';
 import { TransactionCache } from '../../cache/transaction/TransactionCache';
-import { TransactionItemHandler } from '../../cache/transaction/TransactionItemHandler';
 import { ChangesDelta } from '../../ChangesDelta';
 import { BusinessLogicRule } from '../BusinessLogicRule';
 declare type ConditionResult = ItemId[];
@@ -11,7 +10,7 @@ declare type Dependency = ItemResource<ApiEnumItemType.Materiaal, ['aantal']>[];
  * A sales item can never be a case, so if the user changes the item to a case we make it a rental item
  */
 export declare class MateriaalTypeBusinessLogicRule extends BusinessLogicRule<ConditionResult, Dependency> {
-    condition(changesDelta: ChangesDelta, _itemChanges: TransactionItemHandler['itemChanges']): ConditionResult | undefined;
+    condition(changesDelta: ChangesDelta): ConditionResult | undefined;
     dependency(transaction: TransactionCache, materiaalIds: ConditionResult): Promise<Dependency>;
     apply(_changesDelta: ChangesDelta, destinationChangesDelta: ChangesDelta, materiaalResources: Dependency): void;
 }

package/dist/types/src/classes/BusinessLogicManager/Materiaal/MateriaalVerhuurBusinessLogicRule.d.ts

@@ -1,7 +1,6 @@
 import { ApiEnumItemType, ItemId } from '@rentman/backend-types';
 import { ItemResource } from '../../../models/ItemResource';
 import { TransactionCache } from '../../cache/transaction/TransactionCache';
-import { TransactionItemHandler } from '../../cache/transaction/TransactionItemHandler';
 import { ChangesDelta } from '../../ChangesDelta';
 import { BusinessLogicRule } from '../BusinessLogicRule';
 declare type ConditionResult = ItemId[];
@@ -11,7 +10,7 @@ declare type Dependency = ItemResource<ApiEnumItemType.Materiaal, ['aantal']>[];
  * A sales item can never be a case, so if it is we reset it to an item
  */
 export declare class MateriaalVerhuurBusinessLogicRule extends BusinessLogicRule<ConditionResult, Dependency> {
-    condition(changesDelta: ChangesDelta, _itemChanges: TransactionItemHandler['itemChanges']): ConditionResult | undefined;
+    condition(changesDelta: ChangesDelta): ConditionResult | undefined;
     dependency(transaction: TransactionCache, materiaalIds: ConditionResult): Promise<Dependency>;
     apply(_changesDelta: ChangesDelta, destinationChangesDelta: ChangesDelta, materiaalResources: Dependency): void;
 }

package/dist/types/src/classes/BusinessLogicManager/Materiaal/SurfaceArticleSizeBusinessLogicRule.d.ts

@@ -2,7 +2,6 @@ import { ApiEnumItemType, ApiModuleFunctionLocalsGetLocals, ItemId } from '@rent
 import { ItemResource } from '../../../models/ItemResource';
 import { ApiFormatter } from '../../ApiFormatter';
 import { TransactionCache } from '../../cache/transaction/TransactionCache';
-import { TransactionItemHandler } from '../../cache/transaction/TransactionItemHandler';
 import { ChangesDelta } from '../../ChangesDelta';
 import { BusinessLogicRule } from '../BusinessLogicRule';
 declare type ConditionResult = ItemId[];
@@ -12,7 +11,7 @@ export declare class SurfaceArticleSizeBusinessLogicRule extends BusinessLogicRu
     protected apiFormatter: ApiFormatter;
     private locals;
     constructor(apiFormatter: ApiFormatter, locals: ApiModuleFunctionLocalsGetLocals);
-    condition(changesDelta: ChangesDelta, _itemChanges: TransactionItemHandler['itemChanges']): ConditionResult | undefined;
+    condition(changesDelta: ChangesDelta): ConditionResult | undefined;
     dependency(transaction: TransactionCache, materiaalIds: ConditionResult): Promise<Dependency>;
     apply(changesDelta: ChangesDelta, destinationChangesDelta: ChangesDelta, materiaalResources: Dependency): void;
 }

package/dist/types/src/classes/BusinessLogicManager/OfferteContract/OfferteContractDatumBusinessLogicRule.d.ts

@@ -3,7 +3,6 @@ import { PromiseLibraryInterface } from '../../../interfaces/PromiseLibraryInter
 import { ItemResource } from '../../../models/ItemResource';
 import { ApiFormatter } from '../../ApiFormatter';
 import { TransactionCache } from '../../cache/transaction/TransactionCache';
-import { TransactionItemHandler } from '../../cache/transaction/TransactionItemHandler';
 import { ChangesDelta } from '../../ChangesDelta';
 import { BusinessLogicRule } from '../BusinessLogicRule';
 declare type ConditionResult = {
@@ -19,7 +18,7 @@ export declare class OfferteContractDatumBusinessLogicRule extends BusinessLogic
     protected apiFormatter: ApiFormatter;
     private promiseLibrary;
     constructor(apiFormatter: ApiFormatter, promiseLibrary: PromiseLibraryInterface);
-    condition(changesDelta: ChangesDelta, itemChanges: TransactionItemHandler['itemChanges']): ConditionResult | undefined;
+    condition(changesDelta: ChangesDelta, transaction: TransactionCache): ConditionResult | undefined;
     dependency(transaction: TransactionCache, itemIdMap: ConditionResult): Promise<Dependency>;
     apply(_changesDelta: ChangesDelta, destinationChangesDelta: ChangesDelta, items: Dependency): void;
 }

package/dist/types/src/classes/BusinessLogicManager/PlanningPersoneelTransport/PlanningPersoneelTransportBusinessLogicRule.d.ts

@@ -3,7 +3,6 @@ import { PromiseLibraryInterface } from '../../../interfaces/PromiseLibraryInter
 import { ItemResource } from '../../../models/ItemResource';
 import { ApiFormatter } from '../../ApiFormatter';
 import { TransactionCache } from '../../cache/transaction/TransactionCache';
-import { TransactionItemHandler } from '../../cache/transaction/TransactionItemHandler';
 import { ChangesDelta } from '../../ChangesDelta';
 import { BusinessLogicRule } from '../BusinessLogicRule';
 declare type ConditionResult = {
@@ -21,7 +20,7 @@ export declare class PlanningPersoneelTransportBusinessLogicRule extends Busines
     protected apiFormatter: ApiFormatter;
     private promiseLibrary;
     constructor(apiFormatter: ApiFormatter, promiseLibrary: PromiseLibraryInterface);
-    condition(changesDelta: ChangesDelta, itemChanges: TransactionItemHandler['itemChanges']): ConditionResult | undefined;
+    condition(changesDelta: ChangesDelta, transaction: TransactionCache): ConditionResult | undefined;
     dependency(transaction: TransactionCache, itemIdMap: ConditionResult): Promise<Dependency>;
     apply(changesDelta: ChangesDelta, destinationChangesDelta: ChangesDelta, items: Dependency): void;
     private updatePlanningColumns;

package/dist/types/src/classes/BusinessLogicManager/Project/ProjectClientNoteBusinessLogicRule.d.ts

@@ -3,7 +3,6 @@ import { PromiseLibraryInterface } from '../../../interfaces/PromiseLibraryInter
 import { ItemResource } from '../../../models/ItemResource';
 import { ApiFormatter } from '../../ApiFormatter';
 import { TransactionCache } from '../../cache/transaction/TransactionCache';
-import { TransactionItemHandler } from '../../cache/transaction/TransactionItemHandler';
 import { ChangesDelta } from '../../ChangesDelta';
 import { BusinessLogicRule } from '../BusinessLogicRule';
 declare type ConditionResult = {
@@ -16,7 +15,7 @@ export declare class ProjectClientNoteBusinessLogicRule extends BusinessLogicRul
     protected apiFormatter: ApiFormatter;
     private promiseLibrary;
     constructor(apiFormatter: ApiFormatter, promiseLibrary: PromiseLibraryInterface);
-    condition(changesDelta: ChangesDelta, _itemChanges: TransactionItemHandler['itemChanges']): ConditionResult | undefined;
+    condition(changesDelta: ChangesDelta): ConditionResult | undefined;
     dependency(transaction: TransactionCache, obj: ConditionResult): Promise<Dependency>;
     apply(_changesDelta: ChangesDelta, destinationChangesDelta: ChangesDelta, obj: Dependency): Promise<void>;
 }

package/dist/types/src/classes/BusinessLogicManager/Reparatie/ReparatieExemplaarBusinessLogicRule.d.ts

@@ -1,13 +1,12 @@
 import { ApiEnumItemType, ItemId } from '@rentman/backend-types';
 import { ItemResource } from '../../../models/ItemResource';
 import { TransactionCache } from '../../cache/transaction/TransactionCache';
-import { TransactionItemHandler } from '../../cache/transaction/TransactionItemHandler';
 import { ChangesDelta } from '../../ChangesDelta';
 import { BusinessLogicRule } from '../BusinessLogicRule';
 declare type ConditionResult = ItemId[];
 declare type Dependency = ItemResource<ApiEnumItemType.Reparatie, ['aantal']>[];
 export declare class ReparatieAanschafdatumBusinessLogicRule extends BusinessLogicRule<ConditionResult, Dependency> {
-    condition(changesDelta: ChangesDelta, _itemChanges: TransactionItemHandler['itemChanges']): ConditionResult | undefined;
+    condition(changesDelta: ChangesDelta): ConditionResult | undefined;
     dependency(transaction: TransactionCache, reparatieIds: ConditionResult): Promise<Dependency>;
     apply(_changesDelta: ChangesDelta, destinationChangesDelta: ChangesDelta, reparatieResources: Dependency): void;
 }

package/dist/types/src/classes/BusinessLogicManager/Rol/RolDocumentAccessBusinessLogicRule.d.ts

@@ -1,7 +1,6 @@
 import { ApiEnumItemType, ItemId } from '@rentman/backend-types';
 import { ItemResource } from '../../../models/ItemResource';
 import { TransactionCache } from '../../cache/transaction/TransactionCache';
-import { TransactionItemHandler } from '../../cache/transaction/TransactionItemHandler';
 import { ChangesDelta } from '../../ChangesDelta';
 import { BusinessLogicRule } from '../BusinessLogicRule';
 declare type ConditionResult = ItemId[];
@@ -11,7 +10,7 @@ declare type Dependency = ItemResource<ApiEnumItemType.Rol, ['general_bestanden_
  * If you have project access or can make quotations/contracts you should have permissions to download files
  */
 export declare class RolDocumentAccessBusinessLogicRule extends BusinessLogicRule<ConditionResult, Dependency> {
-    condition(changesDelta: ChangesDelta, _itemChanges: TransactionItemHandler['itemChanges']): ConditionResult | undefined;
+    condition(changesDelta: ChangesDelta): ConditionResult | undefined;
     dependency(transaction: TransactionCache, rolIds: ConditionResult): Promise<Dependency>;
     apply(_changesDelta: ChangesDelta, destinationChangesDelta: ChangesDelta, rolResources: Dependency): void;
 }

package/dist/types/src/classes/BusinessLogicManager/Rol/RolEditOwnDataBusinessLogicRule.d.ts

@@ -1,7 +1,6 @@
 import { ApiEnumItemType, ItemId } from '@rentman/backend-types';
 import { ItemResource } from '../../../models/ItemResource';
 import { TransactionCache } from '../../cache/transaction/TransactionCache';
-import { TransactionItemHandler } from '../../cache/transaction/TransactionItemHandler';
 import { ChangesDelta } from '../../ChangesDelta';
 import { BusinessLogicRule } from '../BusinessLogicRule';
 declare type ConditionResult = ItemId[];
@@ -11,7 +10,7 @@ declare type Dependency = ItemResource<ApiEnumItemType.Rol, ['general_eigen_mede
  * If you can access update crew data, you can also always update your own data
  */
 export declare class RolEditOwnDataBusinessLogicRule extends BusinessLogicRule<ConditionResult, Dependency> {
-    condition(changesDelta: ChangesDelta, _itemChanges: TransactionItemHandler['itemChanges']): ConditionResult | undefined;
+    condition(changesDelta: ChangesDelta): ConditionResult | undefined;
     dependency(transaction: TransactionCache, rolIds: ConditionResult): Promise<Dependency>;
     apply(_changesDelta: ChangesDelta, destinationChangesDelta: ChangesDelta, rolResources: Dependency): void;
 }

package/dist/types/src/classes/BusinessLogicManager/Rol/RolFileAccessBusinessLogicRule.d.ts

@@ -1,7 +1,6 @@
 import { ApiEnumItemType, ItemId } from '@rentman/backend-types';
 import { ItemResource } from '../../../models/ItemResource';
 import { TransactionCache } from '../../cache/transaction/TransactionCache';
-import { TransactionItemHandler } from '../../cache/transaction/TransactionItemHandler';
 import { ChangesDelta } from '../../ChangesDelta';
 import { BusinessLogicRule } from '../BusinessLogicRule';
 declare type ConditionResult = ItemId[];
@@ -11,7 +10,7 @@ declare type Dependency = ItemResource<ApiEnumItemType.Rol, ['facturen_eigen', '
  * If you have project access or can make invoices you should have permissions to download files, see invoices and edit invoices
  */
 export declare class RolFileAccessBusinessLogicRule extends BusinessLogicRule<ConditionResult, Dependency> {
-    condition(changesDelta: ChangesDelta, _itemChanges: TransactionItemHandler['itemChanges']): ConditionResult | undefined;
+    condition(changesDelta: ChangesDelta): ConditionResult | undefined;
     dependency(transaction: TransactionCache, rolIds: ConditionResult): Promise<Dependency>;
     apply(changesDelta: ChangesDelta, destinationChangesDelta: ChangesDelta, rolResources: Dependency): void;
 }

package/dist/types/src/classes/BusinessLogicManager/Rol/RolPersoneelsplannerToegangBusinessLogicRule.d.ts

@@ -1,7 +1,6 @@
 import { ApiEnumItemType, ItemId } from '@rentman/backend-types';
 import { ItemResource } from '../../../models/ItemResource';
 import { TransactionCache } from '../../cache/transaction/TransactionCache';
-import { TransactionItemHandler } from '../../cache/transaction/TransactionItemHandler';
 import { ChangesDelta } from '../../ChangesDelta';
 import { BusinessLogicRule } from '../BusinessLogicRule';
 declare type ConditionResult = ItemId[];
@@ -11,7 +10,7 @@ declare type Dependency = ItemResource<ApiEnumItemType.Rol, ['personeelsplanner_
  * 	If you can enter the crew planner you can also access projects
  */
 export declare class RolPersoneelsplannerToegangBusinessLogicRule extends BusinessLogicRule<ConditionResult, Dependency> {
-    condition(changesDelta: ChangesDelta, _itemChanges: TransactionItemHandler['itemChanges']): ConditionResult | undefined;
+    condition(changesDelta: ChangesDelta): ConditionResult | undefined;
     dependency(transaction: TransactionCache, rolIds: ConditionResult): Promise<Dependency>;
     apply(_changesDelta: ChangesDelta, destinationChangesDelta: ChangesDelta, rolResources: Dependency): void;
 }

package/dist/types/src/classes/BusinessLogicManager/Rol/RolProjectenBewerkenBusinessLogicRule.d.ts

@@ -1,7 +1,6 @@
 import { ApiEnumItemType, ItemId } from '@rentman/backend-types';
 import { ItemResource } from '../../../models/ItemResource';
 import { TransactionCache } from '../../cache/transaction/TransactionCache';
-import { TransactionItemHandler } from '../../cache/transaction/TransactionItemHandler';
 import { ChangesDelta } from '../../ChangesDelta';
 import { BusinessLogicRule } from '../BusinessLogicRule';
 declare type ConditionResult = ItemId[];
@@ -11,7 +10,7 @@ declare type Dependency = ItemResource<ApiEnumItemType.Rol, ['materialen_tijdlij
  * If you can edit projects you should be able to see the equipment availability
  */
 export declare class RolProjectenBewerkenBusinessLogicRule extends BusinessLogicRule<ConditionResult, Dependency> {
-    condition(changesDelta: ChangesDelta, _itemChanges: TransactionItemHandler['itemChanges']): ConditionResult | undefined;
+    condition(changesDelta: ChangesDelta): ConditionResult | undefined;
     dependency(transaction: TransactionCache, rolIds: ConditionResult): Promise<Dependency>;
     apply(_changesDelta: ChangesDelta, destinationChangesDelta: ChangesDelta, rolResources: Dependency): void;
 }

package/dist/types/src/classes/BusinessLogicManager/Rol/RolProjectenToegangBusinessLogicRule.d.ts

@@ -1,7 +1,6 @@
 import { ApiEnumItemType, ItemId } from '@rentman/backend-types';
 import { ItemResource } from '../../../models/ItemResource';
 import { TransactionCache } from '../../cache/transaction/TransactionCache';
-import { TransactionItemHandler } from '../../cache/transaction/TransactionItemHandler';
 import { ChangesDelta } from '../../ChangesDelta';
 import { BusinessLogicRule } from '../BusinessLogicRule';
 declare type ConditionResult = ItemId[];
@@ -11,7 +10,7 @@ declare type Dependency = ItemResource<ApiEnumItemType.Rol, ['uren_kosten']>[];
  * 	If you have access to projects you should be able to make costs for registered hours
  */
 export declare class RolProjectenToegangBusinessLogicRule extends BusinessLogicRule<ConditionResult, Dependency> {
-    condition(changesDelta: ChangesDelta, _itemChanges: TransactionItemHandler['itemChanges']): ConditionResult | undefined;
+    condition(changesDelta: ChangesDelta): ConditionResult | undefined;
     dependency(transaction: TransactionCache, rolIds: ConditionResult): Promise<Dependency>;
     apply(_changesDelta: ChangesDelta, destinationChangesDelta: ChangesDelta, rolResources: Dependency): void;
 }

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

@@ -1,11 +1,12 @@
 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<{
+export declare type CacheSyncerQueryMap = ItemTypeMap<CacheSyncerQueryMapEntry>;
+export declare type CacheSyncerQueryMapEntry = {
     [cachedQueryString: string]: {
         cachedQueryItems: CachedQueryItem[];
         collectionResources: CollectionResource[];
     };
-}>;
+};
 declare type CacheSyncerMatchesMapEntry = {
     query: CollectionQuery;
     items: ItemEntry[];

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

@@ -1,5 +1,5 @@
 import { ApiEnumItemType, ApiFields, ItemId } from '@rentman/backend-types';
-import { ApiFormatter, ChangesDeltaBase, ColumnExpansionResult, ColumnSet, CreatedChangesDelta, EntryParent, EntryParentNull, ErrorHandlerInterface, FieldMap, ItemCreateService, ItemEntry, ItemEntryService, PromiseInterface } from '../internal';
+import { ApiFormatter, ChangesDeltaBase, ChangesDeltaItemUpdateMode, ColumnExpansionResult, ColumnSet, CreatedChangesDelta, EntryParent, EntryParentNull, ErrorHandlerInterface, FieldMap, ItemCreateService, ItemEntry, ItemEntryService, PromiseInterface } from '../internal';
 export declare type ChangesDeltaItemDeleteDelta = ItemEntry;
 /**
  * @description
@@ -32,7 +32,7 @@ export declare class ChangesDelta extends ChangesDeltaBase {
      * - 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, updateModified?: boolean, updateInitial?: boolean): this;
+    setItemUpdated<ItemTypeType extends ApiEnumItemType>(entry: ItemEntry<ItemTypeType>, fields: Partial<FieldMap<ItemTypeType>>, columnExpansionResult?: ColumnExpansionResult<ItemTypeType> | null, parent?: EntryParentNull, mode?: ChangesDeltaItemUpdateMode): this;
     setItemDeleted(deleted: ChangesDeltaItemDeleteDelta): this;
     setItemsDeleted(deleted: ChangesDeltaItemDeleteDelta[]): this;
     /**
@@ -60,6 +60,6 @@ export declare class ChangesDelta extends ChangesDeltaBase {
      * @description
      * Convenience function to assign the proper parent fields, will call {@link ChangesDeltaBase.setItemUpdated setItemUpdated} internally
      */
-    setItemMoved(entry: ItemEntry, to: EntryParent, updateModified?: boolean, updateInitial?: boolean): this;
+    setItemMoved(entry: ItemEntry, to: EntryParent, mode?: ChangesDeltaItemUpdateMode): this;
     isEmpty(): boolean;
 }

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

@@ -1,9 +1,14 @@
 import { ApiEnumItemType, ItemId } from '@rentman/backend-types';
-import { ApiFormatter, ColumnExpansionResult, EntryParentNull, FieldMap, ItemEntry, ItemEntryService, ItemIdConversionMap, ItemTypeColumnId, TransactionItemEntryChanges, TransactionItemEntryChangesTuple } from '../internal';
+import { ApiFormatter, ColumnExpansionResult, EntryParentNull, FieldMap, ItemEntry, ItemEntryChangesTuple, ItemEntryService, ItemIdConversionMap, ItemTypeColumnId } from '../internal';
 export declare type ChangesDeltaResult = {
     itemIdConversionMap: ItemIdConversionMap;
     created: ItemEntry[];
 };
+export declare enum ChangesDeltaItemUpdateMode {
+    USER_CHANGE = "user",
+    QUERY_RESULT = "query",
+    SERVER_UPDATE = "update"
+}
 /**
  * @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)
@@ -15,16 +20,7 @@ export declare type ChangesDeltaItemUpdateDelta<ItemTypeType extends ApiEnumItem
         fields: FieldMap<ItemTypeType>;
         parent: EntryParentNull;
     };
-    /**
-     * @description
-     * Should be set to `true` when either the changes are made by the user, or when it's the direct result (not derived value) of a create/update API call
-     */
-    updateModified: boolean;
-    /**
-     * @description
-     * Should be set to `true` when the changes are a result of an API call
-     */
-    updateInitial: boolean;
+    mode: ChangesDeltaItemUpdateMode;
 };
 export declare abstract class ChangesDeltaBase {
     protected itemEntryService: ItemEntryService;
@@ -37,7 +33,7 @@ export declare abstract class ChangesDeltaBase {
      * Only contains remote items, when rolling back local items the whole entries are deleted.
      */
     restored: {
-        [itemEntryId: number]: TransactionItemEntryChangesTuple<any>;
+        [itemEntryId: number]: ItemEntryChangesTuple<any>;
     };
     /**
      * @private
@@ -61,8 +57,17 @@ export declare abstract class ChangesDeltaBase {
             };
         };
     };
+    /**
+     * @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
@@ -72,8 +77,8 @@ export declare abstract class ChangesDeltaBase {
      */
     _setQueryResult(itemType: ApiEnumItemType, queryString: string, itemIds: ItemId[] | {
         [itemId: string]: true;
-    }): void;
-    setItemUpdated<ItemTypeType extends ApiEnumItemType>(entry: ItemEntry<ItemTypeType>, fields: Partial<FieldMap<ItemTypeType>>, columnExpansionResult?: ColumnExpansionResult<ItemTypeType> | null, parent?: EntryParentNull, updateModified?: boolean, updateInitial?: boolean): this;
-    setItemRestored<ItemTypeType extends ApiEnumItemType>(itemEntry: ItemEntry<ItemTypeType>, transactionItemEntryChanges: TransactionItemEntryChanges<ItemTypeType>): void;
+    }): this;
+    setItemUpdated<ItemTypeType extends ApiEnumItemType>(entry: ItemEntry<ItemTypeType>, fields: Partial<FieldMap<ItemTypeType>>, columnExpansionResult?: ColumnExpansionResult<ItemTypeType> | null, parent?: EntryParentNull, mode?: ChangesDeltaItemUpdateMode): this;
+    setItemRestored<ItemTypeType extends ApiEnumItemType>(itemEntry: ItemEntry<ItemTypeType>, transactionItemEntryChanges: FieldMap<ItemTypeType>): void;
     isEmpty(): boolean;
 }