@rentman/rm-core 0.0.0-RM4-44763

package/dist/types/src/classes/BusinessLogicManager/Rol/RolProjectenToegangBusinessLogicRule.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 = ItemId[];
+type Dependency = ItemResource<'Rol', [
+    'uren_kosten',
+    'visibility_financials'
+]>[];
+/**
+ * @description
+ * 	If you have access to projects you should be able to make costs for registered hours
+ */
+export declare class RolProjectenToegangBusinessLogicRule 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/RolPurchaseOrderAttachPlanningBusinessLogicRule.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 roleColumns: readonly ["purchaseorders_edit"];
+type Dependency = ItemResource<'Rol', typeof roleColumns>[];
+/**
+ * @description
+ * 	You can only have the right to attach crew plannings to purchase orders if you can edit all purchase orders
+ */
+export declare class RolPurchaseOrderAttachPlanningBusinessLogicRule 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/RolVisibilityFinancialsBusinessLogicRule.d.ts

@@ -0,0 +1,35 @@
+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', [
+    'visibility_financials',
+    'facturen_toegang',
+    'projecten_facturen_maken',
+    'projecten_offertes_maken',
+    'projecten_toegang'
+]>[];
+/**
+ * @description
+ * If you're not allowed to see financials, then you should not have the permission to
+ * 1. access the invoices module
+ * 2. create invoices, quotes and contracts in projects
+ * 3. see rates of crew members in activities in the time registration.
+ */
+export declare class RolVisibilityFinancialsBusinessLogicRule extends BusinessLogicRule<ConditionResult, Dependency> {
+    condition(context: BusinessLogicRuleConditionContext): ConditionResult | typeof BLR_SKIP_RULE;
+    dependency(transaction: TransactionCache, rolIds: ConditionResult): Promise<Dependency>;
+    /**
+     * If the financial visibility is turned off:
+     *
+     * all financial related permissions should be off as well
+     * with the exception of "uren_kosten", which can be set independently from financial visibility.
+     *
+     *
+     */
+    apply(context: BusinessLogicRuleApplyContext, rolResources: Dependency): void;
+}
+export {};

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

package/dist/types/src/classes/BusinessLogicManager/Setinhoud/SetinhoudCreateFixedBusinessLogicRule.d.ts

@@ -0,0 +1,21 @@
+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';
+declare const materiaalColumns: readonly ["id", "type"];
+type ConditionResult = ChangesDeltaItemCreateDelta<'Setinhoud'>[];
+type Dependency = Record<string, ItemResource<'Materiaal', typeof materiaalColumns>>;
+/**
+ * Legacy users won't have the `FUNCTIONALITY_FLEXIBLE_COMBINATION_IN_PLANNING` flag, meaning the `is_fixed` column from `Setinhoud` column isn't editable
+ * With this business rule we enforce the correct (default) value based on the equipment properties (Backend enforces this as well)
+ *
+ * For users with the flag this just sets a default value in the same way, but `is_fixed` is editable after it has been created
+ */
+export declare class SetinhoudCreateFixedBusinessLogicRule extends BusinessLogicRule<ConditionResult, Dependency> {
+    condition(context: BusinessLogicRuleConditionContext): ConditionResult | typeof BLR_SKIP_RULE;
+    dependency(transaction: TransactionCache, conditionResult: ConditionResult): Promise<Dependency>;
+    apply(context: BusinessLogicRuleApplyContext, dependencyResult: Dependency, conditionResult: ConditionResult): void;
+}
+export {};

package/dist/types/src/classes/BusinessLogicManager/Setinhoud/SetinhoudUpdateFixedBusinessLogicRule.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';
+declare const setinhoudColumns: readonly ["is_fixed", {
+    readonly package: readonly ["type"];
+}];
+type ConditionResult = {
+    Materiaal: ItemId<'Materiaal'>[];
+    Setinhoud: ItemId<'Setinhoud'>[];
+};
+type Dependency = ItemResource<'Setinhoud', typeof setinhoudColumns>[];
+/**
+ * For legacy users we have to keep track of the correct value based on the equipment properties,
+ * similarly to when creating a new `Setinhoud`, see {@link SetinhoudCreateFixedBusinessLogicRule}
+ *
+ * For normal users the `is_fixed` column is editable, so we don't have to update it
+ */
+export declare class SetinhoudUpdateFixedBusinessLogicRule extends BusinessLogicRule<ConditionResult, Dependency> {
+    condition({ previousChangesDelta, }: BusinessLogicRuleConditionContext): ConditionResult | typeof BLR_SKIP_RULE;
+    dependency(transaction: TransactionCache, conditionResult: ConditionResult): Promise<Dependency>;
+    apply(context: BusinessLogicRuleApplyContext, setinhoudResources: Dependency): void;
+}
+export {};

package/dist/types/src/classes/BusinessLogicManager/Subproject/SubprojectInPlanningBusinessLogicRule.d.ts

@@ -0,0 +1,14 @@
+import { ItemId } from '@rentman/backend-types';
+import { BLR_SKIP_RULE, BusinessLogicRule, BusinessLogicRuleApplyContext, BusinessLogicRuleConditionContext, ItemResource, TransactionCache } from '../../../internal';
+type Dependency = Map<ItemId<'Subproject'>, ItemResource<'Functie', ['subproject', 'inplanning']>[]>;
+type ConditionResult = Map<ItemId<'Subproject'>, boolean>;
+/**
+ * Whenever the 'inplanning' field of a subproject changes, set the 'inplanning' field of all functions in the
+ * subproject to the same value.
+ */
+export declare class SubprojectInPlanningBusinessLogicRule extends BusinessLogicRule<ConditionResult, Dependency> {
+    condition(context: BusinessLogicRuleConditionContext): ConditionResult | typeof BLR_SKIP_RULE;
+    dependency(transaction: TransactionCache, subprojectInPlanningMap: ConditionResult): Promise<Dependency>;
+    apply(context: BusinessLogicRuleApplyContext, subprojectFunctionResourceMap: Dependency, subprojectInPlanningMap: ConditionResult): void;
+}
+export {};

package/dist/types/src/classes/BusinessLogicManager/Subproject/SubprojectOneSubLocationAlignBusinessRule.d.ts

@@ -0,0 +1,27 @@
+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]: {
+        Subproject: ItemResource<'Subproject', ['id', 'project', 'locatie', 'locatie_persoon']>;
+        Project: ItemResource<'Project', ['id', 'locatie']>;
+        amountOfSubprojects: number;
+    };
+};
+/**
+ * @description
+ * Whenever the location of a Subproject changes in a one-sub (Project with no subprojects)
+ * we ensure the `locatie` & 'locatie_persoon` field gets applied on the Project too
+ *
+ * Has similar opposite Business Rule for Projects {@link ProjectOneSubLocationAlignBusinessLogicRule}
+ */
+export declare class SubprojectOneSubLocationAlignBusinessLogicRule 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/Subproject/SubprojectOneSubNameAlignBusinessRule.d.ts

@@ -0,0 +1,22 @@
+import { ItemId } from '@rentman/backend-types';
+import { ItemResource } from '../../../models/ItemResource';
+import { TransactionCache } from '../../cache/transaction/TransactionCache';
+import { BLR_SKIP_RULE, BusinessLogicRule } from '../BusinessLogicRule';
+import { BusinessLogicRuleApplyContext } from '../BusinessLogicRuleApplyContext';
+import { BusinessLogicRuleConditionContext } from '../BusinessLogicRuleConditionContext';
+type ConditionResult = ItemId[];
+type Dependency = {
+    projectResource: ItemResource<'Project', ['id', 'naam']>;
+    subprojectResources: ItemResource<'Subproject', ['id', 'project', 'naam']>[];
+}[];
+/**
+ * @description
+ * Whenever the name of a subproject changes in a one-sub (Project with no subprojects) we ensure the name field gets
+ * applied to the project too.
+ */
+export declare class SubprojectOneSubNameAlignBusinessLogicRule extends BusinessLogicRule<ConditionResult, Dependency> {
+    condition(context: BusinessLogicRuleConditionContext): ConditionResult | typeof BLR_SKIP_RULE;
+    dependency(transaction: TransactionCache, projectIds: ConditionResult): Promise<Dependency>;
+    apply(context: BusinessLogicRuleApplyContext, projectTuples: Dependency): void;
+}
+export {};

package/dist/types/src/classes/BusinessLogicManager/Tijd/TijdNameChangedBusinessLogicRule.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 = ItemId[];
+type Dependency = {
+    tijdResource: ItemResource<'Tijd', ['naam', 'id']>;
+    functiegroepResource: ItemResource<'Functiegroep', ['naam']>;
+}[];
+/**
+ * @description
+ * If the 'naam' of the Tijd item changes, update function groups with the same name connected to this Tijd item
+ */
+export declare class TijdNameChangedBusinessLogicRule extends BusinessLogicRule<ConditionResult, Dependency> {
+    condition(context: BusinessLogicRuleConditionContext): ConditionResult | typeof BLR_SKIP_RULE;
+    dependency(transaction: TransactionCache, tijdIds: ConditionResult): Promise<Dependency>;
+    apply(context: BusinessLogicRuleApplyContext, tijdFunctiegroepTuples: Dependency): void;
+}
+export {};

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

@@ -0,0 +1,17 @@
+import { BLR_SKIP_RULE, BusinessLogicConditionResult, BusinessLogicRule, BusinessLogicRuleApplyContext, BusinessLogicRuleConditionContext, CollectionResource, ItemResource, TransactionCache } from '../../../internal';
+declare const projectDefaultTimeColumns: readonly ["id", "gebruiksperiode", "planperiode"];
+type ConditionResult = BusinessLogicConditionResult<'Tijd', 'subproject'>[];
+type Dependency = ItemResource<'Project', typeof projectDefaultTimeColumns, {
+    Subproject: CollectionResource<'Subproject', typeof projectDefaultTimeColumns>;
+}>;
+/**
+ * When moving a time to a subproject, if the default times of the main project and any subprojects
+ * other than the destination subproject refer to the time, set them to `null`. We need to check all subprojects
+ * because the time might be originating from the main project.
+ */
+export declare class TijdSubprojectChangedBusinessLogicRule extends BusinessLogicRule<ConditionResult, Dependency> {
+    condition(context: BusinessLogicRuleConditionContext): ConditionResult | typeof BLR_SKIP_RULE;
+    dependency(transaction: TransactionCache, timeItemChanges: ConditionResult): Promise<Dependency>;
+    apply(context: BusinessLogicRuleApplyContext, projectResource: Dependency, timeItemChanges: ConditionResult): void;
+}
+export {};

package/dist/types/src/classes/BusinessLogicManager/Uren/HoursTypeBusinessLogicRuleBase.d.ts

@@ -0,0 +1,10 @@
+import { ItemId } from '@rentman/backend-types';
+import { ItemTypeColumnId } from '../../../types/ItemTypesCollection';
+import { BLR_SKIP_RULE, BusinessLogicRule } from '../BusinessLogicRule';
+import { BusinessLogicRuleConditionContext } from '../BusinessLogicRuleConditionContext';
+type ConditionResult = ItemId<'Uren'>[];
+export declare abstract class HoursTypeBusinessLogicRuleBase<DependencyType> extends BusinessLogicRule<ConditionResult, DependencyType> {
+    protected abstract conditionColumnId: ItemTypeColumnId<'HoursType'>;
+    condition(context: BusinessLogicRuleConditionContext): Promise<ConditionResult | typeof BLR_SKIP_RULE>;
+}
+export {};

package/dist/types/src/classes/BusinessLogicManager/Uren/UrenCalculatedDurationBusinessLogicRule.d.ts

@@ -0,0 +1,13 @@
+import { ItemId } from '@rentman/backend-types';
+import { ItemResource } from '../../../models/ItemResource';
+import { TransactionCache } from '../../cache/transaction/TransactionCache';
+import { BusinessLogicRuleApplyContext } from '../BusinessLogicRuleApplyContext';
+import { HoursTypeBusinessLogicRuleBase } from './HoursTypeBusinessLogicRuleBase';
+declare const hoursColumns: readonly ["pauze", "reistijd"];
+type Dependency = ItemResource<'Uren', typeof hoursColumns>[];
+export declare class UrenCalculatedDurationBusinessLogicRule extends HoursTypeBusinessLogicRuleBase<Dependency> {
+    conditionColumnId: "has_calculated_duration";
+    dependency(transaction: TransactionCache, conditionResult: ItemId<'Uren'>[]): Promise<Dependency>;
+    apply(context: BusinessLogicRuleApplyContext, hoursResources: Dependency): void;
+}
+export {};

package/dist/types/src/classes/BusinessLogicManager/Uren/UrenCanHaveActivitiesBusinessLogicRule.d.ts

@@ -0,0 +1,13 @@
+import { ItemId } from '@rentman/backend-types';
+import { ItemResource } from '../../../models/ItemResource';
+import { TransactionCache } from '../../cache/transaction/TransactionCache';
+import { BusinessLogicRuleApplyContext } from '../BusinessLogicRuleApplyContext';
+import { HoursTypeBusinessLogicRuleBase } from './HoursTypeBusinessLogicRuleBase';
+declare const functionHourColumns: readonly ["uren"];
+type Dependency = ItemResource<'Functieuur', typeof functionHourColumns>[];
+export declare class UrenCanHaveActivitiesBusinessLogicRule extends HoursTypeBusinessLogicRuleBase<Dependency> {
+    conditionColumnId: "can_have_activities";
+    dependency(transaction: TransactionCache, conditionResult: ItemId<'Uren'>[]): Promise<Dependency>;
+    apply(context: BusinessLogicRuleApplyContext, functieuurResources: Dependency): void;
+}
+export {};

package/dist/types/src/classes/BusinessLogicManager/businessLogicRule.decorator.d.ts

@@ -0,0 +1,13 @@
+import { ApiModuleFunctionResponse } from '@rentman/backend-types';
+import { HasFlagFn } from '../../types/ItemTypesCollection';
+import { BusinessLogicRule } from './BusinessLogicRule';
+export type BusinessLogicRuleConstructor<BusinessLogicRuleType extends BusinessLogicRule<any, any> = BusinessLogicRule<any, any>> = new (locals: ApiModuleFunctionResponse<'locals', 'getLocals'>, hasFlagFn: HasFlagFn) => BusinessLogicRuleType;
+export type BusinessLogicRuleConstructorName = BusinessLogicRuleConstructor & {
+    __name: string;
+};
+/**
+ * Decorator for business logic rules. Currently defines the name. We could add additional metadata in the future.
+ *
+ * All business logic rules should be registered in `registeredBusinessLogicRules.ts`.
+ */
+export declare function businessLogicRule(name: string): (constructor: BusinessLogicRuleConstructor) => void;

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

@@ -0,0 +1,66 @@
+import { AfspraakRecureindBusinessLogicRule } from './Afspraak/AfspraakRecureindBusinessLogicRule';
+import { BeschikbaarheidRecureindBusinessLogicRule } from './Beschikbaarheid/BeschikbaarheidRecureindBusinessLogicRule';
+import { ContactAddressBusinessLogicRule } from './Contact/ContactAddressBusinessLogicRule';
+import { CustomFieldLinkedItemTypeBusinessLogicRule } from './Customfield/CustomFieldLinkedItemTypeBusinessLogicRule';
+import { CustomFieldTypeBusinessLogicRule } from './Customfield/CustomFieldTypeBusinessLogicRule';
+import { DefaultContactPersonUpdateBusinessLogicRule } from './DefaultContactPersonUpdateBusinessLogicRule';
+import { DocumentTemplateBusinessLogicRule } from './Documents/DocumentTemplateBusinessLogicRule';
+import { ExemplaarAanschafdatumBusinessLogicRule } from './Exemplaar/ExemplaarAanschafdatumBusinessLogicRule';
+import { ExemplaarBarcodeDeleteBusinessLogicRule } from './Exemplaar/ExemplaarBarcodeDeleteBusinessLogicRule';
+import { FactuurBetalingsconditieBusinessLogicRule } from './Factuur/FactuurBetalingsconditieBusinessLogicRule';
+import { FactuurDatumBusinessLogicRule } from './Factuur/FactuurDatumBusinessLogicRule';
+import { FactuurNumberseriesBusinessLogicRule } from './Factuur/FactuurNumberseriesBusinessLogicRule';
+import { FilesNameExtensionBusinessLogicRule } from './Files/FilesNameExtensionBusinessLogicRule';
+import { FunctieNaaminternBusinessLogicRule } from './Functie/FunctieNaaminternBusinessLogicRule';
+import { FunctieRecureindBusinessLogicRule } from './Functie/FunctieRecureindBusinessLogicRule';
+import { FunctieTwowayBusinessLogicRule } from './Functie/FunctieTwowayBusinessLogicRule';
+import { FunctiegroepSubprojectBusinessLogicRule } from './Functiegroep/FunctiegroepSubprojectBusinessLogicRule';
+import { InhuurmateriaalAantalBusinessLogicRule } from './Inhuurmateriaal/InhuurmateriaalAantalBusinessLogicRule';
+import { InhuurmateriaalAantaltotaalBusinessLogicRule } from './Inhuurmateriaal/InhuurmateriaalAantaltotaalBusinessLogicRule';
+import { MateriaalBulkToSerialBusinessLogicRule } from './Materiaal/MateriaalBulkToSerialBusinessLogicRule';
+import { MateriaalIsCombinationBusinessLogicRule } from './Materiaal/MateriaalIsCombinationBusinessLogicRule';
+import { MateriaalIsPhysicalCombinationBulkBusinessLogicRule } from './Materiaal/MateriaalIsPhysicalCombinationBulkBusinessLogicRule';
+import { MateriaalSerialToBulkBusinessLogicRule } from './Materiaal/MateriaalSerialToBulkBusinessLogicRule';
+import { MateriaalToPhysicalBusinessLogicRule } from './Materiaal/MateriaalToPhysicalBusinessLogicRule';
+import { MateriaalToVirtualBusinessLogicRule } from './Materiaal/MateriaalToVirtualBusinessLogicRule';
+import { MateriaalTypePropertiesBusinessLogicRule } from './Materiaal/MateriaalTypePropertiesBusinessLogicRule';
+import { MateriaalVerhuurBusinessLogicRule } from './Materiaal/MateriaalVerhuurBusinessLogicRule';
+import { SurfaceArticleSizeBusinessLogicRule } from './Materiaal/SurfaceArticleSizeBusinessLogicRule';
+import { LinkedTimeItemDurationBusinessLogicRule } from './MateriaalCatFunctieFunctiegroep/LinkedTimeItemDurationBusinessLogicRule';
+import { LinkedTimeItemMateriaalCatBusinessLogicRule } from './MateriaalCatFunctieFunctiegroep/LinkedTimeItemMateriaalCatBusinessLogicRule';
+import { LinkedTimeItemSubprojectBusinessLogicRule } from './MateriaalCatFunctieFunctiegroep/LinkedTimeItemSubprojectBusinessLogicRule';
+import { LinkedTimeItemTimeSchemeBusinessLogicRule } from './MateriaalCatFunctieFunctiegroep/LinkedTimeItemTimeSchemeBusinessLogicRule';
+import { LinkedTimeItemTimeSchemeStartBusinessLogicRule } from './MateriaalCatFunctieFunctiegroep/LinkedTimeItemTimeSchemeStartBusinessLogicRule';
+import { LinkedTimeItemTimeValueStartBusinessLogicRule } from './MateriaalCatFunctieFunctiegroep/LinkedTimeItemTimeValueStartBusinessLogicRule';
+import { OfferteContractDatumBusinessLogicRule } from './OfferteContract/OfferteContractDatumBusinessLogicRule';
+import { PlanningmateriaalAantalBusinessLogicRule } from './Planningmateriaal/PlanningmateriaalAantalBusinessLogicRule';
+import { PlanningmateriaalAantaltotaalBusinessLogicRule } from './Planningmateriaal/PlanningmateriaalAantaltotaalBusinessLogicRule';
+import { PlanningmateriaalOptieBusinessLogicRule } from './Planningmateriaal/PlanningmateriaalOptieBusinessLogicRule';
+import { PlanningmateriaalParentBusinessLogicRule } from './Planningmateriaal/PlanningmateriaalParentBusinessLogicRule';
+import { PlanningmateriaalStaysAtLocationBusinessLogicRule } from './Planningmateriaal/PlanningmateriaalStaysAtLocationBusinessLogicRule';
+import { PlanningPersoneelTransportBusinessLogicRule } from './PlanningPersoneelTransport/PlanningPersoneelTransportBusinessLogicRule';
+import { ProjectClientChangedBusinessLogicRule } from './Project/ProjectClientChangedBusinessLogicRule';
+import { ProjectContactProjectNoteBusinessLogicRule } from './Project/ProjectContactProjectNoteBusinessLogicRule';
+import { ProjectOneSubLocationAlignBusinessLogicRule } from './Project/ProjectOneSubLocationAlignBusinessRule';
+import { ProjectSubprojectDefaultTimeBusinessLogicRule } from './ProjectSubproject/ProjectSubprojectDefaultTimeBusinessLogicRule';
+import { PurchaseOrderApprovalStatusBusinessLogicRule } from './PurchaseOrder/PurchaseOrderApprovalStatusBusinessLogicRule';
+import { PurchaseOrderOwnerBusinessLogicRule } from './PurchaseOrder/PurchaseOrderOwnerBusinessLogicRule';
+import { RateUpdatedBusinessLogicRule } from './Rate/RateUpdatedBusinessLogicRule';
+import { ReparatiesExemplaarAantalBusinessLogicRule } from './Reparatie/ReparatieExemplaarAantalBusinessLogicRule';
+import { ReparatieLostItemExemplaarLocationBusinessLogicRule } from './Reparatie/ReparatieLostItemExemplaarLocationBusinessLogicRule';
+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';
+import { RolPurchaseOrderAttachPlanningBusinessLogicRule } from './Rol/RolPurchaseOrderAttachPlanningBusinessLogicRule';
+import { RolVisibilityFinancialsBusinessLogicRule } from './Rol/RolVisibilityFinancialsBusinessLogicRule';
+import { RolWarehouseTrackingLogAccessBusinessLogicRule } from './Rol/RolWarehosueTrackingLogAccessBusinessLogicRule';
+import { SetinhoudCreateFixedBusinessLogicRule } from './Setinhoud/SetinhoudCreateFixedBusinessLogicRule';
+import { SetinhoudUpdateFixedBusinessLogicRule } from './Setinhoud/SetinhoudUpdateFixedBusinessLogicRule';
+import { SubprojectInPlanningBusinessLogicRule } from './Subproject/SubprojectInPlanningBusinessLogicRule';
+import { SubprojectOneSubLocationAlignBusinessLogicRule } from './Subproject/SubprojectOneSubLocationAlignBusinessRule';
+import { SubprojectOneSubNameAlignBusinessLogicRule } from './Subproject/SubprojectOneSubNameAlignBusinessRule';
+import { TijdNameChangedBusinessLogicRule } from './Tijd/TijdNameChangedBusinessLogicRule';
+import { TijdSubprojectChangedBusinessLogicRule } from './Tijd/TijdSubprojectChangedBusinessLogicRule';
+export declare const registeredBusinessLogicRules: readonly [typeof DefaultContactPersonUpdateBusinessLogicRule, typeof ContactAddressBusinessLogicRule, typeof CustomFieldLinkedItemTypeBusinessLogicRule, typeof CustomFieldTypeBusinessLogicRule, typeof DocumentTemplateBusinessLogicRule, typeof ExemplaarAanschafdatumBusinessLogicRule, typeof ExemplaarBarcodeDeleteBusinessLogicRule, typeof FactuurBetalingsconditieBusinessLogicRule, typeof FactuurDatumBusinessLogicRule, typeof FactuurNumberseriesBusinessLogicRule, typeof FilesNameExtensionBusinessLogicRule, typeof FunctieNaaminternBusinessLogicRule, typeof FunctieTwowayBusinessLogicRule, typeof FunctieRecureindBusinessLogicRule, typeof FunctiegroepSubprojectBusinessLogicRule, typeof InhuurmateriaalAantaltotaalBusinessLogicRule, typeof InhuurmateriaalAantalBusinessLogicRule, typeof MateriaalIsCombinationBusinessLogicRule, typeof MateriaalIsPhysicalCombinationBulkBusinessLogicRule, typeof MateriaalToVirtualBusinessLogicRule, typeof MateriaalToPhysicalBusinessLogicRule, typeof MateriaalBulkToSerialBusinessLogicRule, typeof MateriaalSerialToBulkBusinessLogicRule, typeof MateriaalTypePropertiesBusinessLogicRule, typeof MateriaalVerhuurBusinessLogicRule, typeof SurfaceArticleSizeBusinessLogicRule, typeof LinkedTimeItemDurationBusinessLogicRule, typeof LinkedTimeItemTimeSchemeBusinessLogicRule, typeof LinkedTimeItemTimeSchemeStartBusinessLogicRule, typeof LinkedTimeItemTimeValueStartBusinessLogicRule, typeof LinkedTimeItemSubprojectBusinessLogicRule, typeof LinkedTimeItemMateriaalCatBusinessLogicRule, typeof OfferteContractDatumBusinessLogicRule, typeof PlanningmateriaalAantalBusinessLogicRule, typeof PlanningmateriaalAantaltotaalBusinessLogicRule, typeof PlanningmateriaalOptieBusinessLogicRule, typeof PlanningmateriaalParentBusinessLogicRule, typeof PlanningmateriaalStaysAtLocationBusinessLogicRule, typeof PlanningPersoneelTransportBusinessLogicRule, typeof ProjectClientChangedBusinessLogicRule, typeof ProjectContactProjectNoteBusinessLogicRule, typeof ProjectOneSubLocationAlignBusinessLogicRule, typeof ProjectSubprojectDefaultTimeBusinessLogicRule, typeof PurchaseOrderOwnerBusinessLogicRule, typeof PurchaseOrderApprovalStatusBusinessLogicRule, typeof RateUpdatedBusinessLogicRule, typeof ReparatiesExemplaarAantalBusinessLogicRule, typeof ReparatieLostItemExemplaarLocationBusinessLogicRule, typeof RolEditOwnDataBusinessLogicRule, typeof RolFileAccessBusinessLogicRule, typeof RolPersoneelsplannerToegangBusinessLogicRule, typeof RolProjectenBewerkenBusinessLogicRule, typeof RolProjectenToegangBusinessLogicRule, typeof RolVisibilityFinancialsBusinessLogicRule, typeof RolWarehouseTrackingLogAccessBusinessLogicRule, typeof RolPurchaseOrderAttachPlanningBusinessLogicRule, typeof SetinhoudCreateFixedBusinessLogicRule, typeof SetinhoudUpdateFixedBusinessLogicRule, typeof SubprojectOneSubLocationAlignBusinessLogicRule, typeof SubprojectOneSubNameAlignBusinessLogicRule, typeof SubprojectInPlanningBusinessLogicRule, typeof TijdSubprojectChangedBusinessLogicRule, typeof TijdNameChangedBusinessLogicRule, typeof AfspraakRecureindBusinessLogicRule, typeof BeschikbaarheidRecureindBusinessLogicRule];

package/dist/types/src/classes/ChangesCompilation.d.ts

@@ -0,0 +1,26 @@
+import { ApiItemType } from '@rentman/backend-types';
+import { ChildChangesDeltaItemCreateDelta, ItemEntry, ItemEntryMap, ItemMap, TransactionCache } from '../internal';
+export type CreateRequestCompilationParent = ApiItemType | 'Void';
+export type CreateCompilation = {
+    [parentType: string]: {
+        [parentId: number]: ItemMap<ChildChangesDeltaItemCreateDelta>;
+    };
+};
+export type DeleteCompilation = {
+    [itemType: string]: ItemEntry[];
+};
+export type UpdateCompilation = ItemEntryMap;
+export declare class ChangesCompilation {
+    private transaction;
+    compilation: {
+        create: CreateCompilation;
+        delete: DeleteCompilation;
+        update: UpdateCompilation;
+    };
+    constructor(transaction: TransactionCache);
+    private processDelta;
+    private getDefaultParent;
+    private addDeleteEntry;
+    private addUpdateEntry;
+    private addCreateEntry;
+}

package/dist/types/src/classes/ChangesDelta.d.ts

@@ -0,0 +1,81 @@
+import { ApiFields, ApiItemType, ItemId } from '@rentman/backend-types';
+import { ChangesDeltaBase, ChangesDeltaBaseItemDeleteDelta, ChangesDeltaBaseItemUpdateDelta, ChangesDeltaItemCreateDelta, ChangesDeltaItemUpdateMode, ColumnExpansion, ColumnSet, CreatedChangesDelta, EntryParentNull, ErrorHandlerInterface, FieldMap, ItemCreateService, ItemEntry, ItemEntryChangesTuple, ItemEntryService, RequestParameters } from '../internal';
+export interface ChangesDeltaItemDeleteDelta<ItemTypeType extends ApiItemType> extends ChangesDeltaBaseItemDeleteDelta<ItemTypeType> {
+    isCascaded: boolean;
+}
+export interface ChangesDeltaItemUpdateDelta<ItemTypeType extends ApiItemType> extends ChangesDeltaBaseItemUpdateDelta<ItemTypeType> {
+    entry: ItemEntry<ItemTypeType>;
+    changes: {
+        fields: FieldMap<ItemTypeType>;
+        columnExpansions: ColumnExpansion<ItemTypeType>[];
+    };
+    mode: ChangesDeltaItemUpdateMode;
+}
+/**
+ * @description
+ * ChangesDelta used to apply changes from outside of the core to a transaction
+ *
+ * ----------
+ *
+ * The difference between {@link ChildChangesDelta} and {@link ChangesDelta} is that the ChangesDelta
+ * assumes 'created' values have no itemEntries yet.
+ *
+ * Use this when calling {@link TransactionCache.applyChangesDelta applyChangesDelta}
+ */
+export declare class ChangesDelta extends ChangesDeltaBase<ChangesDeltaItemDeleteDelta<any>> {
+    logMissingColumnErrors: boolean;
+    private errorHandler;
+    private itemCreateService;
+    updated: {
+        [itemEntryId: number]: ChangesDeltaItemUpdateDelta<any>;
+    };
+    created: CreatedChangesDelta;
+    /**
+     * Only contains remote items, when rolling back local items the whole entries are deleted.
+     */
+    restored: {
+        [itemEntryId: number]: ItemEntryChangesTuple<any>;
+    };
+    constructor(logMissingColumnErrors: boolean, queryItemTypes: Iterable<ApiItemType> | undefined, errorHandler: ErrorHandlerInterface, itemCreateService: ItemCreateService, itemEntryService: ItemEntryService);
+    getCreatedTuplesIterator<ItemTypeType extends ApiItemType>(itemType: ItemTypeType): IterableIterator<ChangesDeltaItemCreateDelta<ItemTypeType>>;
+    getUpdatedTuplesIterator<ItemTypes extends ApiItemType[]>(...itemTypes: ItemTypes): Generator<ChangesDeltaItemUpdateDelta<ItemTypes extends [] ? any : ItemTypes[number]>>;
+    merge(otherChangesDelta: ChangesDelta): ChangesDelta;
+    /**
+     * @description
+     * Fetches a template for the passed itemType and processes the passed values and sets the item to be created when the delta is applied
+     *
+     * @remark
+     * - If the values don't contain an `id` a new one will be generated
+     * - If you want to set a parent set the proper field, you can't pass it as a separate object
+     */
+    setItemCreated<ItemTypeType extends ApiItemType, Fields extends Partial<FieldMap<ItemTypeType>>>(itemType: ItemTypeType, values: Fields, templateOptions?: Partial<RequestParameters<ItemTypeType>>): Promise<this>;
+    setItemCreatedByTuple<ItemTypeType extends ApiItemType>(itemCreateTuple: ChangesDeltaItemCreateDelta<ItemTypeType>, updatedFields: Partial<FieldMap<ItemTypeType>>): ChangesDelta;
+    setItemUpdated<ItemTypeType extends ApiItemType>(entry: ItemEntry<ItemTypeType>, fields: Partial<FieldMap<ItemTypeType>>, columnExpansion?: ColumnExpansion<ItemTypeType> | null, parent?: EntryParentNull, mode?: ChangesDeltaItemUpdateMode): this;
+    setItemDeleted(entry: ItemEntry, __isCascaded?: boolean): this;
+    setItemsDeleted(deleted: ItemEntry[]): this;
+    setItemDeletedCascaded(itemEntry: ItemEntry): this;
+    /**
+     * @description
+     * Fetches a template for the passed itemType and processes the passed values and sets the items to be created when the delta is applied
+     *
+     * @remark
+     * - If the values don't contain an `id` a new one will be generated
+     * - If you want to set a parent set the proper field, you can't pass it as a separate object
+     */
+    setItemsCreated<ItemTypeType extends ApiItemType, ColumnIds extends (keyof ApiFields[ItemTypeType])[] = (keyof ApiFields[ItemTypeType])[]>(itemType: ItemTypeType, valuesArray: Partial<FieldMap<ItemTypeType, ColumnIds>>[]): Promise<this>;
+    /**
+     * @description
+     * Will create an {@link ItemEntry ItemEntry} when the delta is applied
+     * Does not always mean the item is local, just that it isn't cached yet
+     *
+     * @remark
+     * If you're calling this from the frontend you probably want to call `setItemCreated`, which will fetch a template and process the values for you
+     * If you don't, you have to make sure the values are all correct and all template items are processed
+     *
+     * @internal
+     */
+    _setItemCreated<ItemTypeType extends ApiItemType, Fields extends Partial<FieldMap<ItemTypeType>>>(itemId: ItemId, fields: Fields, columns: ColumnSet<ItemTypeType>, parent?: EntryParentNull, isRoot?: boolean, isApiResponse?: boolean): this;
+    setItemRestored<ItemTypeType extends ApiItemType>(itemEntry: ItemEntry<ItemTypeType>, transactionItemEntryChanges: FieldMap<ItemTypeType>): void;
+    isEmpty(): boolean;
+    toJSON(): any;
+}

package/dist/types/src/classes/ChangesDeltaBase.d.ts

@@ -0,0 +1,85 @@
+import { ApiItemType, ItemId } from '@rentman/backend-types';
+import { ChangesDelta, ChildChangesDelta, FieldMap, GetFieldValueType, ItemEntry, ItemEntryService, ItemTypeColumnId } from '../internal';
+export type ChangesDeltaResult = {
+    /**
+     * The changes delta included in the changes delta result is not necessarily the same as the one being passed to
+     * the `applyChangesDelta()` method, as business logic rules might have been applied.
+     * TODO: Separate results for changes delta and child changes delta.
+     */
+    changesDelta: ChangesDelta | ChildChangesDelta;
+    created: ItemEntry[];
+    allChildrenDonePromise: Promise<void>;
+};
+export type ChangesDeltaItemUpdateMode = 
+/**
+ * For create/update responses you always want to overwrite whatever is cached
+ */
+'CLEAR_ALWAYS'
+/**
+ * For socket messages you want to clear the user's changes if they are the same as what is received
+ */
+ | 'CLEAR_WHEN_SAME'
+/**
+ * Used for query responses (you don't want to do anything with user changes)
+ */
+ | 'QUERY'
+/**
+ * For user changes you want to store them if they are different than on a parent
+ */
+ | 'KEEP_WHEN_DIFFERENT';
+/**
+ * @remark
+ * We explicitly keep track of the new parent, so we can set an item to moved if it isn't null (Needed for linkTo request)
+ */
+export interface ChangesDeltaBaseItemUpdateDelta<ItemTypeType extends ApiItemType> {
+    entry: ItemEntry<ItemTypeType>;
+    changes: {
+        fields: FieldMap<ItemTypeType>;
+    };
+    mode: ChangesDeltaItemUpdateMode;
+}
+export interface ChangesDeltaBaseItemDeleteDelta<ItemTypeType extends ApiItemType> {
+    entry: ItemEntry<ItemTypeType>;
+}
+export declare abstract class ChangesDeltaBase<ItemDeleteDeltaType extends ChangesDeltaBaseItemDeleteDelta<any> = ChangesDeltaBaseItemDeleteDelta<any>> {
+    protected itemEntryService: ItemEntryService;
+    updated: {
+        [itemEntryId: number]: ChangesDeltaBaseItemUpdateDelta<any>;
+    };
+    protected deleted: {
+        [ItemType in ApiItemType]?: Map<ItemEntry<ItemType>, ItemDeleteDeltaType>;
+    };
+    /**
+     * @private
+     */
+    _queryResults: {
+        [itemType: string]: {
+            [queryString: string]: Set<ItemId>;
+        };
+    };
+    /**
+     * @private
+     * When set, only collections of this item type will be matched.
+     */
+    _queryItemTypeSet?: Set<ApiItemType>;
+    protected constructor(itemEntryService: ItemEntryService, queryItemTypes?: Iterable<ApiItemType>);
+    addQueryItemType(itemType: ApiItemType): void;
+    getUpdatedValue<ItemTypeType extends ApiItemType, ColumnId extends ItemTypeColumnId<ItemTypeType>>(itemEntry: ItemEntry<ItemTypeType>, columnId: ColumnId): GetFieldValueType<ItemTypeType, ColumnId> | undefined;
+    hasDeletedItem<ItemTypeType extends ApiItemType>(itemEntry: ItemEntry<ItemTypeType>): boolean;
+    hasUpdatedValue<ItemTypeType extends ApiItemType>(itemEntry: ItemEntry<ItemTypeType>, columnId: ItemTypeColumnId<ItemTypeType>): boolean;
+    getDeletedItemTypesIterator(): Generator<ApiItemType>;
+    getDeletedItemEntriesIterator<ItemTypeType extends ApiItemType>(itemType: ItemTypeType): Generator<ItemEntry<ItemTypeType>>;
+    getDeletedItemEntriesIterator(itemType?: undefined): Generator<ItemEntry<any>>;
+    getDeleteTuplesIterator(itemType?: ApiItemType): Generator<ItemDeleteDeltaType>;
+    isEmpty(): boolean;
+    /**
+     * @description
+     * Adds a hint for the {@link CollectionMatcherBase CacheSyncer] to the ChangesDelta, when the CollectionMatcher encounters a collection
+     * with the exact query, it will use the hint instead of running the matcher
+     *
+     * @private
+     */
+    _setQueryResult<ItemTypeType extends ApiItemType>(itemType: ItemTypeType, queryString: string, itemIds: Iterable<ItemId>): Set<ItemId>;
+    _getQueryResult<ItemTypeType extends ApiItemType>(itemType: ItemTypeType, queryString: string): Set<ItemId> | undefined;
+    protected setItemDeletedByTuple(deletedTuple: ItemDeleteDeltaType): this;
+}

package/dist/types/src/classes/ChangesProcessor.d.ts

@@ -0,0 +1,35 @@
+import { ApiRequestService, ChangesCompilationFactory, ChangesDeltaFactory, ErrorHandlerInterface, ItemIdConversionMap, RequestBufferManager, RequestColumnExpansionFactory, TransactionCache } from '../internal';
+export type OnAfterCreateCallback = (conversionMap: ItemIdConversionMap) => void;
+/**
+ * @description
+ * Executes the changes from a specific {@link TransactionCache transaction} and returns a {@link ChangesDelta ChangesDelta}
+ */
+export declare class ChangesProcessor {
+    private apiRequestService;
+    private changesCompilationFactory;
+    private changesDeltaFactory;
+    private errorHandler;
+    private requestBufferManager;
+    private requestColumnExpansionFactory;
+    private transaction;
+    private breakUpByParent?;
+    private onAfterCreateCallback?;
+    private itemIdConversionMap;
+    private serverCache;
+    constructor(apiRequestService: ApiRequestService, changesCompilationFactory: ChangesCompilationFactory, changesDeltaFactory: ChangesDeltaFactory, errorHandler: ErrorHandlerInterface, requestBufferManager: RequestBufferManager, requestColumnExpansionFactory: RequestColumnExpansionFactory, transaction: TransactionCache, breakUpByParent?: boolean | undefined, onAfterCreateCallback?: OnAfterCreateCallback | undefined);
+    /**
+     * @description
+     * Executes the requests in the order of:
+     * 1. create
+     * 2. update
+     * 3. delete
+     */
+    execute(): Promise<ItemIdConversionMap>;
+    private getMapValue;
+    private executeCreateRequests;
+    private executeCreateRequest;
+    private executeUpdateRequests;
+    private executeUpdateRequest;
+    private executeDeleteRequests;
+    private executeDeleteRequest;
+}