@rentman/rm-core 0.0.0-RM4-44763

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

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

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

@@ -0,0 +1,132 @@
+import { ApiEnumApiType, ItemId } from '@rentman/backend-types';
+import moment from 'moment';
+import { FieldMap } from '../../../types/ItemTypesCollection';
+type TimeColumnDefinitions = typeof timeColumnDefinitions;
+export type TimeColumnId = keyof TimeColumnDefinitions;
+export type TimeColumnIdExcludingTimeFrame = Exclude<TimeColumnId, 'timeframe'>;
+type TimeColumnDefinitionToInstance<TimeColumnDefinitionType extends TimeColumnDefinitions[TimeColumnId]> = {
+    [ColumnId in keyof TimeColumnDefinitionType]: ColumnId extends NonReferenceProperty ? TimeColumnDefinitionType[ColumnId] : TimeColumnDefinitionType[ColumnId] extends TimeColumnId ? TimeColumnInstance<TimeColumnDefinitionType[ColumnId]> : never;
+};
+export type TimeColumnInstance<ColumnId extends TimeColumnId> = {
+    id: ColumnId;
+} & TimeColumnDefinitionToInstance<TimeColumnDefinitions[ColumnId]>;
+type TimeItemFields = {
+    id: ItemId | null;
+    van: moment.Moment;
+    tot: moment.Moment;
+};
+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"];
+type NonReferenceProperty = (typeof nonReferenceProperties)[number];
+declare const timeColumnDefinitions: {
+    readonly schema_gv: {
+        readonly type: ApiEnumApiType.TYPE_ITEM;
+        readonly start: "schema_gv_begin";
+        readonly value: "gebruikvan";
+        readonly opposite: "schema_gt";
+        readonly plan: "schema_pv";
+        readonly isStart: true;
+    };
+    readonly schema_gt: {
+        readonly type: ApiEnumApiType.TYPE_ITEM;
+        readonly start: "schema_gt_begin";
+        readonly value: "gebruiktot";
+        readonly opposite: "schema_gv";
+        readonly plan: "schema_pt";
+        readonly isStart: false;
+    };
+    readonly schema_pv: {
+        readonly type: ApiEnumApiType.TYPE_ITEM;
+        readonly start: "schema_pv_begin";
+        readonly value: "planvan";
+        readonly opposite: "schema_pt";
+        readonly usage: "schema_gv";
+        readonly isStart: true;
+    };
+    readonly schema_pt: {
+        readonly type: ApiEnumApiType.TYPE_ITEM;
+        readonly start: "schema_pt_begin";
+        readonly value: "plantot";
+        readonly opposite: "schema_pv";
+        readonly usage: "schema_gt";
+        readonly isStart: false;
+    };
+    readonly gebruikvan: {
+        readonly type: ApiEnumApiType.TYPE_DATETIME;
+        readonly scheme: "schema_gv";
+        readonly opposite: "gebruiktot";
+        readonly plan: "planvan";
+        readonly isStart: true;
+    };
+    readonly gebruiktot: {
+        readonly type: ApiEnumApiType.TYPE_DATETIME;
+        readonly scheme: "schema_gt";
+        readonly opposite: "gebruikvan";
+        readonly plan: "plantot";
+        readonly isStart: false;
+    };
+    readonly planvan: {
+        readonly type: ApiEnumApiType.TYPE_DATETIME;
+        readonly scheme: "schema_pv";
+        readonly opposite: "plantot";
+        readonly usage: "gebruikvan";
+        readonly isStart: true;
+    };
+    readonly plantot: {
+        readonly type: ApiEnumApiType.TYPE_DATETIME;
+        readonly scheme: "schema_pt";
+        readonly opposite: "planvan";
+        readonly usage: "gebruiktot";
+        readonly isStart: false;
+    };
+    readonly schema_pv_begin: {
+        readonly type: ApiEnumApiType.TYPE_BOOL;
+        readonly usage: "schema_gv_begin";
+        readonly defaultValue: true;
+    };
+    readonly schema_pt_begin: {
+        readonly type: ApiEnumApiType.TYPE_BOOL;
+        readonly usage: "schema_gt_begin";
+        readonly defaultValue: false;
+    };
+    readonly schema_gv_begin: {
+        readonly type: ApiEnumApiType.TYPE_BOOL;
+        readonly plan: "schema_pv_begin";
+        readonly defaultValue: true;
+    };
+    readonly schema_gt_begin: {
+        readonly type: ApiEnumApiType.TYPE_BOOL;
+        readonly plan: "schema_pt_begin";
+        readonly defaultValue: false;
+    };
+    readonly duur: {
+        readonly type: ApiEnumApiType.TYPE_DURATION;
+    };
+    readonly timeframe: {
+        readonly type: ApiEnumApiType.TYPE_ITEM;
+    };
+};
+export declare abstract class TimeColumnUtil {
+    private static columnInstances;
+    static schemeValueStartColumnIds: readonly ["schema_gv", "schema_pv"];
+    static schemeValueEndColumnIds: readonly ["schema_gt", "schema_pt"];
+    static schemeValueColumnIds: readonly ["schema_gv", "schema_pv", "schema_gt", "schema_pt"];
+    static schemeStartColumnIds: readonly ["schema_gv_begin", "schema_gt_begin", "schema_pv_begin", "schema_pt_begin"];
+    static valueStartColumnIds: readonly ["gebruikvan", "planvan"];
+    static valueEndColumnIds: readonly ["gebruiktot", "plantot"];
+    static valueColumnIds: readonly ["gebruikvan", "planvan", "gebruiktot", "plantot"];
+    static usageColumnIds: readonly ["gebruikvan", "gebruiktot", "schema_gv", "schema_gt", "schema_gv_begin", "schema_gt_begin"];
+    static planColumnIds: readonly ["planvan", "plantot", "schema_pv", "schema_pt", "schema_pv_begin", "schema_pt_begin"];
+    static isTimeColumn(columnId: string): columnId is TimeColumnId;
+    static getColumnInstance<ColumnId extends TimeColumnId>(columnId: ColumnId): TimeColumnInstance<ColumnId>;
+    static getColumnIdIterator(itemType: 'Functie'): Generator<TimeColumnId>;
+    static getColumnIdIterator(itemType: any): Generator<TimeColumnIdExcludingTimeFrame>;
+    static getColumnIds(itemType: 'Functie'): TimeColumnId[];
+    static getColumnIds(itemType: any): TimeColumnIdExcludingTimeFrame[];
+    static getDefaultValues<ItemTypeType extends LinkedTimeItemType>(itemType: ItemTypeType, usageFields?: TimeItemFields, planFields?: TimeItemFields): LinkedItemTypeFieldMap<ItemTypeType>;
+    static cloneValues<SourceItemType extends LinkedTimeItemType, DestinationItemType extends LinkedTimeItemType>(itemType: SourceItemType, fields: LinkedItemTypeFieldMap<SourceItemType>, destination?: Partial<LinkedItemTypeFieldMap<DestinationItemType>>): LinkedItemTypeFieldMap<DestinationItemType>;
+    static compareValues<ItemTypeType extends LinkedTimeItemType>(itemType: ItemTypeType, fieldsA: LinkedItemTypeFieldMap<ItemTypeType>, fieldsB: LinkedItemTypeFieldMap<ItemTypeType>): boolean;
+}
+export {};

package/dist/types/src/classes/BusinessLogicManager/OfferteContract/OfferteContractDatumBusinessLogicRule.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, BusinessLogicRule } from '../BusinessLogicRule';
+import { BusinessLogicRuleApplyContext } from '../BusinessLogicRuleApplyContext';
+import { BusinessLogicRuleConditionContext } from '../BusinessLogicRuleConditionContext';
+type ConditionResult = {
+    Offerte: ItemId[];
+    Contract: ItemId[];
+};
+type Dependency = {
+    Offerte: ItemResource<'Offerte', ['vervaldatum']>[];
+    Contract: ItemResource<'Contract', ['vervaldatum']>[];
+    State: ItemResource<'State', ['geldigheidofferte']>;
+};
+export declare class OfferteContractDatumBusinessLogicRule 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/PlanningPersoneelTransport/PlanningPersoneelTransportBusinessLogicRule.d.ts

@@ -0,0 +1,24 @@
+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 = {
+    Planningpersoneel: ItemId[];
+    Planningtransport: ItemId[];
+};
+type Dependency = {
+    Planningpersoneel: ItemResource<'Planningpersoneel', ['vervoer', 'functie', 'planvan', 'plantot']>[];
+    Planningtransport: ItemResource<'Planningtransport', ['vervoer', 'functie', 'planvan', 'plantot']>[];
+    Functie: {
+        [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({ transaction, mergedChangesDelta, destinationChangesDelta, }: BusinessLogicRuleApplyContext, items: Dependency): void;
+    private updatePlanningColumns;
+}
+export {};

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

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

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

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

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

@@ -0,0 +1,26 @@
+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[];
+declare const childPlanningmateriaalColumns: readonly ["id", "optie", "parent"];
+declare const changedPlanningMateriaalColumns: readonly ["id", "optie", "categorie", "parent", {
+    readonly materiaal: readonly ["type"];
+}];
+type Dependency = {
+    childPlanningmateriaalResourcesInCategories: ItemResource<'Planningmateriaal', typeof childPlanningmateriaalColumns>[];
+    changedPlanningmateriaalResources: ItemResource<'Planningmateriaal', typeof changedPlanningMateriaalColumns>[];
+};
+/**
+ * @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 {};

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

@@ -0,0 +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 { BusinessLogicRuleConditionContext } from '../BusinessLogicRuleConditionContext';
+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> {
+    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/PlanningmateriaalStaysAtLocationBusinessLogicRule.d.ts

@@ -0,0 +1,32 @@
+import { ItemId } from '@rentman/backend-types';
+import { ItemResource } from '../../../models/ItemResource';
+import { TransactionCache } from '../../cache/transaction/TransactionCache';
+import { ChangesDeltaItemCreateDelta } from '../../CreatedChangesDelta';
+import { BLR_SKIP_RULE, BusinessLogicRule } from '../BusinessLogicRule';
+import { BusinessLogicRuleApplyContext } from '../BusinessLogicRuleApplyContext';
+import { BusinessLogicRuleConditionContext } from '../BusinessLogicRuleConditionContext';
+type ConditionResult = {
+    changedItems: ItemId[];
+    createdItems: ChangesDeltaItemCreateDelta[];
+};
+declare const planningMateriaalColumns: readonly ["aantaltotaal", "stays_at_location", {
+    readonly categorie: readonly [{
+        readonly project: readonly [{
+            readonly projecttype: readonly ["type"];
+        }];
+    }];
+}];
+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.
+ */
+export declare class PlanningmateriaalStaysAtLocationBusinessLogicRule extends BusinessLogicRule<ConditionResult, Dependency> {
+    condition(context: BusinessLogicRuleConditionContext): ConditionResult | typeof BLR_SKIP_RULE;
+    dependency(transaction: TransactionCache, conditionResult: ConditionResult): Promise<Dependency>;
+    apply(context: BusinessLogicRuleApplyContext, dependency: Dependency): void;
+}
+export {};

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

@@ -0,0 +1,31 @@
+import { ItemId } from '@rentman/backend-types';
+import { BLR_SKIP_RULE, BusinessLogicRule, BusinessLogicRuleApplyContext, BusinessLogicRuleConditionContext, CollectionResource, ItemResource, TransactionCache } from '../../../internal';
+declare const projectColumns: readonly ["factuurmoment", "taxschema"];
+declare const subprojectColumns: readonly ["korting_personeel", "korting_transport", "korting_verkoop", "korting_verhuur", "korting_totaal", "verzekering"];
+declare const clientColumns: readonly ["factuurmoment", "taxschema", "personeelkorting", "transportkorting", "verkoopkorting", "verhuurkorting", "totaalkorting", "verzekering", "verzekering_aangepast"];
+type ConditionResult = {
+    projectId: ItemId;
+    clientId: ItemId;
+}[];
+type Dependency = {
+    [projectId: number]: {
+        projectResource: ItemResource<'Project', typeof projectColumns>;
+        subprojectCollection: CollectionResource<'Subproject', typeof subprojectColumns>;
+        clientResource: ItemResource<'Contact', typeof clientColumns>;
+    };
+};
+/**
+ * @description
+ * Whenever the location of a Client changes in a Project
+ * and client financial values are different from project ones,
+ * trigger the copy financial values modal to provide user
+ * an option to copy the financial values from client.
+ */
+export declare class ProjectClientChangedBusinessLogicRule extends BusinessLogicRule<ConditionResult, Dependency> {
+    condition({ previousChangesDelta, transaction, }: BusinessLogicRuleConditionContext): Promise<ConditionResult | typeof BLR_SKIP_RULE>;
+    dependency(transaction: TransactionCache, obj: ConditionResult): Promise<Dependency>;
+    apply({ destinationChangesDelta, }: BusinessLogicRuleApplyContext, obj: Dependency): void;
+    private valuesEqual;
+    private setValues;
+}
+export {};

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

@@ -0,0 +1,25 @@
+import { ItemId } from '@rentman/backend-types';
+import { ItemResource } from '../../../models/ItemResource';
+import { Template } from '../../../models/Template';
+import { TransactionCache } from '../../cache/transaction/TransactionCache';
+import { BLR_SKIP_RULE, BusinessLogicRule } from '../BusinessLogicRule';
+import { BusinessLogicRuleApplyContext } from '../BusinessLogicRuleApplyContext';
+import { BusinessLogicRuleConditionContext } from '../BusinessLogicRuleConditionContext';
+type ConditionResult = {
+    projectId: ItemId;
+    updatedContactIds: Set<ItemId>;
+}[];
+type Dependency = {
+    template: Template<'Projectnotitie'>;
+    projectTuples: {
+        projectId: ItemId;
+        Contact: ItemResource<'Contact', ['projectnotitie_naam', 'projectnotitie']>[];
+        Projectnotitie: ItemResource<'Projectnotitie', ['naam', 'omschrijving']>[];
+    }[];
+};
+export declare class ProjectContactProjectNoteBusinessLogicRule extends BusinessLogicRule<ConditionResult, Dependency> {
+    condition(context: BusinessLogicRuleConditionContext): ConditionResult | typeof BLR_SKIP_RULE;
+    dependency(transaction: TransactionCache, conditionResult: ConditionResult): Promise<Dependency>;
+    apply(context: BusinessLogicRuleApplyContext, dependency: Dependency): void;
+}
+export {};

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

@@ -0,0 +1,26 @@
+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 = {
+    [projectId: number]: {
+        subprojectResources: ItemResource<'Subproject', ['id', 'locatie']>[];
+        projectResource: ItemResource<'Project', ['id', 'locatie', 'locatie_persoon']>;
+    };
+};
+/**
+ * @description
+ * Whenever the location of a Project changes in a one-sub (Project with no subprojects)
+ * we ensure the `locatie` & 'locatie_persoon` field gets applied on the Subproject too
+ *
+ *  * Has similar opposite Business Rule for Subprojects {@link SubprojectOneSubLocationAlignBusinessLogicRule}
+ */
+export declare class ProjectOneSubLocationAlignBusinessLogicRule extends BusinessLogicRule<ConditionResult, Dependency> {
+    condition(context: BusinessLogicRuleConditionContext): ConditionResult | typeof BLR_SKIP_RULE;
+    dependency(transaction: TransactionCache, obj: ConditionResult): Promise<Dependency>;
+    apply(context: BusinessLogicRuleApplyContext, obj: Dependency): void;
+}
+export {};

package/dist/types/src/classes/BusinessLogicManager/ProjectSubproject/ProjectSubprojectDefaultTimeBusinessLogicRule.d.ts

@@ -0,0 +1,26 @@
+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 = {
+    Project: ItemId[];
+    Subproject: ItemId[];
+};
+type Dependency = {
+    project: ItemResource<'Project', typeof projectColumns>[];
+    subproject: ItemResource<'Subproject', typeof projectColumns>[];
+};
+declare const projectColumns: readonly ["gebruiksperiode", "planperiode", "transport_pickup", "transport_return"];
+/**
+ * @description
+ * Whenever you set a new default time on a project or subproject we make sure the same time isn't used
+ * multiple times (except for gebruik/plan)
+ */
+export declare class ProjectSubprojectDefaultTimeBusinessLogicRule extends BusinessLogicRule<ConditionResult, Dependency> {
+    condition({ previousChangesDelta, }: BusinessLogicRuleConditionContext): ConditionResult | typeof BLR_SKIP_RULE;
+    dependency(transaction: TransactionCache, itemIdMap: ConditionResult): Promise<Dependency>;
+    apply(context: BusinessLogicRuleApplyContext, dep: Dependency): void;
+}
+export {};

package/dist/types/src/classes/BusinessLogicManager/PurchaseOrder/PurchaseOrderApprovalStatusBusinessLogicRule.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 purchaseOrderColumns: readonly ["approval_status", "previous_status"];
+type ConditionResult = ItemId<'PurchaseOrder'>[];
+type Dependency = ItemResource<'PurchaseOrder', typeof purchaseOrderColumns>[];
+/**
+ * @description
+ * When the `approval_status` updates we want to update `previous_status` accordingly
+ */
+export declare class PurchaseOrderApprovalStatusBusinessLogicRule extends BusinessLogicRule<ConditionResult, Dependency> {
+    condition(context: BusinessLogicRuleConditionContext): ConditionResult | typeof BLR_SKIP_RULE;
+    dependency(transaction: TransactionCache, purchaseOrderIds: ConditionResult): Promise<Dependency>;
+    apply(context: BusinessLogicRuleApplyContext, purchaseOrderResources: Dependency): void;
+}
+export {};

package/dist/types/src/classes/BusinessLogicManager/PurchaseOrder/PurchaseOrderOwnerBusinessLogicRule.d.ts

@@ -0,0 +1,16 @@
+import { ItemId } from '@rentman/backend-types';
+import { BLR_SKIP_RULE, BusinessLogicRule } from '../BusinessLogicRule';
+import { BusinessLogicRuleConditionContext } from '../BusinessLogicRuleConditionContext';
+type ConditionResult = ItemId[];
+type Dependency = void;
+/**
+ * @description
+ * Whenever the item has a changed owner
+ * pop-up a modal to ensure the user of the consequences they might face when doing that.
+ */
+export declare class PurchaseOrderOwnerBusinessLogicRule extends BusinessLogicRule<ConditionResult, Dependency> {
+    condition(context: BusinessLogicRuleConditionContext): ConditionResult | typeof BLR_SKIP_RULE;
+    dependency(): Promise<Dependency>;
+    apply(): void;
+}
+export {};

package/dist/types/src/classes/BusinessLogicManager/Rate/RateUpdatedBusinessLogicRule.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 = Set<ItemId>;
+type Dependency = ItemResource<'Rate', ['rate_group', 'active', 'id']>[];
+export declare class RateUpdatedBusinessLogicRule extends BusinessLogicRule<ConditionResult, Dependency> {
+    condition(context: BusinessLogicRuleConditionContext): ConditionResult | typeof BLR_SKIP_RULE;
+    dependency(transaction: TransactionCache, updatedGroups: ConditionResult): Promise<Dependency>;
+    apply(context: BusinessLogicRuleApplyContext, dependency: Dependency): void;
+}
+export {};

package/dist/types/src/classes/BusinessLogicManager/RecurrentItem/RecurrentItemRecureindBusinessLogicRule.d.ts

@@ -0,0 +1,28 @@
+import { ItemId } from '@rentman/backend-types';
+import { ItemResource } from '../../../models/ItemResource';
+import { FieldMap } from '../../../types/ItemTypesCollection';
+import { TransactionCache } from '../../cache/transaction/TransactionCache';
+import { BLR_SKIP_RULE, BusinessLogicRule } from '../BusinessLogicRule';
+import { BusinessLogicRuleApplyContext } from '../BusinessLogicRuleApplyContext';
+import { BusinessLogicRuleConditionContext } from '../BusinessLogicRuleConditionContext';
+type RecurrentItemType = 'Afspraak' | 'Functie' | 'Beschikbaarheid';
+declare const dependencyColumns: readonly ["recureind", "recurperiode", "recurhoe"];
+type ConditionResult = ItemId[];
+type Dependency<ItemTypeType extends RecurrentItemType, ToField extends keyof FieldMap<ItemTypeType>> = ItemResource<ItemTypeType, [
+    ...typeof dependencyColumns,
+    ToField
+]>[];
+/**
+ * @description
+ * Based on the recurhoe field, this business rule will choose a date for recureind that will make sure
+ * at least two recurrences are created after the current tot/plantot date of the item that is being edited.
+ */
+export declare class RecurrentItemRecureindBusinessLogicRule<ItemTypeType extends RecurrentItemType, ToField extends keyof FieldMap<ItemTypeType>> extends BusinessLogicRule<ConditionResult, Dependency<ItemTypeType, ToField>> {
+    protected itemType: ItemTypeType;
+    protected toField: keyof FieldMap<ItemTypeType>;
+    condition(context: BusinessLogicRuleConditionContext): ConditionResult | typeof BLR_SKIP_RULE;
+    dependency(transaction: TransactionCache, recurrentItemIds: ConditionResult): Promise<Dependency<ItemTypeType, ToField>>;
+    apply(context: BusinessLogicRuleApplyContext, recurrentItemResources: Dependency<ItemTypeType, ToField>): void;
+    private convertRecurhoeToMomentDuration;
+}
+export {};

package/dist/types/src/classes/BusinessLogicManager/Reparatie/ReparatieExemplaarAantalBusinessLogicRule.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<'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>;
+    apply(context: BusinessLogicRuleApplyContext, reparatieResources: Dependency): void;
+}
+export {};

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

@@ -0,0 +1,21 @@
+import { ItemId } from '@rentman/backend-types';
+import { ItemEntry } from '../../../models/ItemEntry';
+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 = {
+    entry: ItemEntry<'Reparatie' | 'MateriaalLost'>;
+    exemplaar: ItemId;
+}[];
+type Dependency = {
+    entries: ItemEntry<'Reparatie' | 'MateriaalLost'>[];
+    exemplaarResources: ItemResource<'Exemplaar', ['id', 'asset_location']>[];
+};
+export declare class ReparatieLostItemExemplaarLocationBusinessLogicRule extends BusinessLogicRule<ConditionResult, Dependency> {
+    condition({ previousChangesDelta, }: BusinessLogicRuleConditionContext): ConditionResult | typeof BLR_SKIP_RULE;
+    dependency(transaction: TransactionCache, conditionResult: ConditionResult): Promise<Dependency>;
+    apply(context: BusinessLogicRuleApplyContext, dependency: Dependency): void;
+}
+export {};

package/dist/types/src/classes/BusinessLogicManager/Rol/RolEditOwnDataBusinessLogicRule.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<'Rol', [
+    'general_eigen_medewerker_edit'
+]>[];
+/**
+ * @description
+ * If you can access update crew data, you can also always update your own data
+ */
+export declare class RolEditOwnDataBusinessLogicRule extends BusinessLogicRule<ConditionResult, Dependency> {
+    condition({ previousChangesDelta, }: BusinessLogicRuleConditionContext): ConditionResult | typeof BLR_SKIP_RULE;
+    dependency(transaction: TransactionCache, rolIds: ConditionResult): Promise<Dependency>;
+    apply(context: BusinessLogicRuleApplyContext, rolResources: Dependency): void;
+}
+export {};

package/dist/types/src/classes/BusinessLogicManager/Rol/RolFileAccessBusinessLogicRule.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[];
+declare const rolColumns: readonly ["facturen_eigen", "general_bestanden_downloaden", "facturen_toegang", "projecten_offertes_maken", "projecten_facturen_maken"];
+type Dependency = ItemResource<'Rol', typeof rolColumns>[];
+/**
+ * @description
+ * If you have project access or can make invoices you should have permissions to download files, see invoices and edit invoices
+ */
+export declare class RolFileAccessBusinessLogicRule extends BusinessLogicRule<ConditionResult, Dependency> {
+    condition({ previousChangesDelta, }: BusinessLogicRuleConditionContext): ConditionResult | typeof BLR_SKIP_RULE;
+    dependency(transaction: TransactionCache, rolIds: ConditionResult): Promise<Dependency>;
+    apply(context: BusinessLogicRuleApplyContext, rolResources: Dependency): void;
+}
+export {};

package/dist/types/src/classes/BusinessLogicManager/Rol/RolPersoneelsplannerToegangBusinessLogicRule.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<'Rol', [
+    'projecten_toegang'
+]>[];
+/**
+ * @description
+ * 	If you can enter the crew planner you can also access projects
+ */
+export declare class RolPersoneelsplannerToegangBusinessLogicRule extends BusinessLogicRule<ConditionResult, Dependency> {
+    condition(context: BusinessLogicRuleConditionContext): ConditionResult | typeof BLR_SKIP_RULE;
+    dependency(transaction: TransactionCache, rolIds: ConditionResult): Promise<Dependency>;
+    apply(context: BusinessLogicRuleApplyContext, rolResources: Dependency): void;
+}
+export {};

package/dist/types/src/classes/BusinessLogicManager/Rol/RolProjectenBewerkenBusinessLogicRule.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<'Rol', [
+    'materialen_tijdlijn'
+]>[];
+/**
+ * @description
+ * If you can edit projects you should be able to see the equipment availability
+ */
+export declare class RolProjectenBewerkenBusinessLogicRule extends BusinessLogicRule<ConditionResult, Dependency> {
+    condition({ previousChangesDelta, }: BusinessLogicRuleConditionContext): ConditionResult | typeof BLR_SKIP_RULE;
+    dependency(transaction: TransactionCache, rolIds: ConditionResult): Promise<Dependency>;
+    apply(context: BusinessLogicRuleApplyContext, rolResources: Dependency): void;
+}
+export {};