@rentman/rm-core 63.4.1-blr-01 → 63.4.1

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

@@ -5,8 +5,16 @@ import { BLR_SKIP_RULE, BusinessLogicRule } from '../BusinessLogicRule';
 import { BusinessLogicRuleApplyContext } from '../BusinessLogicRuleApplyContext';
 import { BusinessLogicRuleConditionContext } from '../BusinessLogicRuleConditionContext';
 type ConditionResult = ItemId[];
-declare const materiaalColumns: readonly ["width", "height", "oppervlakteartikel", "nieuwprijs", "inhuurprijs", "verhuurprijs", "naam"];
-type Dependency = ItemResource<'Materiaal', typeof materiaalColumns>[];
+type DependencyColumns = [
+    'width',
+    'height',
+    'oppervlakteartikel',
+    'nieuwprijs',
+    'inhuurprijs',
+    'verhuurprijs',
+    'naam'
+];
+type Dependency = ItemResource<'Materiaal', DependencyColumns>[];
 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,7 +1,8 @@
 import { ItemEntry } from '../../../models/ItemEntry';
 import { ItemResource } from '../../../models/ItemResource';
-import { ApiRequestColumnArray } from '../../../types/ItemTypesCollection';
+import { ApiRequestColumnArray, GetFieldValueType } 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';
@@ -16,24 +17,30 @@ type LinkedTimeItemRequestColumnsMapToItemResourceMap<RequestColumnsMap extends
 export type LinkedTimeItemResourceMap<RequestColumns extends ApiRequestColumnArray<LinkedTimeItemType>> = {
     [ItemType in LinkedTimeItemType]: ItemResource<ItemType, RequestColumns>[];
 };
-/**
- * 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][]>;
+type CreatedTupleMap = {
+    [ItemType in LinkedTimeItemType]: ChangesDeltaItemCreateDelta<ItemType>[];
 };
+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, includeCreatedItems?: boolean): LinkedTimeItemBusinessLogicRuleBaseColumnMap<ConditionColumns>;
+    protected extractUpdatedTuples(context: BusinessLogicRuleConditionContext): LinkedTimeItemBusinessLogicRuleBaseUpdatedTuples<ConditionColumns>;
     /**
      * Like {@link extractUpdatedTuples}, but returns `undefined` when no fields have been updated.
      */
-    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>>;
+    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>>;
 }
 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, LinkedTimeItemBusinessLogicRuleBaseColumnMap, LinkedTimeItemResourceMap } from './LinkedTimeItemBusinessLogicRuleBase';
+import { LinkedTimeItemBusinessLogicRuleBase, LinkedTimeItemBusinessLogicRuleBaseUpdatedTuples, 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, LinkedTimeItemBusinessLogicRuleBaseColumnMap<typeof conditionColumns>, LinkedTimeItemResourceMap<typeof requestColumns>> {
+export declare class LinkedTimeItemDurationBusinessLogicRule extends LinkedTimeItemBusinessLogicRuleBase<typeof conditionColumns, LinkedTimeItemBusinessLogicRuleBaseUpdatedTuples<typeof conditionColumns>, LinkedTimeItemResourceMap<typeof requestColumns>> {
     protected conditionColumns: readonly ["gebruikvan", "gebruiktot"];
-    condition(context: BusinessLogicRuleConditionContext): LinkedTimeItemBusinessLogicRuleBaseColumnMap<typeof conditionColumns> | typeof BLR_SKIP_RULE;
+    condition(context: BusinessLogicRuleConditionContext): LinkedTimeItemBusinessLogicRuleBaseUpdatedTuples<typeof conditionColumns> | typeof BLR_SKIP_RULE;
     apply(context: BusinessLogicRuleApplyContext, dependencies: LinkedTimeItemResourceMap<typeof requestColumns>): void;
-    dependency(transaction: TransactionCache, conditionResult: LinkedTimeItemBusinessLogicRuleBaseColumnMap<typeof conditionColumns>): Promise<LinkedTimeItemResourceMap<typeof requestColumns>>;
+    dependency(transaction: TransactionCache, conditionResult: LinkedTimeItemBusinessLogicRuleBaseUpdatedTuples<typeof conditionColumns>): Promise<LinkedTimeItemResourceMap<typeof requestColumns>>;
 }
 export {};

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

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

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

@@ -1,18 +1,29 @@
 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 InvalidTimesTuple<ItemTypeType extends LinkedTimeItemType> = {
-    item: ItemEntry<ItemTypeType>;
-    invalidTimes: SchemeValueTimeFrameColumnId[];
+type CreatedUpdatedTuple<ItemTypeType extends LinkedTimeItemType> = {
+    created: {
+        item: ChangesDeltaItemCreateDelta<ItemTypeType>;
+        invalidTimes: SchemeValueTimeFrameColumnId[];
+    }[];
+    updated: {
+        item: ItemEntry<ItemTypeType>;
+        invalidTimes: SchemeValueTimeFrameColumnId[];
+    }[];
 };
 export type LinkedTimeItemSubprojectBusinessLogicRuleConditionResult = {
-    [ItemType in LinkedTimeItemType]: InvalidTimesTuple<ItemType>[];
+    [ItemType in LinkedTimeItemType]: CreatedUpdatedTuple<ItemType>;
 };
 /**
  * When updating the subproject of a function / function group / equipment group, or creating a new
@@ -28,6 +39,10 @@ export declare class LinkedTimeItemSubprojectBusinessLogicRule extends LinkedTim
     private validateLinkedTimes;
     private getInvalidTimeColumnIds;
     private extractTimeItemIds;
-    private getTimeIdIterator;
+    /**
+     * The iterator includes the IDs of all times linked to the items in the updated or created items.
+     */
+    private getCreatedItemTimeIdIterator;
+    private getUpdatedItemTimeIdIterator;
 }
 export {};

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

@@ -3,8 +3,7 @@ import { TransactionCache } from '../../cache/transaction/TransactionCache';
 import { BLR_SKIP_RULE } from '../BusinessLogicRule';
 import { BusinessLogicRuleApplyContext } from '../BusinessLogicRuleApplyContext';
 import { BusinessLogicRuleConditionContext } from '../BusinessLogicRuleConditionContext';
-import { BusinessLogicRuleContextBase } from '../BusinessLogicRuleContextBase';
-import { LinkedTimeItemBusinessLogicRuleBase, LinkedTimeItemBusinessLogicRuleBaseColumnMap, LinkedTimeItemResourceMap } from './LinkedTimeItemBusinessLogicRuleBase';
+import { LinkedTimeItemBusinessLogicRuleBase, LinkedTimeItemBusinessLogicRuleBaseUpdatedTuples, 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"];
@@ -12,18 +11,17 @@ 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<SchemeValueColumnIds, LinkedTimeItemBusinessLogicRuleBaseColumnMap<SchemeValueColumnIds>, Dependency> {
+export declare class LinkedTimeItemTimeSchemeBusinessLogicRule extends LinkedTimeItemBusinessLogicRuleBase<typeof TimeColumnUtil.schemeValueColumnIds, LinkedTimeItemBusinessLogicRuleBaseUpdatedTuples<typeof TimeColumnUtil.schemeValueColumnIds>, Dependency> {
     protected conditionColumns: readonly ["schema_gv", "schema_pv", "schema_gt", "schema_pt"];
-    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;
+    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;
     private getTimeItemIds;
 }
 export {};

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

@@ -2,19 +2,17 @@ import { TransactionCache } from '../../cache/transaction/TransactionCache';
 import { BLR_SKIP_RULE } from '../BusinessLogicRule';
 import { BusinessLogicRuleApplyContext } from '../BusinessLogicRuleApplyContext';
 import { BusinessLogicRuleConditionContext } from '../BusinessLogicRuleConditionContext';
-import { LinkedTimeItemBusinessLogicRuleBase, LinkedTimeItemBusinessLogicRuleBaseColumnMap, LinkedTimeItemResourceMap } from './LinkedTimeItemBusinessLogicRuleBase';
+import { LinkedTimeItemBusinessLogicRuleBase, LinkedTimeItemBusinessLogicRuleBaseUpdatedTuples, 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<SchemeValueStartColumnIds, LinkedTimeItemBusinessLogicRuleBaseColumnMap<SchemeValueStartColumnIds>, LinkedTimeItemResourceMap<typeof TimeColumnUtil.schemeValueColumnIds>> {
+export declare class LinkedTimeItemTimeSchemeStartBusinessLogicRule extends LinkedTimeItemBusinessLogicRuleBase<typeof TimeColumnUtil.schemeValueStartColumnIds, LinkedTimeItemBusinessLogicRuleBaseUpdatedTuples<typeof TimeColumnUtil.schemeValueStartColumnIds>, LinkedTimeItemResourceMap<typeof TimeColumnUtil.schemeValueColumnIds>> {
     protected conditionColumns: readonly ["schema_gv", "schema_pv"];
-    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;
+    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;
 }
-export {};

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

@@ -2,20 +2,19 @@ import { TransactionCache } from '../../cache/transaction/TransactionCache';
 import { BLR_SKIP_RULE } from '../BusinessLogicRule';
 import { BusinessLogicRuleApplyContext } from '../BusinessLogicRuleApplyContext';
 import { BusinessLogicRuleConditionContext } from '../BusinessLogicRuleConditionContext';
-import { LinkedTimeItemBusinessLogicRuleBase, LinkedTimeItemBusinessLogicRuleBaseColumnMap, LinkedTimeItemResourceMap } from './LinkedTimeItemBusinessLogicRuleBase';
+import { LinkedTimeItemBusinessLogicRuleBase, LinkedTimeItemBusinessLogicRuleBaseUpdatedTuples, 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<ValueStartColumnIds, LinkedTimeItemBusinessLogicRuleBaseColumnMap<ValueStartColumnIds>, LinkedTimeItemResourceMap<typeof requestColumns>> {
+export declare class LinkedTimeItemTimeValueStartBusinessLogicRule extends LinkedTimeItemBusinessLogicRuleBase<typeof TimeColumnUtil.valueStartColumnIds, LinkedTimeItemBusinessLogicRuleBaseUpdatedTuples<typeof TimeColumnUtil.valueStartColumnIds>, LinkedTimeItemResourceMap<typeof requestColumns>> {
     protected conditionColumns: readonly ["gebruikvan", "planvan"];
-    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;
+    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;
 }
 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: ["MateriaalCat", "Functie", "Functiegroep"];
+export declare const LINKED_TIME_ITEM_TYPES: readonly ["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,14 +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 requestColumns: readonly ["vervaldatum", "datum"];
 type ConditionResult = {
     Offerte: ItemId[];
     Contract: ItemId[];
 };
 type Dependency = {
-    Offerte: ItemResource<'Offerte', typeof requestColumns>[];
-    Contract: ItemResource<'Contract', typeof requestColumns>[];
+    Offerte: ItemResource<'Offerte', ['vervaldatum']>[];
+    Contract: ItemResource<'Contract', ['vervaldatum']>[];
 };
 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,23 +4,21 @@ 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', typeof planningColumns>[];
-    Planningtransport: ItemResource<'Planningtransport', typeof planningColumns>[];
+    Planningpersoneel: ItemResource<'Planningpersoneel', ['vervoer', 'functie', 'planvan', 'plantot']>[];
+    Planningtransport: ItemResource<'Planningtransport', ['vervoer', 'functie', 'planvan', 'plantot']>[];
     Functie: {
-        [functieId: string]: ItemResource<'Functie', typeof functieColumns>;
+        [functieId: string]: ItemResource<'Functie', ['reistijd_vooraf', 'reistijd_achteraf']>;
     };
 };
 export declare class PlanningPersoneelTransportBusinessLogicRule extends BusinessLogicRule<ConditionResult, Dependency> {
     condition(context: BusinessLogicRuleConditionContext): ConditionResult | typeof BLR_SKIP_RULE;
     dependency(transaction: TransactionCache, itemIdMap: ConditionResult): Promise<Dependency>;
-    apply({ destinationChangesDelta, }: BusinessLogicRuleApplyContext, items: Dependency): void;
+    apply({ transaction, mergedChangesDelta, 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 ["is_combination", "is_physical"];
+    readonly materiaal: readonly ["type"];
 }];
 type Dependency = {
     childPlanningmateriaalResourcesInCategories: ItemResource<'Planningmateriaal', typeof childPlanningmateriaalColumns>[];

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

@@ -4,7 +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 planningmateriaalColumns: readonly ["parent", "setcontent"];
+declare const planningmateriaalColumns: readonly ["parent", {
+    readonly setcontent: readonly ["is_fixed"];
+}];
 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,10 +1,14 @@
 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 = ItemId<'Planningmateriaal'>[];
+type ConditionResult = {
+    changedItems: ItemId[];
+    createdItems: ChangesDeltaItemCreateDelta[];
+};
 declare const planningMateriaalColumns: readonly ["aantaltotaal", "stays_at_location", {
     readonly categorie: readonly [{
         readonly project: readonly [{
@@ -12,7 +16,10 @@ declare const planningMateriaalColumns: readonly ["aantaltotaal", "stays_at_loca
         }];
     }];
 }];
-type Dependency = ItemResource<'Planningmateriaal', typeof planningMateriaalColumns>[];
+type Dependency = {
+    changedPlanningMateriaalResources: ItemResource<'Planningmateriaal', typeof planningMateriaalColumns>[];
+    createdItems: ChangesDeltaItemCreateDelta<'Planningmateriaal'>[];
+};
 /**
  * @description
  * If the planningmateriaal 'aantaltotaal' is changed in a transfer project, stays_at_location should copy this value.
@@ -20,6 +27,6 @@ type Dependency = ItemResource<'Planningmateriaal', typeof planningMateriaalColu
 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, plannedEquipmentResources: Dependency): void;
+    apply(context: BusinessLogicRuleApplyContext, dependency: Dependency): void;
 }
 export {};

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

@@ -5,18 +5,16 @@ 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<'Contact'>>;
+    updatedContactIds: Set<ItemId>;
 }[];
 type Dependency = {
     template: Template<'Projectnotitie'>;
     projectTuples: {
         projectId: ItemId;
-        Contact: ItemResource<'Contact', typeof contactColumns>[];
-        Projectnotitie: ItemResource<'Projectnotitie', typeof projectnotitieColumns>[];
+        Contact: ItemResource<'Contact', ['projectnotitie_naam', 'projectnotitie']>[];
+        Projectnotitie: ItemResource<'Projectnotitie', ['naam', 'omschrijving']>[];
     }[];
 };
 export declare class ProjectContactProjectNoteBusinessLogicRule extends BusinessLogicRule<ConditionResult, Dependency> {

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

@@ -4,13 +4,11 @@ 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', typeof subprojectColumns>[];
-        projectResource: ItemResource<'Project', typeof projectColumns>;
+        subprojectResources: ItemResource<'Subproject', ['id', 'locatie']>[];
+        projectResource: ItemResource<'Project', ['id', 'locatie', 'locatie_persoon']>;
     };
 };
 /**

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

@@ -4,9 +4,8 @@ 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', typeof rateColumns>[];
+type Dependency = ItemResource<'Rate', ['rate_group', 'active', 'id']>[];
 /**
  * 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,9 +4,8 @@ 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', typeof reparatieColumns>[];
+type Dependency = ItemResource<'Reparatie', ['aantal']>[];
 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,14 +5,13 @@ 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', typeof exemplaarColumns>[];
+    exemplaarResources: ItemResource<'Exemplaar', ['id', 'asset_location']>[];
 };
 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,9 +4,10 @@ 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', typeof rolColumns>[];
+type Dependency = ItemResource<'Rol', [
+    'general_eigen_medewerker_edit'
+]>[];
 /**
  * @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,9 +4,10 @@ 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', typeof rolColumns>[];
+type Dependency = ItemResource<'Rol', [
+    'projecten_toegang'
+]>[];
 /**
  * @description
  * 	If you can enter the crew planner you can also access projects

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

@@ -4,9 +4,10 @@ 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', typeof rolColumns>[];
+type Dependency = ItemResource<'Rol', [
+    'materialen_tijdlijn'
+]>[];
 /**
  * @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,9 +4,11 @@ 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', typeof rolColumns>[];
+type Dependency = ItemResource<'Rol', [
+    'uren_kosten',
+    'visibility_financials'
+]>[];
 /**
  * @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,9 +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 rolColumns: readonly ["visibility_financials", "facturen_toegang", "projecten_facturen_maken", "projecten_offertes_maken", "projecten_toegang"];
 type ConditionResult = ItemId[];
-type Dependency = ItemResource<'Rol', typeof rolColumns>[];
+type Dependency = ItemResource<'Rol', [
+    'visibility_financials',
+    'facturen_toegang',
+    'projecten_facturen_maken',
+    'projecten_offertes_maken',
+    'projecten_toegang'
+]>[];
 /**
  * @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,8 +5,9 @@ import { BLR_SKIP_RULE, BusinessLogicRule } from '../BusinessLogicRule';
 import { BusinessLogicRuleApplyContext } from '../BusinessLogicRuleApplyContext';
 import { BusinessLogicRuleConditionContext } from '../BusinessLogicRuleConditionContext';
 type ConditionResult = ItemId[];
-declare const rolColumns: readonly ["magazijn_toegang"];
-type Dependency = ItemResource<'Rol', typeof rolColumns>[];
+type Dependency = ItemResource<'Rol', [
+    'magazijn_toegang'
+]>[];
 /**
  * @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 { ChildChangesDeltaItemCreateDelta } from '../../ChildChangesDelta';
+import { ChangesDeltaItemCreateDelta } from '../../CreatedChangesDelta';
 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 = ChildChangesDeltaItemCreateDelta<'Setinhoud'>[];
-type Dependency = Record<string, ItemResource<'Materiaal', typeof materiaalColumns>>;
+type ConditionResult = ChangesDeltaItemCreateDelta<'Setinhoud'>[];
+type Dependency = Record<string, LatestItem<'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,7 +1,6 @@
 import { ItemId } from '@rentman/backend-types';
 import { BLR_SKIP_RULE, BusinessLogicRule, BusinessLogicRuleApplyContext, BusinessLogicRuleConditionContext, ItemResource, TransactionCache } from '../../../internal';
-declare const functieColumns: readonly ["subproject", "inplanning"];
-type Dependency = Map<ItemId<'Subproject'>, ItemResource<'Functie', typeof functieColumns>[]>;
+type Dependency = Map<ItemId<'Subproject'>, ItemResource<'Functie', ['subproject', 'inplanning']>[]>;
 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,13 +4,11 @@ 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', typeof subprojectColumns>;
-        Project: ItemResource<'Project', typeof projectColumns>;
+        Subproject: ItemResource<'Subproject', ['id', 'project', 'locatie', 'locatie_persoon']>;
+        Project: ItemResource<'Project', ['id', 'locatie']>;
         amountOfSubprojects: number;
     };
 };