@rentman/rm-core 12.1.2 → 12.1.3

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

@@ -1,93 +1,93 @@
-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 { ChangesDelta } from '../ChangesDelta';
-import { ChangesDeltaItemUpdateDelta } from '../ChangesDeltaBase';
-export declare type BusinessLogicRuleConfirmFn<ConditionResult = any> = (conditionResult: ConditionResult, changesDelta: ChangesDelta) => 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 transaction
-     * @param changesDelta The changesDelta that is being applied
-     */
-    checkCondition(transaction: TransactionCache, changesDelta: ChangesDelta): 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 transaction
-     * @param changesDelta The source changesDelta that triggered the business rule
-     * @protected
-     */
-    protected abstract condition(changesDelta: ChangesDelta, transaction: TransactionCache): 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 transaction
-     * @param changesDelta The source changesDelta that triggered the business rule
-     * @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>(transaction: TransactionCache, changesDelta: ChangesDelta, itemType: ItemTypeType, columnId: keyof FieldMap<ItemTypeType>): ItemId[] | undefined;
-    /**
-     * @description
-     * This function will compare the stored changes with the given changes, and return a {@link BusinessLogicConditionResult} if the fields have been changed, null otherwise.
-     * If either the source or changed field is `undefined` it will always return `null` (not changed)
-     *
-     * @param 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>>(transaction: TransactionCache, tuple: ChangesDeltaItemUpdateDelta<ItemTypeType>, columnId: ColumnId): null | BusinessLogicConditionResult<ItemTypeType, ColumnId>;
-}
+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 { ChangesDelta } from '../ChangesDelta';
+import { ChangesDeltaItemUpdateDelta } from '../ChangesDeltaBase';
+export declare type BusinessLogicRuleConfirmFn<ConditionResult = any> = (conditionResult: ConditionResult, changesDelta: ChangesDelta) => 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 transaction
+     * @param changesDelta The changesDelta that is being applied
+     */
+    checkCondition(transaction: TransactionCache, changesDelta: ChangesDelta): 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 transaction
+     * @param changesDelta The source changesDelta that triggered the business rule
+     * @protected
+     */
+    protected abstract condition(changesDelta: ChangesDelta, transaction: TransactionCache): 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 transaction
+     * @param changesDelta The source changesDelta that triggered the business rule
+     * @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>(transaction: TransactionCache, changesDelta: ChangesDelta, itemType: ItemTypeType, columnId: keyof FieldMap<ItemTypeType>): ItemId[] | undefined;
+    /**
+     * @description
+     * This function will compare the stored changes with the given changes, and return a {@link BusinessLogicConditionResult} if the fields have been changed, null otherwise.
+     * If either the source or changed field is `undefined` it will always return `null` (not changed)
+     *
+     * @param 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>>(transaction: TransactionCache, tuple: ChangesDeltaItemUpdateDelta<ItemTypeType>, columnId: ColumnId): null | BusinessLogicConditionResult<ItemTypeType, ColumnId>;
+}

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

@@ -1,17 +1,17 @@
-import { ApiEnumItemType, ItemId } from '@rentman/backend-types';
-import { ItemResource } from '../../../models/ItemResource';
-import { TransactionCache } from '../../cache/transaction/TransactionCache';
-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, transaction: TransactionCache): ConditionResult | undefined;
-    dependency(transaction: TransactionCache, functionIds: ConditionResult): Promise<Dependency>;
-    apply(changesDelta: ChangesDelta, destinationChangesDelta: ChangesDelta, customFieldResources: Dependency): void;
-}
-export {};
+import { ApiEnumItemType, ItemId } from '@rentman/backend-types';
+import { ItemResource } from '../../../models/ItemResource';
+import { TransactionCache } from '../../cache/transaction/TransactionCache';
+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, transaction: TransactionCache): ConditionResult | undefined;
+    dependency(transaction: TransactionCache, functionIds: ConditionResult): Promise<Dependency>;
+    apply(changesDelta: ChangesDelta, destinationChangesDelta: ChangesDelta, customFieldResources: Dependency): void;
+}
+export {};

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

@@ -1,24 +1,24 @@
-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 { 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, transaction: TransactionCache): ConditionResult | undefined;
-    dependency(transaction: TransactionCache, itemIdMap: ConditionResult): Promise<Dependency>;
-    apply(_changesDelta: ChangesDelta, destinationChangesDelta: ChangesDelta, items: Dependency): void;
-    private isDocumentType;
-}
-export {};
+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 { 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, transaction: TransactionCache): ConditionResult | undefined;
+    dependency(transaction: TransactionCache, itemIdMap: ConditionResult): Promise<Dependency>;
+    apply(_changesDelta: ChangesDelta, destinationChangesDelta: ChangesDelta, items: Dependency): void;
+    private isDocumentType;
+}
+export {};

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

@@ -1,13 +1,13 @@
-import { ApiEnumItemType, ItemId } from '@rentman/backend-types';
-import { ItemResource } from '../../../models/ItemResource';
-import { TransactionCache } from '../../cache/transaction/TransactionCache';
-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): ConditionResult | undefined;
-    dependency(transaction: TransactionCache, exemplaarIds: ConditionResult): Promise<Dependency>;
-    apply(_changesDelta: ChangesDelta, destinationChangesDelta: ChangesDelta, exemplaarResources: Dependency): void;
-}
-export {};
+import { ApiEnumItemType, ItemId } from '@rentman/backend-types';
+import { ItemResource } from '../../../models/ItemResource';
+import { TransactionCache } from '../../cache/transaction/TransactionCache';
+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): ConditionResult | undefined;
+    dependency(transaction: TransactionCache, exemplaarIds: ConditionResult): Promise<Dependency>;
+    apply(_changesDelta: ChangesDelta, destinationChangesDelta: ChangesDelta, exemplaarResources: Dependency): void;
+}
+export {};

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

@@ -1,19 +1,19 @@
-import { ApiEnumItemType, ItemId } from '@rentman/backend-types';
-import { ItemResource } from '../../../models/ItemResource';
-import { TransactionCache } from '../../cache/transaction/TransactionCache';
-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, transaction: TransactionCache): ConditionResult | undefined;
-    dependency(transaction: TransactionCache, result: ConditionResult, changesDelta: ChangesDelta): Promise<Dependency>;
-    apply(changesDelta: ChangesDelta, destinationChangesDelta: ChangesDelta, deps: Dependency): void;
-}
-export {};
+import { ApiEnumItemType, ItemId } from '@rentman/backend-types';
+import { ItemResource } from '../../../models/ItemResource';
+import { TransactionCache } from '../../cache/transaction/TransactionCache';
+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, transaction: TransactionCache): ConditionResult | undefined;
+    dependency(transaction: TransactionCache, result: ConditionResult, changesDelta: ChangesDelta): Promise<Dependency>;
+    apply(changesDelta: ChangesDelta, destinationChangesDelta: ChangesDelta, deps: Dependency): void;
+}
+export {};

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

@@ -1,18 +1,18 @@
-import { ApiEnumItemType, ItemId } from '@rentman/backend-types';
-import { ItemResource } from '../../../models/ItemResource';
-import { TransactionCache } from '../../cache/transaction/TransactionCache';
-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, transaction: TransactionCache): ConditionResult | undefined;
-    dependency(transaction: TransactionCache, factuurIds: ConditionResult, _changesDelta: ChangesDelta): Promise<Dependency>;
-    apply(changesDelta: ChangesDelta, destinationChangesDelta: ChangesDelta, deps: Dependency): void;
-}
-export {};
+import { ApiEnumItemType, ItemId } from '@rentman/backend-types';
+import { ItemResource } from '../../../models/ItemResource';
+import { TransactionCache } from '../../cache/transaction/TransactionCache';
+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, transaction: TransactionCache): ConditionResult | undefined;
+    dependency(transaction: TransactionCache, factuurIds: ConditionResult, _changesDelta: ChangesDelta): Promise<Dependency>;
+    apply(changesDelta: ChangesDelta, destinationChangesDelta: ChangesDelta, deps: Dependency): void;
+}
+export {};

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

@@ -1,13 +1,13 @@
-import { ApiEnumItemType, ItemId } from '@rentman/backend-types';
-import { ItemResource } from '../../../models/ItemResource';
-import { TransactionCache } from '../../cache/transaction/TransactionCache';
-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, transaction: TransactionCache): ConditionResult | undefined;
-    dependency(transaction: TransactionCache, factuurIds: ConditionResult): Promise<Dependency>;
-    apply(_changesDelta: ChangesDelta, destinationChangesDelta: ChangesDelta, factuurResources: Dependency): void;
-}
-export {};
+import { ApiEnumItemType, ItemId } from '@rentman/backend-types';
+import { ItemResource } from '../../../models/ItemResource';
+import { TransactionCache } from '../../cache/transaction/TransactionCache';
+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, transaction: TransactionCache): ConditionResult | undefined;
+    dependency(transaction: TransactionCache, factuurIds: ConditionResult): Promise<Dependency>;
+    apply(_changesDelta: ChangesDelta, destinationChangesDelta: ChangesDelta, factuurResources: Dependency): void;
+}
+export {};

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

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

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

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

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

@@ -1,15 +1,15 @@
-import { ApiEnumItemType, ItemId } from '@rentman/backend-types';
-import { ItemEntry, TransactionCache } from '../../..';
-import { ChangesDelta } from '../../ChangesDelta';
-import { BusinessLogicRule } from '../BusinessLogicRule';
-export declare type ConditionResult = ItemId[];
-declare type Dependency = {
-    local: ItemEntry<ApiEnumItemType.Voorraadmutatie>[];
-    remote: ItemEntry<ApiEnumItemType.Voorraadmutatie>[];
-};
-export declare class MateriaalTelexemplarenBusinessLogicRule extends BusinessLogicRule<ConditionResult, Dependency> {
-    protected condition(changesDelta: ChangesDelta): ConditionResult | undefined;
-    dependency(transaction: TransactionCache, conditionResult: ConditionResult): Promise<Dependency>;
-    apply(_changesDelta: ChangesDelta, destinationChangesDelta: ChangesDelta, dependencies: Dependency): Promise<any> | void;
-}
-export {};
+import { ApiEnumItemType, ItemId } from '@rentman/backend-types';
+import { ItemEntry, TransactionCache } from '../../..';
+import { ChangesDelta } from '../../ChangesDelta';
+import { BusinessLogicRule } from '../BusinessLogicRule';
+export declare type ConditionResult = ItemId[];
+declare type Dependency = {
+    local: ItemEntry<ApiEnumItemType.Voorraadmutatie>[];
+    remote: ItemEntry<ApiEnumItemType.Voorraadmutatie>[];
+};
+export declare class MateriaalTelexemplarenBusinessLogicRule extends BusinessLogicRule<ConditionResult, Dependency> {
+    protected condition(changesDelta: ChangesDelta): ConditionResult | undefined;
+    dependency(transaction: TransactionCache, conditionResult: ConditionResult): Promise<Dependency>;
+    apply(_changesDelta: ChangesDelta, destinationChangesDelta: ChangesDelta, dependencies: Dependency): Promise<any> | void;
+}
+export {};

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

@@ -1,17 +1,17 @@
-import { ApiEnumItemType, ItemId } from '@rentman/backend-types';
-import { ItemResource } from '../../../models/ItemResource';
-import { TransactionCache } from '../../cache/transaction/TransactionCache';
-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): ConditionResult | undefined;
-    dependency(transaction: TransactionCache, materiaalIds: ConditionResult): Promise<Dependency>;
-    apply(_changesDelta: ChangesDelta, destinationChangesDelta: ChangesDelta, materiaalResources: Dependency): void;
-}
-export {};
+import { ApiEnumItemType, ItemId } from '@rentman/backend-types';
+import { ItemResource } from '../../../models/ItemResource';
+import { TransactionCache } from '../../cache/transaction/TransactionCache';
+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): ConditionResult | undefined;
+    dependency(transaction: TransactionCache, materiaalIds: ConditionResult): Promise<Dependency>;
+    apply(_changesDelta: ChangesDelta, destinationChangesDelta: ChangesDelta, materiaalResources: Dependency): void;
+}
+export {};

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

@@ -1,17 +1,17 @@
-import { ApiEnumItemType, ItemId } from '@rentman/backend-types';
-import { ItemResource } from '../../../models/ItemResource';
-import { TransactionCache } from '../../cache/transaction/TransactionCache';
-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): ConditionResult | undefined;
-    dependency(transaction: TransactionCache, materiaalIds: ConditionResult): Promise<Dependency>;
-    apply(_changesDelta: ChangesDelta, destinationChangesDelta: ChangesDelta, materiaalResources: Dependency): void;
-}
-export {};
+import { ApiEnumItemType, ItemId } from '@rentman/backend-types';
+import { ItemResource } from '../../../models/ItemResource';
+import { TransactionCache } from '../../cache/transaction/TransactionCache';
+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): ConditionResult | undefined;
+    dependency(transaction: TransactionCache, materiaalIds: ConditionResult): Promise<Dependency>;
+    apply(_changesDelta: ChangesDelta, destinationChangesDelta: ChangesDelta, materiaalResources: Dependency): void;
+}
+export {};