@rentman/rm-core 0.0.0-RM4-44763

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

@@ -0,0 +1,20 @@
+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 documentTypes: readonly ["Factuur", "Offerte", "Contract", "Bon", "Inhuurbon", "Materiaalbon", "Medewerkerbon", "Aanmaning", "Reparatiebon", "Voertuigbon"];
+type DocumentTypes = (typeof documentTypes)[number];
+type ConditionResult = {
+    [key in DocumentTypes]?: ItemId[];
+};
+type Dependency = {
+    [key in DocumentTypes]?: ItemResource<DocumentTypes, ['filename', 'betreft']>[];
+};
+export declare class DocumentTemplateBusinessLogicRule extends BusinessLogicRule<ConditionResult, Dependency> {
+    condition(context: BusinessLogicRuleConditionContext): ConditionResult | typeof BLR_SKIP_RULE;
+    dependency(transaction: TransactionCache, itemIdMap: ConditionResult): Promise<Dependency>;
+    apply(context: BusinessLogicRuleApplyContext, items: Dependency): void;
+}
+export {};

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

@@ -0,0 +1,14 @@
+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';
+type ConditionResult = ItemId[];
+type Dependency = ItemResource<'Exemplaar', ['actief']>[];
+export declare class ExemplaarAanschafdatumBusinessLogicRule extends BusinessLogicRule<ConditionResult, Dependency> {
+    condition({ previousChangesDelta, }: BusinessLogicRuleConditionContext): ConditionResult | typeof BLR_SKIP_RULE;
+    dependency(transaction: TransactionCache, exemplaarIds: ConditionResult): Promise<Dependency>;
+    apply(context: BusinessLogicRuleApplyContext, exemplaarResources: Dependency): void;
+}
+export {};

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

@@ -0,0 +1,14 @@
+import { ItemId } from '@rentman/backend-types';
+import { ItemEntry } from '../../../models/ItemEntry';
+import { TransactionCache } from '../../cache/transaction/TransactionCache';
+import { BLR_SKIP_RULE, BusinessLogicRule } from '../BusinessLogicRule';
+import { BusinessLogicRuleApplyContext } from '../BusinessLogicRuleApplyContext';
+import { BusinessLogicRuleConditionContext } from '../BusinessLogicRuleConditionContext';
+type ConditionResult = ItemId[];
+type Dependency = ItemEntry<'Barcode'>[];
+export declare class ExemplaarBarcodeDeleteBusinessLogicRule extends BusinessLogicRule<ConditionResult, Dependency> {
+    condition({ previousChangesDelta, }: BusinessLogicRuleConditionContext): ConditionResult | typeof BLR_SKIP_RULE;
+    dependency(transaction: TransactionCache, exemplaarIds: ConditionResult): Promise<Dependency>;
+    apply(context: BusinessLogicRuleApplyContext, barcodeResources: Dependency): void;
+}
+export {};

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

@@ -0,0 +1,21 @@
+import { ItemId } from '@rentman/backend-types';
+import { ItemResource } from '../../../models/ItemResource';
+import { TransactionCache } from '../../cache/transaction/TransactionCache';
+import { BLR_SKIP_RULE, BusinessLogicConditionResult, BusinessLogicRule } from '../BusinessLogicRule';
+import { BusinessLogicRuleApplyContext } from '../BusinessLogicRuleApplyContext';
+import { BusinessLogicRuleConditionContext } from '../BusinessLogicRuleConditionContext';
+import { BusinessLogicRuleContextBase } from '../BusinessLogicRuleContextBase';
+type ConditionResult = BusinessLogicConditionResult<'Factuur', 'betalingsconditie'>[];
+type Dependency = {
+    Factuur: ItemResource<'Factuur', ['vervaldatum', 'datum']>[];
+    Betalingsconditie: {
+        [conditieId: string]: ItemResource<'Betalingsconditie', ['dagen']>;
+    };
+    defaultPaymentConditionId: ItemId | null;
+};
+export declare class FactuurBetalingsconditieBusinessLogicRule extends BusinessLogicRule<ConditionResult, Dependency> {
+    condition(context: BusinessLogicRuleConditionContext): ConditionResult | typeof BLR_SKIP_RULE;
+    dependency(transaction: TransactionCache, result: ConditionResult, context: BusinessLogicRuleContextBase): Promise<Dependency>;
+    apply(context: BusinessLogicRuleApplyContext, deps: Dependency): void;
+}
+export {};

package/dist/types/src/classes/BusinessLogicManager/Factuur/FactuurDatumBusinessLogicRule.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';
+import { BusinessLogicRuleContextBase } from '../BusinessLogicRuleContextBase';
+type ConditionResult = ItemId[];
+type Dependency = {
+    Factuur: ItemResource<'Factuur', ['vervaldatum', 'betalingsconditie']>[];
+    Betalingsconditie: {
+        [conditieId: string]: ItemResource<'Betalingsconditie', ['dagen']>;
+    };
+    latestTaxSchemasByDateMap: {
+        [taxschemaId: string]: ItemId<'TaxSchema'>;
+    };
+};
+export declare class FactuurDatumBusinessLogicRule extends BusinessLogicRule<ConditionResult, Dependency> {
+    condition(context: BusinessLogicRuleConditionContext): ConditionResult | typeof BLR_SKIP_RULE;
+    dependency(transaction: TransactionCache, factuurIds: ConditionResult, context: BusinessLogicRuleContextBase): Promise<Dependency>;
+    apply(context: BusinessLogicRuleApplyContext, deps: Dependency): void;
+}
+export {};

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

@@ -0,0 +1,14 @@
+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';
+type ConditionResult = ItemId[];
+type Dependency = ItemResource<'Factuur', ['nummer']>[];
+export declare class FactuurNumberseriesBusinessLogicRule extends BusinessLogicRule<ConditionResult, Dependency> {
+    condition(context: BusinessLogicRuleConditionContext): ConditionResult | typeof BLR_SKIP_RULE;
+    dependency(transaction: TransactionCache, factuurIds: ConditionResult): Promise<Dependency>;
+    apply(context: BusinessLogicRuleApplyContext, factuurResources: Dependency): void;
+}
+export {};

package/dist/types/src/classes/BusinessLogicManager/Files/FilesNameExtensionBusinessLogicRule.d.ts

@@ -0,0 +1,20 @@
+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';
+type ConditionResult = ItemId[];
+type Dependency = ItemResource<'Files', ['name', 'friendlyname']>[];
+/**
+ * @description
+ * Automatically appends the file extension again when the user removes it from the name
+ * so that, when the file is downloaded, it is still properly openable
+ */
+export declare class FilesNameExtensionBusinessLogicRule extends BusinessLogicRule<ConditionResult, Dependency> {
+    private static getExtension;
+    condition(context: BusinessLogicRuleConditionContext): ConditionResult | typeof BLR_SKIP_RULE;
+    dependency(transaction: TransactionCache, fileIds: ConditionResult): Promise<Dependency>;
+    apply(context: BusinessLogicRuleApplyContext, fileResources: Dependency): void;
+}
+export {};

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

@@ -0,0 +1,18 @@
+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';
+type ConditionResult = ItemId[];
+type Dependency = ItemResource<'Functie', ['naamintern']>[];
+/**
+ * @description
+ * If the `naamofferte` is set and the user hasn't filled in a `naamintern` we sync the fields
+ */
+export declare class FunctieNaaminternBusinessLogicRule extends BusinessLogicRule<ConditionResult, Dependency> {
+    condition(context: BusinessLogicRuleConditionContext): ConditionResult | typeof BLR_SKIP_RULE;
+    dependency(transaction: TransactionCache, functionIds: ConditionResult): Promise<Dependency>;
+    apply(context: BusinessLogicRuleApplyContext, functionResources: Dependency): void;
+}
+export {};

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

@@ -0,0 +1,5 @@
+import { RecurrentItemRecureindBusinessLogicRule } from '../RecurrentItem/RecurrentItemRecureindBusinessLogicRule';
+export declare class FunctieRecureindBusinessLogicRule extends RecurrentItemRecureindBusinessLogicRule<'Functie', 'plantot'> {
+    protected itemType: "Functie";
+    protected toField: "plantot";
+}

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

@@ -0,0 +1,14 @@
+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';
+type ConditionResult = ItemId[];
+type Dependency = ItemResource<'Functie', ['afstand']>[];
+export declare class FunctieTwowayBusinessLogicRule extends BusinessLogicRule<ConditionResult, Dependency> {
+    condition(context: BusinessLogicRuleConditionContext): ConditionResult | typeof BLR_SKIP_RULE;
+    dependency(transaction: TransactionCache, functionIds: ConditionResult): Promise<Dependency>;
+    apply(context: BusinessLogicRuleApplyContext, functionResources: Dependency): void;
+}
+export {};

package/dist/types/src/classes/BusinessLogicManager/Functiegroep/FunctiegroepSubprojectBusinessLogicRule.d.ts

@@ -0,0 +1,17 @@
+import { ItemResource } from '../../../models/ItemResource';
+import { TransactionCache } from '../../cache/transaction/TransactionCache';
+import { BLR_SKIP_RULE, BusinessLogicConditionResult, BusinessLogicRule } from '../BusinessLogicRule';
+import { BusinessLogicRuleApplyContext } from '../BusinessLogicRuleApplyContext';
+import { BusinessLogicRuleConditionContext } from '../BusinessLogicRuleConditionContext';
+type ConditionResult = BusinessLogicConditionResult<'Functiegroep', 'subproject'>[];
+type Dependency = ItemResource<'Functie', ['subproject']>[][];
+/**
+ * When the subproject field of a function group is updated, set the subproject field of all the functions within the
+ * function group to the same value.
+ */
+export declare class FunctiegroepSubprojectBusinessLogicRule extends BusinessLogicRule<ConditionResult, Dependency> {
+    condition(context: BusinessLogicRuleConditionContext): ConditionResult | typeof BLR_SKIP_RULE;
+    dependency(transaction: TransactionCache, conditionResult: ConditionResult): Promise<Dependency>;
+    apply(context: BusinessLogicRuleApplyContext, functionResourcesArray: Dependency, conditionResult: ConditionResult): void;
+}
+export {};

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

@@ -0,0 +1,4 @@
+import { AantalBusinessLogicRuleBase } from '../AantalBusinessLogicRuleBase';
+export declare class InhuurmateriaalAantalBusinessLogicRule extends AantalBusinessLogicRuleBase<'Inhuurmateriaal'> {
+    protected readonly itemType = "Inhuurmateriaal";
+}

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

@@ -0,0 +1,9 @@
+import { AantaltotaalBusinessLogicRuleBase } from '../AantaltotaalBusinessLogicRuleBase';
+export declare class InhuurmateriaalAantaltotaalBusinessLogicRule extends AantaltotaalBusinessLogicRuleBase<'Inhuurmateriaal'> {
+    protected readonly itemType = "Inhuurmateriaal";
+    protected readonly groupingProperties: {
+        readonly itemType: "Inhuurgroep";
+        readonly columnId: "inhuurgroep";
+    };
+    protected readonly requestColumns: readonly ["id", "aantal", "aantaltotaal", "parent", "materiaal", "inhuurgroep"];
+}

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

@@ -0,0 +1,17 @@
+import { ItemId } from '@rentman/backend-types';
+import { BLR_SKIP_RULE, BusinessLogicRule, BusinessLogicRuleApplyContext, BusinessLogicRuleConditionContext, ItemEntry, ItemResource, TransactionCache } from '../../../internal';
+export type ConditionResult = ItemId[];
+type Dependency = {
+    voorraadmutatieTuples: {
+        local: ItemEntry<'Voorraadmutatie'>[];
+        remote: ItemEntry<'Voorraadmutatie'>[];
+    };
+    materiaalResources: ItemResource<'Materiaal', ['is_combination']>[];
+    containerContentResources: ItemResource<'ContainerContent', ['equipment']>[];
+};
+export declare class MateriaalBulkToSerialBusinessLogicRule extends BusinessLogicRule<ConditionResult, Dependency> {
+    dependency(transaction: TransactionCache, materiaalIds: ConditionResult): Promise<Dependency>;
+    apply(context: BusinessLogicRuleApplyContext, dependencies: Dependency): void;
+    condition(context: BusinessLogicRuleConditionContext): ConditionResult | typeof BLR_SKIP_RULE;
+}
+export {};

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

@@ -0,0 +1,20 @@
+import { ItemId } from '@rentman/backend-types';
+import { ItemEntry } from '../../../models/ItemEntry';
+import { TransactionCache } from '../../cache/transaction/TransactionCache';
+import { BLR_SKIP_RULE, BusinessLogicRule } from '../BusinessLogicRule';
+import { BusinessLogicRuleApplyContext } from '../BusinessLogicRuleApplyContext';
+import { BusinessLogicRuleConditionContext } from '../BusinessLogicRuleConditionContext';
+type ConditionResult = ItemId[];
+type Dependency = ItemEntry<'Setinhoud'>[];
+/**
+ * @description
+ * Whenever the item is changed from (is_combination: true -> is_combination: false),
+ * pop-up a modal to ensure the user of the consequences he might face when doing that.
+ * If the modal is confirmed, we ensure that the content of the combination is cleared.
+ */
+export declare class MateriaalIsCombinationBusinessLogicRule extends BusinessLogicRule<ConditionResult, Dependency> {
+    condition(context: BusinessLogicRuleConditionContext): ConditionResult | typeof BLR_SKIP_RULE;
+    dependency(transaction: TransactionCache, equipmentIds: ConditionResult): Promise<Dependency>;
+    apply(context: BusinessLogicRuleApplyContext, setinhoudEntries: Dependency): void;
+}
+export {};

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

@@ -0,0 +1,19 @@
+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 materiaalColumns: readonly ["is_physical", "is_combination", "telexemplaren", "can_edit_content_during_planning"];
+type ConditionResult = ItemId<'Materiaal'>[];
+type Dependency = ItemResource<'Materiaal', typeof materiaalColumns>[];
+/**
+ * We want to force equipment to have `can_edit_content_during_planning` set to false
+ * when it's a physical combination bulk equipment
+ */
+export declare class MateriaalIsPhysicalCombinationBulkBusinessLogicRule extends BusinessLogicRule<ConditionResult, Dependency> {
+    condition({ previousChangesDelta, }: BusinessLogicRuleConditionContext): ConditionResult | typeof BLR_SKIP_RULE;
+    dependency(transaction: TransactionCache, conditionResult: ConditionResult): Promise<Dependency>;
+    apply(context: BusinessLogicRuleApplyContext, equipmentResources: Dependency): void;
+}
+export {};

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

@@ -0,0 +1,16 @@
+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 { BusinessLogicRuleConditionContext } from '../BusinessLogicRuleConditionContext';
+type ConditionResult = ItemId[];
+type Dependency = {
+    materiaalResources: ItemResource<'Materiaal', ['is_combination']>[];
+    containerContentResources: ItemResource<'ContainerContent', ['equipment']>[];
+};
+export declare class MateriaalSerialToBulkBusinessLogicRule extends BusinessLogicRule<ConditionResult, Dependency> {
+    dependency(transaction: TransactionCache, materiaalIds: ConditionResult): Promise<Dependency>;
+    apply(): void;
+    condition(context: BusinessLogicRuleConditionContext): ConditionResult | typeof BLR_SKIP_RULE;
+}
+export {};

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

@@ -0,0 +1,18 @@
+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 materiaalColumns: readonly ["is_combination", "verhuur", "can_edit_content_during_planning"];
+type ConditionResult = ItemId[];
+type Dependency = ItemResource<'Materiaal', typeof materiaalColumns>[];
+/**
+ * This BLR only triggers a confirmFn in the frontend (RmCoreService)
+ */
+export declare class MateriaalToPhysicalBusinessLogicRule extends BusinessLogicRule<ConditionResult, Dependency> {
+    condition(context: BusinessLogicRuleConditionContext): ConditionResult | typeof BLR_SKIP_RULE;
+    dependency(transaction: TransactionCache, materiaalIds: ConditionResult): Promise<Dependency>;
+    apply(context: BusinessLogicRuleApplyContext, materiaalResources: Dependency): void;
+}
+export {};

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

@@ -0,0 +1,22 @@
+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 materiaalColumns: readonly ["is_combination", "can_edit_content_during_planning"];
+type ConditionResult = ItemId[];
+type Dependency = ItemResource<'Materiaal', typeof materiaalColumns>[];
+/**
+ * @description
+ * A virtual equipment (is_phyiscal: false)
+ *      - is always a combination (otherwise it doesn't make sense)
+ *      - shows a warning letting the user know the consequences of this field
+ *          (it will delete serials & stock mutations, this happens onSave through backend)
+ */
+export declare class MateriaalToVirtualBusinessLogicRule extends BusinessLogicRule<ConditionResult, Dependency> {
+    condition(context: BusinessLogicRuleConditionContext): ConditionResult | typeof BLR_SKIP_RULE;
+    dependency(transaction: TransactionCache, materiaalIds: ConditionResult): Promise<Dependency>;
+    apply(context: BusinessLogicRuleApplyContext, materiaalResources: Dependency): void;
+}
+export {};

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

@@ -0,0 +1,19 @@
+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 materiaalColumns: readonly ["type", "is_combination", "is_physical", "can_edit_content_during_planning"];
+type ConditionResult = ItemId<'Materiaal'>[];
+type Dependency = ItemResource<'Materiaal', typeof materiaalColumns>[];
+/**
+ * Untill we fully remove `type` we still need to correctly set this value in the background,
+ * based on the new equipment types properties
+ */
+export declare class MateriaalTypePropertiesBusinessLogicRule extends BusinessLogicRule<ConditionResult, Dependency> {
+    condition({ previousChangesDelta, }: BusinessLogicRuleConditionContext): ConditionResult | typeof BLR_SKIP_RULE;
+    dependency(transaction: TransactionCache, materiaalIds: ConditionResult): Promise<Dependency>;
+    apply(context: BusinessLogicRuleApplyContext, materiaalResources: Dependency): void;
+}
+export {};

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

@@ -0,0 +1,19 @@
+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';
+type ConditionResult = ItemId[];
+type Dependency = ItemResource<'Materiaal', ['type']>[];
+/**
+ * @description
+ * A sales item can never be a case, so if it is we reset it to an item
+ * A physical sales item can never be a combination, if it is we set it to a single item
+ */
+export declare class MateriaalVerhuurBusinessLogicRule extends BusinessLogicRule<ConditionResult, Dependency> {
+    condition(context: BusinessLogicRuleConditionContext): ConditionResult | typeof BLR_SKIP_RULE;
+    dependency(transaction: TransactionCache, materiaalIds: ConditionResult): Promise<Dependency>;
+    apply(context: BusinessLogicRuleApplyContext, materiaalResources: Dependency): void;
+}
+export {};

package/dist/types/src/classes/BusinessLogicManager/Materiaal/SurfaceArticleSizeBusinessLogicRule.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';
+type ConditionResult = ItemId[];
+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>;
+    apply(context: BusinessLogicRuleApplyContext, materiaalResources: Dependency): void;
+}
+export {};

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

@@ -0,0 +1,46 @@
+import { ItemEntry } from '../../../models/ItemEntry';
+import { ItemResource } from '../../../models/ItemResource';
+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';
+type LinkedTimeItemColumn = 'project' | 'subproject' | Exclude<TimeColumnId, 'timeframe'>;
+type LinkedTimeItemColumnArray = readonly LinkedTimeItemColumn[];
+type LinkedTimeItemRequestColumnsMap = {
+    [ItemType in LinkedTimeItemType]: ApiRequestColumnArray<ItemType>;
+};
+type LinkedTimeItemRequestColumnsMapToItemResourceMap<RequestColumnsMap extends LinkedTimeItemRequestColumnsMap> = {
+    [ItemType in LinkedTimeItemType]: ItemResource<ItemType, RequestColumnsMap[ItemType] extends ApiRequestColumnArray<ItemType> ? RequestColumnsMap[ItemType] : never>[];
+};
+export type LinkedTimeItemResourceMap<RequestColumns extends ApiRequestColumnArray<LinkedTimeItemType>> = {
+    [ItemType in LinkedTimeItemType]: ItemResource<ItemType, RequestColumns>[];
+};
+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): LinkedTimeItemBusinessLogicRuleBaseUpdatedTuples<ConditionColumns>;
+    /**
+     * Like {@link extractUpdatedTuples}, but returns `undefined` when no fields have been updated.
+     */
+    protected extractUpdatedTuplesCondition(context: BusinessLogicRuleConditionContext): LinkedTimeItemBusinessLogicRuleBaseUpdatedTuples<ConditionColumns> | typeof BLR_SKIP_RULE;
+    protected fetchLinkedItemResourcesWithColumns<RequestColumnsMap extends LinkedTimeItemRequestColumnsMap>(transaction: TransactionCache, updatedTuples: LinkedTimeItemBusinessLogicRuleBaseUpdatedTuples<any>, requestColumnsMap: RequestColumnsMap): Promise<LinkedTimeItemRequestColumnsMapToItemResourceMap<RequestColumnsMap>>;
+    protected fetchLinkedItemResources<RequestColumns extends ApiRequestColumnArray<LinkedTimeItemType>>(transaction: TransactionCache, updatedTuples: LinkedTimeItemBusinessLogicRuleBaseUpdatedTuples<any>, requestColumns: RequestColumns): Promise<LinkedTimeItemResourceMap<RequestColumns>>;
+}
+export {};

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

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

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

@@ -0,0 +1,25 @@
+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';
+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"];
+}, {
+    readonly schema_gv: readonly ["van", "tot", "is_absolute_times_substitute"];
+}, {
+    readonly schema_gt: readonly ["van", "tot", "is_absolute_times_substitute"];
+}];
+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, changedMateriaalCatItemIds: ConditionResult): Promise<Dependency>;
+    apply(context: BusinessLogicRuleApplyContext, dependency: Dependency): void;
+}
+export {};

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

@@ -0,0 +1,48 @@
+import { ItemEntry } from '../../../models/ItemEntry';
+import { ChangesDeltaItemCreateDelta } from '../../CreatedChangesDelta';
+import { BLR_SKIP_RULE } from '../BusinessLogicRule';
+import { BusinessLogicRuleApplyContext } from '../BusinessLogicRuleApplyContext';
+import { BusinessLogicRuleConditionContext } from '../BusinessLogicRuleConditionContext';
+import { LinkedTimeItemBusinessLogicRuleBase } from './LinkedTimeItemBusinessLogicRuleBase';
+import { LinkedTimeItemType } from './TimeColumnUtil';
+declare const conditionColumns: readonly ["project", "subproject"];
+/**
+ * Function items are the only linked time item that have a 'timeframe' field, which, like the 'schema_**' fields,
+ * refers to a project time.
+ */
+declare const schemeValueTimeFrameColumnIds: readonly ["schema_gv", "schema_pv", "schema_gt", "schema_pt", "timeframe"];
+type SchemeValueTimeFrameColumnId = (typeof schemeValueTimeFrameColumnIds)[number];
+type CreatedUpdatedTuple<ItemTypeType extends LinkedTimeItemType> = {
+    created: {
+        item: ChangesDeltaItemCreateDelta<ItemTypeType>;
+        invalidTimes: SchemeValueTimeFrameColumnId[];
+    }[];
+    updated: {
+        item: ItemEntry<ItemTypeType>;
+        invalidTimes: SchemeValueTimeFrameColumnId[];
+    }[];
+};
+export type LinkedTimeItemSubprojectBusinessLogicRuleConditionResult = {
+    [ItemType in LinkedTimeItemType]: CreatedUpdatedTuple<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
+ * the created or updated item is in, set the associated item field to `null`.
+ */
+export declare class LinkedTimeItemSubprojectBusinessLogicRule extends LinkedTimeItemBusinessLogicRuleBase<typeof conditionColumns, LinkedTimeItemSubprojectBusinessLogicRuleConditionResult, null> {
+    protected conditionColumns: readonly ["project", "subproject"];
+    condition(context: BusinessLogicRuleConditionContext): Promise<LinkedTimeItemSubprojectBusinessLogicRuleConditionResult | typeof BLR_SKIP_RULE>;
+    apply(context: BusinessLogicRuleApplyContext, _dependency: null, conditionResult: LinkedTimeItemSubprojectBusinessLogicRuleConditionResult): void;
+    dependency(): Promise<null>;
+    private schemeValueColumnIdArrayToFieldMap;
+    private validateLinkedTimes;
+    private getInvalidTimeColumnIds;
+    private extractTimeItemIds;
+    /**
+     * The iterator includes the IDs of all times linked to the items in the updated or created items.
+     */
+    private getCreatedItemTimeIdIterator;
+    private getUpdatedItemTimeIdIterator;
+}
+export {};

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

@@ -0,0 +1,27 @@
+import { ItemResource } from '../../../models/ItemResource';
+import { TransactionCache } from '../../cache/transaction/TransactionCache';
+import { BLR_SKIP_RULE } from '../BusinessLogicRule';
+import { BusinessLogicRuleApplyContext } from '../BusinessLogicRuleApplyContext';
+import { BusinessLogicRuleConditionContext } from '../BusinessLogicRuleConditionContext';
+import { LinkedTimeItemBusinessLogicRuleBase, LinkedTimeItemBusinessLogicRuleBaseUpdatedTuples, LinkedTimeItemResourceMap } from './LinkedTimeItemBusinessLogicRuleBase';
+import { 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"];
+interface Dependency {
+    timeResources: ItemResource<'Tijd', typeof timeColumns>[];
+    linkedTimeItemResources: LinkedTimeItemResourceMap<typeof requestColumns>;
+}
+/**
+ * - When setting 'schema_gv', set 'gebruikvan' to the corresponding time, and 'schema_gv_begin' to `true`.
+ * - When setting 'schema_gt', set 'gebruiktot' to the corresponding time, and 'schema_gt_begin' to `false`.
+ * - When setting 'schema_pv', set 'planvan' to the corresponding time, and 'schema_pv_begin' to `true`.
+ * - When setting 'schema_pt', set 'plantot' to the corresponding time, and 'schema_pt_begin' to `false`.
+ */
+export declare class LinkedTimeItemTimeSchemeBusinessLogicRule extends LinkedTimeItemBusinessLogicRuleBase<typeof TimeColumnUtil.schemeValueColumnIds, LinkedTimeItemBusinessLogicRuleBaseUpdatedTuples<typeof TimeColumnUtil.schemeValueColumnIds>, Dependency> {
+    protected conditionColumns: readonly ["schema_gv", "schema_pv", "schema_gt", "schema_pt"];
+    condition(context: BusinessLogicRuleConditionContext): LinkedTimeItemBusinessLogicRuleBaseUpdatedTuples<typeof TimeColumnUtil.schemeValueColumnIds> | typeof BLR_SKIP_RULE;
+    dependency(transaction: TransactionCache, conditionResult: LinkedTimeItemBusinessLogicRuleBaseUpdatedTuples<typeof TimeColumnUtil.schemeValueColumnIds>): Promise<Dependency>;
+    apply(context: BusinessLogicRuleApplyContext, dependency: Dependency, conditionResult: LinkedTimeItemBusinessLogicRuleBaseUpdatedTuples<typeof TimeColumnUtil.schemeValueColumnIds>): void;
+    private getTimeItemIds;
+}
+export {};

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

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