@rentman/rm-core 11.0.2 → 11.0.3

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

@@ -1,19 +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 {};
+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/src/classes/BusinessLogicManager/OfferteContract/OfferteContractDatumBusinessLogicRule.d.ts

@@ -1,26 +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 {};
+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/src/classes/BusinessLogicManager/PlanningPersoneelTransport/PlanningPersoneelTransportBusinessLogicRule.d.ts

@@ -1,29 +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 {};
+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/src/classes/BusinessLogicManager/Project/ProjectClientNoteBusinessLogicRule.d.ts

@@ -1,23 +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 {};
+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/src/classes/BusinessLogicManager/Reparatie/ReparatieExemplaarBusinessLogicRule.d.ts

@@ -1,14 +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 {};
+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/src/classes/BusinessLogicManager/Rol/RolDocumentAccessBusinessLogicRule.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 { 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 {};
+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/src/classes/BusinessLogicManager/Rol/RolEditOwnDataBusinessLogicRule.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 { 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 {};
+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/src/classes/BusinessLogicManager/Rol/RolFileAccessBusinessLogicRule.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 { 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', 'projecten_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 {};
+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', 'projecten_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/src/classes/BusinessLogicManager/Rol/RolPersoneelsplannerToegangBusinessLogicRule.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 { 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 {};
+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/src/classes/BusinessLogicManager/Rol/RolProjectenBewerkenBusinessLogicRule.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 { 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 {};
+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 {};

package/dist/types/src/classes/BusinessLogicManager/Rol/RolProjectenToegangBusinessLogicRule.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 { TransactionItemHandler } from '../../cache/transaction/TransactionItemHandler';
-import { ChangesDelta } from '../../ChangesDelta';
-import { BusinessLogicRule } from '../BusinessLogicRule';
-declare type ConditionResult = ItemId[];
-declare type Dependency = ItemResource<ApiEnumItemType.Rol, ['uren_kosten']>[];
-/**
- * @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(changesDelta: ChangesDelta, _itemChanges: TransactionItemHandler['itemChanges']): ConditionResult | undefined;
-    dependency(transaction: TransactionCache, rolIds: ConditionResult): Promise<Dependency>;
-    apply(_changesDelta: ChangesDelta, destinationChangesDelta: ChangesDelta, rolResources: Dependency): void;
-}
-export {};
+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, ['uren_kosten']>[];
+/**
+ * @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(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/src/classes/CacheSyncer.d.ts

@@ -1,70 +1,70 @@
-import { ApiEnumItemType } from '@rentman/backend-types';
-import { AbstractCache, ApiRequestService, CachedQueryItem, ChangesDeltaBase, CollectionQuery, CollectionResource, FieldMap, ItemEntry, ItemTypeMap, ParentChangesDelta, PromiseInterface, PromiseLibraryInterface, QueryMatcherFactory, QueryService } from '../internal';
-export declare type CacheSyncerQueryMap = ItemTypeMap<{
-    [cachedQueryString: string]: {
-        cachedQueryItems: CachedQueryItem[];
-        collectionResources: CollectionResource[];
-    };
-}>;
-declare type CacheSyncerMatchesMapEntry = {
-    query: CollectionQuery;
-    items: ItemEntry[];
-};
-declare type CacheSyncerMatchesMap = ItemTypeMap<{
-    [cachedQueryString: string]: CacheSyncerMatchesMapEntry;
-}>;
-export declare class CacheSyncer {
-    private queryService;
-    private queryMatcherFactory;
-    private apiRequestService;
-    private promiseService;
-    private transaction;
-    private cachedQueryMap;
-    matches: {
-        true: CacheSyncerMatchesMap;
-        false: CacheSyncerMatchesMap;
-        maybe: CacheSyncerMatchesMap;
-    };
-    constructor(queryService: QueryService, queryMatcherFactory: QueryMatcherFactory, apiRequestService: ApiRequestService, promiseService: PromiseLibraryInterface, transaction: AbstractCache, cachedQueryMap: CacheSyncerQueryMap);
-    getMatches<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, queryString: string, type: 'true' | 'false' | 'maybe'): ItemEntry<ItemTypeType>[];
-    /**
-     * Syncing of collections always runs in 3 phases:
-     * - Remove items from collections
-     * - Add items to collections
-     * - Process MAYBE matches
-     * -- Remove MAYBE items from collections
-     * -- Add MAYBE items to collections
-     *
-     * @param isCalledAfterSocketUpdate
-     * @param changesDelta
-     */
-    syncCollections(isCalledAfterSocketUpdate?: boolean, changesDelta?: ChangesDeltaBase): PromiseInterface<void>;
-    /**
-     * Syncing of cached queries runs in 3 phases:
-     * - Remove items from collections
-     * - Add items to collections
-     * - Process MAYBE matches
-     * -- Remove MAYBE items from collections
-     * -- Add MAYBE items to collections
-     *
-     * @param _isCalledAfterSocketUpdate
-     * @param changesDelta
-     */
-    syncCachedQueries(_isCalledAfterSocketUpdate?: boolean, changesDelta?: ChangesDeltaBase): PromiseInterface<void[]>;
-    expand<ItemEntryType extends ItemEntry>(itemEntry: ItemEntryType, fields: FieldMap<ItemEntryType['itemType']>): this;
-    processDelta(parentChangesDelta: ParentChangesDelta): this;
-    _expand<ItemTypeType extends ApiEnumItemType = any>(itemEntry: ItemEntry<ItemTypeType>, matchFunction: (itemType: ItemTypeType, parsedQuery: CollectionQuery) => boolean | 'maybe'): this;
-    /**
-     * Unlike the functions that use a promise accumulator, this function *can* result in a rejection. It should be handled
-     * by the caller.
-     */
-    protected processMaybeMatches<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, query: CollectionQuery, maybeItemEntries: ItemEntry<ItemTypeType>[], changesDelta: ChangesDeltaBase | undefined): PromiseInterface<ItemEntry<ItemTypeType>[]>;
-    /**
-     * Returns null if none of the promises resulted in an exception, or the exception otherwise.
-     */
-    private resolveAll;
-    private addMatchedEntriesToCollections;
-    private processCollectionMaybe;
-    private processCachedQueryMaybe;
-}
-export {};
+import { ApiEnumItemType } from '@rentman/backend-types';
+import { AbstractCache, ApiRequestService, CachedQueryItem, ChangesDeltaBase, CollectionQuery, CollectionResource, FieldMap, ItemEntry, ItemTypeMap, ParentChangesDelta, PromiseInterface, PromiseLibraryInterface, QueryMatcherFactory, QueryService } from '../internal';
+export declare type CacheSyncerQueryMap = ItemTypeMap<{
+    [cachedQueryString: string]: {
+        cachedQueryItems: CachedQueryItem[];
+        collectionResources: CollectionResource[];
+    };
+}>;
+declare type CacheSyncerMatchesMapEntry = {
+    query: CollectionQuery;
+    items: ItemEntry[];
+};
+declare type CacheSyncerMatchesMap = ItemTypeMap<{
+    [cachedQueryString: string]: CacheSyncerMatchesMapEntry;
+}>;
+export declare class CacheSyncer {
+    private queryService;
+    private queryMatcherFactory;
+    private apiRequestService;
+    private promiseService;
+    private transaction;
+    private cachedQueryMap;
+    matches: {
+        true: CacheSyncerMatchesMap;
+        false: CacheSyncerMatchesMap;
+        maybe: CacheSyncerMatchesMap;
+    };
+    constructor(queryService: QueryService, queryMatcherFactory: QueryMatcherFactory, apiRequestService: ApiRequestService, promiseService: PromiseLibraryInterface, transaction: AbstractCache, cachedQueryMap: CacheSyncerQueryMap);
+    getMatches<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, queryString: string, type: 'true' | 'false' | 'maybe'): ItemEntry<ItemTypeType>[];
+    /**
+     * Syncing of collections always runs in 3 phases:
+     * - Remove items from collections
+     * - Add items to collections
+     * - Process MAYBE matches
+     * -- Remove MAYBE items from collections
+     * -- Add MAYBE items to collections
+     *
+     * @param isCalledAfterSocketUpdate
+     * @param changesDelta
+     */
+    syncCollections(isCalledAfterSocketUpdate?: boolean, changesDelta?: ChangesDeltaBase): PromiseInterface<void>;
+    /**
+     * Syncing of cached queries runs in 3 phases:
+     * - Remove items from collections
+     * - Add items to collections
+     * - Process MAYBE matches
+     * -- Remove MAYBE items from collections
+     * -- Add MAYBE items to collections
+     *
+     * @param _isCalledAfterSocketUpdate
+     * @param changesDelta
+     */
+    syncCachedQueries(_isCalledAfterSocketUpdate?: boolean, changesDelta?: ChangesDeltaBase): PromiseInterface<void[]>;
+    expand<ItemEntryType extends ItemEntry>(itemEntry: ItemEntryType, fields: FieldMap<ItemEntryType['itemType']>): this;
+    processDelta(parentChangesDelta: ParentChangesDelta): this;
+    _expand<ItemTypeType extends ApiEnumItemType = any>(itemEntry: ItemEntry<ItemTypeType>, matchFunction: (itemType: ItemTypeType, parsedQuery: CollectionQuery) => boolean | 'maybe'): this;
+    /**
+     * Unlike the functions that use a promise accumulator, this function *can* result in a rejection. It should be handled
+     * by the caller.
+     */
+    protected processMaybeMatches<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, query: CollectionQuery, maybeItemEntries: ItemEntry<ItemTypeType>[], changesDelta: ChangesDeltaBase | undefined): PromiseInterface<ItemEntry<ItemTypeType>[]>;
+    /**
+     * Returns null if none of the promises resulted in an exception, or the exception otherwise.
+     */
+    private resolveAll;
+    private addMatchedEntriesToCollections;
+    private processCollectionMaybe;
+    private processCachedQueryMaybe;
+}
+export {};