@rentman/rm-core 9.3.1 → 10.0.0-alpha.1

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

@@ -0,0 +1,95 @@
+import { ApiModuleFunctionLocalsGetLocals } from '@rentman/backend-types';
+import { ChangesDeltaFactory } from '../../factories/ChangesDeltaFactory';
+import { ErrorHandlerInterface } from '../../interfaces/ErrorHandlerInterface';
+import { PromiseLibraryInterface } from '../../interfaces/PromiseLibraryInterface';
+import { ApiFormatter } from '../ApiFormatter';
+import { TransactionCache } from '../cache/transaction/TransactionCache';
+import { ChangesDelta } from '../ChangesDelta';
+import { CustomFieldTypeBusinessLogicRule } from './Customfield/CustomFieldTypeBusinessLogicRule';
+import { DocumentTemplateBusinessLogicRule } from './Documents/DocumentTemplateBusinessLogicRule';
+import { ExemplaarAanschafdatumBusinessLogicRule } from './Exemplaar/ExemplaarAanschafdatumBusinessLogicRule';
+import { FactuurBetalingsconditieBusinessLogicRule } from './Factuur/FactuurBetalingsconditieBusinessLogicRule';
+import { FactuurDatumBusinessLogicRule } from './Factuur/FactuurDatumBusinessLogicRule';
+import { FactuurNumberseriesBusinessLogicRule } from './Factuur/FactuurNumberseriesBusinessLogicRule';
+import { FunctieNaaminternBusinessLogicRule } from './Functie/FunctieNaaminternBusinessLogicRule';
+import { FunctieTwowayBusinessLogicRule } from './Functie/FunctieTwowayBusinessLogicRule';
+import { MateriaalTypeBusinessLogicRule } from './Materiaal/MateriaalTypeBusinessLogicRule';
+import { MateriaalVerhuurBusinessLogicRule } from './Materiaal/MateriaalVerhuurBusinessLogicRule';
+import { SurfaceArticleSizeBusinessLogicRule } from './Materiaal/SurfaceArticleSizeBusinessLogicRule';
+import { OfferteContractDatumBusinessLogicRule } from './OfferteContract/OfferteContractDatumBusinessLogicRule';
+import { PlanningPersoneelTransportBusinessLogicRule } from './PlanningPersoneelTransport/PlanningPersoneelTransportBusinessLogicRule';
+import { ProjectClientNoteBusinessLogicRule } from './Project/ProjectClientNoteBusinessLogicRule';
+import { ReparatieAanschafdatumBusinessLogicRule } from './Reparatie/ReparatieExemplaarBusinessLogicRule';
+import { RolDocumentAccessBusinessLogicRule } from './Rol/RolDocumentAccessBusinessLogicRule';
+import { RolEditOwnDataBusinessLogicRule } from './Rol/RolEditOwnDataBusinessLogicRule';
+import { RolFileAccessBusinessLogicRule } from './Rol/RolFileAccessBusinessLogicRule';
+import { RolPersoneelsplannerToegangBusinessLogicRule } from './Rol/RolPersoneelsplannerToegangBusinessLogicRule';
+import { RolProjectenBewerkenBusinessLogicRule } from './Rol/RolProjectenBewerkenBusinessLogicRule';
+import { RolProjectenToegangBusinessLogicRule } from './Rol/RolProjectenToegangBusinessLogicRule';
+/**
+ * @description
+ * The BusinessLogicManager is responsible for calling all business rules with a ChangesDelta and storing their results for the {@link BusinessLogicRule business logic phases}.
+ */
+export declare class BusinessLogicManager {
+    private apiFormatter;
+    private changesDeltaFactory;
+    private errorHandler;
+    private promiseLibrary;
+    private locals;
+    /**
+     * @description
+     * The business rules are stored in a map so that the core-consumer can overwrite the {@link BusinessLogicRule.confirmFn confirmFn} to show a confirmation
+     *
+     * @remark
+     * This property is intentionally not typed so that the keys can be inferred
+     *
+     * @private
+     */
+    allBusinessRules: {
+        FunctieTwowayBusinessLogicRule: FunctieTwowayBusinessLogicRule;
+        FunctieNaaminternBusinessLogicRule: FunctieNaaminternBusinessLogicRule;
+        CustomFieldTypeBusinessLogicRule: CustomFieldTypeBusinessLogicRule;
+        RolDocumentAccessBusinessLogicRule: RolDocumentAccessBusinessLogicRule;
+        RolEditOwnDataBusinessLogicRule: RolEditOwnDataBusinessLogicRule;
+        RolFileAccessBusinessLogicRule: RolFileAccessBusinessLogicRule;
+        RolPersoneelsplannerToegangBusinessLogicRule: RolPersoneelsplannerToegangBusinessLogicRule;
+        RolProjectenBewerkenBusinessLogicRule: RolProjectenBewerkenBusinessLogicRule;
+        RolProjectenToegangBusinessLogicRule: RolProjectenToegangBusinessLogicRule;
+        ExemplaarAanschafdatumBusinessLogicRule: ExemplaarAanschafdatumBusinessLogicRule;
+        ReparatieAanschafdatumBusinessLogicRule: ReparatieAanschafdatumBusinessLogicRule;
+        MateriaalVerhuurBusinessLogicRule: MateriaalVerhuurBusinessLogicRule;
+        MateriaalTypeBusinessLogicRule: MateriaalTypeBusinessLogicRule;
+        SurfaceArticleSizeBusinessLogicRule: SurfaceArticleSizeBusinessLogicRule;
+        PlanningPersoneelTransportBusinessLogicRule: PlanningPersoneelTransportBusinessLogicRule;
+        ProjectClientNoteBusinessLogicRule: ProjectClientNoteBusinessLogicRule;
+        FactuurNumberseriesBusinessLogicRule: FactuurNumberseriesBusinessLogicRule;
+        FactuurBetalingsconditieBusinessLogicRule: FactuurBetalingsconditieBusinessLogicRule;
+        FactuurDatumBusinessLogicRule: FactuurDatumBusinessLogicRule;
+        OfferteContractDatumBusinessLogicRule: OfferteContractDatumBusinessLogicRule;
+        DocumentTemplateBusinessLogicRule: DocumentTemplateBusinessLogicRule;
+    };
+    constructor(apiFormatter: ApiFormatter, changesDeltaFactory: ChangesDeltaFactory, errorHandler: ErrorHandlerInterface, promiseLibrary: PromiseLibraryInterface, locals: ApiModuleFunctionLocalsGetLocals);
+    /**
+     * @description
+     * Handles the business logic for a given ChangesDelta. It will provide a *new* ChangesDelta on which the business rules can apply their data, so that
+     * if new changes are made on *only those new changes* the business logic can be run again.
+     *
+     * example:
+     * - `Functie.twoway` changes the `Functie.afstand` field
+     * - In a second iteration (recursive call) the `Functie.afstand` field updates `Functie.prijs`
+     *   (by doing `Functie.afstand` * `Functie.kilometerprijs`)
+     * - In a third iteration (2nd recursive call) the `Functie.kilometerprijs` has no business logic, so the function
+     *   exits early (`rulesToRun.size === 0`) and the recursion ends
+     *
+     * @param transaction The transaction the ChangesDelta will be applied on
+     * @param changesDelta The source ChangesDelta which contains the changes the rules should be checked on
+     *
+     * @private should only be called by the core
+     */
+    handleBusinessLogic(transaction: TransactionCache, changesDelta: ChangesDelta): Promise<ChangesDelta>;
+    private waitForRuleApplication;
+    private waitForRuleDependencies;
+    private waitForRuleDependency;
+    private extractRulesToRun;
+    private extractRuleToRun;
+}

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

@@ -0,0 +1,94 @@
+import { ApiEnumItemType, ItemId, ResponseColumn } from '@rentman/backend-types';
+import { ItemEntry } from '../../models/ItemEntry';
+import { FieldMap, GetFieldValueType, ItemTypeColumnId } from '../../types/ItemTypesCollection';
+import { ApiFormatter } from '../ApiFormatter';
+import { TransactionCache } from '../cache/transaction/TransactionCache';
+import { TransactionItemHandler } from '../cache/transaction/TransactionItemHandler';
+import { ChangesDelta } from '../ChangesDelta';
+import { ChangesDeltaItemUpdateDelta } from '../ChangesDeltaBase';
+export declare type BusinessLogicRuleConfirmFn<ConditionResult = any> = (conditionResult: ConditionResult) => Promise<boolean>;
+export declare type BusinessLogicConditionResult<ItemTypeType extends ApiEnumItemType, ColumnId extends ItemTypeColumnId<ItemTypeType>> = {
+    itemEntry: ItemEntry<ItemTypeType>;
+    responseColumn: ResponseColumn<ItemTypeType, ColumnId>;
+    oldValue: GetFieldValueType<ItemTypeType, ColumnId>;
+    newValue: GetFieldValueType<ItemTypeType, ColumnId>;
+};
+/**
+ * @description
+ * A business rule is a class that does some data transformation depending on other fields.
+ * You can hook into any data change using the {@link BusinessLogicRule.condition `condition`} function (also deletes/creates)
+ *
+ * All business rule logic is always run in these phases:
+ * 1. condition checking - handled by the {@link BusinessLogicRule.condition `condition`} function
+ * 2. dependency fetching - handled by the {@link BusinessLogicRule.dependency `dependency`} function
+ * 3. rule applying - handled by the {@link BusinessLogicRule.apply `apply`} function
+ */
+export declare abstract class BusinessLogicRule<ConditionResult extends any = any, DependencyType extends any = any> {
+    protected apiFormatter: ApiFormatter;
+    confirmFn: null | BusinessLogicRuleConfirmFn<ConditionResult>;
+    constructor(apiFormatter: ApiFormatter);
+    /**
+     * @description
+     * Checks if the business rule should run. It will first check if there's any item in the changesDelta this rule applies to. If this is the case it will check if the rule has a {@link BusinessLogicRule.confirmFn confirmFn} and show it if there is one.
+     *
+     * @param changesDelta The changesDelta that is being applied
+     * @param itemChanges The transaction's item changes
+     */
+    checkCondition(changesDelta: ChangesDelta, itemChanges: TransactionItemHandler['itemChanges']): Promise<ConditionResult | undefined>;
+    /**
+     * @description
+     * The {@link BusinessLogicRule.dependency `dependency`} function gets the result of the {@link BusinessLogicRule.condition `condition`} function and has to ensure that
+     * the data that the {@link BusinessLogicRule.apply `apply`} function reads/writes is fetched (because you cannot write columns you don't have)
+     *
+     * @param transaction The transaction that the delta is being applied on
+     * @param conditionResult The result of the {@link BusinessLogicRule.condition `condition`} call
+     * @param changesDelta The source changesDelta that triggered the business rule
+     */
+    abstract dependency(transaction: TransactionCache, conditionResult: ConditionResult, changesDelta: ChangesDelta): Promise<DependencyType>;
+    /**
+     * @description
+     * The {@link BusinessLogicRule.apply `apply`} function gets the result of the {@link BusinessLogicRule.dependency `dependency`} function and is responsible for actually doing the business logic
+     * In this function other fields can be updated or new items can be created
+     *
+     * @remark
+     * Do not alter data in the `changesDelta` but use the `destinationChangesDelta`, this is so that for the changed values in the `destinationChangesDelta` business logic can also be done.
+     *
+     * @param changesDelta The source changesDelta that triggered the business rule
+     * @param destinationChangesDelta The destination changesDelta on which you should put the new changes you want to add
+     * @param dependencies The result of the {@link BusinessLogicRule.dependency `dependency`} function
+     * @param transaction The transaction that the delta is being applied on
+     */
+    abstract apply(changesDelta: ChangesDelta, destinationChangesDelta: ChangesDelta, dependencies: DependencyType, transaction: TransactionCache): Promise<any> | void;
+    /**
+     * @description
+     * The {@link BusinessLogicRule.condition `condition`} function should extract the items from the {@link ChangesDelta `ChangesDelta`} so that the {@link BusinessLogicRule.dependency `dependency`} function can fetch the required data for the business rule.
+     * This function can return `undefined` if the rule does not apply to the items in the given ChangesDelta.
+     *
+     * @param changesDelta The source changesDelta that triggered the business rule
+     * @param itemChanges The {@link TransactionItemHandler.itemChanges ItemChanges} of the transaction
+     * @protected
+     */
+    protected abstract condition(changesDelta: ChangesDelta, itemChanges: TransactionItemHandler['itemChanges']): ConditionResult | undefined;
+    /**
+     * @description
+     * This function is a utility function that will return the {@link ItemId ItemIds} of updated items in the {@link ChangesDelta ChangesDelta} which match the {@link ApiEnumItemType ItemType} and of which the provided column's field has changed
+     *
+     * @param changesDelta The source changesDelta that triggered the business rule
+     * @param itemChanges The {@link TransactionItemHandler.itemChanges ItemChanges} of the transaction
+     * @param itemType The ItemType of the item you want to compare a field from
+     * @param columnId The columnId of the field that should've been changed for the ID to be included
+     * @protected
+     */
+    protected getItemIdsWithUpdatedField<ItemTypeType extends ApiEnumItemType>(changesDelta: ChangesDelta, itemChanges: TransactionItemHandler['itemChanges'], itemType: ItemTypeType, columnId: keyof FieldMap<ItemTypeType>): ItemId[] | undefined;
+    /**
+     * @description
+     * This function will compare the stored changes with the given changes, and return `false` if the fields have been changed.
+     * If either the source or changed field is `undefined` it will always return `true` (not changed)
+     *
+     * @param itemChanges The {@link TransactionItemHandler.itemChanges ItemChanges} of the transaction
+     * @param tuple The {@link ChangesDelta.updated update tuple} from a ChangesDelta
+     * @param columnId The columnId of the field that should've been changed for the ID to be included
+     * @protected
+     */
+    protected fieldChanged<ItemTypeType extends ApiEnumItemType, ColumnId extends ItemTypeColumnId<ItemTypeType>>(itemChanges: TransactionItemHandler['itemChanges'], tuple: ChangesDeltaItemUpdateDelta<ItemTypeType>, columnId: ColumnId): null | BusinessLogicConditionResult<ItemTypeType, ColumnId>;
+}

package/dist/types/classes/BusinessLogicManager/Customfield/CustomFieldTypeBusinessLogicRule.d.ts

@@ -0,0 +1,18 @@
+import { ApiEnumItemType, ItemId } from '@rentman/backend-types';
+import { ItemResource } from '../../../models/ItemResource';
+import { TransactionCache } from '../../cache/transaction/TransactionCache';
+import { TransactionItemHandler } from '../../cache/transaction/TransactionItemHandler';
+import { ChangesDelta } from '../../ChangesDelta';
+import { BusinessLogicRule } from '../BusinessLogicRule';
+declare type ConditionResult = ItemId[];
+declare type Dependency = ItemResource<ApiEnumItemType.Customfield, ['defaultvalue', 'attributes']>[];
+/**
+ * @description
+ * If the 'type' field changes we reset the 'defaultvalue' and 'attribute' fields so that they do not contain invalid values
+ */
+export declare class CustomFieldTypeBusinessLogicRule extends BusinessLogicRule<ConditionResult, Dependency> {
+    condition(changesDelta: ChangesDelta, itemChanges: TransactionItemHandler['itemChanges']): ConditionResult | undefined;
+    dependency(transaction: TransactionCache, functionIds: ConditionResult): Promise<Dependency>;
+    apply(changesDelta: ChangesDelta, destinationChangesDelta: ChangesDelta, customFieldResources: Dependency): void;
+}
+export {};

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

@@ -0,0 +1,25 @@
+import { ApiEnumItemType, ItemId } from '@rentman/backend-types';
+import { PromiseLibraryInterface } from '../../../interfaces/PromiseLibraryInterface';
+import { ItemResource } from '../../../models/ItemResource';
+import { ApiFormatter } from '../../ApiFormatter';
+import { TransactionCache } from '../../cache/transaction/TransactionCache';
+import { TransactionItemHandler } from '../../cache/transaction/TransactionItemHandler';
+import { ChangesDelta } from '../../ChangesDelta';
+import { BusinessLogicRule } from '../BusinessLogicRule';
+declare type DocumentTypes = ApiEnumItemType.Factuur | ApiEnumItemType.Offerte | ApiEnumItemType.Contract | ApiEnumItemType.Bon | ApiEnumItemType.Inhuurbon | ApiEnumItemType.Materiaalbon | ApiEnumItemType.Medewerkerbon | ApiEnumItemType.Aanmaning | ApiEnumItemType.Reparatiebon | ApiEnumItemType.Voertuigbon;
+declare type ConditionResult = {
+    [key in DocumentTypes]?: ItemId[];
+};
+declare type Dependency = {
+    [key in DocumentTypes]?: ItemResource<DocumentTypes, ['filename', 'betreft']>[];
+};
+export declare class DocumentTemplateBusinessLogicRule extends BusinessLogicRule<ConditionResult, Dependency> {
+    protected apiFormatter: ApiFormatter;
+    private promiseLibrary;
+    constructor(apiFormatter: ApiFormatter, promiseLibrary: PromiseLibraryInterface);
+    condition(changesDelta: ChangesDelta, itemChanges: TransactionItemHandler['itemChanges']): ConditionResult | undefined;
+    dependency(transaction: TransactionCache, itemIdMap: ConditionResult): Promise<Dependency>;
+    apply(_changesDelta: ChangesDelta, destinationChangesDelta: ChangesDelta, items: Dependency): void;
+    private isDocumentType;
+}
+export {};

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

@@ -0,0 +1,14 @@
+import { ApiEnumItemType, ItemId } from '@rentman/backend-types';
+import { ItemResource } from '../../../models/ItemResource';
+import { TransactionCache } from '../../cache/transaction/TransactionCache';
+import { TransactionItemHandler } from '../../cache/transaction/TransactionItemHandler';
+import { ChangesDelta } from '../../ChangesDelta';
+import { BusinessLogicRule } from '../BusinessLogicRule';
+declare type ConditionResult = ItemId[];
+declare type Dependency = ItemResource<ApiEnumItemType.Exemplaar, ['actief']>[];
+export declare class ExemplaarAanschafdatumBusinessLogicRule extends BusinessLogicRule<ConditionResult, Dependency> {
+    condition(changesDelta: ChangesDelta, _itemChanges: TransactionItemHandler['itemChanges']): ConditionResult | undefined;
+    dependency(transaction: TransactionCache, exemplaarIds: ConditionResult): Promise<Dependency>;
+    apply(_changesDelta: ChangesDelta, destinationChangesDelta: ChangesDelta, exemplaarResources: Dependency): void;
+}
+export {};

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

@@ -0,0 +1,20 @@
+import { ApiEnumItemType, ItemId } from '@rentman/backend-types';
+import { ItemResource } from '../../../models/ItemResource';
+import { TransactionCache } from '../../cache/transaction/TransactionCache';
+import { TransactionItemHandler } from '../../cache/transaction/TransactionItemHandler';
+import { ChangesDelta } from '../../ChangesDelta';
+import { BusinessLogicConditionResult, BusinessLogicRule } from '../BusinessLogicRule';
+declare type ConditionResult = BusinessLogicConditionResult<ApiEnumItemType.Factuur, 'betalingsconditie'>[];
+declare type Dependency = {
+    Factuur: ItemResource<ApiEnumItemType.Factuur, ['vervaldatum', 'datum']>[];
+    Betalingsconditie: {
+        [conditieId: string]: ItemResource<ApiEnumItemType.Betalingsconditie, ['dagen']>;
+    };
+    defaultPaymentConditionId: ItemId | null;
+};
+export declare class FactuurBetalingsconditieBusinessLogicRule extends BusinessLogicRule<ConditionResult, Dependency> {
+    condition(changesDelta: ChangesDelta, itemChanges: TransactionItemHandler['itemChanges']): ConditionResult | undefined;
+    dependency(transaction: TransactionCache, result: ConditionResult, changesDelta: ChangesDelta): Promise<Dependency>;
+    apply(changesDelta: ChangesDelta, destinationChangesDelta: ChangesDelta, deps: Dependency): void;
+}
+export {};

package/dist/types/classes/BusinessLogicManager/Factuur/FactuurDatumBusinessLogicRule.d.ts

@@ -0,0 +1,19 @@
+import { ApiEnumItemType, ItemId } from '@rentman/backend-types';
+import { ItemResource } from '../../../models/ItemResource';
+import { TransactionCache } from '../../cache/transaction/TransactionCache';
+import { TransactionItemHandler } from '../../cache/transaction/TransactionItemHandler';
+import { ChangesDelta } from '../../ChangesDelta';
+import { BusinessLogicRule } from '../BusinessLogicRule';
+declare type ConditionResult = ItemId[];
+declare type Dependency = {
+    Factuur: ItemResource<ApiEnumItemType.Factuur, ['vervaldatum', 'betalingsconditie']>[];
+    Betalingsconditie: {
+        [conditieId: string]: ItemResource<ApiEnumItemType.Betalingsconditie, ['dagen']>;
+    };
+};
+export declare class FactuurDatumBusinessLogicRule extends BusinessLogicRule<ConditionResult, Dependency> {
+    condition(changesDelta: ChangesDelta, itemChanges: TransactionItemHandler['itemChanges']): ConditionResult | undefined;
+    dependency(transaction: TransactionCache, factuurIds: ConditionResult, _changesDelta: ChangesDelta): Promise<Dependency>;
+    apply(changesDelta: ChangesDelta, destinationChangesDelta: ChangesDelta, deps: Dependency): void;
+}
+export {};

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

@@ -0,0 +1,14 @@
+import { ApiEnumItemType, ItemId } from '@rentman/backend-types';
+import { ItemResource } from '../../../models/ItemResource';
+import { TransactionCache } from '../../cache/transaction/TransactionCache';
+import { TransactionItemHandler } from '../../cache/transaction/TransactionItemHandler';
+import { ChangesDelta } from '../../ChangesDelta';
+import { BusinessLogicRule } from '../BusinessLogicRule';
+declare type ConditionResult = ItemId[];
+declare type Dependency = ItemResource<ApiEnumItemType.Factuur, ['nummer']>[];
+export declare class FactuurNumberseriesBusinessLogicRule extends BusinessLogicRule<ConditionResult, Dependency> {
+    condition(changesDelta: ChangesDelta, itemChanges: TransactionItemHandler['itemChanges']): ConditionResult | undefined;
+    dependency(transaction: TransactionCache, factuurIds: ConditionResult): Promise<Dependency>;
+    apply(_changesDelta: ChangesDelta, destinationChangesDelta: ChangesDelta, factuurResources: Dependency): void;
+}
+export {};

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

@@ -0,0 +1,18 @@
+import { ApiEnumItemType, ItemId } from '@rentman/backend-types';
+import { ItemResource } from '../../../models/ItemResource';
+import { TransactionCache } from '../../cache/transaction/TransactionCache';
+import { TransactionItemHandler } from '../../cache/transaction/TransactionItemHandler';
+import { ChangesDelta } from '../../ChangesDelta';
+import { BusinessLogicRule } from '../BusinessLogicRule';
+declare type ConditionResult = ItemId[];
+declare type Dependency = ItemResource<ApiEnumItemType.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(changesDelta: ChangesDelta, itemChanges: TransactionItemHandler['itemChanges']): ConditionResult | undefined;
+    dependency(transaction: TransactionCache, functionIds: ConditionResult): Promise<Dependency>;
+    apply(changesDelta: ChangesDelta, destinationChangesDelta: ChangesDelta, functionResources: Dependency): void;
+}
+export {};

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

@@ -0,0 +1,14 @@
+import { ApiEnumItemType, ItemId } from '@rentman/backend-types';
+import { ItemResource } from '../../../models/ItemResource';
+import { TransactionCache } from '../../cache/transaction/TransactionCache';
+import { TransactionItemHandler } from '../../cache/transaction/TransactionItemHandler';
+import { ChangesDelta } from '../../ChangesDelta';
+import { BusinessLogicRule } from '../BusinessLogicRule';
+declare type ConditionResult = ItemId[];
+declare type Dependency = ItemResource<ApiEnumItemType.Functie, ['afstand']>[];
+export declare class FunctieTwowayBusinessLogicRule extends BusinessLogicRule<ConditionResult, Dependency> {
+    condition(changesDelta: ChangesDelta, itemChanges: TransactionItemHandler['itemChanges']): ConditionResult | undefined;
+    dependency(transaction: TransactionCache, functionIds: ConditionResult): Promise<Dependency>;
+    apply(changesDelta: ChangesDelta, destinationChangesDelta: ChangesDelta, functionResources: Dependency): void;
+}
+export {};

package/dist/types/classes/BusinessLogicManager/Materiaal/MateriaalTypeBusinessLogicRule.d.ts

@@ -0,0 +1,18 @@
+import { ApiEnumItemType, ItemId } from '@rentman/backend-types';
+import { ItemResource } from '../../../models/ItemResource';
+import { TransactionCache } from '../../cache/transaction/TransactionCache';
+import { TransactionItemHandler } from '../../cache/transaction/TransactionItemHandler';
+import { ChangesDelta } from '../../ChangesDelta';
+import { BusinessLogicRule } from '../BusinessLogicRule';
+declare type ConditionResult = ItemId[];
+declare type Dependency = ItemResource<ApiEnumItemType.Materiaal, ['aantal']>[];
+/**
+ * @description
+ * A sales item can never be a case, so if the user changes the item to a case we make it a rental item
+ */
+export declare class MateriaalTypeBusinessLogicRule extends BusinessLogicRule<ConditionResult, Dependency> {
+    condition(changesDelta: ChangesDelta, _itemChanges: TransactionItemHandler['itemChanges']): ConditionResult | undefined;
+    dependency(transaction: TransactionCache, materiaalIds: ConditionResult): Promise<Dependency>;
+    apply(_changesDelta: ChangesDelta, destinationChangesDelta: ChangesDelta, materiaalResources: Dependency): void;
+}
+export {};

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

@@ -0,0 +1,18 @@
+import { ApiEnumItemType, ItemId } from '@rentman/backend-types';
+import { ItemResource } from '../../../models/ItemResource';
+import { TransactionCache } from '../../cache/transaction/TransactionCache';
+import { TransactionItemHandler } from '../../cache/transaction/TransactionItemHandler';
+import { ChangesDelta } from '../../ChangesDelta';
+import { BusinessLogicRule } from '../BusinessLogicRule';
+declare type ConditionResult = ItemId[];
+declare type Dependency = ItemResource<ApiEnumItemType.Materiaal, ['aantal']>[];
+/**
+ * @description
+ * A sales item can never be a case, so if it is we reset it to an item
+ */
+export declare class MateriaalVerhuurBusinessLogicRule extends BusinessLogicRule<ConditionResult, Dependency> {
+    condition(changesDelta: ChangesDelta, _itemChanges: TransactionItemHandler['itemChanges']): ConditionResult | undefined;
+    dependency(transaction: TransactionCache, materiaalIds: ConditionResult): Promise<Dependency>;
+    apply(_changesDelta: ChangesDelta, destinationChangesDelta: ChangesDelta, materiaalResources: Dependency): void;
+}
+export {};

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

@@ -0,0 +1,19 @@
+import { ApiEnumItemType, ApiModuleFunctionLocalsGetLocals, ItemId } from '@rentman/backend-types';
+import { ItemResource } from '../../../models/ItemResource';
+import { ApiFormatter } from '../../ApiFormatter';
+import { TransactionCache } from '../../cache/transaction/TransactionCache';
+import { TransactionItemHandler } from '../../cache/transaction/TransactionItemHandler';
+import { ChangesDelta } from '../../ChangesDelta';
+import { BusinessLogicRule } from '../BusinessLogicRule';
+declare type ConditionResult = ItemId[];
+declare type DependencyColumns = ['width', 'height', 'oppervlakteartikel', 'nieuwprijs', 'inhuurprijs', 'verhuurprijs', 'naam'];
+declare type Dependency = ItemResource<ApiEnumItemType.Materiaal, DependencyColumns>[];
+export declare class SurfaceArticleSizeBusinessLogicRule extends BusinessLogicRule<ConditionResult, Dependency> {
+    protected apiFormatter: ApiFormatter;
+    private locals;
+    constructor(apiFormatter: ApiFormatter, locals: ApiModuleFunctionLocalsGetLocals);
+    condition(changesDelta: ChangesDelta, _itemChanges: TransactionItemHandler['itemChanges']): ConditionResult | undefined;
+    dependency(transaction: TransactionCache, materiaalIds: ConditionResult): Promise<Dependency>;
+    apply(changesDelta: ChangesDelta, destinationChangesDelta: ChangesDelta, materiaalResources: Dependency): void;
+}
+export {};

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

@@ -0,0 +1,26 @@
+import { ApiEnumItemType, ItemId } from '@rentman/backend-types';
+import { PromiseLibraryInterface } from '../../../interfaces/PromiseLibraryInterface';
+import { ItemResource } from '../../../models/ItemResource';
+import { ApiFormatter } from '../../ApiFormatter';
+import { TransactionCache } from '../../cache/transaction/TransactionCache';
+import { TransactionItemHandler } from '../../cache/transaction/TransactionItemHandler';
+import { ChangesDelta } from '../../ChangesDelta';
+import { BusinessLogicRule } from '../BusinessLogicRule';
+declare type ConditionResult = {
+    Offerte: ItemId[];
+    Contract: ItemId[];
+};
+declare type Dependency = {
+    Offerte: ItemResource<ApiEnumItemType.Offerte, ['vervaldatum']>[];
+    Contract: ItemResource<ApiEnumItemType.Contract, ['vervaldatum']>[];
+    State: ItemResource<ApiEnumItemType.State, ['geldigheidofferte']>;
+};
+export declare class OfferteContractDatumBusinessLogicRule extends BusinessLogicRule<ConditionResult, Dependency> {
+    protected apiFormatter: ApiFormatter;
+    private promiseLibrary;
+    constructor(apiFormatter: ApiFormatter, promiseLibrary: PromiseLibraryInterface);
+    condition(changesDelta: ChangesDelta, itemChanges: TransactionItemHandler['itemChanges']): ConditionResult | undefined;
+    dependency(transaction: TransactionCache, itemIdMap: ConditionResult): Promise<Dependency>;
+    apply(_changesDelta: ChangesDelta, destinationChangesDelta: ChangesDelta, items: Dependency): void;
+}
+export {};

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

@@ -0,0 +1,29 @@
+import { ApiEnumItemType, ItemId } from '@rentman/backend-types';
+import { PromiseLibraryInterface } from '../../../interfaces/PromiseLibraryInterface';
+import { ItemResource } from '../../../models/ItemResource';
+import { ApiFormatter } from '../../ApiFormatter';
+import { TransactionCache } from '../../cache/transaction/TransactionCache';
+import { TransactionItemHandler } from '../../cache/transaction/TransactionItemHandler';
+import { ChangesDelta } from '../../ChangesDelta';
+import { BusinessLogicRule } from '../BusinessLogicRule';
+declare type ConditionResult = {
+    Planningpersoneel: ItemId[];
+    Planningtransport: ItemId[];
+};
+declare type Dependency = {
+    Planningpersoneel: ItemResource<ApiEnumItemType.Planningpersoneel, ['vervoer', 'functie', 'planvan', 'plantot']>[];
+    Planningtransport: ItemResource<ApiEnumItemType.Planningtransport, ['vervoer', 'functie', 'planvan', 'plantot']>[];
+    Functie: {
+        [functieId: string]: ItemResource<ApiEnumItemType.Functie, ['reistijd_vooraf', 'reistijd_achteraf']>;
+    };
+};
+export declare class PlanningPersoneelTransportBusinessLogicRule extends BusinessLogicRule<ConditionResult, Dependency> {
+    protected apiFormatter: ApiFormatter;
+    private promiseLibrary;
+    constructor(apiFormatter: ApiFormatter, promiseLibrary: PromiseLibraryInterface);
+    condition(changesDelta: ChangesDelta, itemChanges: TransactionItemHandler['itemChanges']): ConditionResult | undefined;
+    dependency(transaction: TransactionCache, itemIdMap: ConditionResult): Promise<Dependency>;
+    apply(changesDelta: ChangesDelta, destinationChangesDelta: ChangesDelta, items: Dependency): void;
+    private updatePlanningColumns;
+}
+export {};

package/dist/types/classes/BusinessLogicManager/Project/ProjectClientNoteBusinessLogicRule.d.ts

@@ -0,0 +1,23 @@
+import { ApiEnumItemType, ItemId } from '@rentman/backend-types';
+import { PromiseLibraryInterface } from '../../../interfaces/PromiseLibraryInterface';
+import { ItemResource } from '../../../models/ItemResource';
+import { ApiFormatter } from '../../ApiFormatter';
+import { TransactionCache } from '../../cache/transaction/TransactionCache';
+import { TransactionItemHandler } from '../../cache/transaction/TransactionItemHandler';
+import { ChangesDelta } from '../../ChangesDelta';
+import { BusinessLogicRule } from '../BusinessLogicRule';
+declare type ConditionResult = {
+    [projectId: string]: ItemId;
+};
+declare type Dependency = {
+    [projectId: string]: ItemResource<ApiEnumItemType.Contact, ['projectnotitie_naam', 'projectnotitie']>;
+};
+export declare class ProjectClientNoteBusinessLogicRule extends BusinessLogicRule<ConditionResult, Dependency> {
+    protected apiFormatter: ApiFormatter;
+    private promiseLibrary;
+    constructor(apiFormatter: ApiFormatter, promiseLibrary: PromiseLibraryInterface);
+    condition(changesDelta: ChangesDelta, _itemChanges: TransactionItemHandler['itemChanges']): ConditionResult | undefined;
+    dependency(transaction: TransactionCache, obj: ConditionResult): Promise<Dependency>;
+    apply(_changesDelta: ChangesDelta, destinationChangesDelta: ChangesDelta, obj: Dependency): Promise<void>;
+}
+export {};

package/dist/types/classes/BusinessLogicManager/Reparatie/ReparatieExemplaarBusinessLogicRule.d.ts

@@ -0,0 +1,14 @@
+import { ApiEnumItemType, ItemId } from '@rentman/backend-types';
+import { ItemResource } from '../../../models/ItemResource';
+import { TransactionCache } from '../../cache/transaction/TransactionCache';
+import { TransactionItemHandler } from '../../cache/transaction/TransactionItemHandler';
+import { ChangesDelta } from '../../ChangesDelta';
+import { BusinessLogicRule } from '../BusinessLogicRule';
+declare type ConditionResult = ItemId[];
+declare type Dependency = ItemResource<ApiEnumItemType.Reparatie, ['aantal']>[];
+export declare class ReparatieAanschafdatumBusinessLogicRule extends BusinessLogicRule<ConditionResult, Dependency> {
+    condition(changesDelta: ChangesDelta, _itemChanges: TransactionItemHandler['itemChanges']): ConditionResult | undefined;
+    dependency(transaction: TransactionCache, reparatieIds: ConditionResult): Promise<Dependency>;
+    apply(_changesDelta: ChangesDelta, destinationChangesDelta: ChangesDelta, reparatieResources: Dependency): void;
+}
+export {};

package/dist/types/classes/BusinessLogicManager/Rol/RolDocumentAccessBusinessLogicRule.d.ts

@@ -0,0 +1,18 @@
+import { ApiEnumItemType, ItemId } from '@rentman/backend-types';
+import { ItemResource } from '../../../models/ItemResource';
+import { TransactionCache } from '../../cache/transaction/TransactionCache';
+import { TransactionItemHandler } from '../../cache/transaction/TransactionItemHandler';
+import { ChangesDelta } from '../../ChangesDelta';
+import { BusinessLogicRule } from '../BusinessLogicRule';
+declare type ConditionResult = ItemId[];
+declare type Dependency = ItemResource<ApiEnumItemType.Rol, ['general_bestanden_downloaden']>[];
+/**
+ * @description
+ * If you have project access or can make quotations/contracts you should have permissions to download files
+ */
+export declare class RolDocumentAccessBusinessLogicRule extends BusinessLogicRule<ConditionResult, Dependency> {
+    condition(changesDelta: ChangesDelta, _itemChanges: TransactionItemHandler['itemChanges']): ConditionResult | undefined;
+    dependency(transaction: TransactionCache, rolIds: ConditionResult): Promise<Dependency>;
+    apply(_changesDelta: ChangesDelta, destinationChangesDelta: ChangesDelta, rolResources: Dependency): void;
+}
+export {};

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

@@ -0,0 +1,18 @@
+import { ApiEnumItemType, ItemId } from '@rentman/backend-types';
+import { ItemResource } from '../../../models/ItemResource';
+import { TransactionCache } from '../../cache/transaction/TransactionCache';
+import { TransactionItemHandler } from '../../cache/transaction/TransactionItemHandler';
+import { ChangesDelta } from '../../ChangesDelta';
+import { BusinessLogicRule } from '../BusinessLogicRule';
+declare type ConditionResult = ItemId[];
+declare type Dependency = ItemResource<ApiEnumItemType.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(changesDelta: ChangesDelta, _itemChanges: TransactionItemHandler['itemChanges']): ConditionResult | undefined;
+    dependency(transaction: TransactionCache, rolIds: ConditionResult): Promise<Dependency>;
+    apply(_changesDelta: ChangesDelta, destinationChangesDelta: ChangesDelta, rolResources: Dependency): void;
+}
+export {};

package/dist/types/classes/BusinessLogicManager/Rol/RolFileAccessBusinessLogicRule.d.ts

@@ -0,0 +1,18 @@
+import { ApiEnumItemType, ItemId } from '@rentman/backend-types';
+import { ItemResource } from '../../../models/ItemResource';
+import { TransactionCache } from '../../cache/transaction/TransactionCache';
+import { TransactionItemHandler } from '../../cache/transaction/TransactionItemHandler';
+import { ChangesDelta } from '../../ChangesDelta';
+import { BusinessLogicRule } from '../BusinessLogicRule';
+declare type ConditionResult = ItemId[];
+declare type Dependency = ItemResource<ApiEnumItemType.Rol, ['facturen_eigen', 'general_bestanden_downloaden', 'facturen_toegang']>[];
+/**
+ * @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(changesDelta: ChangesDelta, _itemChanges: TransactionItemHandler['itemChanges']): ConditionResult | undefined;
+    dependency(transaction: TransactionCache, rolIds: ConditionResult): Promise<Dependency>;
+    apply(_changesDelta: ChangesDelta, destinationChangesDelta: ChangesDelta, rolResources: Dependency): void;
+}
+export {};

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

@@ -0,0 +1,18 @@
+import { ApiEnumItemType, ItemId } from '@rentman/backend-types';
+import { ItemResource } from '../../../models/ItemResource';
+import { TransactionCache } from '../../cache/transaction/TransactionCache';
+import { TransactionItemHandler } from '../../cache/transaction/TransactionItemHandler';
+import { ChangesDelta } from '../../ChangesDelta';
+import { BusinessLogicRule } from '../BusinessLogicRule';
+declare type ConditionResult = ItemId[];
+declare type Dependency = ItemResource<ApiEnumItemType.Rol, ['personeelsplanner_toegang']>[];
+/**
+ * @description
+ * 	If you can enter the crew planner you can also access projects
+ */
+export declare class RolPersoneelsplannerToegangBusinessLogicRule extends BusinessLogicRule<ConditionResult, Dependency> {
+    condition(changesDelta: ChangesDelta, _itemChanges: TransactionItemHandler['itemChanges']): ConditionResult | undefined;
+    dependency(transaction: TransactionCache, rolIds: ConditionResult): Promise<Dependency>;
+    apply(_changesDelta: ChangesDelta, destinationChangesDelta: ChangesDelta, rolResources: Dependency): void;
+}
+export {};

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

@@ -0,0 +1,18 @@
+import { ApiEnumItemType, ItemId } from '@rentman/backend-types';
+import { ItemResource } from '../../../models/ItemResource';
+import { TransactionCache } from '../../cache/transaction/TransactionCache';
+import { TransactionItemHandler } from '../../cache/transaction/TransactionItemHandler';
+import { ChangesDelta } from '../../ChangesDelta';
+import { BusinessLogicRule } from '../BusinessLogicRule';
+declare type ConditionResult = ItemId[];
+declare type Dependency = ItemResource<ApiEnumItemType.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(changesDelta: ChangesDelta, _itemChanges: TransactionItemHandler['itemChanges']): ConditionResult | undefined;
+    dependency(transaction: TransactionCache, rolIds: ConditionResult): Promise<Dependency>;
+    apply(_changesDelta: ChangesDelta, destinationChangesDelta: ChangesDelta, rolResources: Dependency): void;
+}
+export {};