@rentman/rm-core 66.10.0 → 67.0.0-beta.0

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

@@ -49,7 +49,7 @@ export declare abstract class BusinessLogicRule<ConditionResult, DependencyType,
      * @param transaction The transaction that the delta is being applied on
      * @param conditionResult The result of the {@link BusinessLogicRule.condition `condition`} call
      */
-    abstract dependency(transaction: TransactionCache, conditionResult: ConditionResult, context: BusinessLogicRuleContextBase): Promise<DependencyType>;
+    abstract dependency(transaction: TransactionCache, conditionResult: ConditionResult, context: BusinessLogicRuleContextBase): Promise<DependencyType | typeof BLR_SKIP_RULE>;
     /**
      * @description
      * The {@link BusinessLogicRule.apply `apply`} function gets the result of the

package/dist/types/src/classes/BusinessLogicManager/{MateriaalCatFunctieFunctiegroep → FunctieFunctiegroep}/LinkedTimeItemSubprojectBusinessLogicRule.d.ts

@@ -15,8 +15,8 @@ export type LinkedTimeItemSubprojectBusinessLogicRuleConditionResult = {
     [ItemType in LinkedTimeItemType]: InvalidTimesTuple<ItemType>[];
 };
 /**
- * When updating the subproject of a function / function group / equipment group, or creating a new
- * function / function group / equipment group, and one of the times of these items is not in the project / subproject
+ * When updating the subproject of a function / function group  or creating a new
+ * function / function group and one of the times of these items is not in the project / subproject
  * the created or updated item is in, set the associated item field to `null`.
  */
 export declare class LinkedTimeItemSubprojectBusinessLogicRule extends LinkedTimeItemBusinessLogicRuleBase<typeof conditionColumns, LinkedTimeItemSubprojectBusinessLogicRuleConditionResult, null> {

package/dist/types/src/classes/BusinessLogicManager/{MateriaalCatFunctieFunctiegroep → FunctieFunctiegroep}/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: ["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/Inhuurmateriaal/InhuurmateriaalFactorBusinessLogicRuleBase.d.ts

@@ -0,0 +1,40 @@
+import { TransactionCache } from '../../cache/transaction/TransactionCache';
+import { BLR_SKIP_RULE, BusinessLogicRule } from '../BusinessLogicRule';
+import { BusinessLogicRuleConditionContext } from '../BusinessLogicRuleConditionContext';
+import { ItemResource } from '../../../models/ItemResource';
+import { BusinessLogicRuleApplyContext } from '../BusinessLogicRuleApplyContext';
+import moment from 'moment/moment';
+import { FactorUpdate } from '../../../services/rm-factor.service';
+export declare const subhireEquipmentColumns: readonly ["id", "staffel", "parent", {
+    readonly materiaal: readonly ["staffelgroep", "verhuur"];
+}];
+export type InhuurmateriaalResource = ItemResource<'Inhuurmateriaal', typeof subhireEquipmentColumns>;
+/**
+ * A single Inhuurmateriaal item together with the usage duration of its governing Inhuur.
+ */
+export interface InhuurmateriaalEquipmentDurationInput {
+    item: InhuurmateriaalResource;
+    currentDuration: moment.Duration;
+    initialDuration: moment.Duration;
+    treatAsNewlyCreatedItem: boolean;
+}
+export type InhuurmateriaalFactorLogicRuleBaseDependency = FactorUpdate<InhuurmateriaalResource>[];
+/**
+ * @description
+ * Shared logic for recalculating the factor (staffel) of Inhuurmateriaal items based on the usage duration of their
+ * governing Inhuur. The duration is the difference between the Inhuur's `gebruikvan` and `gebruiktot` fields.
+ *
+ * Subclasses decide *which* items to (re)calculate and *how* the governing duration is resolved (see
+ * {@link InhuurmateriaalFactorBusinessLogicRuleBase.condition condition} and
+ * {@link InhuurmateriaalFactorBusinessLogicRuleBase.dependency dependency}), then delegate to
+ * {@link InhuurmateriaalFactorBusinessLogicRuleBase.buildDependency buildDependency}. The actual factor calculation is
+ * shared with other factor rules via {@link RmFactorService}.
+ */
+export declare abstract class InhuurmateriaalFactorBusinessLogicRuleBase<ConditionResult> extends BusinessLogicRule<ConditionResult, InhuurmateriaalFactorLogicRuleBaseDependency> {
+    private factorService;
+    abstract condition(context: BusinessLogicRuleConditionContext): ConditionResult | typeof BLR_SKIP_RULE;
+    abstract dependency(transaction: TransactionCache, conditionResult: ConditionResult): Promise<InhuurmateriaalFactorLogicRuleBaseDependency | typeof BLR_SKIP_RULE>;
+    apply(context: BusinessLogicRuleApplyContext, dependency: InhuurmateriaalFactorLogicRuleBaseDependency): void;
+    protected buildDependency(transaction: TransactionCache, equipmentDurationInputs: InhuurmateriaalEquipmentDurationInput[]): Promise<InhuurmateriaalFactorLogicRuleBaseDependency | typeof BLR_SKIP_RULE>;
+    protected calculateDuration(gebruikvan: moment.Moment | null, gebruiktot: moment.Moment | null): moment.Duration;
+}

package/dist/types/src/classes/BusinessLogicManager/Inhuurmateriaal/InhuurmateriaalFactorCreateBusinessLogicRule.d.ts

@@ -0,0 +1,17 @@
+import { ItemId } from '@rentman/backend-types';
+import { TransactionCache } from '../../cache/transaction/TransactionCache';
+import { BLR_SKIP_RULE } from '../BusinessLogicRule';
+import { BusinessLogicRuleConditionContext } from '../BusinessLogicRuleConditionContext';
+import { InhuurmateriaalFactorBusinessLogicRuleBase, InhuurmateriaalFactorLogicRuleBaseDependency } from './InhuurmateriaalFactorBusinessLogicRuleBase';
+type ConditionResult = ItemId<'Inhuurmateriaal'>[];
+/**
+ * @description
+ * When an Inhuurmateriaal is added, set its factor (staffel) based on the usage duration of the Inhuur it belongs to
+ * (traced via Inhuurmateriaal -> Inhuurgroep -> Inhuur). Since the item is new there is no custom value to preserve,
+ * so the factor is always set to the schema-derived value.
+ */
+export declare class InhuurmateriaalFactorCreateBusinessLogicRule extends InhuurmateriaalFactorBusinessLogicRuleBase<ConditionResult> {
+    condition(context: BusinessLogicRuleConditionContext): ConditionResult | typeof BLR_SKIP_RULE;
+    dependency(transaction: TransactionCache, createdItemIds: ConditionResult): Promise<InhuurmateriaalFactorLogicRuleBaseDependency | typeof BLR_SKIP_RULE>;
+}
+export {};

package/dist/types/src/classes/BusinessLogicManager/Inhuurmateriaal/InhuurmateriaalFactorUpdateBusinessLogicRule.d.ts

@@ -0,0 +1,16 @@
+import { ItemId } from '@rentman/backend-types';
+import { TransactionCache } from '../../cache/transaction/TransactionCache';
+import { BLR_SKIP_RULE } from '../BusinessLogicRule';
+import { BusinessLogicRuleConditionContext } from '../BusinessLogicRuleConditionContext';
+import { InhuurmateriaalFactorBusinessLogicRuleBase, InhuurmateriaalFactorLogicRuleBaseDependency } from './InhuurmateriaalFactorBusinessLogicRuleBase';
+type ConditionResult = ItemId<'Inhuur'>;
+/**
+ * @description
+ * When the usage duration of an Inhuur changes, recalculate the factor (staffel) of all Inhuurmateriaal items in its
+ * groups. Items whose factor was custom set keep their value (see the base class' guard).
+ */
+export declare class InhuurmateriaalFactorUpdateBusinessLogicRule extends InhuurmateriaalFactorBusinessLogicRuleBase<ConditionResult> {
+    condition(context: BusinessLogicRuleConditionContext): ConditionResult | typeof BLR_SKIP_RULE;
+    dependency(transaction: TransactionCache, inhuurId: ConditionResult): Promise<InhuurmateriaalFactorLogicRuleBaseDependency | typeof BLR_SKIP_RULE>;
+}
+export {};

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

@@ -0,0 +1,29 @@
+import { ItemId } from '@rentman/backend-types';
+import { TransactionCache } from '../../cache/transaction/TransactionCache';
+import { BLR_SKIP_RULE, BusinessLogicRule } from '../BusinessLogicRule';
+import { BusinessLogicRuleApplyContext } from '../BusinessLogicRuleApplyContext';
+import { BusinessLogicRuleConditionContext } from '../BusinessLogicRuleConditionContext';
+import { ItemResource } from '../../../models/ItemResource';
+import { Duration } from 'moment';
+type ConditionResult = ItemId<'Planningmateriaal'>[];
+type Dependency = ItemResource<'Planningmateriaal', typeof columnExtensions>[];
+declare const columnExtensions: readonly ["schema_pt", "schema_pv", {
+    readonly schema_gv: readonly ["van", "tot"];
+}, {
+    readonly schema_gt: readonly ["van", "tot"];
+}, "schema_gv_begin", "schema_gt_begin", "duur", {
+    readonly parent: readonly [{
+        readonly materiaal: readonly ["is_physical"];
+    }];
+}];
+/**
+ * @description
+ * When any of the schema planning or usage fields are updated, we want to calculate the duration (duur) based on the linked schema fields and update it.
+ */
+export declare class PlanningmateriaalCalculateDuurBusinessLogicRule extends BusinessLogicRule<ConditionResult, Dependency> {
+    condition(context: BusinessLogicRuleConditionContext): ConditionResult | typeof BLR_SKIP_RULE;
+    dependency(transaction: TransactionCache, conditionResult: ConditionResult): Promise<Dependency | typeof BLR_SKIP_RULE>;
+    apply(context: BusinessLogicRuleApplyContext, dependencies: Dependency): void;
+    static calculateDuration(planningmateriaalResource: Dependency[number], context: BusinessLogicRuleApplyContext): Duration;
+}
+export {};

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

@@ -0,0 +1,31 @@
+import { ItemId } from '@rentman/backend-types';
+import { ItemResource } from '../../../models/ItemResource';
+import { ApiRequestColumnArray, ItemTypeColumnIds } from '../../../types/ItemTypesCollection';
+import { TransactionCache } from '../../cache/transaction/TransactionCache';
+import { ChangesDelta } from '../../ChangesDelta';
+import { BLR_SKIP_RULE, BusinessLogicRule } from '../BusinessLogicRule';
+import { BusinessLogicRuleApplyContext } from '../BusinessLogicRuleApplyContext';
+import { BusinessLogicRuleConditionContext } from '../BusinessLogicRuleConditionContext';
+export declare const baseChildColumns: readonly ["id", "parent", "naam"];
+export declare const baseChangedColumns: readonly ["id", "categorie", "parent", "naam", {
+    readonly materiaal: readonly ["is_combination", "is_physical"];
+}];
+export type ExtendedChildResource<T extends ItemTypeColumnIds<'Planningmateriaal'>> = ItemResource<'Planningmateriaal', typeof baseChildColumns> & ItemResource<'Planningmateriaal', T>;
+export type ExtendedChangedResource<T extends ItemTypeColumnIds<'Planningmateriaal'>> = ItemResource<'Planningmateriaal', typeof baseChangedColumns> & ItemResource<'Planningmateriaal', T>;
+type CombinationChildrenDependency<T extends ItemTypeColumnIds<'Planningmateriaal'>> = {
+    childResources: ExtendedChildResource<T>[];
+    changedResources: ExtendedChangedResource<T>[];
+};
+export declare abstract class PlanningmateriaalCombinationChildrenBusinessLogicRuleBase<T extends ItemTypeColumnIds<'Planningmateriaal'>> extends BusinessLogicRule<ItemId<'Planningmateriaal'>[], CombinationChildrenDependency<T>> {
+    protected childColumns: ApiRequestColumnArray<'Planningmateriaal'>;
+    protected changedColumns: ApiRequestColumnArray<'Planningmateriaal'>;
+    protected abstract columnExtensions: T;
+    protected abstract getConditionResult(context: BusinessLogicRuleConditionContext): ItemId<'Planningmateriaal'>[] | typeof BLR_SKIP_RULE;
+    protected abstract applyChangesToChild(parentResource: ExtendedChangedResource<T>, childResource: ExtendedChildResource<T>, destinationChangesDelta: ChangesDelta): void;
+    protected shouldSkipChangedResource(changedResource: ExtendedChangedResource<T>): boolean;
+    condition(context: BusinessLogicRuleConditionContext): ItemId<'Planningmateriaal'>[] | typeof BLR_SKIP_RULE;
+    dependency(transaction: TransactionCache, changedPlanningmateriaalIds: ItemId<'Planningmateriaal'>[]): Promise<CombinationChildrenDependency<T>>;
+    apply(context: BusinessLogicRuleApplyContext, dependency: CombinationChildrenDependency<T>): void;
+    private updateChildrenRecursively;
+}
+export {};

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

@@ -0,0 +1,28 @@
+import { BLR_SKIP_RULE, BusinessLogicRule } from '../BusinessLogicRule';
+import { BusinessLogicRuleConditionContext } from '../BusinessLogicRuleConditionContext';
+import { ItemId } from '@rentman/backend-types';
+import { TransactionCache } from '../../cache/transaction/TransactionCache';
+import { ItemResource } from '../../../models/ItemResource';
+import { BusinessLogicRuleApplyContext } from '../BusinessLogicRuleApplyContext';
+import { RmProjectDefaultTimeResources } from '../../../services/rm-project-default-time.service';
+declare const planningmateriaalColumns: readonly ["id", "parent", {
+    readonly categorie: readonly ["subproject", "project"];
+}];
+type ConditionResult = Set<ItemId> | typeof BLR_SKIP_RULE;
+type DependencyResult = {
+    planningmateriaalItems: ItemResource<'Planningmateriaal', typeof planningmateriaalColumns>[];
+    defaultTimesPerSubprojectMap: Map<ItemId<'Subproject'>, RmProjectDefaultTimeResources>;
+};
+type Dependency = DependencyResult | typeof BLR_SKIP_RULE;
+/**
+ * @description
+ * If the planningmateriaal is created, set the schema fields to the (sub)project's planperiode and gebruiksperiode.'
+ * If these are not available, we fall back to last created schema values
+ */
+export declare class PlanningmateriaalCreatePeriodBusinessLogicRule extends BusinessLogicRule<ConditionResult, Dependency> {
+    private timeResourceFallbackService;
+    condition(context: BusinessLogicRuleConditionContext): ConditionResult;
+    dependency(transaction: TransactionCache, createdItems: Set<ItemId<'Planningmateriaal'>>): Promise<Dependency>;
+    apply(context: BusinessLogicRuleApplyContext, dependency: DependencyResult): void;
+}
+export {};

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

@@ -0,0 +1,16 @@
+import { ChangesDelta } from '../../ChangesDelta';
+import { BLR_SKIP_RULE } from '../BusinessLogicRule';
+import { BusinessLogicRuleConditionContext } from '../BusinessLogicRuleConditionContext';
+import { ExtendedChangedResource, ExtendedChildResource, PlanningmateriaalCombinationChildrenBusinessLogicRuleBase } from './PlanningmateriaalCombinationChildrenBusinessLogicRuleBase';
+import { ItemId } from '@rentman/backend-types';
+declare const columnExtensions: readonly ["schema_pv", "schema_pv_begin", "schema_pt", "schema_pt_begin", "is_delayed"];
+/**
+ * @description
+ * If planningmateriaal schema fields are edited, the same edits should be applied to the children of Planningmateriaal combinations.
+ */
+export declare class PlanningmateriaalEditTijdSchemaPlanningBusinessLogicRule extends PlanningmateriaalCombinationChildrenBusinessLogicRuleBase<typeof columnExtensions> {
+    protected readonly columnExtensions: typeof columnExtensions;
+    protected getConditionResult(context: BusinessLogicRuleConditionContext): ItemId<'Planningmateriaal'>[] | typeof BLR_SKIP_RULE;
+    protected applyChangesToChild(parentResource: ExtendedChangedResource<typeof columnExtensions>, childResource: ExtendedChildResource<typeof columnExtensions>, destinationChangesDelta: ChangesDelta): void;
+}
+export {};

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

@@ -0,0 +1,16 @@
+import { ChangesDelta } from '../../ChangesDelta';
+import { BLR_SKIP_RULE } from '../BusinessLogicRule';
+import { BusinessLogicRuleConditionContext } from '../BusinessLogicRuleConditionContext';
+import { ExtendedChangedResource, ExtendedChildResource, PlanningmateriaalCombinationChildrenBusinessLogicRuleBase } from './PlanningmateriaalCombinationChildrenBusinessLogicRuleBase';
+import { ItemId } from '@rentman/backend-types';
+declare const columnExtensions: readonly ["schema_gv", "schema_gv_begin", "schema_gt", "schema_gt_begin", "duur", "is_delayed"];
+/**
+ * @description
+ * If planningmateriaal schema fields are edited, the same edits should be applied to the children of Planningmateriaal combinations.
+ */
+export declare class PlanningmateriaalEditTijdSchemaUsageBusinessLogicRule extends PlanningmateriaalCombinationChildrenBusinessLogicRuleBase<typeof columnExtensions> {
+    protected readonly columnExtensions: typeof columnExtensions;
+    protected getConditionResult(context: BusinessLogicRuleConditionContext): ItemId<'Planningmateriaal'>[] | typeof BLR_SKIP_RULE;
+    protected applyChangesToChild(parentResource: ExtendedChangedResource<typeof columnExtensions>, childResource: ExtendedChildResource<typeof columnExtensions>, destinationChangesDelta: ChangesDelta): void;
+}
+export {};

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

@@ -0,0 +1,25 @@
+import { ItemId } from '@rentman/backend-types';
+import { TransactionCache } from '../../cache/transaction/TransactionCache';
+import { BLR_SKIP_RULE, BusinessLogicRule } from '../BusinessLogicRule';
+import { BusinessLogicRuleConditionContext } from '../BusinessLogicRuleConditionContext';
+import { ItemResource } from '../../../models/ItemResource';
+import { BusinessLogicRuleApplyContext } from '../BusinessLogicRuleApplyContext';
+import { FactorUpdate } from '../../../services/rm-factor.service';
+declare const plannedEquipmentColumns: readonly ["id", "staffel", "duur", "parent", {
+    readonly materiaal: readonly ["staffelgroep", "verhuur"];
+}];
+type ConditionResult = ItemId<'Planningmateriaal'>[];
+type PlanningmateriaalFactorLogicRuleBaseDependency = FactorUpdate<ItemResource<'Planningmateriaal', typeof plannedEquipmentColumns>>[];
+/**
+ * @description
+ * If the planningmateriaal duur has changed, we should update the factor (staffel).
+ * The update should only trigger when the initial duration matches the factor from the staffelgroup.
+ * Otherwise, it means its custom set and the factor should keep its original value.
+ */
+export declare class PlanningmateriaalFactorUpdateBusinessLogicRule extends BusinessLogicRule<ConditionResult, PlanningmateriaalFactorLogicRuleBaseDependency> {
+    private factorService;
+    condition(context: BusinessLogicRuleConditionContext): ConditionResult | typeof BLR_SKIP_RULE;
+    dependency(transaction: TransactionCache, planningmateriaalIds: ConditionResult, context: BusinessLogicRuleConditionContext): Promise<PlanningmateriaalFactorLogicRuleBaseDependency | typeof BLR_SKIP_RULE>;
+    apply(context: BusinessLogicRuleApplyContext, dependency: PlanningmateriaalFactorLogicRuleBaseDependency): void;
+}
+export {};

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

@@ -1,26 +1,17 @@
-import { ItemId } from '@rentman/backend-types';
-import { ItemResource } from '../../../models/ItemResource';
-import { TransactionCache } from '../../cache/transaction/TransactionCache';
-import { BLR_SKIP_RULE, BusinessLogicRule } from '../BusinessLogicRule';
-import { BusinessLogicRuleApplyContext } from '../BusinessLogicRuleApplyContext';
+import { ChangesDelta } from '../../ChangesDelta';
+import { BLR_SKIP_RULE } from '../BusinessLogicRule';
 import { BusinessLogicRuleConditionContext } from '../BusinessLogicRuleConditionContext';
-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"];
-}];
-type Dependency = {
-    childPlanningmateriaalResourcesInCategories: ItemResource<'Planningmateriaal', typeof childPlanningmateriaalColumns>[];
-    changedPlanningmateriaalResources: ItemResource<'Planningmateriaal', typeof changedPlanningMateriaalColumns>[];
-};
+import { ExtendedChangedResource, ExtendedChildResource, PlanningmateriaalCombinationChildrenBusinessLogicRuleBase } from './PlanningmateriaalCombinationChildrenBusinessLogicRuleBase';
+import { ItemId } from '@rentman/backend-types';
+declare const columnExtensions: readonly ["optie"];
 /**
  * @description
  * If the kit's 'optie' is changed then the children should follow
  */
-export declare class PlanningmateriaalOptieBusinessLogicRule extends BusinessLogicRule<ConditionResult, Dependency> {
-    condition(context: BusinessLogicRuleConditionContext): ConditionResult | typeof BLR_SKIP_RULE;
-    dependency(transaction: TransactionCache, changedPlanningmateriaalIds: ConditionResult): Promise<Dependency>;
-    apply(context: BusinessLogicRuleApplyContext, dependency: Dependency): void;
-    private updatePlanningmateriaalByParent;
+export declare class PlanningmateriaalOptieBusinessLogicRule extends PlanningmateriaalCombinationChildrenBusinessLogicRuleBase<typeof columnExtensions> {
+    protected readonly columnExtensions: typeof columnExtensions;
+    protected shouldSkipChangedResource(changedResource: ExtendedChangedResource<typeof columnExtensions>): boolean;
+    protected getConditionResult(context: BusinessLogicRuleConditionContext): ItemId<'Planningmateriaal'>[] | typeof BLR_SKIP_RULE;
+    protected applyChangesToChild(parentResource: ExtendedChangedResource<typeof columnExtensions>, childResource: ExtendedChildResource<typeof columnExtensions>, destinationChangesDelta: ChangesDelta): void;
 }
 export {};

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

@@ -0,0 +1,23 @@
+import { ItemId } from '@rentman/backend-types';
+import { ItemResource } from '../../../models/ItemResource';
+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 [{
+    readonly parent: readonly ["schema_gv", "schema_pv", "schema_gt", "schema_pt", "schema_gv_begin", "schema_gt_begin", "schema_pv_begin", "schema_pt_begin", "duur", "is_delayed"];
+}];
+type ConditionResult = ItemId<'Planningmateriaal'>[];
+type Dependency = ItemResource<'Planningmateriaal', typeof planningmateriaalColumns>[];
+/**
+ * @description
+ * Set schema fields to the parent's values. Schema values of equipment children should not be editable by the
+ * user and always inherit parent schema values. This runs both when an item is created with a parent and when an
+ * item's parent changes, so the inherited values stay in sync.
+ */
+export declare class PlanningmateriaalParentSchemaBusinessLogicRule extends BusinessLogicRule<ConditionResult, Dependency> {
+    condition(context: BusinessLogicRuleConditionContext): ConditionResult | typeof BLR_SKIP_RULE;
+    dependency(transaction: TransactionCache, planningmateriaalIds: ConditionResult): Promise<Dependency>;
+    apply(context: BusinessLogicRuleApplyContext, planningmateriaalResources: Dependency): void;
+}
+export {};

package/dist/types/src/classes/BusinessLogicManager/Planningmateriaal/{PlanningmateriaalParentBusinessLogicRule.d.ts → PlanningmateriaalParentSetcontentBusinessLogicRule.d.ts}

@@ -7,7 +7,12 @@ import { BusinessLogicRuleConditionContext } from '../BusinessLogicRuleCondition
 declare const planningmateriaalColumns: readonly ["parent", "setcontent"];
 type ConditionResult = ItemId<'Planningmateriaal'>[];
 type Dependency = ItemResource<'Planningmateriaal', typeof planningmateriaalColumns>[];
-export declare class PlanningmateriaalParentBusinessLogicRule extends BusinessLogicRule<ConditionResult, Dependency> {
+/**
+ * @description
+ * When an existing planningmateriaal with a parent set & setcontent>is_fixed is false (meaning you CAN drag/drop)
+ * is moved outside its current parent, we clear `setcontent` since it would no longer be correct.
+ */
+export declare class PlanningmateriaalParentSetcontentBusinessLogicRule extends BusinessLogicRule<ConditionResult, Dependency> {
     condition(context: BusinessLogicRuleConditionContext): ConditionResult | typeof BLR_SKIP_RULE;
     dependency(transaction: TransactionCache, planningmateriaalIds: ConditionResult): Promise<Dependency>;
     apply(context: BusinessLogicRuleApplyContext, planningmateriaalResources: Dependency): void;

package/dist/types/src/classes/BusinessLogicManager/Tijd/TijdCalculatePlanningmateriaalDuurBusinessLogicRule.d.ts

@@ -0,0 +1,28 @@
+import { ItemId } from '@rentman/backend-types';
+import { TransactionCache } from '../../cache/transaction/TransactionCache';
+import { BLR_SKIP_RULE, BusinessLogicRule } from '../BusinessLogicRule';
+import { BusinessLogicRuleApplyContext } from '../BusinessLogicRuleApplyContext';
+import { BusinessLogicRuleConditionContext } from '../BusinessLogicRuleConditionContext';
+import { ItemResource } from '../../../models/ItemResource';
+type ConditionResult = ItemId<'Tijd'>[];
+type Dependency = ItemResource<'Planningmateriaal', typeof planningmateriaalColumns>[];
+declare const planningmateriaalColumns: readonly ["schema_pv", "schema_pt", {
+    readonly schema_gv: readonly ["van", "tot"];
+}, {
+    readonly schema_gt: readonly ["van", "tot"];
+}, "schema_gv_begin", "schema_gt_begin", "duur", {
+    readonly parent: readonly [{
+        readonly materiaal: readonly ["is_physical"];
+    }];
+}];
+/**
+ * @description
+ * When `van` or `tot` fields of a Tijd resource are changed, we want to keep the planningmateriaal duur in sync with these updated times.
+ * We fetch all relevant planningmateriaal that use these tijd items and re-calculate the duur field
+ */
+export declare class TijdCalculatePlanningmateriaalDuurBusinessLogicRule extends BusinessLogicRule<ConditionResult, Dependency> {
+    condition(context: BusinessLogicRuleConditionContext): ConditionResult | typeof BLR_SKIP_RULE;
+    dependency(transaction: TransactionCache, tijdIds: ConditionResult): Promise<Dependency | typeof BLR_SKIP_RULE>;
+    apply(context: BusinessLogicRuleApplyContext, dependencies: Dependency): void;
+}
+export {};

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

@@ -20,6 +20,8 @@ import { FunctieTwowayBusinessLogicRule } from './Functie/FunctieTwowayBusinessL
 import { FunctiegroepSubprojectBusinessLogicRule } from './Functiegroep/FunctiegroepSubprojectBusinessLogicRule';
 import { InhuurmateriaalAantalRoundUpBusinessLogicRule } from './Inhuurmateriaal/InhuurmateriaalAantalRoundUpBusinessLogicRule';
 import { InhuurmateriaalAantaltotaalBusinessLogicRule } from './Inhuurmateriaal/InhuurmateriaalAantaltotaalBusinessLogicRule';
+import { InhuurmateriaalFactorUpdateBusinessLogicRule } from './Inhuurmateriaal/InhuurmateriaalFactorUpdateBusinessLogicRule';
+import { InhuurmateriaalFactorCreateBusinessLogicRule } from './Inhuurmateriaal/InhuurmateriaalFactorCreateBusinessLogicRule';
 import { MateriaalBulkToSerialBusinessLogicRule } from './Materiaal/MateriaalBulkToSerialBusinessLogicRule';
 import { MateriaalIsCombinationBusinessLogicRule } from './Materiaal/MateriaalIsCombinationBusinessLogicRule';
 import { MateriaalIsPhysicalCombinationBulkBusinessLogicRule } from './Materiaal/MateriaalIsPhysicalCombinationBulkBusinessLogicRule';
@@ -29,17 +31,17 @@ import { MateriaalToVirtualBusinessLogicRule } from './Materiaal/MateriaalToVirt
 import { MateriaalTypePropertiesBusinessLogicRule } from './Materiaal/MateriaalTypePropertiesBusinessLogicRule';
 import { MateriaalVerhuurBusinessLogicRule } from './Materiaal/MateriaalVerhuurBusinessLogicRule';
 import { SurfaceArticleSizeBusinessLogicRule } from './Materiaal/SurfaceArticleSizeBusinessLogicRule';
-import { LinkedTimeItemDurationBusinessLogicRule } from './MateriaalCatFunctieFunctiegroep/LinkedTimeItemDurationBusinessLogicRule';
-import { LinkedTimeItemMateriaalCatBusinessLogicRule } from './MateriaalCatFunctieFunctiegroep/LinkedTimeItemMateriaalCatBusinessLogicRule';
-import { LinkedTimeItemSubprojectBusinessLogicRule } from './MateriaalCatFunctieFunctiegroep/LinkedTimeItemSubprojectBusinessLogicRule';
-import { LinkedTimeItemTimeSchemeBusinessLogicRule } from './MateriaalCatFunctieFunctiegroep/LinkedTimeItemTimeSchemeBusinessLogicRule';
-import { LinkedTimeItemTimeSchemeStartBusinessLogicRule } from './MateriaalCatFunctieFunctiegroep/LinkedTimeItemTimeSchemeStartBusinessLogicRule';
-import { LinkedTimeItemTimeValueStartBusinessLogicRule } from './MateriaalCatFunctieFunctiegroep/LinkedTimeItemTimeValueStartBusinessLogicRule';
+import { LinkedTimeItemDurationBusinessLogicRule } from './FunctieFunctiegroep/LinkedTimeItemDurationBusinessLogicRule';
+import { LinkedTimeItemSubprojectBusinessLogicRule } from './FunctieFunctiegroep/LinkedTimeItemSubprojectBusinessLogicRule';
+import { LinkedTimeItemTimeSchemeBusinessLogicRule } from './FunctieFunctiegroep/LinkedTimeItemTimeSchemeBusinessLogicRule';
+import { LinkedTimeItemTimeSchemeStartBusinessLogicRule } from './FunctieFunctiegroep/LinkedTimeItemTimeSchemeStartBusinessLogicRule';
+import { LinkedTimeItemTimeValueStartBusinessLogicRule } from './FunctieFunctiegroep/LinkedTimeItemTimeValueStartBusinessLogicRule';
 import { OfferteContractDatumBusinessLogicRule } from './OfferteContract/OfferteContractDatumBusinessLogicRule';
 import { PlanningmateriaalAantalRoundUpBusinessLogicRule } from './Planningmateriaal/PlanningmateriaalAantalRoundUpBusinessLogicRule';
 import { PlanningmateriaalAantaltotaalBusinessLogicRule } from './Planningmateriaal/PlanningmateriaalAantaltotaalBusinessLogicRule';
 import { PlanningmateriaalOptieBusinessLogicRule } from './Planningmateriaal/PlanningmateriaalOptieBusinessLogicRule';
-import { PlanningmateriaalParentBusinessLogicRule } from './Planningmateriaal/PlanningmateriaalParentBusinessLogicRule';
+import { PlanningmateriaalParentSchemaBusinessLogicRule } from './Planningmateriaal/PlanningmateriaalParentSchemaBusinessLogicRule';
+import { PlanningmateriaalParentSetcontentBusinessLogicRule } from './Planningmateriaal/PlanningmateriaalParentSetcontentBusinessLogicRule';
 import { PlanningmateriaalStaysAtLocationBusinessLogicRule } from './Planningmateriaal/PlanningmateriaalStaysAtLocationBusinessLogicRule';
 import { PlanningPersoneelTransportBusinessLogicRule } from './PlanningPersoneelTransport/PlanningPersoneelTransportBusinessLogicRule';
 import { ProjectClientChangedBusinessLogicRule } from './Project/ProjectClientChangedBusinessLogicRule';
@@ -69,4 +71,10 @@ import { TaakDeadlineTypeBusinessLogicRule } from './Taak/TaakDeadlineTypeBusine
 import { TaakDeadlineOffsetBusinessLogicRule } from './Taak/TaakDeadlineOffsetBusinessLogicRule';
 import { TijdPropagateNameToFunctiegroepBusinessLogicRule } from './Tijd/TijdPropagateNameToFunctiegroepBusinessLogicRule';
 import { TijdSubprojectChangedBusinessLogicRule } from './Tijd/TijdSubprojectChangedBusinessLogicRule';
-export declare const registeredBusinessLogicRules: readonly [typeof DefaultContactPersonUpdateBusinessLogicRule, typeof ContactAddressBusinessLogicRule, typeof CustomFieldLinkedItemTypeBusinessLogicRule, typeof CustomFieldTypeBusinessLogicRule, typeof DocumentTemplateBusinessLogicRule, typeof ExemplaarAanschafdatumBusinessLogicRule, typeof ExemplaarBarcodeDeleteBusinessLogicRule, typeof FactuurBetalingsconditieBusinessLogicRule, typeof FactuurDatumBusinessLogicRule, typeof FactuurNumberseriesBusinessLogicRule, typeof FilesNameExtensionBusinessLogicRule, typeof FunctieNaaminternBusinessLogicRule, typeof FunctieTravelDistanceFromLocationBusinessLogicRule, typeof FunctieTravelDistanceUnlinkLocationBusinessLogicRule, typeof FunctieTravelTimeFromLocationBusinessLogicRule, typeof FunctieTwowayBusinessLogicRule, typeof FunctieRecureindBusinessLogicRule, typeof FunctiegroepSubprojectBusinessLogicRule, typeof InhuurmateriaalAantaltotaalBusinessLogicRule, typeof InhuurmateriaalAantalRoundUpBusinessLogicRule, typeof MateriaalIsCombinationBusinessLogicRule, typeof MateriaalIsPhysicalCombinationBulkBusinessLogicRule, typeof MateriaalToVirtualBusinessLogicRule, typeof MateriaalToPhysicalBusinessLogicRule, typeof MateriaalBulkToSerialBusinessLogicRule, typeof MateriaalSerialToBulkBusinessLogicRule, typeof MateriaalTypePropertiesBusinessLogicRule, typeof MateriaalVerhuurBusinessLogicRule, typeof SurfaceArticleSizeBusinessLogicRule, typeof LinkedTimeItemDurationBusinessLogicRule, typeof LinkedTimeItemTimeSchemeBusinessLogicRule, typeof LinkedTimeItemTimeSchemeStartBusinessLogicRule, typeof LinkedTimeItemTimeValueStartBusinessLogicRule, typeof LinkedTimeItemSubprojectBusinessLogicRule, typeof LinkedTimeItemMateriaalCatBusinessLogicRule, typeof OfferteContractDatumBusinessLogicRule, typeof PlanningmateriaalAantalRoundUpBusinessLogicRule, typeof PlanningmateriaalAantaltotaalBusinessLogicRule, typeof PlanningmateriaalOptieBusinessLogicRule, typeof PlanningmateriaalParentBusinessLogicRule, typeof PlanningmateriaalStaysAtLocationBusinessLogicRule, typeof PlanningPersoneelTransportBusinessLogicRule, typeof ProjectClientChangedBusinessLogicRule, typeof ProjectContactProjectNoteBusinessLogicRule, typeof ProjectOneSubLocationAlignBusinessLogicRule, typeof ProjectSubprojectDefaultTimeBusinessLogicRule, typeof PurchaseOrderOwnerBusinessLogicRule, typeof PurchaseOrderApprovalStatusBusinessLogicRule, typeof RateDeactivateExistingOnCreateBusinessLogicRule, typeof ReparatiesExemplaarAantalBusinessLogicRule, typeof ReparatieLostItemExemplaarLocationBusinessLogicRule, typeof RolEditOwnDataBusinessLogicRule, typeof RolFileAccessBusinessLogicRule, typeof RolLoginFieldsLastSeenBusinessLogicRule, typeof RolPersoneelsplannerToegangBusinessLogicRule, typeof RolProjectenBewerkenBusinessLogicRule, typeof RolProjectenToegangBusinessLogicRule, typeof RolVisibilityFinancialsBusinessLogicRule, typeof RolWarehouseTrackingLogAccessBusinessLogicRule, typeof RolPurchaseOrderAttachPlanningBusinessLogicRule, typeof SetinhoudCreateFixedBusinessLogicRule, typeof SetinhoudUpdateFixedBusinessLogicRule, typeof SubprojectOneSubLocationAlignBusinessLogicRule, typeof SubprojectOneSubNameAlignBusinessLogicRule, typeof SubprojectInPlanningBusinessLogicRule, typeof TaakDeadlineTypeBusinessLogicRule, typeof TaakDeadlineOffsetBusinessLogicRule, typeof TijdSubprojectChangedBusinessLogicRule, typeof TijdPropagateNameToFunctiegroepBusinessLogicRule, typeof AfspraakRecureindBusinessLogicRule, typeof BeschikbaarheidRecureindBusinessLogicRule];
+import { PlanningmateriaalFactorUpdateBusinessLogicRule } from './Planningmateriaal/PlanningmateriaalFactorUpdateBusinessLogicRule';
+import { PlanningmateriaalCreatePeriodBusinessLogicRule } from './Planningmateriaal/PlanningmateriaalCreatePeriodBusinessLogicRule';
+import { PlanningmateriaalEditTijdSchemaUsageBusinessLogicRule } from './Planningmateriaal/PlanningmateriaalEditTijdSchemaUsageBusinessLogicRule';
+import { PlanningmateriaalCalculateDuurBusinessLogicRule } from './Planningmateriaal/PlanningmateriaalCalculateDuurBusinessLogicRule';
+import { TijdCalculatePlanningmateriaalDuurBusinessLogicRule } from './Tijd/TijdCalculatePlanningmateriaalDuurBusinessLogicRule';
+import { PlanningmateriaalEditTijdSchemaPlanningBusinessLogicRule } from './Planningmateriaal/PlanningmateriaalEditTijdSchemaPlanningBusinessLogicRule';
+export declare const registeredBusinessLogicRules: readonly [typeof DefaultContactPersonUpdateBusinessLogicRule, typeof ContactAddressBusinessLogicRule, typeof CustomFieldLinkedItemTypeBusinessLogicRule, typeof CustomFieldTypeBusinessLogicRule, typeof DocumentTemplateBusinessLogicRule, typeof ExemplaarAanschafdatumBusinessLogicRule, typeof ExemplaarBarcodeDeleteBusinessLogicRule, typeof FactuurBetalingsconditieBusinessLogicRule, typeof FactuurDatumBusinessLogicRule, typeof FactuurNumberseriesBusinessLogicRule, typeof FilesNameExtensionBusinessLogicRule, typeof FunctieNaaminternBusinessLogicRule, typeof FunctieTravelDistanceFromLocationBusinessLogicRule, typeof FunctieTravelDistanceUnlinkLocationBusinessLogicRule, typeof FunctieTravelTimeFromLocationBusinessLogicRule, typeof FunctieTwowayBusinessLogicRule, typeof FunctieRecureindBusinessLogicRule, typeof FunctiegroepSubprojectBusinessLogicRule, typeof InhuurmateriaalAantaltotaalBusinessLogicRule, typeof InhuurmateriaalAantalRoundUpBusinessLogicRule, typeof InhuurmateriaalFactorUpdateBusinessLogicRule, typeof InhuurmateriaalFactorCreateBusinessLogicRule, typeof MateriaalIsCombinationBusinessLogicRule, typeof MateriaalIsPhysicalCombinationBulkBusinessLogicRule, typeof MateriaalToVirtualBusinessLogicRule, typeof MateriaalToPhysicalBusinessLogicRule, typeof MateriaalBulkToSerialBusinessLogicRule, typeof MateriaalSerialToBulkBusinessLogicRule, typeof MateriaalTypePropertiesBusinessLogicRule, typeof MateriaalVerhuurBusinessLogicRule, typeof SurfaceArticleSizeBusinessLogicRule, typeof LinkedTimeItemDurationBusinessLogicRule, typeof LinkedTimeItemTimeSchemeBusinessLogicRule, typeof LinkedTimeItemTimeSchemeStartBusinessLogicRule, typeof LinkedTimeItemTimeValueStartBusinessLogicRule, typeof LinkedTimeItemSubprojectBusinessLogicRule, typeof OfferteContractDatumBusinessLogicRule, typeof PlanningmateriaalAantalRoundUpBusinessLogicRule, typeof PlanningmateriaalAantaltotaalBusinessLogicRule, typeof PlanningmateriaalOptieBusinessLogicRule, typeof PlanningmateriaalParentSchemaBusinessLogicRule, typeof PlanningmateriaalParentSetcontentBusinessLogicRule, typeof PlanningmateriaalStaysAtLocationBusinessLogicRule, typeof PlanningmateriaalFactorUpdateBusinessLogicRule, typeof PlanningmateriaalCreatePeriodBusinessLogicRule, typeof PlanningmateriaalEditTijdSchemaUsageBusinessLogicRule, typeof PlanningmateriaalEditTijdSchemaPlanningBusinessLogicRule, typeof PlanningmateriaalCalculateDuurBusinessLogicRule, typeof PlanningPersoneelTransportBusinessLogicRule, typeof ProjectClientChangedBusinessLogicRule, typeof ProjectContactProjectNoteBusinessLogicRule, typeof ProjectOneSubLocationAlignBusinessLogicRule, typeof ProjectSubprojectDefaultTimeBusinessLogicRule, typeof PurchaseOrderOwnerBusinessLogicRule, typeof PurchaseOrderApprovalStatusBusinessLogicRule, typeof RateDeactivateExistingOnCreateBusinessLogicRule, typeof ReparatiesExemplaarAantalBusinessLogicRule, typeof ReparatieLostItemExemplaarLocationBusinessLogicRule, typeof RolEditOwnDataBusinessLogicRule, typeof RolFileAccessBusinessLogicRule, typeof RolLoginFieldsLastSeenBusinessLogicRule, typeof RolPersoneelsplannerToegangBusinessLogicRule, typeof RolProjectenBewerkenBusinessLogicRule, typeof RolProjectenToegangBusinessLogicRule, typeof RolVisibilityFinancialsBusinessLogicRule, typeof RolWarehouseTrackingLogAccessBusinessLogicRule, typeof RolPurchaseOrderAttachPlanningBusinessLogicRule, typeof SetinhoudCreateFixedBusinessLogicRule, typeof SetinhoudUpdateFixedBusinessLogicRule, typeof SubprojectOneSubLocationAlignBusinessLogicRule, typeof SubprojectOneSubNameAlignBusinessLogicRule, typeof SubprojectInPlanningBusinessLogicRule, typeof TaakDeadlineTypeBusinessLogicRule, typeof TaakDeadlineOffsetBusinessLogicRule, typeof TijdSubprojectChangedBusinessLogicRule, typeof TijdPropagateNameToFunctiegroepBusinessLogicRule, typeof TijdCalculatePlanningmateriaalDuurBusinessLogicRule, typeof AfspraakRecureindBusinessLogicRule, typeof BeschikbaarheidRecureindBusinessLogicRule];

package/dist/types/src/classes/cache/AbstractCache.d.ts

@@ -39,7 +39,7 @@ export declare abstract class AbstractCache {
     getCurrentItemEntryCache(): ItemCache;
     abstract getServerCache(): ServerCache;
     abstract getLocalItemEntry(itemEntryId: ItemEntry['id']): ItemEntry;
-    abstract getLocalItemEntryByItemId<const ItemTypeType extends ApiItemType>(itemType: ItemTypeType, itemId: ItemEntry<ItemTypeType>['itemId']): ItemEntry<ItemTypeType>;
+    abstract getLocalItemEntryByItemId<const ItemTypeType extends ApiItemType>(itemType: ItemTypeType, itemId: ItemEntry<ItemTypeType>['itemId']): ItemEntry<ItemTypeType> | undefined;
     abstract containsLocalItemEntryByItemId(itemType: ApiItemType, itemId: ItemEntry['itemId']): boolean;
     /**
      * @description

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

@@ -395,7 +395,7 @@ export declare class TransactionCache extends AbstractCache {
      * @description
      * Gets an ItemEntry from the cache by ItemId. Looks at the current as well as the parent transaction.
      */
-    getLocalItemEntryByItemId<const ItemTypeType extends ApiItemType>(itemType: ItemTypeType, itemId: ItemEntry<ItemTypeType>['itemId']): ItemEntry<ItemTypeType>;
+    getLocalItemEntryByItemId<const ItemTypeType extends ApiItemType>(itemType: ItemTypeType, itemId: ItemEntry<ItemTypeType>['itemId']): ItemEntry<ItemTypeType> | undefined;
     containsLocalItemEntryByItemId(itemType: ApiItemType, itemId: ItemEntry['itemId']): boolean;
     /**
      * @description

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

@@ -4,8 +4,13 @@ export * from './classes/BusinessLogicManager/Materiaal/MateriaalBulkToSerialBus
 export * from './classes/BusinessLogicManager/Materiaal/MateriaalSerialToBulkBusinessLogicRule';
 export * from './classes/BusinessLogicManager/Materiaal/MateriaalToPhysicalBusinessLogicRule';
 export * from './classes/BusinessLogicManager/Materiaal/MateriaalToVirtualBusinessLogicRule';
-export * from './classes/BusinessLogicManager/MateriaalCatFunctieFunctiegroep/LinkedTimeItemSubprojectBusinessLogicRule';
+export * from './classes/BusinessLogicManager/FunctieFunctiegroep/LinkedTimeItemSubprojectBusinessLogicRule';
 export * from './classes/BusinessLogicManager/Project/ProjectClientChangedBusinessLogicRule';
 export * from './classes/BusinessLogicManager/PurchaseOrder/PurchaseOrderOwnerBusinessLogicRule';
 export * from './classes/BusinessLogicManager/Subproject/SubprojectInPlanningBusinessLogicRule';
+export * from './classes/BusinessLogicManager/Planningmateriaal/PlanningmateriaalFactorUpdateBusinessLogicRule';
+export * from './classes/BusinessLogicManager/Inhuurmateriaal/InhuurmateriaalFactorCreateBusinessLogicRule';
+export * from './classes/BusinessLogicManager/Inhuurmateriaal/InhuurmateriaalFactorUpdateBusinessLogicRule';
 export * from './services/rm-holidays.service';
+export * from './services/rm-project-default-time.service';
+export * from './services/rm-factor.service';

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

@@ -84,7 +84,7 @@ export * from './classes/BusinessLogicManager/BusinessLogicRule';
 export * from './classes/BusinessLogicManager/businessLogicRule.decorator';
 export * from './classes/BusinessLogicManager/registeredBusinessLogicRules';
 export * from './classes/BusinessLogicManager/BusinessLogicManager';
-export * from './classes/BusinessLogicManager/MateriaalCatFunctieFunctiegroep/TimeColumnUtil';
+export * from './classes/BusinessLogicManager/FunctieFunctiegroep/TimeColumnUtil';
 export * from './factories/ApiResponseProcessorFactory';
 export * from './factories/CollectionResourceFactory';
 export * from './factories/ColumnExpansionFactory';

package/dist/types/src/models/CollectionResource.d.ts

@@ -94,7 +94,7 @@ export declare class CollectionResource<ItemTypeType extends ApiItemType, Reques
      */
     onRemove(callback: OnRemoveCallback<this>): DeregFunction;
     getIdArray(): ItemId[];
-    getItemById(itemId: ItemId): ItemResource<ItemTypeType, RequestColumns, Children>;
+    getItemById(itemId: ItemId): ItemResource<ItemTypeType, RequestColumns, Children> | undefined;
     triggerCollectionChangesListeners(changedItemResources: AddedRemovedItemResources<ItemResource<ItemTypeType, RequestColumns, Children>> & {
         changedItems?: undefined;
     }, sourceChangesDelta: null, itemIdConversionMap: ItemIdConversionMap | undefined, isCalledAfterSocketUpdate: boolean, isInitialCall: boolean, collectionChangesAccumulator: AggregatedChangesByListener | null): void;

package/dist/types/src/services/rm-factor.service.d.ts

@@ -0,0 +1,72 @@
+import moment from 'moment';
+import { ItemId } from '@rentman/backend-types';
+import { ItemResource } from '../models/ItemResource';
+import { CollectionResource } from '../models/CollectionResource';
+import { TransactionCache } from '../classes/cache/transaction/TransactionCache';
+export declare const factorColumns: readonly ["van", "tot", "staffel", "staffelgroep"];
+export type FactorGroupResource = ItemResource<'Staffelgroep', [
+    'id'
+], {
+    Staffel: CollectionResource<'Staffel', typeof factorColumns>;
+}>;
+export interface FactorUpdateInput<TItem> {
+    item: TItem;
+    staffelgroepId: ItemId<'Staffelgroep'> | null;
+    isRental: boolean;
+    currentStaffel: number;
+    parent: ItemId | null;
+    currentDuration: moment.Duration;
+    initialDuration: moment.Duration;
+    treatAsNewlyCreatedItem: boolean;
+}
+/**
+ * A single resolved factor (staffel) update produced by {@link RmFactorService.createFactorUpdateMap}.
+ *
+ * @template TItem The resource the update refers back to; passed through untouched from the matching
+ * {@link FactorUpdateInput}.
+ */
+export interface FactorUpdate<TItem> {
+    /** The item whose factor should be updated. */
+    item: TItem;
+    /** The new factor (staffel) value to set on the item. */
+    factor: number;
+    /**
+     * Whether the confirmation modal should be skipped for this change.
+     * When the factor field is changed, in the frontend-redesign repo, the user gets a modal that allows them to optionally reject these changes.
+     * This modal should not be shown if this calculation is triggered by the creation of a new item or if the item is a child of a parent item.
+     */
+    shouldSkipConfirmationModal: boolean;
+}
+export declare class RmFactorService {
+    private static instance;
+    private constructor();
+    static construct(): RmFactorService;
+    /**
+     * Determines the factor (staffel) for a duration by finding the matching staffel range (`van`..`tot` in days).
+     * Falls back to the factor of the widest range when the duration exceeds all defined ranges.
+     * Returns `1` if duration is invalid, is zero or if no staffel resources are provided.
+     * @param duration - The duration to calculate the factor for.
+     * @param factorResources - The staffel resources to use for calculating the factor.
+     * @returns The factor (staffel) for the given duration.
+     */
+    getFactor(duration: moment.Duration, factorResources: ItemResource<'Staffel', typeof factorColumns>[]): number;
+    /**
+     * This function creates a map of staffel factors to update.
+     * It requires a mapped set of inputs that have been created or mutated.
+     * For every entry in the provided input map, it checks if the factor needs to be updated and returns those that do in a newly created array.
+     *
+     * @param transaction - The transaction cache to use.
+     * @param inputs - The inputs to use.
+     * @returns A map of staffel factors to update.
+     */
+    createFactorUpdateMap<TItem>(transaction: TransactionCache, inputs: FactorUpdateInput<TItem>[]): Promise<FactorUpdate<TItem>[]>;
+    /**
+     * This function creates the same map as createFactorUpdateMap but adjusts the inputs to satisfy the requirements of the forced factor update.
+     *
+     * @param transaction - The transaction cache to use.
+     * @param inputs - The inputs to use without the `initialDuration` and `treatAsNewlyCreatedItem`
+     * @returns A map of staffel factors to update.
+     * */
+    createForcedFactorUpdateMap<TItem>(transaction: TransactionCache, inputs: Omit<FactorUpdateInput<TItem>, 'initialDuration' | 'treatAsNewlyCreatedItem'>[]): Promise<FactorUpdate<TItem>[]>;
+    private getFactorGroupResources;
+}