@rentman/rm-core 63.4.1 → 64.0.0

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

@@ -5,16 +5,8 @@ import { BLR_SKIP_RULE, BusinessLogicRule } from '../BusinessLogicRule';
 import { BusinessLogicRuleApplyContext } from '../BusinessLogicRuleApplyContext';
 import { BusinessLogicRuleConditionContext } from '../BusinessLogicRuleConditionContext';
 type ConditionResult = ItemId[];
-type DependencyColumns = [
-    'width',
-    'height',
-    'oppervlakteartikel',
-    'nieuwprijs',
-    'inhuurprijs',
-    'verhuurprijs',
-    'naam'
-];
-type Dependency = ItemResource<'Materiaal', DependencyColumns>[];
+declare const materiaalColumns: readonly ["width", "height", "oppervlakteartikel", "nieuwprijs", "inhuurprijs", "verhuurprijs", "naam"];
+type Dependency = ItemResource<'Materiaal', typeof materiaalColumns>[];
 export declare class SurfaceArticleSizeBusinessLogicRule extends BusinessLogicRule<ConditionResult, Dependency> {
     condition({ previousChangesDelta, }: BusinessLogicRuleConditionContext): ConditionResult | typeof BLR_SKIP_RULE;
     dependency(transaction: TransactionCache, materiaalIds: ConditionResult): Promise<Dependency>;

package/dist/types/src/classes/BusinessLogicManager/MateriaalCatFunctieFunctiegroep/LinkedTimeItemBusinessLogicRuleBase.d.ts

@@ -1,8 +1,7 @@
 import { ItemEntry } from '../../../models/ItemEntry';
 import { ItemResource } from '../../../models/ItemResource';
-import { ApiRequestColumnArray, GetFieldValueType } from '../../../types/ItemTypesCollection';
+import { ApiRequestColumnArray } from '../../../types/ItemTypesCollection';
 import { TransactionCache } from '../../cache/transaction/TransactionCache';
-import { ChangesDeltaItemCreateDelta } from '../../CreatedChangesDelta';
 import { BLR_SKIP_RULE, BusinessLogicRule } from '../BusinessLogicRule';
 import { BusinessLogicRuleConditionContext } from '../BusinessLogicRuleConditionContext';
 import { LinkedTimeItemType, TimeColumnId } from './TimeColumnUtil';
@@ -17,30 +16,24 @@ type LinkedTimeItemRequestColumnsMapToItemResourceMap<RequestColumnsMap extends
 export type LinkedTimeItemResourceMap<RequestColumns extends ApiRequestColumnArray<LinkedTimeItemType>> = {
     [ItemType in LinkedTimeItemType]: ItemResource<ItemType, RequestColumns>[];
 };
-type CreatedTupleMap = {
-    [ItemType in LinkedTimeItemType]: ChangesDeltaItemCreateDelta<ItemType>[];
+/**
+ * The item entry key could be typed as `ItemEntry<ItemType>`, but that leads to typing issues when reading from the resulting map.
+ */
+export type LinkedTimeItemBusinessLogicRuleBaseColumnMap<RequestColumns extends LinkedTimeItemColumnArray> = {
+    [ItemType in LinkedTimeItemType]: Map<ItemEntry<LinkedTimeItemType>, RequestColumns[number][]>;
 };
-export type LinkedTimeItemBusinessLogicRuleBaseUpdatedTuples<RequestColumns extends LinkedTimeItemColumnArray> = {
-    [ItemType in LinkedTimeItemType]: UpdatedTuple<LinkedTimeItemType, RequestColumns[number]>[];
-};
-interface UpdatedTuple<ItemTypeType extends LinkedTimeItemType, ColumnId extends LinkedTimeItemColumn = LinkedTimeItemColumn> {
-    itemEntry: ItemEntry<ItemTypeType>;
-    columnId: ColumnId;
-    newValue: GetFieldValueType<ItemTypeType, ColumnId>;
-}
 export declare abstract class LinkedTimeItemBusinessLogicRuleBase<ConditionColumns extends LinkedTimeItemColumnArray, ConditionResult, Dependency> extends BusinessLogicRule<ConditionResult, Dependency> {
     protected conditionColumns: ConditionColumns;
-    protected extractCreatedTuples(context: BusinessLogicRuleConditionContext): CreatedTupleMap;
     /**
      * Extract updated fields of functions / function groups / equipment groups, using the columns specified in
      * `conditionColumns`.
      */
-    protected extractUpdatedTuples(context: BusinessLogicRuleConditionContext): LinkedTimeItemBusinessLogicRuleBaseUpdatedTuples<ConditionColumns>;
+    protected extractUpdatedTuples(context: BusinessLogicRuleConditionContext, includeCreatedItems?: boolean): LinkedTimeItemBusinessLogicRuleBaseColumnMap<ConditionColumns>;
     /**
      * Like {@link extractUpdatedTuples}, but returns `undefined` when no fields have been updated.
      */
-    protected extractUpdatedTuplesCondition(context: BusinessLogicRuleConditionContext): LinkedTimeItemBusinessLogicRuleBaseUpdatedTuples<ConditionColumns> | typeof BLR_SKIP_RULE;
-    protected fetchLinkedItemResourcesWithColumns<RequestColumnsMap extends LinkedTimeItemRequestColumnsMap>(transaction: TransactionCache, updatedTuples: LinkedTimeItemBusinessLogicRuleBaseUpdatedTuples<any>, requestColumnsMap: RequestColumnsMap): Promise<LinkedTimeItemRequestColumnsMapToItemResourceMap<RequestColumnsMap>>;
-    protected fetchLinkedItemResources<RequestColumns extends ApiRequestColumnArray<LinkedTimeItemType>>(transaction: TransactionCache, updatedTuples: LinkedTimeItemBusinessLogicRuleBaseUpdatedTuples<any>, requestColumns: RequestColumns): Promise<LinkedTimeItemResourceMap<RequestColumns>>;
+    protected extractUpdatedTuplesCondition(context: BusinessLogicRuleConditionContext): LinkedTimeItemBusinessLogicRuleBaseColumnMap<ConditionColumns> | typeof BLR_SKIP_RULE;
+    protected fetchLinkedItemResourcesWithColumns<RequestColumnsMap extends LinkedTimeItemRequestColumnsMap>(transaction: TransactionCache, columnTuples: LinkedTimeItemBusinessLogicRuleBaseColumnMap<any>, requestColumnsMap: RequestColumnsMap): Promise<LinkedTimeItemRequestColumnsMapToItemResourceMap<RequestColumnsMap>>;
+    protected fetchLinkedItemResources<RequestColumns extends ApiRequestColumnArray<LinkedTimeItemType>>(transaction: TransactionCache, columnTuples: LinkedTimeItemBusinessLogicRuleBaseColumnMap<any>, requestColumns: RequestColumns): Promise<LinkedTimeItemResourceMap<RequestColumns>>;
 }
 export {};

package/dist/types/src/classes/BusinessLogicManager/MateriaalCatFunctieFunctiegroep/LinkedTimeItemDurationBusinessLogicRule.d.ts

@@ -2,16 +2,16 @@ import { TransactionCache } from '../../cache/transaction/TransactionCache';
 import { BLR_SKIP_RULE } from '../BusinessLogicRule';
 import { BusinessLogicRuleApplyContext } from '../BusinessLogicRuleApplyContext';
 import { BusinessLogicRuleConditionContext } from '../BusinessLogicRuleConditionContext';
-import { LinkedTimeItemBusinessLogicRuleBase, LinkedTimeItemBusinessLogicRuleBaseUpdatedTuples, LinkedTimeItemResourceMap } from './LinkedTimeItemBusinessLogicRuleBase';
+import { LinkedTimeItemBusinessLogicRuleBase, LinkedTimeItemBusinessLogicRuleBaseColumnMap, LinkedTimeItemResourceMap } from './LinkedTimeItemBusinessLogicRuleBase';
 declare const conditionColumns: readonly ["gebruikvan", "gebruiktot"];
 declare const requestColumns: readonly ["gebruikvan", "gebruiktot", "duur"];
 /**
  * When changing 'gebruikvan' or 'gebruiktot', and both fields are valid, set the duration.
  */
-export declare class LinkedTimeItemDurationBusinessLogicRule extends LinkedTimeItemBusinessLogicRuleBase<typeof conditionColumns, LinkedTimeItemBusinessLogicRuleBaseUpdatedTuples<typeof conditionColumns>, LinkedTimeItemResourceMap<typeof requestColumns>> {
+export declare class LinkedTimeItemDurationBusinessLogicRule extends LinkedTimeItemBusinessLogicRuleBase<typeof conditionColumns, LinkedTimeItemBusinessLogicRuleBaseColumnMap<typeof conditionColumns>, LinkedTimeItemResourceMap<typeof requestColumns>> {
     protected conditionColumns: readonly ["gebruikvan", "gebruiktot"];
-    condition(context: BusinessLogicRuleConditionContext): LinkedTimeItemBusinessLogicRuleBaseUpdatedTuples<typeof conditionColumns> | typeof BLR_SKIP_RULE;
+    condition(context: BusinessLogicRuleConditionContext): LinkedTimeItemBusinessLogicRuleBaseColumnMap<typeof conditionColumns> | typeof BLR_SKIP_RULE;
     apply(context: BusinessLogicRuleApplyContext, dependencies: LinkedTimeItemResourceMap<typeof requestColumns>): void;
-    dependency(transaction: TransactionCache, conditionResult: LinkedTimeItemBusinessLogicRuleBaseUpdatedTuples<typeof conditionColumns>): Promise<LinkedTimeItemResourceMap<typeof requestColumns>>;
+    dependency(transaction: TransactionCache, conditionResult: LinkedTimeItemBusinessLogicRuleBaseColumnMap<typeof conditionColumns>): Promise<LinkedTimeItemResourceMap<typeof requestColumns>>;
 }
 export {};

package/dist/types/src/classes/BusinessLogicManager/MateriaalCatFunctieFunctiegroep/LinkedTimeItemMateriaalCatBusinessLogicRule.d.ts

@@ -4,8 +4,9 @@ import { TransactionCache } from '../../cache/transaction/TransactionCache';
 import { BLR_SKIP_RULE, BusinessLogicRule } from '../BusinessLogicRule';
 import { BusinessLogicRuleApplyContext } from '../BusinessLogicRuleApplyContext';
 import { BusinessLogicRuleConditionContext } from '../BusinessLogicRuleConditionContext';
-type ConditionResult = ItemId<'MateriaalCat'>[];
-declare const changedMateriaalCatResourceColumns: readonly ["gebruikvan", "gebruiktot", "planvan", "plantot", {
+import { TimeColumnUtil } from './TimeColumnUtil';
+type ConditionResult = Map<ItemId<'MateriaalCat'>, (typeof TimeColumnUtil.valueColumnIds)[number][]>;
+declare const materiaalCatColumns: readonly ["id", "gebruikvan", "planvan", "gebruiktot", "plantot", "schema_gv_begin", "schema_gt_begin", "schema_pv_begin", "schema_pt_begin", {
     readonly schema_pv: readonly ["van", "tot", "is_absolute_times_substitute"];
 }, {
     readonly schema_pt: readonly ["van", "tot", "is_absolute_times_substitute"];
@@ -14,12 +15,10 @@ declare const changedMateriaalCatResourceColumns: readonly ["gebruikvan", "gebru
 }, {
     readonly schema_gt: readonly ["van", "tot", "is_absolute_times_substitute"];
 }];
-type Dependency = {
-    changedResources: ItemResource<'MateriaalCat', typeof changedMateriaalCatResourceColumns>[];
-};
+type Dependency = ItemResource<'MateriaalCat', typeof materiaalCatColumns>[];
 export declare class LinkedTimeItemMateriaalCatBusinessLogicRule extends BusinessLogicRule<ConditionResult, Dependency> {
     condition(context: BusinessLogicRuleConditionContext): ConditionResult | typeof BLR_SKIP_RULE;
-    dependency(transaction: TransactionCache, changedMateriaalCatItemIds: ConditionResult): Promise<Dependency>;
-    apply(context: BusinessLogicRuleApplyContext, dependency: Dependency): void;
+    dependency(transaction: TransactionCache, conditionResult: ConditionResult): Promise<Dependency>;
+    apply(context: BusinessLogicRuleApplyContext, dependency: Dependency, conditionResult: ConditionResult): void;
 }
 export {};

package/dist/types/src/classes/BusinessLogicManager/MateriaalCatFunctieFunctiegroep/LinkedTimeItemSubprojectBusinessLogicRule.d.ts

@@ -1,29 +1,18 @@
 import { ItemEntry } from '../../../models/ItemEntry';
-import { ChangesDeltaItemCreateDelta } from '../../CreatedChangesDelta';
 import { BLR_SKIP_RULE } from '../BusinessLogicRule';
 import { BusinessLogicRuleApplyContext } from '../BusinessLogicRuleApplyContext';
 import { BusinessLogicRuleConditionContext } from '../BusinessLogicRuleConditionContext';
 import { LinkedTimeItemBusinessLogicRuleBase } from './LinkedTimeItemBusinessLogicRuleBase';
 import { LinkedTimeItemType } from './TimeColumnUtil';
 declare const conditionColumns: readonly ["project", "subproject"];
-/**
- * Function items are the only linked time item that have a 'timeframe' field, which, like the 'schema_**' fields,
- * refers to a project time.
- */
 declare const schemeValueTimeFrameColumnIds: readonly ["schema_gv", "schema_pv", "schema_gt", "schema_pt", "timeframe"];
 type SchemeValueTimeFrameColumnId = (typeof schemeValueTimeFrameColumnIds)[number];
-type CreatedUpdatedTuple<ItemTypeType extends LinkedTimeItemType> = {
-    created: {
-        item: ChangesDeltaItemCreateDelta<ItemTypeType>;
-        invalidTimes: SchemeValueTimeFrameColumnId[];
-    }[];
-    updated: {
-        item: ItemEntry<ItemTypeType>;
-        invalidTimes: SchemeValueTimeFrameColumnId[];
-    }[];
+type InvalidTimesTuple<ItemTypeType extends LinkedTimeItemType> = {
+    item: ItemEntry<ItemTypeType>;
+    invalidTimes: SchemeValueTimeFrameColumnId[];
 };
 export type LinkedTimeItemSubprojectBusinessLogicRuleConditionResult = {
-    [ItemType in LinkedTimeItemType]: CreatedUpdatedTuple<ItemType>;
+    [ItemType in LinkedTimeItemType]: InvalidTimesTuple<ItemType>[];
 };
 /**
  * When updating the subproject of a function / function group / equipment group, or creating a new
@@ -39,10 +28,6 @@ export declare class LinkedTimeItemSubprojectBusinessLogicRule extends LinkedTim
     private validateLinkedTimes;
     private getInvalidTimeColumnIds;
     private extractTimeItemIds;
-    /**
-     * The iterator includes the IDs of all times linked to the items in the updated or created items.
-     */
-    private getCreatedItemTimeIdIterator;
-    private getUpdatedItemTimeIdIterator;
+    private getTimeIdIterator;
 }
 export {};

package/dist/types/src/classes/BusinessLogicManager/MateriaalCatFunctieFunctiegroep/LinkedTimeItemTimeSchemeBusinessLogicRule.d.ts

@@ -3,7 +3,8 @@ import { TransactionCache } from '../../cache/transaction/TransactionCache';
 import { BLR_SKIP_RULE } from '../BusinessLogicRule';
 import { BusinessLogicRuleApplyContext } from '../BusinessLogicRuleApplyContext';
 import { BusinessLogicRuleConditionContext } from '../BusinessLogicRuleConditionContext';
-import { LinkedTimeItemBusinessLogicRuleBase, LinkedTimeItemBusinessLogicRuleBaseUpdatedTuples, LinkedTimeItemResourceMap } from './LinkedTimeItemBusinessLogicRuleBase';
+import { BusinessLogicRuleContextBase } from '../BusinessLogicRuleContextBase';
+import { LinkedTimeItemBusinessLogicRuleBase, LinkedTimeItemBusinessLogicRuleBaseColumnMap, LinkedTimeItemResourceMap } from './LinkedTimeItemBusinessLogicRuleBase';
 import { TimeColumnUtil } from './TimeColumnUtil';
 declare const requestColumns: readonly ["gebruikvan", "planvan", "gebruiktot", "plantot", "schema_gv_begin", "schema_gt_begin", "schema_pv_begin", "schema_pt_begin"];
 export declare const timeColumns: readonly ["id", "van", "tot"];
@@ -11,17 +12,18 @@ interface Dependency {
     timeResources: ItemResource<'Tijd', typeof timeColumns>[];
     linkedTimeItemResources: LinkedTimeItemResourceMap<typeof requestColumns>;
 }
+type SchemeValueColumnIds = typeof TimeColumnUtil.schemeValueColumnIds;
 /**
  * - When setting 'schema_gv', set 'gebruikvan' to the corresponding time, and 'schema_gv_begin' to `true`.
  * - When setting 'schema_gt', set 'gebruiktot' to the corresponding time, and 'schema_gt_begin' to `false`.
  * - When setting 'schema_pv', set 'planvan' to the corresponding time, and 'schema_pv_begin' to `true`.
  * - When setting 'schema_pt', set 'plantot' to the corresponding time, and 'schema_pt_begin' to `false`.
  */
-export declare class LinkedTimeItemTimeSchemeBusinessLogicRule extends LinkedTimeItemBusinessLogicRuleBase<typeof TimeColumnUtil.schemeValueColumnIds, LinkedTimeItemBusinessLogicRuleBaseUpdatedTuples<typeof TimeColumnUtil.schemeValueColumnIds>, Dependency> {
+export declare class LinkedTimeItemTimeSchemeBusinessLogicRule extends LinkedTimeItemBusinessLogicRuleBase<SchemeValueColumnIds, LinkedTimeItemBusinessLogicRuleBaseColumnMap<SchemeValueColumnIds>, Dependency> {
     protected conditionColumns: readonly ["schema_gv", "schema_pv", "schema_gt", "schema_pt"];
-    condition(context: BusinessLogicRuleConditionContext): LinkedTimeItemBusinessLogicRuleBaseUpdatedTuples<typeof TimeColumnUtil.schemeValueColumnIds> | typeof BLR_SKIP_RULE;
-    dependency(transaction: TransactionCache, conditionResult: LinkedTimeItemBusinessLogicRuleBaseUpdatedTuples<typeof TimeColumnUtil.schemeValueColumnIds>): Promise<Dependency>;
-    apply(context: BusinessLogicRuleApplyContext, dependency: Dependency, conditionResult: LinkedTimeItemBusinessLogicRuleBaseUpdatedTuples<typeof TimeColumnUtil.schemeValueColumnIds>): void;
+    condition(context: BusinessLogicRuleConditionContext): LinkedTimeItemBusinessLogicRuleBaseColumnMap<SchemeValueColumnIds> | typeof BLR_SKIP_RULE;
+    dependency(transaction: TransactionCache, conditionResult: LinkedTimeItemBusinessLogicRuleBaseColumnMap<SchemeValueColumnIds>, context: BusinessLogicRuleContextBase): Promise<Dependency>;
+    apply(context: BusinessLogicRuleApplyContext, dependency: Dependency, conditionResult: LinkedTimeItemBusinessLogicRuleBaseColumnMap<SchemeValueColumnIds>): void;
     private getTimeItemIds;
 }
 export {};

package/dist/types/src/classes/BusinessLogicManager/MateriaalCatFunctieFunctiegroep/LinkedTimeItemTimeSchemeStartBusinessLogicRule.d.ts

@@ -2,17 +2,19 @@ import { TransactionCache } from '../../cache/transaction/TransactionCache';
 import { BLR_SKIP_RULE } from '../BusinessLogicRule';
 import { BusinessLogicRuleApplyContext } from '../BusinessLogicRuleApplyContext';
 import { BusinessLogicRuleConditionContext } from '../BusinessLogicRuleConditionContext';
-import { LinkedTimeItemBusinessLogicRuleBase, LinkedTimeItemBusinessLogicRuleBaseUpdatedTuples, LinkedTimeItemResourceMap } from './LinkedTimeItemBusinessLogicRuleBase';
+import { LinkedTimeItemBusinessLogicRuleBase, LinkedTimeItemBusinessLogicRuleBaseColumnMap, LinkedTimeItemResourceMap } from './LinkedTimeItemBusinessLogicRuleBase';
 import { TimeColumnUtil } from './TimeColumnUtil';
+type SchemeValueStartColumnIds = typeof TimeColumnUtil.schemeValueStartColumnIds;
 /**
  * - If 'schema_gv' changes, while 'schema_gv_start' is `true`, and previously, 'schema_gv' and 'schema_gt' had the same
  * value, set 'schema_gt' to the new value of 'schema_gv'.
  * - If 'schema_pv' changes, while 'schema_pv_start' is `true` and previously, 'schema_pv' and 'schema_pt' had the same
  * value, set 'schema_pt' to the new value of 'schema_pv'.
  */
-export declare class LinkedTimeItemTimeSchemeStartBusinessLogicRule extends LinkedTimeItemBusinessLogicRuleBase<typeof TimeColumnUtil.schemeValueStartColumnIds, LinkedTimeItemBusinessLogicRuleBaseUpdatedTuples<typeof TimeColumnUtil.schemeValueStartColumnIds>, LinkedTimeItemResourceMap<typeof TimeColumnUtil.schemeValueColumnIds>> {
+export declare class LinkedTimeItemTimeSchemeStartBusinessLogicRule extends LinkedTimeItemBusinessLogicRuleBase<SchemeValueStartColumnIds, LinkedTimeItemBusinessLogicRuleBaseColumnMap<SchemeValueStartColumnIds>, LinkedTimeItemResourceMap<typeof TimeColumnUtil.schemeValueColumnIds>> {
     protected conditionColumns: readonly ["schema_gv", "schema_pv"];
-    condition(context: BusinessLogicRuleConditionContext): LinkedTimeItemBusinessLogicRuleBaseUpdatedTuples<typeof TimeColumnUtil.schemeValueStartColumnIds> | typeof BLR_SKIP_RULE;
-    dependency(transaction: TransactionCache, conditionResult: LinkedTimeItemBusinessLogicRuleBaseUpdatedTuples<typeof TimeColumnUtil.schemeValueStartColumnIds>): Promise<LinkedTimeItemResourceMap<typeof TimeColumnUtil.schemeValueColumnIds>>;
-    apply(context: BusinessLogicRuleApplyContext, _dependencies: LinkedTimeItemResourceMap<typeof TimeColumnUtil.schemeValueColumnIds>, conditionResult: LinkedTimeItemBusinessLogicRuleBaseUpdatedTuples<typeof TimeColumnUtil.schemeValueStartColumnIds>): void;
+    condition(context: BusinessLogicRuleConditionContext): LinkedTimeItemBusinessLogicRuleBaseColumnMap<SchemeValueStartColumnIds> | typeof BLR_SKIP_RULE;
+    dependency(transaction: TransactionCache, conditionResult: LinkedTimeItemBusinessLogicRuleBaseColumnMap<SchemeValueStartColumnIds>): Promise<LinkedTimeItemResourceMap<typeof TimeColumnUtil.schemeValueColumnIds>>;
+    apply(context: BusinessLogicRuleApplyContext, dependency: LinkedTimeItemResourceMap<typeof TimeColumnUtil.schemeValueColumnIds>, conditionResult: LinkedTimeItemBusinessLogicRuleBaseColumnMap<SchemeValueStartColumnIds>): void;
 }
+export {};

package/dist/types/src/classes/BusinessLogicManager/MateriaalCatFunctieFunctiegroep/LinkedTimeItemTimeValueStartBusinessLogicRule.d.ts

@@ -2,19 +2,20 @@ import { TransactionCache } from '../../cache/transaction/TransactionCache';
 import { BLR_SKIP_RULE } from '../BusinessLogicRule';
 import { BusinessLogicRuleApplyContext } from '../BusinessLogicRuleApplyContext';
 import { BusinessLogicRuleConditionContext } from '../BusinessLogicRuleConditionContext';
-import { LinkedTimeItemBusinessLogicRuleBase, LinkedTimeItemBusinessLogicRuleBaseUpdatedTuples, LinkedTimeItemResourceMap } from './LinkedTimeItemBusinessLogicRuleBase';
+import { LinkedTimeItemBusinessLogicRuleBase, LinkedTimeItemBusinessLogicRuleBaseColumnMap, LinkedTimeItemResourceMap } from './LinkedTimeItemBusinessLogicRuleBase';
 import { TimeColumnUtil } from './TimeColumnUtil';
 declare const requestColumns: readonly ["gebruikvan", "planvan", "gebruiktot", "plantot", "schema_gt", "schema_pt"];
+type ValueStartColumnIds = typeof TimeColumnUtil.valueStartColumnIds;
 /**
  * - When 'gebruikvan' changes, and 'gebruiktot' is invalid or equal to the previous value of 'gebruikvan',
  * and 'schema_gt' is `null` (not referring to a time), set 'gebruiktot' to the new value of 'gebruikvan'.
  * - When 'planvan' changes, and 'plantot' is invalid or equal to the previous value of 'planvan',
  * and 'schema_pt' is `null` (not referring to a time), set 'plantot' to the new value of 'planvan'.
  */
-export declare class LinkedTimeItemTimeValueStartBusinessLogicRule extends LinkedTimeItemBusinessLogicRuleBase<typeof TimeColumnUtil.valueStartColumnIds, LinkedTimeItemBusinessLogicRuleBaseUpdatedTuples<typeof TimeColumnUtil.valueStartColumnIds>, LinkedTimeItemResourceMap<typeof requestColumns>> {
+export declare class LinkedTimeItemTimeValueStartBusinessLogicRule extends LinkedTimeItemBusinessLogicRuleBase<ValueStartColumnIds, LinkedTimeItemBusinessLogicRuleBaseColumnMap<ValueStartColumnIds>, LinkedTimeItemResourceMap<typeof requestColumns>> {
     protected conditionColumns: readonly ["gebruikvan", "planvan"];
-    condition(context: BusinessLogicRuleConditionContext): LinkedTimeItemBusinessLogicRuleBaseUpdatedTuples<typeof TimeColumnUtil.valueStartColumnIds> | typeof BLR_SKIP_RULE;
-    dependency(transaction: TransactionCache, conditionResult: LinkedTimeItemBusinessLogicRuleBaseUpdatedTuples<typeof TimeColumnUtil.valueStartColumnIds>): Promise<LinkedTimeItemResourceMap<typeof requestColumns>>;
-    apply(context: BusinessLogicRuleApplyContext, _dependencies: LinkedTimeItemResourceMap<typeof requestColumns>, conditionResult: LinkedTimeItemBusinessLogicRuleBaseUpdatedTuples<typeof TimeColumnUtil.valueStartColumnIds>): void;
+    condition(context: BusinessLogicRuleConditionContext): LinkedTimeItemBusinessLogicRuleBaseColumnMap<ValueStartColumnIds> | typeof BLR_SKIP_RULE;
+    dependency(transaction: TransactionCache, conditionResult: LinkedTimeItemBusinessLogicRuleBaseColumnMap<ValueStartColumnIds>): Promise<LinkedTimeItemResourceMap<typeof requestColumns>>;
+    apply(context: BusinessLogicRuleApplyContext, linkedTimeItemResourceMap: LinkedTimeItemResourceMap<typeof requestColumns>, conditionResult: LinkedTimeItemBusinessLogicRuleBaseColumnMap<ValueStartColumnIds>): void;
 }
 export {};

package/dist/types/src/classes/BusinessLogicManager/MateriaalCatFunctieFunctiegroep/TimeColumnUtil.d.ts

@@ -15,7 +15,7 @@ type TimeItemFields = {
     van: moment.Moment;
     tot: moment.Moment;
 };
-export declare const LINKED_TIME_ITEM_TYPES: readonly ["MateriaalCat", "Functie", "Functiegroep"];
+export declare const LINKED_TIME_ITEM_TYPES: ["MateriaalCat", "Functie", "Functiegroep"];
 export type LinkedTimeItemType = (typeof LINKED_TIME_ITEM_TYPES)[number];
 export type LinkedItemTypeFieldMap<ItemTypeType extends LinkedTimeItemType> = ItemTypeType extends 'Functie' ? FieldMap<'Functie', TimeColumnId[]> : FieldMap<ItemTypeType, TimeColumnIdExcludingTimeFrame[]>;
 declare const nonReferenceProperties: readonly ["type", "isStart", "defaultValue"];

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

@@ -4,13 +4,14 @@ import { TransactionCache } from '../../cache/transaction/TransactionCache';
 import { BLR_SKIP_RULE, BusinessLogicRule } from '../BusinessLogicRule';
 import { BusinessLogicRuleApplyContext } from '../BusinessLogicRuleApplyContext';
 import { BusinessLogicRuleConditionContext } from '../BusinessLogicRuleConditionContext';
+declare const requestColumns: readonly ["vervaldatum", "datum"];
 type ConditionResult = {
     Offerte: ItemId[];
     Contract: ItemId[];
 };
 type Dependency = {
-    Offerte: ItemResource<'Offerte', ['vervaldatum']>[];
-    Contract: ItemResource<'Contract', ['vervaldatum']>[];
+    Offerte: ItemResource<'Offerte', typeof requestColumns>[];
+    Contract: ItemResource<'Contract', typeof requestColumns>[];
 };
 export declare class OfferteContractDatumBusinessLogicRule extends BusinessLogicRule<ConditionResult, Dependency> {
     condition(context: BusinessLogicRuleConditionContext): ConditionResult | typeof BLR_SKIP_RULE;

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

@@ -4,21 +4,23 @@ import { TransactionCache } from '../../cache/transaction/TransactionCache';
 import { BLR_SKIP_RULE, BusinessLogicRule } from '../BusinessLogicRule';
 import { BusinessLogicRuleApplyContext } from '../BusinessLogicRuleApplyContext';
 import { BusinessLogicRuleConditionContext } from '../BusinessLogicRuleConditionContext';
+declare const planningColumns: readonly ["vervoer", "functie", "planvan", "plantot"];
+declare const functieColumns: readonly ["id", "reistijd_vooraf", "reistijd_achteraf"];
 type ConditionResult = {
     Planningpersoneel: ItemId[];
     Planningtransport: ItemId[];
 };
 type Dependency = {
-    Planningpersoneel: ItemResource<'Planningpersoneel', ['vervoer', 'functie', 'planvan', 'plantot']>[];
-    Planningtransport: ItemResource<'Planningtransport', ['vervoer', 'functie', 'planvan', 'plantot']>[];
+    Planningpersoneel: ItemResource<'Planningpersoneel', typeof planningColumns>[];
+    Planningtransport: ItemResource<'Planningtransport', typeof planningColumns>[];
     Functie: {
-        [functieId: string]: ItemResource<'Functie', ['reistijd_vooraf', 'reistijd_achteraf']>;
+        [functieId: string]: ItemResource<'Functie', typeof functieColumns>;
     };
 };
 export declare class PlanningPersoneelTransportBusinessLogicRule extends BusinessLogicRule<ConditionResult, Dependency> {
     condition(context: BusinessLogicRuleConditionContext): ConditionResult | typeof BLR_SKIP_RULE;
     dependency(transaction: TransactionCache, itemIdMap: ConditionResult): Promise<Dependency>;
-    apply({ transaction, mergedChangesDelta, destinationChangesDelta, }: BusinessLogicRuleApplyContext, items: Dependency): void;
+    apply({ destinationChangesDelta, }: BusinessLogicRuleApplyContext, items: Dependency): void;
     private updatePlanningColumns;
 }
 export {};

package/dist/types/src/classes/BusinessLogicManager/Planningmateriaal/PlanningmateriaalOptieBusinessLogicRule.d.ts

@@ -7,7 +7,7 @@ import { BusinessLogicRuleConditionContext } from '../BusinessLogicRuleCondition
 type ConditionResult = ItemId[];
 declare const childPlanningmateriaalColumns: readonly ["id", "optie", "parent"];
 declare const changedPlanningMateriaalColumns: readonly ["id", "optie", "categorie", "parent", {
-    readonly materiaal: readonly ["type"];
+    readonly materiaal: readonly ["is_combination", "is_physical"];
 }];
 type Dependency = {
     childPlanningmateriaalResourcesInCategories: ItemResource<'Planningmateriaal', typeof childPlanningmateriaalColumns>[];

package/dist/types/src/classes/BusinessLogicManager/Planningmateriaal/PlanningmateriaalParentBusinessLogicRule.d.ts

@@ -4,9 +4,7 @@ import { TransactionCache } from '../../cache/transaction/TransactionCache';
 import { BLR_SKIP_RULE, BusinessLogicRule } from '../BusinessLogicRule';
 import { BusinessLogicRuleApplyContext } from '../BusinessLogicRuleApplyContext';
 import { BusinessLogicRuleConditionContext } from '../BusinessLogicRuleConditionContext';
-declare const planningmateriaalColumns: readonly ["parent", {
-    readonly setcontent: readonly ["is_fixed"];
-}];
+declare const planningmateriaalColumns: readonly ["parent", "setcontent"];
 type ConditionResult = ItemId<'Planningmateriaal'>[];
 type Dependency = ItemResource<'Planningmateriaal', typeof planningmateriaalColumns>[];
 export declare class PlanningmateriaalParentBusinessLogicRule extends BusinessLogicRule<ConditionResult, Dependency> {

package/dist/types/src/classes/BusinessLogicManager/Planningmateriaal/PlanningmateriaalStaysAtLocationBusinessLogicRule.d.ts

@@ -1,14 +1,10 @@
 import { ItemId } from '@rentman/backend-types';
 import { ItemResource } from '../../../models/ItemResource';
 import { TransactionCache } from '../../cache/transaction/TransactionCache';
-import { ChangesDeltaItemCreateDelta } from '../../CreatedChangesDelta';
 import { BLR_SKIP_RULE, BusinessLogicRule } from '../BusinessLogicRule';
 import { BusinessLogicRuleApplyContext } from '../BusinessLogicRuleApplyContext';
 import { BusinessLogicRuleConditionContext } from '../BusinessLogicRuleConditionContext';
-type ConditionResult = {
-    changedItems: ItemId[];
-    createdItems: ChangesDeltaItemCreateDelta[];
-};
+type ConditionResult = ItemId<'Planningmateriaal'>[];
 declare const planningMateriaalColumns: readonly ["aantaltotaal", "stays_at_location", {
     readonly categorie: readonly [{
         readonly project: readonly [{
@@ -16,10 +12,7 @@ declare const planningMateriaalColumns: readonly ["aantaltotaal", "stays_at_loca
         }];
     }];
 }];
-type Dependency = {
-    changedPlanningMateriaalResources: ItemResource<'Planningmateriaal', typeof planningMateriaalColumns>[];
-    createdItems: ChangesDeltaItemCreateDelta<'Planningmateriaal'>[];
-};
+type Dependency = ItemResource<'Planningmateriaal', typeof planningMateriaalColumns>[];
 /**
  * @description
  * If the planningmateriaal 'aantaltotaal' is changed in a transfer project, stays_at_location should copy this value.
@@ -27,6 +20,6 @@ type Dependency = {
 export declare class PlanningmateriaalStaysAtLocationBusinessLogicRule extends BusinessLogicRule<ConditionResult, Dependency> {
     condition(context: BusinessLogicRuleConditionContext): ConditionResult | typeof BLR_SKIP_RULE;
     dependency(transaction: TransactionCache, conditionResult: ConditionResult): Promise<Dependency>;
-    apply(context: BusinessLogicRuleApplyContext, dependency: Dependency): void;
+    apply(context: BusinessLogicRuleApplyContext, plannedEquipmentResources: Dependency): void;
 }
 export {};

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

@@ -5,16 +5,18 @@ import { TransactionCache } from '../../cache/transaction/TransactionCache';
 import { BLR_SKIP_RULE, BusinessLogicRule } from '../BusinessLogicRule';
 import { BusinessLogicRuleApplyContext } from '../BusinessLogicRuleApplyContext';
 import { BusinessLogicRuleConditionContext } from '../BusinessLogicRuleConditionContext';
+declare const contactColumns: readonly ["projectnotitie_naam", "projectnotitie"];
+declare const projectnotitieColumns: readonly ["naam", "omschrijving"];
 type ConditionResult = {
     projectId: ItemId;
-    updatedContactIds: Set<ItemId>;
+    updatedContactIds: Set<ItemId<'Contact'>>;
 }[];
 type Dependency = {
     template: Template<'Projectnotitie'>;
     projectTuples: {
         projectId: ItemId;
-        Contact: ItemResource<'Contact', ['projectnotitie_naam', 'projectnotitie']>[];
-        Projectnotitie: ItemResource<'Projectnotitie', ['naam', 'omschrijving']>[];
+        Contact: ItemResource<'Contact', typeof contactColumns>[];
+        Projectnotitie: ItemResource<'Projectnotitie', typeof projectnotitieColumns>[];
     }[];
 };
 export declare class ProjectContactProjectNoteBusinessLogicRule extends BusinessLogicRule<ConditionResult, Dependency> {

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

@@ -4,11 +4,13 @@ import { TransactionCache } from '../../cache/transaction/TransactionCache';
 import { BLR_SKIP_RULE, BusinessLogicRule } from '../BusinessLogicRule';
 import { BusinessLogicRuleApplyContext } from '../BusinessLogicRuleApplyContext';
 import { BusinessLogicRuleConditionContext } from '../BusinessLogicRuleConditionContext';
+declare const subprojectColumns: readonly ["id", "locatie"];
+declare const projectColumns: readonly ["id", "locatie", "locatie_persoon"];
 type ConditionResult = ItemId[];
 type Dependency = {
     [projectId: number]: {
-        subprojectResources: ItemResource<'Subproject', ['id', 'locatie']>[];
-        projectResource: ItemResource<'Project', ['id', 'locatie', 'locatie_persoon']>;
+        subprojectResources: ItemResource<'Subproject', typeof subprojectColumns>[];
+        projectResource: ItemResource<'Project', typeof projectColumns>;
     };
 };
 /**

package/dist/types/src/classes/BusinessLogicManager/Rate/RateDeactivateExistingOnCreateBusinessLogicRule.d.ts

@@ -4,8 +4,9 @@ import { TransactionCache } from '../../cache/transaction/TransactionCache';
 import { BLR_SKIP_RULE, BusinessLogicRule } from '../BusinessLogicRule';
 import { BusinessLogicRuleApplyContext } from '../BusinessLogicRuleApplyContext';
 import { BusinessLogicRuleConditionContext } from '../BusinessLogicRuleConditionContext';
+declare const rateColumns: readonly ["rate_group", "active", "id"];
 type ConditionResult = Set<ItemId>;
-type Dependency = ItemResource<'Rate', ['rate_group', 'active', 'id']>[];
+type Dependency = ItemResource<'Rate', typeof rateColumns>[];
 /**
  * When new Rate items are created within a rate group, this rule deactivates all existing
  * active rates in those groups by setting their `active` field to false.

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

@@ -4,8 +4,9 @@ import { TransactionCache } from '../../cache/transaction/TransactionCache';
 import { BLR_SKIP_RULE, BusinessLogicRule } from '../BusinessLogicRule';
 import { BusinessLogicRuleApplyContext } from '../BusinessLogicRuleApplyContext';
 import { BusinessLogicRuleConditionContext } from '../BusinessLogicRuleConditionContext';
+declare const reparatieColumns: readonly ["aantal"];
 type ConditionResult = ItemId[];
-type Dependency = ItemResource<'Reparatie', ['aantal']>[];
+type Dependency = ItemResource<'Reparatie', typeof reparatieColumns>[];
 export declare class ReparatiesExemplaarAantalBusinessLogicRule extends BusinessLogicRule<ConditionResult, Dependency> {
     condition({ previousChangesDelta, }: BusinessLogicRuleConditionContext): ConditionResult | typeof BLR_SKIP_RULE;
     dependency(transaction: TransactionCache, reparatieIds: ConditionResult): Promise<Dependency>;

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

@@ -5,13 +5,14 @@ import { TransactionCache } from '../../cache/transaction/TransactionCache';
 import { BLR_SKIP_RULE, BusinessLogicRule } from '../BusinessLogicRule';
 import { BusinessLogicRuleApplyContext } from '../BusinessLogicRuleApplyContext';
 import { BusinessLogicRuleConditionContext } from '../BusinessLogicRuleConditionContext';
+declare const exemplaarColumns: readonly ["id", "asset_location"];
 type ConditionResult = {
     entry: ItemEntry<'Reparatie' | 'MateriaalLost'>;
     exemplaar: ItemId;
 }[];
 type Dependency = {
     entries: ItemEntry<'Reparatie' | 'MateriaalLost'>[];
-    exemplaarResources: ItemResource<'Exemplaar', ['id', 'asset_location']>[];
+    exemplaarResources: ItemResource<'Exemplaar', typeof exemplaarColumns>[];
 };
 export declare class ReparatieLostItemExemplaarLocationBusinessLogicRule extends BusinessLogicRule<ConditionResult, Dependency> {
     condition({ previousChangesDelta, }: BusinessLogicRuleConditionContext): ConditionResult | typeof BLR_SKIP_RULE;

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

@@ -4,10 +4,9 @@ import { TransactionCache } from '../../cache/transaction/TransactionCache';
 import { BLR_SKIP_RULE, BusinessLogicRule } from '../BusinessLogicRule';
 import { BusinessLogicRuleApplyContext } from '../BusinessLogicRuleApplyContext';
 import { BusinessLogicRuleConditionContext } from '../BusinessLogicRuleConditionContext';
+declare const rolColumns: readonly ["general_eigen_medewerker_edit"];
 type ConditionResult = ItemId[];
-type Dependency = ItemResource<'Rol', [
-    'general_eigen_medewerker_edit'
-]>[];
+type Dependency = ItemResource<'Rol', typeof rolColumns>[];
 /**
  * @description
  * If you can access update crew data, you can also always update your own data

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

@@ -4,10 +4,9 @@ import { TransactionCache } from '../../cache/transaction/TransactionCache';
 import { BLR_SKIP_RULE, BusinessLogicRule } from '../BusinessLogicRule';
 import { BusinessLogicRuleApplyContext } from '../BusinessLogicRuleApplyContext';
 import { BusinessLogicRuleConditionContext } from '../BusinessLogicRuleConditionContext';
+declare const rolColumns: readonly ["projecten_toegang"];
 type ConditionResult = ItemId[];
-type Dependency = ItemResource<'Rol', [
-    'projecten_toegang'
-]>[];
+type Dependency = ItemResource<'Rol', typeof rolColumns>[];
 /**
  * @description
  * 	If you can enter the crew planner you can also access projects

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

@@ -4,10 +4,9 @@ import { TransactionCache } from '../../cache/transaction/TransactionCache';
 import { BLR_SKIP_RULE, BusinessLogicRule } from '../BusinessLogicRule';
 import { BusinessLogicRuleApplyContext } from '../BusinessLogicRuleApplyContext';
 import { BusinessLogicRuleConditionContext } from '../BusinessLogicRuleConditionContext';
+declare const rolColumns: readonly ["materialen_tijdlijn"];
 type ConditionResult = ItemId[];
-type Dependency = ItemResource<'Rol', [
-    'materialen_tijdlijn'
-]>[];
+type Dependency = ItemResource<'Rol', typeof rolColumns>[];
 /**
  * @description
  * If you can edit projects you should be able to see the equipment availability

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

@@ -4,11 +4,9 @@ import { TransactionCache } from '../../cache/transaction/TransactionCache';
 import { BLR_SKIP_RULE, BusinessLogicRule } from '../BusinessLogicRule';
 import { BusinessLogicRuleApplyContext } from '../BusinessLogicRuleApplyContext';
 import { BusinessLogicRuleConditionContext } from '../BusinessLogicRuleConditionContext';
+declare const rolColumns: readonly ["uren_kosten", "visibility_financials"];
 type ConditionResult = ItemId[];
-type Dependency = ItemResource<'Rol', [
-    'uren_kosten',
-    'visibility_financials'
-]>[];
+type Dependency = ItemResource<'Rol', typeof rolColumns>[];
 /**
  * @description
  * 	If you have access to projects you should be able to make costs for registered hours

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

@@ -4,14 +4,9 @@ import { TransactionCache } from '../../cache/transaction/TransactionCache';
 import { BLR_SKIP_RULE, BusinessLogicRule } from '../BusinessLogicRule';
 import { BusinessLogicRuleApplyContext } from '../BusinessLogicRuleApplyContext';
 import { BusinessLogicRuleConditionContext } from '../BusinessLogicRuleConditionContext';
+declare const rolColumns: readonly ["visibility_financials", "facturen_toegang", "projecten_facturen_maken", "projecten_offertes_maken", "projecten_toegang"];
 type ConditionResult = ItemId[];
-type Dependency = ItemResource<'Rol', [
-    'visibility_financials',
-    'facturen_toegang',
-    'projecten_facturen_maken',
-    'projecten_offertes_maken',
-    'projecten_toegang'
-]>[];
+type Dependency = ItemResource<'Rol', typeof rolColumns>[];
 /**
  * @description
  * If you're not allowed to see financials, then you should not have the permission to

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

@@ -5,9 +5,8 @@ import { BLR_SKIP_RULE, BusinessLogicRule } from '../BusinessLogicRule';
 import { BusinessLogicRuleApplyContext } from '../BusinessLogicRuleApplyContext';
 import { BusinessLogicRuleConditionContext } from '../BusinessLogicRuleConditionContext';
 type ConditionResult = ItemId[];
-type Dependency = ItemResource<'Rol', [
-    'magazijn_toegang'
-]>[];
+declare const rolColumns: readonly ["magazijn_toegang"];
+type Dependency = ItemResource<'Rol', typeof rolColumns>[];
 /**
  * @description
  * 	If you can enter access the Warehouse Tracking Log, you can also access Warehouse module

package/dist/types/src/classes/BusinessLogicManager/Setinhoud/SetinhoudCreateFixedBusinessLogicRule.d.ts

@@ -1,12 +1,12 @@
+import { ItemResource } from '../../../models/ItemResource';
 import { TransactionCache } from '../../cache/transaction/TransactionCache';
-import { ChangesDeltaItemCreateDelta } from '../../CreatedChangesDelta';
+import { ChildChangesDeltaItemCreateDelta } from '../../ChildChangesDelta';
 import { BLR_SKIP_RULE, BusinessLogicRule } from '../BusinessLogicRule';
 import { BusinessLogicRuleApplyContext } from '../BusinessLogicRuleApplyContext';
 import { BusinessLogicRuleConditionContext } from '../BusinessLogicRuleConditionContext';
-import { LatestItem } from '../BusinessLogicRuleContextBase';
 declare const materiaalColumns: readonly ["id", "type", "is_combination", "is_physical", "telexemplaren", "verhuur"];
-type ConditionResult = ChangesDeltaItemCreateDelta<'Setinhoud'>[];
-type Dependency = Record<string, LatestItem<'Materiaal', typeof materiaalColumns>>;
+type ConditionResult = ChildChangesDeltaItemCreateDelta<'Setinhoud'>[];
+type Dependency = Record<string, ItemResource<'Materiaal', typeof materiaalColumns>>;
 /**
  * Legacy users won't have the `FUNCTIONALITY_FLEXIBLE_COMBINATION_IN_PLANNING` flag, meaning the `is_fixed` column from `Setinhoud` column isn't editable
  * With this business rule we enforce the correct (default) value based on the equipment properties (Backend enforces this as well)

package/dist/types/src/classes/BusinessLogicManager/Subproject/SubprojectInPlanningBusinessLogicRule.d.ts

@@ -1,6 +1,7 @@
 import { ItemId } from '@rentman/backend-types';
 import { BLR_SKIP_RULE, BusinessLogicRule, BusinessLogicRuleApplyContext, BusinessLogicRuleConditionContext, ItemResource, TransactionCache } from '../../../internal';
-type Dependency = Map<ItemId<'Subproject'>, ItemResource<'Functie', ['subproject', 'inplanning']>[]>;
+declare const functieColumns: readonly ["subproject", "inplanning"];
+type Dependency = Map<ItemId<'Subproject'>, ItemResource<'Functie', typeof functieColumns>[]>;
 type ConditionResult = Map<ItemId<'Subproject'>, boolean>;
 /**
  * Whenever the 'inplanning' field of a subproject changes, set the 'inplanning' field of all functions in the

package/dist/types/src/classes/BusinessLogicManager/Subproject/SubprojectOneSubLocationAlignBusinessRule.d.ts

@@ -4,11 +4,13 @@ import { TransactionCache } from '../../cache/transaction/TransactionCache';
 import { BLR_SKIP_RULE, BusinessLogicRule } from '../BusinessLogicRule';
 import { BusinessLogicRuleApplyContext } from '../BusinessLogicRuleApplyContext';
 import { BusinessLogicRuleConditionContext } from '../BusinessLogicRuleConditionContext';
+declare const subprojectColumns: readonly ["id", "project", "locatie", "locatie_persoon"];
+declare const projectColumns: readonly ["id", "locatie"];
 type ConditionResult = ItemId[];
 type Dependency = {
     [projectId: number]: {
-        Subproject: ItemResource<'Subproject', ['id', 'project', 'locatie', 'locatie_persoon']>;
-        Project: ItemResource<'Project', ['id', 'locatie']>;
+        Subproject: ItemResource<'Subproject', typeof subprojectColumns>;
+        Project: ItemResource<'Project', typeof projectColumns>;
         amountOfSubprojects: number;
     };
 };