@acorex/modules 21.0.0-next.75 → 21.0.0-next.76

package/fesm2022/acorex-modules-maintenance-management.mjs

@@ -1,8 +1,8 @@
 import { AXP_IDENTIFIER_SERVICE, AXP_IDENTIFIER_RULES } from '@acorex/modules/identifier-management';
 import { AXPSessionService, AXP_PERMISSION_DEFINITION_PROVIDER } from '@acorex/platform/auth';
-import { AXPStatusProvider, AXP_MENU_PROVIDER, AXP_SEARCH_PROVIDER, AXP_STATUS_PROVIDERS, AXPSearchCommandProvider, createEntityCommandOptions, createAllQueryView, AXPEntityCommandScope } from '@acorex/platform/common';
-import { applyFilterArray, applySortArray, AXP_MODULE_MANIFEST_PROVIDER, AXP_DATASOURCE_DEFINITION_PROVIDER, provideLazyProvider, AXPSystemActionType, objectKeyValueTransforms } from '@acorex/platform/core';
-import { AXP_ENTITY_STORAGE_BACKEND, AXPEntityStorageService, AXPEntityDefinitionRegistryService, AXPEntityDataSelectorService, AXPEntityService, AXP_ENTITY_STORAGE_MIDDLEWARE, AXP_ENTITY_DEFINITION_LOADER, entityMasterCrudActions, entityMasterRecordActions, entityDetailsCrudActions } from '@acorex/platform/layout/entity';
+import { AXP_MENU_PROVIDER, AXP_SEARCH_PROVIDER, AXP_STATUS_PROVIDERS, AXPSearchCommandProvider, createEntityCommandOptions } from '@acorex/platform/common';
+import { applyFilterArray, applySortArray, AXP_MODULE_MANIFEST_PROVIDER, AXP_DATASOURCE_DEFINITION_PROVIDER, provideLazyProvider } from '@acorex/platform/core';
+import { AXP_ENTITY_STORAGE_BACKEND, AXPEntityStorageService, AXPEntityDefinitionRegistryService, AXPEntityDataSelectorService, AXPEntityService, AXP_ENTITY_STORAGE_MIDDLEWARE, AXP_ENTITY_DEFINITION_LOADER } from '@acorex/platform/layout/entity';
 import { provideCommandSetups } from '@acorex/platform/runtime';
 import * as i0 from '@angular/core';
 import { inject, NgModule } from '@angular/core';
@@ -11,8 +11,8 @@ import { isValidMultiLanguageObject, resolveMultiLanguageString, AXTranslationSe
 import { isString, get, isNumber, defaultTo } from 'lodash-es';
 import { AXDataSource } from '@acorex/cdk/common';
 import { AXPWidgetsCatalog } from '@acorex/platform/layout/widget-core';
-import { AXPCommonMenuKeys, AXPWidgetsList } from '@acorex/modules/common';
-import { RootConfig as RootConfig$1 } from '@acorex/modules/asset-management';
+import { AXPCommonMenuKeys } from '@acorex/modules/common';
+import { createAllQueryView, entityMasterCrudActions, entityMasterRecordActions, AXPWidgetsCatalog as AXPWidgetsCatalog$1, AXPEntityCommandScope, AXPSystemActionType, entityDetailsCrudActions, AXPWidgetsList } from '@acorex/platform/contracts';
 
 //#region ----   Root Configuration   ----
 const config = {
@@ -215,82 +215,6 @@ const RootConfig = {
 };
 //#endregion
 
-//#region ----   Imports   ----
-//#endregion
-//#region ----   Entity Provider   ----
-class AXMMaintenanceManagementEntityProvider {
-    async get(moduleName, entityName) {
-        if (moduleName === RootConfig.module.name) {
-            switch (entityName) {
-                case RootConfig.entities.maintenanceType.name:
-                    return (await Promise.resolve().then(function () { return maintenanceType_entity; })).factory();
-                case RootConfig.entities.maintenanceTemplate.name:
-                    return (await import('./acorex-modules-maintenance-management-maintenance-template.entity-B9Jp4r3m.mjs')).factory();
-                case RootConfig.entities.maintenancePlan.name:
-                    return (await Promise.resolve().then(function () { return index$8; })).maintenancePlanEntityFactory();
-                case RootConfig.entities.workPackage.name:
-                    return (await Promise.resolve().then(function () { return index$7; })).workPackageEntityFactory();
-                case RootConfig.entities.workOrder.name:
-                    return (await Promise.resolve().then(function () { return index$6; })).workOrderEntityFactory();
-                case RootConfig.entities.workReport.name:
-                    return (await Promise.resolve().then(function () { return index$5; })).workReportEntityFactory();
-                case RootConfig.entities.maintenanceTemplateActivityType.name:
-                    return (await Promise.resolve().then(function () { return index$4; }))
-                        .maintenanceTemplateActivityTypeEntityFactory();
-                case RootConfig.entities.maintenanceTemplateResource.name:
-                    return (await Promise.resolve().then(function () { return index$2; })).maintenanceTemplateResourceEntityFactory();
-                case RootConfig.entities.maintenanceTemplateFailureMode.name:
-                    return (await Promise.resolve().then(function () { return index$3; })).maintenanceTemplateFailureModeEntityFactory();
-                case RootConfig.entities.activityType.name:
-                    return (await Promise.resolve().then(function () { return activityType_entity; })).factory();
-                case RootConfig.entities.activityTypeAssetType.name:
-                    return (await Promise.resolve().then(function () { return index$1; })).activityTypeAssetTypeEntityFactory();
-                case RootConfig.entities.activityTypeResource.name:
-                    return (await Promise.resolve().then(function () { return index; })).activityTypeResourceEntityFactory();
-                case RootConfig.entities.failureCause.name:
-                    return (await Promise.resolve().then(function () { return failureCause_entity; })).factory();
-                case RootConfig.entities.failureMechanism.name:
-                    return (await Promise.resolve().then(function () { return failureMechanism_entity; })).factory();
-                case RootConfig.entities.failureDetection.name:
-                    return (await Promise.resolve().then(function () { return failureDetection_entity; })).factory();
-                case RootConfig.entities.failureType.name:
-                    return (await Promise.resolve().then(function () { return failureType_entity; })).factory();
-                case RootConfig.entities.failureMode.name:
-                    return (await Promise.resolve().then(function () { return failureMode_entity; })).factory();
-                case RootConfig.entities.failureModeAssetType.name:
-                    return (await Promise.resolve().then(function () { return failureModeAssetType_entity; })).factory();
-                case RootConfig.entities.failureModeMechanism.name:
-                    return (await Promise.resolve().then(function () { return failureModeMechanism_entity; })).factory();
-                case RootConfig.entities.failureModeSolution.name:
-                    return (await Promise.resolve().then(function () { return failureModeSolution_entity; })).factory();
-                case RootConfig.entities.failureEffect.name:
-                    return (await Promise.resolve().then(function () { return failureEffect_entity; })).factory();
-                case RootConfig.entities.failureSeverity.name:
-                    return (await Promise.resolve().then(function () { return failureSeverity_entity; })).factory();
-                case RootConfig.entities.failureRegister.name:
-                    return (await Promise.resolve().then(function () { return failureRegister_entity; })).factory();
-                case RootConfig.entities.failureRegisterEffect.name:
-                    return (await Promise.resolve().then(function () { return failureRegisterEffect_entity; })).factory();
-                case RootConfig.entities.failureRegisterCause.name:
-                    return (await Promise.resolve().then(function () { return failureRegisterCause_entity; })).factory();
-                case RootConfig.entities.failureRegisterMechanism.name:
-                    return (await Promise.resolve().then(function () { return failureRegisterMechanism_entity; })).factory();
-            }
-        }
-        return null;
-    }
-    async list() {
-        const m = RootConfig.module.name;
-        return Promise.resolve(Object.values(RootConfig.entities).map((e) => ({ name: e.name, module: m })));
-    }
-}
-//#endregion
-
-var entity_provider = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    AXMMaintenanceManagementEntityProvider: AXMMaintenanceManagementEntityProvider
-});
-
 //#region ---- Datasource keys ----
 /** Maintenance Management datasource registry names. */
 const AXMMaintenanceManagementDataSourceKeys = {
@@ -483,9 +407,98 @@ const AXMMaintenanceManagementPermissionKeys = {
     },
 };
 
+//#region ---- Status names ----
+var AXMWorkOrderStatus;
+(function (AXMWorkOrderStatus) {
+    AXMWorkOrderStatus["Planned"] = "planned";
+    AXMWorkOrderStatus["Scheduled"] = "scheduled";
+    AXMWorkOrderStatus["Assigned"] = "assigned";
+    AXMWorkOrderStatus["InProgress"] = "in-progress";
+    AXMWorkOrderStatus["OnHold"] = "on-hold";
+    AXMWorkOrderStatus["Completed"] = "completed";
+    AXMWorkOrderStatus["SignedOff"] = "signed-off";
+    AXMWorkOrderStatus["Cancelled"] = "cancelled";
+})(AXMWorkOrderStatus || (AXMWorkOrderStatus = {}));
+//#endregion
+
 //#region ---- Contracts barrel ----
 //#endregion
 
+//#region ----   Imports   ----
+//#endregion
+//#region ----   Entity Provider   ----
+class AXMMaintenanceManagementEntityProvider {
+    async get(moduleName, entityName) {
+        if (moduleName === RootConfig.module.name) {
+            switch (entityName) {
+                case RootConfig.entities.maintenanceType.name:
+                    return (await Promise.resolve().then(function () { return index$p; })).factoryMaintenanceType();
+                case RootConfig.entities.maintenanceTemplate.name:
+                    return (await Promise.resolve().then(function () { return index$o; })).factoryMaintenanceTemplate();
+                case RootConfig.entities.maintenancePlan.name:
+                    return (await Promise.resolve().then(function () { return index$n; })).maintenancePlanEntityFactory();
+                case RootConfig.entities.workPackage.name:
+                    return (await Promise.resolve().then(function () { return index$m; })).workPackageEntityFactory();
+                case RootConfig.entities.workOrder.name:
+                    return (await Promise.resolve().then(function () { return index$l; })).workOrderEntityFactory();
+                case RootConfig.entities.workReport.name:
+                    return (await Promise.resolve().then(function () { return index$k; })).workReportEntityFactory();
+                case RootConfig.entities.maintenanceTemplateActivityType.name:
+                    return (await Promise.resolve().then(function () { return index$j; })).factoryMaintenanceTemplateActivityType();
+                case RootConfig.entities.maintenanceTemplateResource.name:
+                    return (await Promise.resolve().then(function () { return index$h; })).maintenanceTemplateResourceEntityFactory();
+                case RootConfig.entities.maintenanceTemplateFailureMode.name:
+                    return (await Promise.resolve().then(function () { return index$i; })).maintenanceTemplateFailureModeEntityFactory();
+                case RootConfig.entities.activityType.name:
+                    return (await Promise.resolve().then(function () { return index$g; })).factoryActivityType();
+                case RootConfig.entities.activityTypeAssetType.name:
+                    return (await Promise.resolve().then(function () { return index$f; })).factoryActivityTypeAssetType();
+                case RootConfig.entities.activityTypeResource.name:
+                    return (await Promise.resolve().then(function () { return index$e; })).factoryActivityTypeResource();
+                case RootConfig.entities.failureCause.name:
+                    return (await Promise.resolve().then(function () { return index$d; })).factoryFailureCause();
+                case RootConfig.entities.failureMechanism.name:
+                    return (await Promise.resolve().then(function () { return index$c; })).factoryFailureMechanism();
+                case RootConfig.entities.failureDetection.name:
+                    return (await Promise.resolve().then(function () { return index$b; })).factoryFailureDetection();
+                case RootConfig.entities.failureType.name:
+                    return (await Promise.resolve().then(function () { return index$a; })).factoryFailureType();
+                case RootConfig.entities.failureMode.name:
+                    return (await Promise.resolve().then(function () { return index$9; })).factoryFailureMode();
+                case RootConfig.entities.failureModeAssetType.name:
+                    return (await Promise.resolve().then(function () { return index$5; })).factoryFailureModeAssetType();
+                case RootConfig.entities.failureModeMechanism.name:
+                    return (await Promise.resolve().then(function () { return index$4; })).factoryFailureModeMechanism();
+                case RootConfig.entities.failureModeSolution.name:
+                    return (await Promise.resolve().then(function () { return index$6; })).factoryFailureModeSolution();
+                case RootConfig.entities.failureEffect.name:
+                    return (await Promise.resolve().then(function () { return index$8; })).factoryFailureEffect();
+                case RootConfig.entities.failureSeverity.name:
+                    return (await Promise.resolve().then(function () { return index$7; })).factoryFailureSeverity();
+                case RootConfig.entities.failureRegister.name:
+                    return (await Promise.resolve().then(function () { return index$3; })).factoryFailureRegister();
+                case RootConfig.entities.failureRegisterEffect.name:
+                    return (await Promise.resolve().then(function () { return index$1; })).factoryFailureRegisterEffect();
+                case RootConfig.entities.failureRegisterCause.name:
+                    return (await Promise.resolve().then(function () { return index$2; })).factoryFailureRegisterCause();
+                case RootConfig.entities.failureRegisterMechanism.name:
+                    return (await Promise.resolve().then(function () { return index; })).factoryFailureRegisterMechanism();
+            }
+        }
+        return null;
+    }
+    async list() {
+        const m = RootConfig.module.name;
+        return Promise.resolve(Object.values(RootConfig.entities).map((e) => ({ name: e.name, module: m })));
+    }
+}
+//#endregion
+
+var entity_provider = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    AXMMaintenanceManagementEntityProvider: AXMMaintenanceManagementEntityProvider
+});
+
 const AXM_FAILURE_REGISTER_CODE_IDENTIFIER_RULE = {
     id: 'failure-register-code',
     title: 'Failure Register Code',
@@ -548,201 +561,6 @@ const MaintenanceManagementManifest = {
 };
 //#endregion
 
-//#region ----   Imports   ----
-//#endregion
-//#region ----   Status names   ----
-var AXMWorkOrderStatus;
-(function (AXMWorkOrderStatus) {
-    AXMWorkOrderStatus["Planned"] = "planned";
-    AXMWorkOrderStatus["Scheduled"] = "scheduled";
-    AXMWorkOrderStatus["Assigned"] = "assigned";
-    AXMWorkOrderStatus["InProgress"] = "in-progress";
-    AXMWorkOrderStatus["OnHold"] = "on-hold";
-    AXMWorkOrderStatus["Completed"] = "completed";
-    AXMWorkOrderStatus["SignedOff"] = "signed-off";
-    AXMWorkOrderStatus["Cancelled"] = "cancelled";
-})(AXMWorkOrderStatus || (AXMWorkOrderStatus = {}));
-//#endregion
-//#region ----   Status provider   ----
-class AXMMaintenanceManagementWorkOrderStatusProvider extends AXPStatusProvider {
-    constructor() {
-        super(...arguments);
-        this.key = 'maintenance-management.status.work-order';
-        this.statuses = [
-            {
-                name: AXMWorkOrderStatus.Planned,
-                title: '@maintenance-management:work-orders.states.planned',
-                icon: 'fa-light fa-clipboard-list',
-                color: 'secondary',
-                order: 1,
-                isInitial: true,
-                isFinal: false,
-                generateView: true,
-            },
-            {
-                name: AXMWorkOrderStatus.Scheduled,
-                title: '@maintenance-management:work-orders.states.scheduled',
-                icon: 'fa-light fa-calendar-clock',
-                color: 'info',
-                order: 2,
-                isInitial: false,
-                isFinal: false,
-                generateView: true,
-            },
-            {
-                name: AXMWorkOrderStatus.Assigned,
-                title: '@maintenance-management:work-orders.states.assigned',
-                icon: 'fa-light fa-user-check',
-                color: 'info',
-                order: 3,
-                isInitial: false,
-                isFinal: false,
-                generateView: true,
-            },
-            {
-                name: AXMWorkOrderStatus.InProgress,
-                title: '@maintenance-management:work-orders.states.in-progress',
-                icon: 'fa-light fa-screwdriver-wrench',
-                color: 'warning',
-                order: 4,
-                isInitial: false,
-                isFinal: false,
-                generateView: true,
-            },
-            {
-                name: AXMWorkOrderStatus.OnHold,
-                title: '@maintenance-management:work-orders.states.on-hold',
-                icon: 'fa-light fa-pause',
-                color: 'warning',
-                order: 5,
-                isInitial: false,
-                isFinal: false,
-                generateView: true,
-            },
-            {
-                name: AXMWorkOrderStatus.Completed,
-                title: '@maintenance-management:work-orders.states.completed',
-                icon: 'fa-light fa-circle-check',
-                color: 'success',
-                order: 6,
-                isInitial: false,
-                isFinal: false,
-                generateView: true,
-            },
-            {
-                name: AXMWorkOrderStatus.SignedOff,
-                title: '@maintenance-management:work-orders.states.signed-off',
-                icon: 'fa-light fa-file-signature',
-                color: 'success',
-                order: 7,
-                isInitial: false,
-                isFinal: true,
-                generateView: true,
-            },
-            {
-                name: AXMWorkOrderStatus.Cancelled,
-                title: '@maintenance-management:work-orders.states.cancelled',
-                icon: 'fa-light fa-ban',
-                color: 'neutral',
-                order: 8,
-                isInitial: false,
-                isFinal: true,
-                generateView: true,
-            },
-        ];
-        this.transitions = [
-            {
-                from: AXMWorkOrderStatus.Planned,
-                to: AXMWorkOrderStatus.Scheduled,
-                title: '@maintenance-management:work-orders.status.transitions.schedule',
-            },
-            {
-                from: AXMWorkOrderStatus.Planned,
-                to: AXMWorkOrderStatus.Assigned,
-                title: '@maintenance-management:work-orders.status.transitions.assign',
-            },
-            {
-                from: AXMWorkOrderStatus.Planned,
-                to: AXMWorkOrderStatus.Cancelled,
-                title: '@maintenance-management:work-orders.status.transitions.cancel',
-            },
-            {
-                from: AXMWorkOrderStatus.Scheduled,
-                to: AXMWorkOrderStatus.Assigned,
-                title: '@maintenance-management:work-orders.status.transitions.assign',
-            },
-            {
-                from: AXMWorkOrderStatus.Scheduled,
-                to: AXMWorkOrderStatus.InProgress,
-                title: '@maintenance-management:work-orders.status.transitions.start-work',
-            },
-            {
-                from: AXMWorkOrderStatus.Scheduled,
-                to: AXMWorkOrderStatus.Cancelled,
-                title: '@maintenance-management:work-orders.status.transitions.cancel',
-            },
-            {
-                from: AXMWorkOrderStatus.Assigned,
-                to: AXMWorkOrderStatus.InProgress,
-                title: '@maintenance-management:work-orders.status.transitions.start-work',
-            },
-            {
-                from: AXMWorkOrderStatus.Assigned,
-                to: AXMWorkOrderStatus.Scheduled,
-                title: '@maintenance-management:work-orders.status.transitions.reschedule',
-            },
-            {
-                from: AXMWorkOrderStatus.Assigned,
-                to: AXMWorkOrderStatus.Cancelled,
-                title: '@maintenance-management:work-orders.status.transitions.cancel',
-            },
-            {
-                from: AXMWorkOrderStatus.InProgress,
-                to: AXMWorkOrderStatus.OnHold,
-                title: '@maintenance-management:work-orders.status.transitions.put-on-hold',
-            },
-            {
-                from: AXMWorkOrderStatus.InProgress,
-                to: AXMWorkOrderStatus.Completed,
-                title: '@maintenance-management:work-orders.status.transitions.complete',
-            },
-            {
-                from: AXMWorkOrderStatus.InProgress,
-                to: AXMWorkOrderStatus.Cancelled,
-                title: '@maintenance-management:work-orders.status.transitions.cancel',
-            },
-            {
-                from: AXMWorkOrderStatus.OnHold,
-                to: AXMWorkOrderStatus.InProgress,
-                title: '@maintenance-management:work-orders.status.transitions.resume',
-            },
-            {
-                from: AXMWorkOrderStatus.OnHold,
-                to: AXMWorkOrderStatus.Cancelled,
-                title: '@maintenance-management:work-orders.status.transitions.cancel',
-            },
-            {
-                from: AXMWorkOrderStatus.Completed,
-                to: AXMWorkOrderStatus.SignedOff,
-                title: '@maintenance-management:work-orders.status.transitions.sign-off',
-            },
-            {
-                from: AXMWorkOrderStatus.Completed,
-                to: AXMWorkOrderStatus.InProgress,
-                title: '@maintenance-management:work-orders.status.transitions.reopen',
-            },
-        ];
-        this.defaultStatus = AXMWorkOrderStatus.Planned;
-    }
-}
-//#endregion
-
-var workOrderStatus_provider = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    AXMMaintenanceManagementWorkOrderStatusProvider: AXMMaintenanceManagementWorkOrderStatusProvider,
-    get AXMWorkOrderStatus () { return AXMWorkOrderStatus; }
-});
-
 //#region ----   Imports   ----
 //#endregion
 //#region ----   Identifier rules   ----
@@ -1723,8 +1541,8 @@ class AXMMaintenanceManagementModule {
             provideLazyProvider(AXP_MENU_PROVIDER, () => Promise.resolve().then(function () { return menu_provider; }).then((m) => m.AXMMaintenanceManagementMenuProvider)),
             provideLazyProvider(AXP_ENTITY_DEFINITION_LOADER, () => Promise.resolve().then(function () { return entity_provider; }).then((m) => m.AXMMaintenanceManagementEntityProvider)),
             provideLazyProvider(AXP_SEARCH_PROVIDER, () => Promise.resolve().then(function () { return searchCommand_provider; }).then((m) => m.AXMMaintenanceManagementSearchCommandProvider)),
-            provideLazyProvider(AXP_STATUS_PROVIDERS, () => import('./acorex-modules-maintenance-management-failure-register-status.provider-B8-Snxbx.mjs').then((m) => m.AXMMaintenanceManagementFailureRegisterStatusProvider)),
-            provideLazyProvider(AXP_STATUS_PROVIDERS, () => Promise.resolve().then(function () { return workOrderStatus_provider; }).then((m) => m.AXMMaintenanceManagementWorkOrderStatusProvider)),
+            provideLazyProvider(AXP_STATUS_PROVIDERS, () => import('./acorex-modules-maintenance-management-failure-register-status.provider-DM5m-VsU.mjs').then((m) => m.AXMMaintenanceManagementFailureRegisterStatusProvider)),
+            provideLazyProvider(AXP_STATUS_PROVIDERS, () => import('./acorex-modules-maintenance-management-work-order-status.provider-BvnpsgY3.mjs').then((m) => m.AXMMaintenanceManagementWorkOrderStatusProvider)),
             provideCommandSetups([
                 {
                     key: 'Entity:List',
@@ -1789,8 +1607,8 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImpor
                         provideLazyProvider(AXP_MENU_PROVIDER, () => Promise.resolve().then(function () { return menu_provider; }).then((m) => m.AXMMaintenanceManagementMenuProvider)),
                         provideLazyProvider(AXP_ENTITY_DEFINITION_LOADER, () => Promise.resolve().then(function () { return entity_provider; }).then((m) => m.AXMMaintenanceManagementEntityProvider)),
                         provideLazyProvider(AXP_SEARCH_PROVIDER, () => Promise.resolve().then(function () { return searchCommand_provider; }).then((m) => m.AXMMaintenanceManagementSearchCommandProvider)),
-                        provideLazyProvider(AXP_STATUS_PROVIDERS, () => import('./acorex-modules-maintenance-management-failure-register-status.provider-B8-Snxbx.mjs').then((m) => m.AXMMaintenanceManagementFailureRegisterStatusProvider)),
-                        provideLazyProvider(AXP_STATUS_PROVIDERS, () => Promise.resolve().then(function () { return workOrderStatus_provider; }).then((m) => m.AXMMaintenanceManagementWorkOrderStatusProvider)),
+                        provideLazyProvider(AXP_STATUS_PROVIDERS, () => import('./acorex-modules-maintenance-management-failure-register-status.provider-DM5m-VsU.mjs').then((m) => m.AXMMaintenanceManagementFailureRegisterStatusProvider)),
+                        provideLazyProvider(AXP_STATUS_PROVIDERS, () => import('./acorex-modules-maintenance-management-work-order-status.provider-BvnpsgY3.mjs').then((m) => m.AXMMaintenanceManagementWorkOrderStatusProvider)),
                         provideCommandSetups([
                             {
                                 key: 'Entity:List',
@@ -2371,17 +2189,13 @@ var searchCommand_provider = /*#__PURE__*/Object.freeze({
     AXMMaintenanceManagementSearchCommandProvider: AXMMaintenanceManagementSearchCommandProvider
 });
 
-//#region ----   Types   ----
-//#endregion
-
-//#region ----   Imports   ----
 //#endregion
 //#region ----   Entity Factory   ----
 /**
  * Entity definition aligned with {@link AXMMaintenanceManagementMaintenanceTypeEntityModel}.
  * `code` is generated via the `identifier` plugin and {@link AXM_MAINTENANCE_TYPE_CODE_IDENTIFIER_RULE}.
  */
-async function factory$i() {
+async function factoryMaintenanceType() {
     const entityDef = {
         module: RootConfig.module.name,
         name: RootConfig.entities.maintenanceType.name,
@@ -2424,7 +2238,7 @@ async function factory$i() {
                     dataType: 'string',
                     unique: { enabled: true },
                     interface: {
-                        type: AXPWidgetsCatalog.text,
+                        type: AXPWidgetsCatalog$1.text,
                         options: {
                             disabled: true,
                         },
@@ -2453,7 +2267,7 @@ async function factory$i() {
                 schema: {
                     dataType: 'string',
                     interface: {
-                        type: AXPWidgetsCatalog.text,
+                        type: AXPWidgetsCatalog$1.text,
                         options: {
                             placeholder: '@maintenance-management:maintenance-types.entities.maintenance-type.fields.title.placeholder',
                         },
@@ -2467,56 +2281,495 @@ async function factory$i() {
                 groupId: 'basic-info',
                 options: {
                     sort: { enabled: false },
-                    filter: {
-                        advance: { enabled: false },
-                        inline: { enabled: false },
-                    },
+                    filter: {
+                        advance: { enabled: false },
+                        inline: { enabled: false },
+                    },
+                },
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsCatalog$1.largeText,
+                        options: {
+                            placeholder: '@maintenance-management:maintenance-types.entities.maintenance-type.fields.description.placeholder',
+                        },
+                    },
+                },
+            },
+            {
+                name: 'autoGeneratePlan',
+                title: '@maintenance-management:maintenance-types.entities.maintenance-type.fields.autoGeneratePlan.title',
+                groupId: 'plan-scheduling',
+                options: {
+                    sort: { enabled: true },
+                    filter: {
+                        advance: { enabled: true },
+                        inline: { enabled: true },
+                    },
+                },
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsCatalog$1.toggle,
+                        options: {},
+                    },
+                },
+            },
+            {
+                name: 'hasSchedule',
+                title: '@maintenance-management:maintenance-types.entities.maintenance-type.fields.hasSchedule.title',
+                groupId: 'plan-scheduling',
+                options: {
+                    sort: { enabled: true },
+                    filter: {
+                        advance: { enabled: true },
+                        inline: { enabled: true },
+                    },
+                },
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsCatalog$1.toggle,
+                        options: {},
+                    },
+                },
+            },
+        ],
+        columns: [
+            { name: 'code' },
+            { name: 'title' },
+            { name: 'description' },
+            { name: 'autoGeneratePlan' },
+            { name: 'hasSchedule' },
+        ],
+        interfaces: {
+            master: {
+                create: {
+                    sections: [{ id: 'basic-info' }, { id: 'plan-scheduling' }],
+                    properties: [
+                        { name: 'code', layout: { positions: { lg: { colSpan: 6, order: 1 } } } },
+                        { name: 'title', layout: { positions: { lg: { colSpan: 6, order: 2 } } } },
+                        { name: 'description', layout: { positions: { lg: { colSpan: 12, order: 3 } } } },
+                        { name: 'autoGeneratePlan', layout: { positions: { lg: { colSpan: 6, order: 4 } } } },
+                        { name: 'hasSchedule', layout: { positions: { lg: { colSpan: 6, order: 5 } } } },
+                    ],
+                },
+                update: {
+                    sections: [{ id: 'basic-info' }, { id: 'plan-scheduling' }],
+                    properties: [
+                        { name: 'code', layout: { positions: { lg: { colSpan: 6, order: 1 } } } },
+                        { name: 'title', layout: { positions: { lg: { colSpan: 6, order: 2 } } } },
+                        { name: 'description', layout: { positions: { lg: { colSpan: 12, order: 3 } } } },
+                        { name: 'autoGeneratePlan', layout: { positions: { lg: { colSpan: 6, order: 4 } } } },
+                        { name: 'hasSchedule', layout: { positions: { lg: { colSpan: 6, order: 5 } } } },
+                    ],
+                },
+                single: {
+                    title: '{{ title }}',
+                    sections: [{ id: 'basic-info' }, { id: 'plan-scheduling' }],
+                    properties: [
+                        { name: 'code', layout: { positions: { lg: { colSpan: 6, order: 1 } } } },
+                        { name: 'title', layout: { positions: { lg: { colSpan: 6, order: 2 } } } },
+                        { name: 'description', layout: { positions: { lg: { colSpan: 12, order: 3 } } } },
+                        { name: 'autoGeneratePlan', layout: { positions: { lg: { colSpan: 6, order: 4 } } } },
+                        { name: 'hasSchedule', layout: { positions: { lg: { colSpan: 6, order: 5 } } } },
+                    ],
+                    actions: [...entityMasterRecordActions()],
+                },
+                list: {
+                    actions: [...entityMasterCrudActions()],
+                    views: [
+                        createAllQueryView({
+                            sorts: [{ name: 'title', dir: 'asc' }],
+                        }),
+                    ],
+                },
+            },
+        },
+    };
+    return entityDef;
+}
+//#endregion
+
+//#endregion
+
+var index$p = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    factoryMaintenanceType: factoryMaintenanceType
+});
+
+//#endregion
+//#region ----   Factory   ----
+async function factoryMaintenanceTemplate() {
+    const entityDef = {
+        module: RootConfig.module.name,
+        name: RootConfig.entities.maintenanceTemplate.name,
+        title: RootConfig.entities.maintenanceTemplate.title,
+        icon: RootConfig.entities.maintenanceTemplate.icon,
+        plugins: [
+            { name: 'history' },
+            { name: 'identifier', options: { field: 'code', rule: 'maintenance-template-code' } },
+            { name: 'unique-fields', options: { fields: 'code', scope: 'global' } },
+            //{ name: 'meta-data-builder' },
+            { name: 'archive' },
+        ],
+        formats: {
+            individual: RootConfig.entities.maintenanceTemplate.title,
+            plural: RootConfig.entities.maintenanceTemplate.titlePlural,
+            searchResult: {
+                title: '{{ title }}',
+                description: '{{ code }}',
+            },
+        },
+        relatedEntities: [
+            {
+                entity: `${RootConfig.module.name}.${RootConfig.entities.maintenanceTemplateActivityType.name}`,
+                title: '@maintenance-management:maintenance-templates.entities.maintenance-template.related-entities.activity-types.title',
+                columns: ['activityTypeId', 'sequenceNo', 'isMainActivity', 'needShutdown', 'estimatedMinutes'],
+                conditions: [{ name: 'maintenanceTemplateId', operator: { type: 'equal' }, value: '{{ context.eval("id") }}' }],
+                actions: [
+                    {
+                        title: '@general:actions.create.title',
+                        command: {
+                            name: 'Entity:Create',
+                            options: {
+                                process: {
+                                    redirect: false,
+                                    canCreateNewOne: true,
+                                    data: {
+                                        maintenanceTemplateId: '{{ context.eval("id") }}',
+                                    },
+                                },
+                            },
+                        },
+                        priority: 'primary',
+                        type: AXPSystemActionType.Create,
+                        scope: AXPEntityCommandScope.TypeLevel,
+                    },
+                    ...entityDetailsCrudActions('maintenanceTemplateId', { create: false }),
+                ],
+                excludeProperties: ['maintenanceTemplateId'],
+                layout: {
+                    type: 'page-list',
+                },
+            },
+        ],
+        groups: [
+            { id: 'basic-info', title: '@general:terms.interface.basic-info' },
+            {
+                id: 'configuration',
+                title: '@maintenance-management:maintenance-templates.entities.maintenance-template.groups.configuration',
+            },
+            {
+                id: 'execution',
+                title: '@maintenance-management:maintenance-templates.entities.maintenance-template.groups.execution',
+            },
+            {
+                id: 'assessment-compliance',
+                title: '@maintenance-management:maintenance-templates.entities.maintenance-template.groups.assessment-compliance',
+            },
+            {
+                id: 'scheduling',
+                title: '@maintenance-management:maintenance-templates.entities.maintenance-template.groups.scheduling',
+            },
+        ],
+        properties: [
+            {
+                name: 'id',
+                title: 'ID',
+                schema: { dataType: 'uuid', visible: false, nullable: false, readonly: true, unique: { enabled: true } },
+            },
+            {
+                name: 'code',
+                title: '@maintenance-management:maintenance-templates.entities.maintenance-template.fields.code.title',
+                groupId: 'basic-info',
+                options: {
+                    sort: { enabled: true },
+                    filter: { advance: { enabled: true }, inline: { enabled: true } },
+                },
+                schema: {
+                    dataType: 'string',
+                    unique: { enabled: true },
+                    interface: {
+                        type: AXPWidgetsCatalog$1.text,
+                        options: {
+                            disabled: true,
+                            placeholder: '@maintenance-management:maintenance-templates.entities.maintenance-template.fields.code.placeholder',
+                        },
+                    },
+                },
+                validations: [{ rule: 'required' }],
+            },
+            {
+                name: 'title',
+                title: '@maintenance-management:maintenance-templates.entities.maintenance-template.fields.title.title',
+                groupId: 'basic-info',
+                options: {
+                    sort: { enabled: true },
+                    filter: { advance: { enabled: true }, inline: { enabled: true } },
+                },
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsCatalog$1.text,
+                        options: {
+                            placeholder: '@maintenance-management:maintenance-templates.entities.maintenance-template.fields.title.placeholder',
+                        },
+                    },
+                },
+                validations: [{ rule: 'required' }],
+            },
+            {
+                name: 'description',
+                title: '@general:terms.common.description',
+                groupId: 'basic-info',
+                options: {
+                    sort: { enabled: false },
+                    filter: { advance: { enabled: false }, inline: { enabled: false } },
+                },
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsCatalog$1.largeText,
+                        options: {
+                            placeholder: '@maintenance-management:maintenance-templates.entities.maintenance-template.fields.description.placeholder',
+                        },
+                    },
+                },
+            },
+            {
+                name: 'assetTypeId',
+                title: '@maintenance-management:maintenance-templates.entities.maintenance-template.fields.asset-type-id.title',
+                groupId: 'configuration',
+                options: {
+                    sort: { enabled: true },
+                    filter: { advance: { enabled: true }, inline: { enabled: true } },
+                },
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsCatalog$1.lookup,
+                        triggers: [
+                            {
+                                event: "{{ events.context('assetTypeId') }}",
+                                action: '{{ context.set("metadataIds", null); widget.refresh(); }}',
+                            },
+                        ],
+                        options: {
+                            look: 'select',
+                            entity: 'AssetManagement.AssetType',
+                            textField: 'title',
+                            valueField: 'id',
+                            disabled: true,
+                            expose: [
+                                { source: 'id', target: 'assetType.id' },
+                                { source: 'title', target: 'assetType.title' },
+                                { source: 'maintenanceTypeIds', target: 'assetType.maintenanceTypeIds' },
+                            ],
+                        },
+                    },
+                },
+                validations: [{ rule: 'required' }],
+            },
+            {
+                name: 'maintenanceTypeId',
+                title: '@maintenance-management:maintenance-templates.entities.maintenance-template.fields.maintenance-type-id.title',
+                groupId: 'configuration',
+                options: {
+                    sort: { enabled: true },
+                    filter: { advance: { enabled: true }, inline: { enabled: true } },
+                },
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsCatalog$1.lookup,
+                        triggers: [
+                            {
+                                event: "{{ events.context('maintenanceTypeId') }}",
+                                action: '{{ context.set("metadataIds", null); const fromType = (v) => [true, "true", 1, "1"].includes(v); if (!context.eval("maintenanceTypeId")) { context.set("hasSchedule", false); context.set("autoGeneratePlan", false); return; } if (context.eval("maintenanceType.id") !== context.eval("maintenanceTypeId")) return; context.set("hasSchedule", fromType(context.eval("maintenanceType.hasSchedule"))); context.set("autoGeneratePlan", fromType(context.eval("maintenanceType.autoGeneratePlan"))); }}',
+                            },
+                            {
+                                event: "{{ events.context('assetTypeId') }}",
+                                action: '{{ widget.setValue(null); context.set("maintenanceType", null); context.set("hasSchedule", false); context.set("autoGeneratePlan", false); widget.refresh(); }}',
+                            },
+                        ],
+                        options: {
+                            look: 'select',
+                            hasClearButton: true,
+                            disabled: '{{ !context.eval("assetTypeId") }}',
+                            entity: `${RootConfig.module.name}.${RootConfig.entities.maintenanceType.name}`,
+                            textField: 'title',
+                            valueField: 'id',
+                            filter: {
+                                field: 'id',
+                                operator: { type: 'in' },
+                                value: '{{ context.eval("assetType.maintenanceTypeIds") || [] }}',
+                            },
+                            expose: [
+                                { source: 'id', target: 'maintenanceType.id' },
+                                { source: 'title', target: 'maintenanceType.title' },
+                                { source: 'hasSchedule', target: 'maintenanceType.hasSchedule' },
+                                { source: 'autoGeneratePlan', target: 'maintenanceType.autoGeneratePlan' },
+                            ],
+                        },
+                    },
+                },
+                validations: [{ rule: 'required' }],
+            },
+            {
+                name: 'autoGeneratePlan',
+                title: '@maintenance-management:maintenance-templates.entities.maintenance-template.fields.auto-generate-plan.title',
+                groupId: 'configuration',
+                options: {
+                    sort: { enabled: true },
+                    filter: { advance: { enabled: true }, inline: { enabled: true } },
+                },
+                schema: {
+                    dataType: 'boolean',
+                    defaultValue: false,
+                    interface: { type: AXPWidgetsCatalog$1.toggle, options: {} },
+                },
+            },
+            {
+                name: 'hasSchedule',
+                title: '@maintenance-management:maintenance-templates.entities.maintenance-template.fields.has-schedule.title',
+                groupId: 'configuration',
+                options: {
+                    sort: { enabled: true },
+                    filter: { advance: { enabled: true }, inline: { enabled: true } },
+                },
+                schema: {
+                    dataType: 'boolean',
+                    defaultValue: false,
+                    interface: { type: AXPWidgetsCatalog$1.toggle, options: {} },
+                },
+            },
+            {
+                name: 'needPermission',
+                title: '@maintenance-management:maintenance-templates.entities.maintenance-template.fields.work-permit.title',
+                groupId: 'configuration',
+                options: {
+                    sort: { enabled: true },
+                    filter: { advance: { enabled: true }, inline: { enabled: true } },
+                },
+                schema: {
+                    dataType: 'boolean',
+                    defaultValue: false,
+                    interface: { type: AXPWidgetsCatalog$1.toggle, options: {} },
+                },
+            },
+            {
+                name: 'needShutdown',
+                title: '@maintenance-management:maintenance-templates.entities.maintenance-template.fields.need-shutdown.title',
+                groupId: 'configuration',
+                options: {
+                    sort: { enabled: true },
+                    filter: { advance: { enabled: true }, inline: { enabled: true } },
+                },
+                schema: {
+                    dataType: 'boolean',
+                    defaultValue: false,
+                    interface: { type: AXPWidgetsCatalog$1.toggle, options: {} },
+                },
+            },
+            {
+                name: 'estimatedMinutes',
+                title: '@maintenance-management:maintenance-templates.entities.maintenance-template.fields.estimated-minutes.title',
+                groupId: 'configuration',
+                options: {
+                    sort: { enabled: true },
+                    filter: { advance: { enabled: true }, inline: { enabled: false } },
+                },
+                schema: {
+                    dataType: 'number',
+                    interface: {
+                        type: AXPWidgetsCatalog$1.number,
+                        options: {
+                            min: 0,
+                            placeholder: '@maintenance-management:maintenance-templates.entities.maintenance-template.fields.estimated-minutes.placeholder',
+                        },
+                    },
+                },
+            },
+            {
+                name: 'metadataIds',
+                title: '@maintenance-management:maintenance-templates.entities.maintenance-template.fields.metadata-ids.title',
+                groupId: 'configuration',
+                options: {
+                    sort: { enabled: false },
+                    filter: { advance: { enabled: false }, inline: { enabled: false } },
                 },
                 schema: {
-                    dataType: 'string',
+                    dataType: 'array',
                     interface: {
-                        type: AXPWidgetsCatalog.largeText,
+                        type: AXPWidgetsCatalog$1.select,
                         options: {
-                            placeholder: '@maintenance-management:maintenance-types.entities.maintenance-type.fields.description.placeholder',
+                            look: 'lookup',
+                            multiple: true,
+                            allowSearch: true,
+                            hasClearButton: true,
+                            disabled: '{{ !context.eval("assetTypeId") }}',
+                            dataSource: AXMMaintenanceManagementDataSourceKeys.AssetTypeMetadataOptions,
+                            textField: 'title',
+                            valueField: 'id',
+                            filter: {
+                                field: 'assetTypeId',
+                                operator: { type: 'equal' },
+                                value: '{{ context.eval("assetTypeId") }}',
+                            },
+                            triggers: [
+                                {
+                                    event: "{{ events.context('assetTypeId') }}",
+                                    action: '{{ widget.setValue(null); widget.refresh(); }}',
+                                },
+                            ],
                         },
                     },
                 },
             },
             {
-                name: 'autoGeneratePlan',
-                title: '@maintenance-management:maintenance-types.entities.maintenance-type.fields.autoGeneratePlan.title',
-                groupId: 'plan-scheduling',
+                name: 'assessmentTemplateIds',
+                title: '@maintenance-management:maintenance-templates.entities.maintenance-template.fields.assessment-template-ids.title',
+                groupId: 'assessment-compliance',
                 options: {
-                    sort: { enabled: true },
-                    filter: {
-                        advance: { enabled: true },
-                        inline: { enabled: true },
-                    },
+                    sort: { enabled: false },
+                    filter: { advance: { enabled: false }, inline: { enabled: false } },
                 },
                 schema: {
-                    dataType: 'string',
+                    dataType: 'array',
                     interface: {
-                        type: AXPWidgetsCatalog.toggle,
-                        options: {},
+                        type: AXPWidgetsCatalog$1.lookup,
+                        options: {
+                            look: 'drop-down',
+                            multiple: true,
+                            entity: 'AssessmentManagement.Questionnaire',
+                            textField: 'title',
+                            valueField: 'id',
+                        },
                     },
                 },
             },
             {
-                name: 'hasSchedule',
-                title: '@maintenance-management:maintenance-types.entities.maintenance-type.fields.hasSchedule.title',
-                groupId: 'plan-scheduling',
+                name: 'schedule',
+                title: '@maintenance-management:maintenance-templates.entities.maintenance-template.fields.schedule.title',
+                groupId: 'Scheduling',
                 options: {
-                    sort: { enabled: true },
-                    filter: {
-                        advance: { enabled: true },
-                        inline: { enabled: true },
-                    },
+                    sort: { enabled: false },
+                    filter: { advance: { enabled: false }, inline: { enabled: false } },
                 },
                 schema: {
-                    dataType: 'string',
+                    dataType: 'object',
+                    defaultValue: {
+                        startCondition: {
+                            type: 'byDate',
+                            startDate: new Date(),
+                        },
+                    },
                     interface: {
-                        type: AXPWidgetsCatalog.toggle,
-                        options: {},
+                        type: AXPWidgetsCatalog$1.schedulerPicker,
+                        options: {
+                            placeholder: '@maintenance-management:maintenance-templates.entities.maintenance-template.fields.schedule.placeholder',
+                        },
                     },
                 },
             },
@@ -2524,51 +2777,97 @@ async function factory$i() {
         columns: [
             { name: 'code' },
             { name: 'title' },
-            { name: 'description' },
-            { name: 'autoGeneratePlan' },
-            { name: 'hasSchedule' },
+            { name: 'maintenanceTypeId', options: { dataPath: 'maintenanceType.title' } },
+            // { name: 'assetTypeId', options: { dataPath: 'assetType.title' } },
+            { name: 'estimatedMinutes' },
+            { name: 'needPermission' },
+            { name: 'needShutdown' },
         ],
         interfaces: {
             master: {
                 create: {
-                    sections: [{ id: 'basic-info' }, { id: 'plan-scheduling' }],
+                    sections: [
+                        { id: 'basic-info' },
+                        { id: 'configuration' },
+                        { id: 'execution' },
+                        { id: 'assessment-compliance' },
+                        { id: 'scheduling' },
+                    ],
                     properties: [
                         { name: 'code', layout: { positions: { lg: { colSpan: 6, order: 1 } } } },
                         { name: 'title', layout: { positions: { lg: { colSpan: 6, order: 2 } } } },
                         { name: 'description', layout: { positions: { lg: { colSpan: 12, order: 3 } } } },
-                        { name: 'autoGeneratePlan', layout: { positions: { lg: { colSpan: 6, order: 4 } } } },
-                        { name: 'hasSchedule', layout: { positions: { lg: { colSpan: 6, order: 5 } } } },
+                        { name: 'assetTypeId', layout: { positions: { lg: { colSpan: 6, order: 4 } } } },
+                        { name: 'maintenanceTypeId', layout: { positions: { lg: { colSpan: 6, order: 5 } } } },
+                        { name: 'autoGeneratePlan', layout: { positions: { lg: { colSpan: 3, order: 6 } } } },
+                        { name: 'hasSchedule', layout: { positions: { lg: { colSpan: 3, order: 7 } } } },
+                        { name: 'needPermission', layout: { positions: { lg: { colSpan: 3, order: 8 } } } },
+                        { name: 'needShutdown', layout: { positions: { lg: { colSpan: 3, order: 9 } } } },
+                        { name: 'estimatedMinutes', layout: { positions: { lg: { colSpan: 6, order: 10 } } } },
+                        { name: 'metadataIds', layout: { positions: { lg: { colSpan: 12, order: 11 } } } },
+                        {
+                            name: 'assessmentTemplateIds',
+                            layout: { label: { visible: false }, positions: { lg: { colSpan: 12, order: 12 } } },
+                        },
+                        { name: 'schedule', layout: { label: { visible: false }, positions: { lg: { colSpan: 12, order: 13 } } } },
                     ],
                 },
                 update: {
-                    sections: [{ id: 'basic-info' }, { id: 'plan-scheduling' }],
+                    sections: [
+                        { id: 'basic-info' },
+                        { id: 'configuration' },
+                        { id: 'execution' },
+                        { id: 'assessment-compliance' },
+                        { id: 'scheduling' },
+                    ],
                     properties: [
                         { name: 'code', layout: { positions: { lg: { colSpan: 6, order: 1 } } } },
                         { name: 'title', layout: { positions: { lg: { colSpan: 6, order: 2 } } } },
                         { name: 'description', layout: { positions: { lg: { colSpan: 12, order: 3 } } } },
-                        { name: 'autoGeneratePlan', layout: { positions: { lg: { colSpan: 6, order: 4 } } } },
-                        { name: 'hasSchedule', layout: { positions: { lg: { colSpan: 6, order: 5 } } } },
+                        { name: 'assetTypeId', layout: { positions: { lg: { colSpan: 6, order: 4 } } } },
+                        { name: 'maintenanceTypeId', layout: { positions: { lg: { colSpan: 6, order: 5 } } } },
+                        { name: 'autoGeneratePlan', layout: { positions: { lg: { colSpan: 3, order: 6 } } } },
+                        { name: 'hasSchedule', layout: { positions: { lg: { colSpan: 3, order: 7 } } } },
+                        { name: 'needPermission', layout: { positions: { lg: { colSpan: 3, order: 8 } } } },
+                        { name: 'needShutdown', layout: { positions: { lg: { colSpan: 3, order: 9 } } } },
+                        { name: 'estimatedMinutes', layout: { positions: { lg: { colSpan: 6, order: 10 } } } },
+                        { name: 'metadataIds', layout: { positions: { lg: { colSpan: 12, order: 11 } } } },
+                        {
+                            name: 'assessmentTemplateIds',
+                            layout: { label: { visible: false }, positions: { lg: { colSpan: 12, order: 12 } } },
+                        },
+                        { name: 'schedule', layout: { label: { visible: false }, positions: { lg: { colSpan: 12, order: 13 } } } },
                     ],
                 },
                 single: {
                     title: '{{ title }}',
-                    sections: [{ id: 'basic-info' }, { id: 'plan-scheduling' }],
+                    sections: [
+                        { id: 'basic-info' },
+                        { id: 'configuration' },
+                        { id: 'execution' },
+                        { id: 'assessment-compliance' },
+                        { id: 'scheduling' },
+                    ],
                     properties: [
                         { name: 'code', layout: { positions: { lg: { colSpan: 6, order: 1 } } } },
                         { name: 'title', layout: { positions: { lg: { colSpan: 6, order: 2 } } } },
                         { name: 'description', layout: { positions: { lg: { colSpan: 12, order: 3 } } } },
-                        { name: 'autoGeneratePlan', layout: { positions: { lg: { colSpan: 6, order: 4 } } } },
-                        { name: 'hasSchedule', layout: { positions: { lg: { colSpan: 6, order: 5 } } } },
+                        { name: 'assetTypeId', layout: { positions: { lg: { colSpan: 6, order: 4 } } } },
+                        { name: 'maintenanceTypeId', layout: { positions: { lg: { colSpan: 6, order: 5 } } } },
+                        { name: 'autoGeneratePlan', layout: { positions: { lg: { colSpan: 3, order: 6 } } } },
+                        { name: 'hasSchedule', layout: { positions: { lg: { colSpan: 3, order: 7 } } } },
+                        { name: 'needPermission', layout: { positions: { lg: { colSpan: 3, order: 8 } } } },
+                        { name: 'needShutdown', layout: { positions: { lg: { colSpan: 3, order: 9 } } } },
+                        { name: 'estimatedMinutes', layout: { positions: { lg: { colSpan: 6, order: 10 } } } },
+                        { name: 'metadataIds', layout: { positions: { lg: { colSpan: 12, order: 11 } } } },
+                        { name: 'assessmentTemplateIds', layout: { positions: { lg: { colSpan: 12, order: 12 } } } },
+                        { name: 'schedule', layout: { label: { visible: false }, positions: { lg: { colSpan: 12, order: 13 } } } },
                     ],
                     actions: [...entityMasterRecordActions()],
                 },
                 list: {
                     actions: [...entityMasterCrudActions()],
-                    views: [
-                        createAllQueryView({
-                            sorts: [{ name: 'title', dir: 'asc' }],
-                        }),
-                    ],
+                    views: [createAllQueryView({ sorts: [{ name: 'title', dir: 'asc' }] })],
                 },
             },
         },
@@ -2577,16 +2876,12 @@ async function factory$i() {
 }
 //#endregion
 
-var maintenanceType_entity = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    factory: factory$i
-});
-
-//#region ----   Types   ----
 //#endregion
 
-//#region ----   Types   ----
-//#endregion
+var index$o = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    factoryMaintenanceTemplate: factoryMaintenanceTemplate
+});
 
 const prioritySelectDataSource$4 = [
     { id: 'critical', title: '@maintenance-management:failure-modes.priorities.critical' },
@@ -2630,7 +2925,7 @@ async function maintenancePlanEntityFactory() {
             plural: RootConfig.entities.maintenancePlan.titlePlural,
             searchResult: {
                 title: '{{ title }}',
-                description: '{{ context.eval("maintenanceTemplate.title") + " · " + context.eval("asset.title") }}',
+                description: '{{ context.eval("maintenanceTemplate.title", { pipes: ["translate"] }) + " · " + context.eval("asset.title", { pipes: ["translate"] }) }}',
             },
         },
         groups: [
@@ -2663,7 +2958,7 @@ async function maintenancePlanEntityFactory() {
                     dataType: 'string',
                     unique: { enabled: true },
                     interface: {
-                        type: AXPWidgetsCatalog.text,
+                        type: AXPWidgetsCatalog$1.text,
                         options: {
                             disabled: true,
                             placeholder: '@maintenance-management:maintenance-plans.entities.maintenance-plan.fields.code.placeholder',
@@ -2681,7 +2976,7 @@ async function maintenancePlanEntityFactory() {
                     dataType: 'string',
                     readonly: '{{ context.eval("id") }}',
                     interface: {
-                        type: AXPWidgetsCatalog.text,
+                        type: AXPWidgetsCatalog$1.text,
                         options: {
                             disabled: '{{ !!context.eval("id") }}',
                             placeholder: '@maintenance-management:maintenance-plans.entities.maintenance-plan.fields.title.placeholder',
@@ -2698,7 +2993,7 @@ async function maintenancePlanEntityFactory() {
                 schema: {
                     dataType: 'string',
                     interface: {
-                        type: AXPWidgetsCatalog.lookup,
+                        type: AXPWidgetsCatalog$1.lookup,
                         options: {
                             look: 'select',
                             entity: 'AssetManagement.Asset',
@@ -2724,7 +3019,7 @@ async function maintenancePlanEntityFactory() {
                 schema: {
                     dataType: 'string',
                     interface: {
-                        type: AXPWidgetsCatalog.lookup,
+                        type: AXPWidgetsCatalog$1.lookup,
                         triggers: [
                             {
                                 event: "{{ events.context('maintenanceTypeId') }}",
@@ -2765,7 +3060,7 @@ async function maintenancePlanEntityFactory() {
                     dataType: 'string',
                     readonly: '{{ !!context.eval("id") || !context.eval("maintenanceTypeId") }}',
                     interface: {
-                        type: AXPWidgetsCatalog.lookup,
+                        type: AXPWidgetsCatalog$1.lookup,
                         triggers: [
                             {
                                 event: "{{ events.context('maintenanceTypeId') }}",
@@ -2804,7 +3099,7 @@ async function maintenancePlanEntityFactory() {
                 schema: {
                     dataType: 'boolean',
                     defaultValue: false,
-                    interface: { type: AXPWidgetsCatalog.toggle, options: { disabled: true } },
+                    interface: { type: AXPWidgetsCatalog$1.toggle, options: { disabled: true } },
                 },
             },
             {
@@ -2821,7 +3116,7 @@ async function maintenancePlanEntityFactory() {
                         },
                     },
                     interface: {
-                        type: AXPWidgetsCatalog.schedulerPicker,
+                        type: AXPWidgetsCatalog$1.schedulerPicker,
                         options: {
                             placeholder: '@maintenance-management:maintenance-plans.entities.maintenance-plan.fields.schedule.placeholder',
                             // config: {
@@ -2838,7 +3133,7 @@ async function maintenancePlanEntityFactory() {
                 schema: {
                     dataType: 'string',
                     interface: {
-                        type: AXPWidgetsCatalog.lookup,
+                        type: AXPWidgetsCatalog$1.lookup,
                         options: {
                             look: 'select',
                             entity: 'HumanCapitalManagement.Employee',
@@ -2856,7 +3151,7 @@ async function maintenancePlanEntityFactory() {
                 schema: {
                     dataType: 'string',
                     interface: {
-                        type: AXPWidgetsCatalog.select,
+                        type: AXPWidgetsCatalog$1.select,
                         options: {
                             valueField: 'id',
                             textField: 'title',
@@ -2873,7 +3168,7 @@ async function maintenancePlanEntityFactory() {
                 schema: {
                     dataType: 'number',
                     interface: {
-                        type: AXPWidgetsCatalog.number,
+                        type: AXPWidgetsCatalog$1.number,
                         options: { min: 0 },
                     },
                 },
@@ -2885,7 +3180,7 @@ async function maintenancePlanEntityFactory() {
                 schema: {
                     dataType: 'boolean',
                     defaultValue: false,
-                    interface: { type: AXPWidgetsCatalog.toggle, options: {} },
+                    interface: { type: AXPWidgetsCatalog$1.toggle, options: {} },
                 },
             },
             {
@@ -2895,7 +3190,7 @@ async function maintenancePlanEntityFactory() {
                 schema: {
                     dataType: 'boolean',
                     defaultValue: false,
-                    interface: { type: AXPWidgetsCatalog.toggle, options: {} },
+                    interface: { type: AXPWidgetsCatalog$1.toggle, options: {} },
                 },
             },
         ],
@@ -2991,7 +3286,9 @@ async function maintenancePlanEntityFactory() {
     return entityDef;
 }
 
-var index$8 = /*#__PURE__*/Object.freeze({
+//#endregion
+
+var index$n = /*#__PURE__*/Object.freeze({
     __proto__: null,
     maintenancePlanEntityFactory: maintenancePlanEntityFactory
 });
@@ -3060,7 +3357,7 @@ async function workPackageEntityFactory() {
                 groupId: 'basic-info',
                 schema: {
                     dataType: 'string',
-                    interface: { type: AXPWidgetsCatalog.text, options: {} },
+                    interface: { type: AXPWidgetsCatalog$1.text, options: {} },
                 },
                 validations: [{ rule: 'required' }],
             },
@@ -3070,7 +3367,7 @@ async function workPackageEntityFactory() {
                 groupId: 'basic-info',
                 schema: {
                     dataType: 'string',
-                    interface: { type: AXPWidgetsCatalog.text, options: {} },
+                    interface: { type: AXPWidgetsCatalog$1.text, options: {} },
                 },
                 validations: [{ rule: 'required' }],
             },
@@ -3080,7 +3377,7 @@ async function workPackageEntityFactory() {
                 groupId: 'basic-info',
                 schema: {
                     dataType: 'string',
-                    interface: { type: AXPWidgetsCatalog.largeText, options: {} },
+                    interface: { type: AXPWidgetsCatalog$1.largeText, options: {} },
                 },
             },
             {
@@ -3090,7 +3387,7 @@ async function workPackageEntityFactory() {
                 schema: {
                     dataType: 'string',
                     interface: {
-                        type: AXPWidgetsCatalog.lookup,
+                        type: AXPWidgetsCatalog$1.lookup,
                         options: {
                             look: 'select',
                             entity: 'AssetManagement.AssetSystem',
@@ -3111,7 +3408,7 @@ async function workPackageEntityFactory() {
                 groupId: 'timing',
                 schema: {
                     dataType: 'date',
-                    interface: { type: AXPWidgetsCatalog.dateTime, options: { format: 'datetime' } },
+                    interface: { type: AXPWidgetsCatalog$1.dateTime, options: { format: 'datetime' } },
                 },
             },
             {
@@ -3120,7 +3417,7 @@ async function workPackageEntityFactory() {
                 groupId: 'timing',
                 schema: {
                     dataType: 'date',
-                    interface: { type: AXPWidgetsCatalog.dateTime, options: { format: 'datetime' } },
+                    interface: { type: AXPWidgetsCatalog$1.dateTime, options: { format: 'datetime' } },
                 },
             },
             {
@@ -3129,7 +3426,7 @@ async function workPackageEntityFactory() {
                 groupId: 'timing',
                 schema: {
                     dataType: 'date',
-                    interface: { type: AXPWidgetsCatalog.dateTime, options: { format: 'datetime' } },
+                    interface: { type: AXPWidgetsCatalog$1.dateTime, options: { format: 'datetime' } },
                 },
             },
             {
@@ -3139,7 +3436,7 @@ async function workPackageEntityFactory() {
                 schema: {
                     dataType: 'date',
                     nullable: true,
-                    interface: { type: AXPWidgetsCatalog.dateTime, options: { format: 'datetime' } },
+                    interface: { type: AXPWidgetsCatalog$1.dateTime, options: { format: 'datetime' } },
                 },
             },
             {
@@ -3149,7 +3446,7 @@ async function workPackageEntityFactory() {
                 schema: {
                     dataType: 'boolean',
                     defaultValue: false,
-                    interface: { type: AXPWidgetsCatalog.toggle, options: {} },
+                    interface: { type: AXPWidgetsCatalog$1.toggle, options: {} },
                 },
             },
             {
@@ -3238,7 +3535,7 @@ async function workPackageEntityFactory() {
     return entityDef;
 }
 
-var index$7 = /*#__PURE__*/Object.freeze({
+var index$m = /*#__PURE__*/Object.freeze({
     __proto__: null,
     workPackageEntityFactory: workPackageEntityFactory
 });
@@ -3354,7 +3651,7 @@ async function workOrderEntityFactory() {
                     dataType: 'string',
                     unique: { enabled: true },
                     interface: {
-                        type: AXPWidgetsCatalog.text,
+                        type: AXPWidgetsCatalog$1.text,
                         options: {
                             disabled: true,
                             placeholder: '@maintenance-management:work-orders.entities.work-order.fields.work-order-no.placeholder',
@@ -3372,7 +3669,7 @@ async function workOrderEntityFactory() {
                     defaultValue: false,
                     visible: '{{ !context.eval("id") }}',
                     interface: {
-                        type: AXPWidgetsCatalog.toggle,
+                        type: AXPWidgetsCatalog$1.toggle,
                         options: {
                             triggers: [
                                 {
@@ -3393,10 +3690,10 @@ async function workOrderEntityFactory() {
                     dataType: 'string',
                     visible: '{{ !context.eval("maintenancePlanId") || (!context.eval("plannable") && (!context.eval("id") || !context.eval("maintenancePlanId"))) }}',
                     interface: {
-                        type: AXPWidgetsCatalog.lookup,
+                        type: AXPWidgetsCatalog$1.lookup,
                         options: {
                             look: 'select',
-                            entity: RootConfig$1.entities.asset.source,
+                            entity: "AssetManagement.Asset",
                             textField: 'title',
                             valueField: 'id',
                             disabled: true,
@@ -3422,7 +3719,7 @@ async function workOrderEntityFactory() {
                     dataType: 'string',
                     visible: unplannableFormVisible,
                     interface: {
-                        type: AXPWidgetsCatalog.lookup,
+                        type: AXPWidgetsCatalog$1.lookup,
                         triggers: [
                             {
                                 event: "{{ events.context('maintenanceTypeId') }}",
@@ -3463,13 +3760,12 @@ async function workOrderEntityFactory() {
                     dataType: 'string',
                     visible: plannableFormVisible,
                     interface: {
-                        type: AXPWidgetsCatalog.lookup,
+                        type: AXPWidgetsCatalog$1.lookup,
                         options: {
                             look: 'lookup',
                             allowCreate: 'quick',
                             hasClearButton: true,
                             disabled: '{{ !!context.eval("id") }}',
-                            valueTransforms: objectKeyValueTransforms('id'),
                             entity: `${RootConfig.module.name}.${RootConfig.entities.maintenancePlan.name}`,
                             textField: 'title',
                             valueField: 'id',
@@ -3497,7 +3793,7 @@ async function workOrderEntityFactory() {
                     readonly: '{{ !!context.eval("id") || (!context.eval("plannable") && !context.eval("maintenanceTypeId")) }}',
                     visible: unplannableFormVisible,
                     interface: {
-                        type: AXPWidgetsCatalog.lookup,
+                        type: AXPWidgetsCatalog$1.lookup,
                         triggers: [
                             {
                                 event: "{{ events.context('maintenanceTypeId') }}",
@@ -3507,7 +3803,6 @@ async function workOrderEntityFactory() {
                         options: {
                             disabled: '{{ !!context.eval("plannable") || !!context.eval("id") || !context.eval("maintenanceTypeId") }}',
                             look: 'select',
-                            valueTransforms: objectKeyValueTransforms('id'),
                             entity: `${RootConfig.module.name}.${RootConfig.entities.maintenanceTemplate.name}`,
                             textField: 'title',
                             valueField: 'id',
@@ -3534,13 +3829,12 @@ async function workOrderEntityFactory() {
                     dataType: 'string',
                     visible: unplannableFormVisible,
                     interface: {
-                        type: AXPWidgetsCatalog.lookup,
+                        type: AXPWidgetsCatalog$1.lookup,
                         options: {
                             look: 'lookup',
                             hasClearButton: true,
                             allowCreate: 'quick',
                             disabled: '{{ !!context.eval("id") }}',
-                            valueTransforms: objectKeyValueTransforms('id'),
                             entity: `${RootConfig.module.name}.${RootConfig.entities.failureRegister.name}`,
                             textField: 'code',
                             valueField: 'id',
@@ -3565,7 +3859,7 @@ async function workOrderEntityFactory() {
                 schema: {
                     dataType: 'string',
                     interface: {
-                        type: AXPWidgetsCatalog.select,
+                        type: AXPWidgetsCatalog$1.select,
                         options: {
                             valueField: 'id',
                             textField: 'title',
@@ -3583,7 +3877,7 @@ async function workOrderEntityFactory() {
                 schema: {
                     dataType: 'boolean',
                     defaultValue: false,
-                    interface: { type: AXPWidgetsCatalog.toggle, options: { disabled: true } },
+                    interface: { type: AXPWidgetsCatalog$1.toggle, options: { disabled: true } },
                 },
             },
             {
@@ -3591,28 +3885,28 @@ async function workOrderEntityFactory() {
                 title: '@maintenance-management:work-orders.entities.work-order.fields.scheduled-start.title',
                 groupId: 'scheduling-execution',
                 options: listSortAndFilterOptions,
-                schema: { dataType: 'date', interface: { type: AXPWidgetsCatalog.dateTime, options: { format: 'datetime' } } },
+                schema: { dataType: 'date', interface: { type: AXPWidgetsCatalog$1.dateTime, options: { format: 'datetime' } } },
             },
             {
                 name: 'scheduledEnd',
                 title: '@maintenance-management:work-orders.entities.work-order.fields.scheduled-end.title',
                 groupId: 'scheduling-execution',
                 options: listSortAndFilterOptions,
-                schema: { dataType: 'date', interface: { type: AXPWidgetsCatalog.dateTime, options: { format: 'datetime' } } },
+                schema: { dataType: 'date', interface: { type: AXPWidgetsCatalog$1.dateTime, options: { format: 'datetime' } } },
             },
             {
                 name: 'startedAt',
                 title: '@maintenance-management:work-orders.entities.work-order.fields.started-at.title',
                 groupId: 'scheduling-execution',
                 options: listSortAndFilterOptions,
-                schema: { dataType: 'date', interface: { type: AXPWidgetsCatalog.dateTime, options: { format: 'datetime' } } },
+                schema: { dataType: 'date', interface: { type: AXPWidgetsCatalog$1.dateTime, options: { format: 'datetime' } } },
             },
             {
                 name: 'completedAt',
                 title: '@maintenance-management:work-orders.entities.work-order.fields.completed-at.title',
                 groupId: 'scheduling-execution',
                 options: listSortAndFilterOptions,
-                schema: { dataType: 'date', interface: { type: AXPWidgetsCatalog.dateTime, options: { format: 'datetime' } } },
+                schema: { dataType: 'date', interface: { type: AXPWidgetsCatalog$1.dateTime, options: { format: 'datetime' } } },
             },
             {
                 name: 'assignedToId',
@@ -3622,10 +3916,9 @@ async function workOrderEntityFactory() {
                 schema: {
                     dataType: 'string',
                     interface: {
-                        type: AXPWidgetsCatalog.lookup,
+                        type: AXPWidgetsCatalog$1.lookup,
                         options: {
                             look: 'select',
-                            valueTransforms: objectKeyValueTransforms('id'),
                             entity: 'PersonCore.Person',
                             textField: 'fullName',
                             valueField: 'id',
@@ -3646,10 +3939,9 @@ async function workOrderEntityFactory() {
                 schema: {
                     dataType: 'string',
                     interface: {
-                        type: AXPWidgetsCatalog.lookup,
+                        type: AXPWidgetsCatalog$1.lookup,
                         options: {
                             look: 'select',
-                            valueTransforms: objectKeyValueTransforms('id'),
                             entity: 'PersonCore.Person',
                             textField: 'fullName',
                             valueField: 'id',
@@ -3667,21 +3959,21 @@ async function workOrderEntityFactory() {
                 title: '@maintenance-management:work-orders.entities.work-order.fields.estimated-hours.title',
                 groupId: 'execution-settings',
                 options: listSortAndFilterOptions,
-                schema: { dataType: 'number', interface: { type: AXPWidgetsCatalog.number, options: { min: 0 } } },
+                schema: { dataType: 'number', interface: { type: AXPWidgetsCatalog$1.number, options: { min: 0 } } },
             },
             {
                 name: 'actualHours',
                 title: '@maintenance-management:work-orders.entities.work-order.fields.actual-hours.title',
                 groupId: 'execution-settings',
                 options: listSortAndFilterOptions,
-                schema: { dataType: 'number', interface: { type: AXPWidgetsCatalog.number, options: { min: 0 } } },
+                schema: { dataType: 'number', interface: { type: AXPWidgetsCatalog$1.number, options: { min: 0 } } },
             },
             {
                 name: 'downtimeMinutes',
                 title: '@maintenance-management:work-orders.entities.work-order.fields.downtime-minutes.title',
                 groupId: 'execution-settings',
                 options: listSortAndFilterOptions,
-                schema: { dataType: 'number', interface: { type: AXPWidgetsCatalog.number, options: { min: 0 } } },
+                schema: { dataType: 'number', interface: { type: AXPWidgetsCatalog$1.number, options: { min: 0 } } },
             },
             {
                 name: 'needPermission',
@@ -3691,7 +3983,7 @@ async function workOrderEntityFactory() {
                 schema: {
                     dataType: 'boolean',
                     defaultValue: false,
-                    interface: { type: AXPWidgetsCatalog.toggle, options: {} },
+                    interface: { type: AXPWidgetsCatalog$1.toggle, options: {} },
                 },
             },
             {
@@ -3702,7 +3994,7 @@ async function workOrderEntityFactory() {
                 schema: {
                     dataType: 'boolean',
                     defaultValue: false,
-                    interface: { type: AXPWidgetsCatalog.toggle, options: {} },
+                    interface: { type: AXPWidgetsCatalog$1.toggle, options: {} },
                 },
             },
         ],
@@ -3829,15 +4121,11 @@ async function workOrderEntityFactory() {
     return entityDef;
 }
 
-var index$6 = /*#__PURE__*/Object.freeze({
+var index$l = /*#__PURE__*/Object.freeze({
     __proto__: null,
     workOrderEntityFactory: workOrderEntityFactory
 });
 
-//#region ----   Types   ----
-//#endregion
-
-//#region ----   Imports   ----
 //#endregion
 //#region ----   Entity factory   ----
 async function workReportEntityFactory() {
@@ -3875,7 +4163,7 @@ async function workReportEntityFactory() {
                 schema: {
                     dataType: 'string',
                     interface: {
-                        type: AXPWidgetsCatalog.lookup,
+                        type: AXPWidgetsCatalog$1.lookup,
                         options: {
                             look: 'select',
                             entity: `${RootConfig.module.name}.${RootConfig.entities.workOrder.name}`,
@@ -3900,7 +4188,7 @@ async function workReportEntityFactory() {
                 schema: {
                     dataType: 'date',
                     interface: {
-                        type: AXPWidgetsCatalog.dateTime,
+                        type: AXPWidgetsCatalog$1.dateTime,
                         options: { format: 'datetime' },
                     },
                 },
@@ -3914,7 +4202,7 @@ async function workReportEntityFactory() {
                 schema: {
                     dataType: 'string',
                     interface: {
-                        type: AXPWidgetsCatalog.lookup,
+                        type: AXPWidgetsCatalog$1.lookup,
                         options: {
                             look: 'select',
                             entity: 'HumanCapitalManagement.Employee',
@@ -3936,7 +4224,7 @@ async function workReportEntityFactory() {
                 schema: {
                     dataType: 'date',
                     interface: {
-                        type: AXPWidgetsCatalog.dateTime,
+                        type: AXPWidgetsCatalog$1.dateTime,
                         options: { format: 'datetime' },
                     },
                 },
@@ -3948,7 +4236,7 @@ async function workReportEntityFactory() {
                 schema: {
                     dataType: 'date',
                     interface: {
-                        type: AXPWidgetsCatalog.dateTime,
+                        type: AXPWidgetsCatalog$1.dateTime,
                         options: { format: 'datetime' },
                     },
                 },
@@ -3960,7 +4248,7 @@ async function workReportEntityFactory() {
                 schema: {
                     dataType: 'number',
                     interface: {
-                        type: AXPWidgetsCatalog.number,
+                        type: AXPWidgetsCatalog$1.number,
                         options: { min: 0 },
                     },
                 },
@@ -3972,7 +4260,7 @@ async function workReportEntityFactory() {
                 schema: {
                     dataType: 'number',
                     interface: {
-                        type: AXPWidgetsCatalog.number,
+                        type: AXPWidgetsCatalog$1.number,
                         options: { min: 0 },
                     },
                 },
@@ -3984,7 +4272,7 @@ async function workReportEntityFactory() {
                 schema: {
                     dataType: 'string',
                     interface: {
-                        type: AXPWidgetsCatalog.largeText,
+                        type: AXPWidgetsCatalog$1.largeText,
                         options: {
                             placeholder: '@maintenance-management:work-reports.entities.work-report.fields.result.placeholder',
                         },
@@ -3998,7 +4286,7 @@ async function workReportEntityFactory() {
                 schema: {
                     dataType: 'string',
                     interface: {
-                        type: AXPWidgetsCatalog.largeText,
+                        type: AXPWidgetsCatalog$1.largeText,
                         options: {
                             placeholder: '@maintenance-management:work-reports.entities.work-report.fields.summary.placeholder',
                         },
@@ -4012,7 +4300,7 @@ async function workReportEntityFactory() {
                 schema: {
                     dataType: 'string',
                     interface: {
-                        type: AXPWidgetsCatalog.largeText,
+                        type: AXPWidgetsCatalog$1.largeText,
                         options: {
                             placeholder: '@maintenance-management:work-reports.entities.work-report.fields.action-taken.placeholder',
                         },
@@ -4026,7 +4314,7 @@ async function workReportEntityFactory() {
                 schema: {
                     dataType: 'string',
                     interface: {
-                        type: AXPWidgetsCatalog.largeText,
+                        type: AXPWidgetsCatalog$1.largeText,
                         options: {
                             placeholder: '@maintenance-management:work-reports.entities.work-report.fields.recommendation.placeholder',
                         },
@@ -4040,7 +4328,7 @@ async function workReportEntityFactory() {
                 schema: {
                     dataType: 'boolean',
                     defaultValue: false,
-                    interface: { type: AXPWidgetsCatalog.toggle, options: {} },
+                    interface: { type: AXPWidgetsCatalog$1.toggle, options: {} },
                 },
             },
             {
@@ -4050,7 +4338,7 @@ async function workReportEntityFactory() {
                 schema: {
                     dataType: 'string',
                     interface: {
-                        type: AXPWidgetsCatalog.lookup,
+                        type: AXPWidgetsCatalog$1.lookup,
                         options: {
                             look: 'select',
                             entity: `${RootConfig.module.name}.${RootConfig.entities.workOrder.name}`,
@@ -4145,15 +4433,14 @@ async function workReportEntityFactory() {
 }
 //#endregion
 
-var index$5 = /*#__PURE__*/Object.freeze({
+//#endregion
+
+var index$k = /*#__PURE__*/Object.freeze({
     __proto__: null,
     workReportEntityFactory: workReportEntityFactory
 });
 
-//#region ----   Types   ----
-//#endregion
-
-async function factory$h() {
+async function factoryMaintenanceTemplateActivityType() {
     const entityDef = {
         module: RootConfig.module.name,
         name: RootConfig.entities.maintenanceTemplateActivityType.name,
@@ -4179,7 +4466,7 @@ async function factory$h() {
                 schema: {
                     dataType: 'string',
                     interface: {
-                        type: AXPWidgetsCatalog.lookup,
+                        type: AXPWidgetsCatalog$1.lookup,
                         options: {
                             look: 'select',
                             entity: `${RootConfig.module.name}.${RootConfig.entities.maintenanceTemplate.name}`,
@@ -4201,7 +4488,7 @@ async function factory$h() {
                 schema: {
                     dataType: 'string',
                     interface: {
-                        type: AXPWidgetsCatalog.lookup,
+                        type: AXPWidgetsCatalog$1.lookup,
                         options: {
                             look: 'select',
                             entity: `${RootConfig.module.name}.${RootConfig.entities.activityType.name}`,
@@ -4223,7 +4510,7 @@ async function factory$h() {
                 schema: {
                     dataType: 'number',
                     interface: {
-                        type: AXPWidgetsCatalog.number,
+                        type: AXPWidgetsCatalog$1.number,
                         options: {
                             min: 1,
                             placeholder: '@maintenance-management:maintenance-template-activity-types.entities.maintenance-template-activity-type.fields.sequence-no.placeholder',
@@ -4239,7 +4526,7 @@ async function factory$h() {
                 schema: {
                     dataType: 'number',
                     interface: {
-                        type: AXPWidgetsCatalog.number,
+                        type: AXPWidgetsCatalog$1.number,
                         options: {
                             min: 0,
                             placeholder: '@maintenance-management:maintenance-template-activity-types.entities.maintenance-template-activity-type.fields.estimated-minutes.placeholder',
@@ -4254,7 +4541,7 @@ async function factory$h() {
                 schema: {
                     dataType: 'boolean',
                     defaultValue: false,
-                    interface: { type: AXPWidgetsCatalog.toggle, options: {} },
+                    interface: { type: AXPWidgetsCatalog$1.toggle, options: {} },
                 },
             },
             {
@@ -4264,7 +4551,7 @@ async function factory$h() {
                 schema: {
                     dataType: 'boolean',
                     defaultValue: false,
-                    interface: { type: AXPWidgetsCatalog.toggle, options: {} },
+                    interface: { type: AXPWidgetsCatalog$1.toggle, options: {} },
                 },
             },
             {
@@ -4274,7 +4561,7 @@ async function factory$h() {
                 schema: {
                     dataType: 'string',
                     interface: {
-                        type: AXPWidgetsCatalog.largeText,
+                        type: AXPWidgetsCatalog$1.largeText,
                         options: {
                             placeholder: '@maintenance-management:maintenance-template-activity-types.entities.maintenance-template-activity-type.fields.description.placeholder',
                         },
@@ -4344,14 +4631,13 @@ async function factory$h() {
     return entityDef;
 }
 
-var index$4 = /*#__PURE__*/Object.freeze({
+//#endregion
+
+var index$j = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    maintenanceTemplateActivityTypeEntityFactory: factory$h
+    factoryMaintenanceTemplateActivityType: factoryMaintenanceTemplateActivityType
 });
 
-//#region ----   Types   ----
-//#endregion
-
 async function maintenanceTemplateFailureModeEntityFactory() {
     const entityDef = {
         module: RootConfig.module.name,
@@ -4380,7 +4666,7 @@ async function maintenanceTemplateFailureModeEntityFactory() {
                 schema: {
                     dataType: 'string',
                     interface: {
-                        type: AXPWidgetsCatalog.text,
+                        type: AXPWidgetsCatalog$1.text,
                         options: {
                             placeholder: '@maintenance-management:maintenance-template-failure-modes.entities.maintenance-template-failure-mode.fields.code.placeholder',
                         },
@@ -4395,7 +4681,7 @@ async function maintenanceTemplateFailureModeEntityFactory() {
                 schema: {
                     dataType: 'string',
                     interface: {
-                        type: AXPWidgetsCatalog.lookup,
+                        type: AXPWidgetsCatalog$1.lookup,
                         options: {
                             look: 'select',
                             entity: `${RootConfig.module.name}.${RootConfig.entities.maintenanceTemplate.name}`,
@@ -4417,7 +4703,7 @@ async function maintenanceTemplateFailureModeEntityFactory() {
                 schema: {
                     dataType: 'string',
                     interface: {
-                        type: AXPWidgetsCatalog.lookup,
+                        type: AXPWidgetsCatalog$1.lookup,
                         options: {
                             look: 'select',
                             entity: `${RootConfig.module.name}.${RootConfig.entities.failureMode.name}`,
@@ -4439,7 +4725,7 @@ async function maintenanceTemplateFailureModeEntityFactory() {
                 schema: {
                     dataType: 'string',
                     interface: {
-                        type: AXPWidgetsCatalog.largeText,
+                        type: AXPWidgetsCatalog$1.largeText,
                         options: {
                             placeholder: '@maintenance-management:maintenance-template-failure-modes.entities.maintenance-template-failure-mode.fields.description.placeholder',
                         },
@@ -4498,14 +4784,13 @@ async function maintenanceTemplateFailureModeEntityFactory() {
     return entityDef;
 }
 
-var index$3 = /*#__PURE__*/Object.freeze({
+//#endregion
+
+var index$i = /*#__PURE__*/Object.freeze({
     __proto__: null,
     maintenanceTemplateFailureModeEntityFactory: maintenanceTemplateFailureModeEntityFactory
 });
 
-//#region ----   Types   ----
-//#endregion
-
 const MAINTENANCE_RESOURCE_TYPE_OPTIONS = [
     {
         id: 'assettype',
@@ -4547,7 +4832,7 @@ async function maintenanceTemplateResourceEntityFactory() {
                 schema: {
                     dataType: 'string',
                     interface: {
-                        type: AXPWidgetsCatalog.text,
+                        type: AXPWidgetsCatalog$1.text,
                         options: {
                             placeholder: '@maintenance-management:maintenance-template-resources.entities.maintenance-template-resource.fields.code.placeholder',
                         },
@@ -4562,7 +4847,7 @@ async function maintenanceTemplateResourceEntityFactory() {
                 schema: {
                     dataType: 'string',
                     interface: {
-                        type: AXPWidgetsCatalog.lookup,
+                        type: AXPWidgetsCatalog$1.lookup,
                         options: {
                             look: 'select',
                             entity: `${RootConfig.module.name}.${RootConfig.entities.maintenanceTemplate.name}`,
@@ -4584,7 +4869,7 @@ async function maintenanceTemplateResourceEntityFactory() {
                 schema: {
                     dataType: 'string',
                     interface: {
-                        type: AXPWidgetsCatalog.select,
+                        type: AXPWidgetsCatalog$1.select,
                         options: {
                             valueField: 'id',
                             textField: 'title',
@@ -4603,7 +4888,7 @@ async function maintenanceTemplateResourceEntityFactory() {
                     dataType: 'string',
                     visible: '{{ ((context.eval("resourceType") && context.eval("resourceType").id) || context.eval("resourceType")) === "inventoryitem" }}',
                     interface: {
-                        type: AXPWidgetsCatalog.text,
+                        type: AXPWidgetsCatalog$1.text,
                         options: {
                             placeholder: '@maintenance-management:maintenance-template-resources.entities.maintenance-template-resource.fields.resource-id.placeholder',
                         },
@@ -4618,7 +4903,7 @@ async function maintenanceTemplateResourceEntityFactory() {
                     dataType: 'array',
                     visible: '{{ ["assettype","jobdefinition"].includes((context.eval("resourceType") && context.eval("resourceType").id) || context.eval("resourceType")) }}',
                     interface: {
-                        type: AXPWidgetsCatalog.lookup,
+                        type: AXPWidgetsCatalog$1.lookup,
                         options: {
                             look: 'drop-down',
                             multiple: true,
@@ -4637,7 +4922,7 @@ async function maintenanceTemplateResourceEntityFactory() {
                 schema: {
                     dataType: 'number',
                     interface: {
-                        type: AXPWidgetsCatalog.number,
+                        type: AXPWidgetsCatalog$1.number,
                         options: {
                             min: 0,
                             placeholder: '@maintenance-management:maintenance-template-resources.entities.maintenance-template-resource.fields.quantity.placeholder',
@@ -4652,7 +4937,7 @@ async function maintenanceTemplateResourceEntityFactory() {
                 schema: {
                     dataType: 'number',
                     interface: {
-                        type: AXPWidgetsCatalog.number,
+                        type: AXPWidgetsCatalog$1.number,
                         options: {
                             min: 0,
                             placeholder: '@maintenance-management:maintenance-template-resources.entities.maintenance-template-resource.fields.estimated-hours.placeholder',
@@ -4667,7 +4952,7 @@ async function maintenanceTemplateResourceEntityFactory() {
                 schema: {
                     dataType: 'string',
                     interface: {
-                        type: AXPWidgetsCatalog.largeText,
+                        type: AXPWidgetsCatalog$1.largeText,
                         options: {
                             placeholder: '@maintenance-management:maintenance-template-resources.entities.maintenance-template-resource.fields.description.placeholder',
                         },
@@ -4681,7 +4966,7 @@ async function maintenanceTemplateResourceEntityFactory() {
                 schema: {
                     dataType: 'string',
                     interface: {
-                        type: AXPWidgetsCatalog.text,
+                        type: AXPWidgetsCatalog$1.text,
                         options: {
                             readonly: true,
                         },
@@ -4754,15 +5039,14 @@ async function maintenanceTemplateResourceEntityFactory() {
     return entityDef;
 }
 
-var index$2 = /*#__PURE__*/Object.freeze({
+//#endregion
+
+var index$h = /*#__PURE__*/Object.freeze({
     __proto__: null,
     maintenanceTemplateResourceEntityFactory: maintenanceTemplateResourceEntityFactory
 });
 
-//#region ----   Types   ----
-//#endregion
-
-async function factory$g() {
+async function factoryActivityType() {
     const entityRef = `${RootConfig.module.name}.${RootConfig.entities.activityType.name}`;
     const entityDef = {
         module: RootConfig.module.name,
@@ -4839,7 +5123,7 @@ async function factory$g() {
                 schema: {
                     dataType: 'string',
                     interface: {
-                        type: AXPWidgetsCatalog.text,
+                        type: AXPWidgetsCatalog$1.text,
                         options: {
                             placeholder: '@maintenance-management:activity-types.entities.activity-type.fields.code.placeholder',
                         },
@@ -4861,7 +5145,7 @@ async function factory$g() {
                 schema: {
                     dataType: 'string',
                     interface: {
-                        type: AXPWidgetsCatalog.text,
+                        type: AXPWidgetsCatalog$1.text,
                         options: {
                             placeholder: '@maintenance-management:activity-types.entities.activity-type.fields.title.placeholder',
                         },
@@ -4883,7 +5167,7 @@ async function factory$g() {
                 schema: {
                     dataType: 'string',
                     interface: {
-                        type: AXPWidgetsCatalog.largeText,
+                        type: AXPWidgetsCatalog$1.largeText,
                         options: {
                             placeholder: '@maintenance-management:activity-types.entities.activity-type.fields.description.placeholder',
                         },
@@ -4913,7 +5197,7 @@ async function factory$g() {
                     //   endCondition: { type: 'never' },
                     // },
                     interface: {
-                        type: AXPWidgetsCatalog.schedulerPicker,
+                        type: AXPWidgetsCatalog$1.schedulerPicker,
                         options: {
                             placeholder: '@maintenance-management:activity-types.entities.activity-type.fields.schadule-id.placeholder',
                         },
@@ -4935,7 +5219,7 @@ async function factory$g() {
                 schema: {
                     dataType: 'number',
                     interface: {
-                        type: AXPWidgetsCatalog.number,
+                        type: AXPWidgetsCatalog$1.number,
                         options: {
                             min: 0,
                             placeholder: '@maintenance-management:activity-types.entities.activity-type.fields.initial-estimated-time.placeholder',
@@ -4958,7 +5242,7 @@ async function factory$g() {
                     dataType: 'boolean',
                     defaultValue: false,
                     interface: {
-                        type: AXPWidgetsCatalog.toggle,
+                        type: AXPWidgetsCatalog$1.toggle,
                         options: {},
                     },
                 },
@@ -5023,15 +5307,14 @@ async function factory$g() {
     return entityDef;
 }
 
-var activityType_entity = /*#__PURE__*/Object.freeze({
+//#endregion
+
+var index$g = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    factory: factory$g
+    factoryActivityType: factoryActivityType
 });
 
-//#region ----   Types   ----
-//#endregion
-
-async function factory$f() {
+async function factoryActivityTypeAssetType() {
     const entityDef = {
         module: RootConfig.module.name,
         name: RootConfig.entities.activityTypeAssetType.name,
@@ -5061,7 +5344,7 @@ async function factory$f() {
                 schema: {
                     dataType: 'string',
                     interface: {
-                        type: AXPWidgetsCatalog.lookup,
+                        type: AXPWidgetsCatalog$1.lookup,
                         options: {
                             look: 'select',
                             entity: `${RootConfig.module.name}.${RootConfig.entities.activityType.name}`,
@@ -5090,7 +5373,7 @@ async function factory$f() {
                 schema: {
                     dataType: 'string',
                     interface: {
-                        type: AXPWidgetsCatalog.lookup,
+                        type: AXPWidgetsCatalog$1.lookup,
                         options: {
                             look: 'select',
                             entity: 'AssetManagement.AssetType',
@@ -5120,7 +5403,7 @@ async function factory$f() {
                 schema: {
                     dataType: 'string',
                     interface: {
-                        type: AXPWidgetsCatalog.lookup,
+                        type: AXPWidgetsCatalog$1.lookup,
                         options: {
                             look: 'select',
                             entity: 'OrganizationManagement.Team',
@@ -5182,14 +5465,13 @@ async function factory$f() {
     return entityDef;
 }
 
-var index$1 = /*#__PURE__*/Object.freeze({
+//#endregion
+
+var index$f = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    activityTypeAssetTypeEntityFactory: factory$f
+    factoryActivityTypeAssetType: factoryActivityTypeAssetType
 });
 
-//#region ----   Types   ----
-//#endregion
-
 const RESOURCE_TYPE_OPTIONS = [
     {
         id: 'assettype',
@@ -5204,7 +5486,7 @@ const RESOURCE_TYPE_OPTIONS = [
         title: '@maintenance-management:activity-type-resources.entities.activity-type-resource.fields.resource-type.options.inventoryitem',
     },
 ];
-async function factory$e() {
+async function factoryActivityTypeResource() {
     const entityDef = {
         module: RootConfig.module.name,
         name: RootConfig.entities.activityTypeResource.name,
@@ -5227,7 +5509,7 @@ async function factory$e() {
                 schema: {
                     dataType: 'string',
                     interface: {
-                        type: AXPWidgetsCatalog.lookup,
+                        type: AXPWidgetsCatalog$1.lookup,
                         options: {
                             look: 'select',
                             entity: `${RootConfig.module.name}.${RootConfig.entities.activityType.name}`,
@@ -5249,7 +5531,7 @@ async function factory$e() {
                 schema: {
                     dataType: 'string',
                     interface: {
-                        type: AXPWidgetsCatalog.select,
+                        type: AXPWidgetsCatalog$1.select,
                         options: {
                             valueField: 'id',
                             textField: 'title',
@@ -5267,7 +5549,7 @@ async function factory$e() {
                 schema: {
                     dataType: 'number',
                     interface: {
-                        type: AXPWidgetsCatalog.number,
+                        type: AXPWidgetsCatalog$1.number,
                         options: {
                             min: 0,
                             placeholder: '@maintenance-management:activity-type-resources.entities.activity-type-resource.fields.count.placeholder',
@@ -5283,7 +5565,7 @@ async function factory$e() {
                     dataType: 'string',
                     visible: '{{ ((context.eval("resourceType") && context.eval("resourceType").id) || context.eval("resourceType")) === "inventoryitem" }}',
                     interface: {
-                        type: AXPWidgetsCatalog.text,
+                        type: AXPWidgetsCatalog$1.text,
                         options: {
                             placeholder: '@maintenance-management:activity-type-resources.entities.activity-type-resource.fields.resource-id.placeholder',
                         },
@@ -5298,7 +5580,7 @@ async function factory$e() {
                     dataType: 'array',
                     visible: '{{ ["assettype","jobdefinition"].includes((context.eval("resourceType") && context.eval("resourceType").id) || context.eval("resourceType")) }}',
                     interface: {
-                        type: AXPWidgetsCatalog.lookup,
+                        type: AXPWidgetsCatalog$1.lookup,
                         options: {
                             look: 'drop-down',
                             multiple: true,
@@ -5316,7 +5598,7 @@ async function factory$e() {
                 schema: {
                     dataType: 'number',
                     interface: {
-                        type: AXPWidgetsCatalog.number,
+                        type: AXPWidgetsCatalog$1.number,
                         options: {
                             min: 0,
                             placeholder: '@maintenance-management:activity-type-resources.entities.activity-type-resource.fields.initial-estimated-time.placeholder',
@@ -5331,7 +5613,7 @@ async function factory$e() {
                 schema: {
                     dataType: 'string',
                     interface: {
-                        type: AXPWidgetsCatalog.largeText,
+                        type: AXPWidgetsCatalog$1.largeText,
                         options: {
                             placeholder: '@maintenance-management:activity-type-resources.entities.activity-type-resource.fields.description.placeholder',
                         },
@@ -5345,7 +5627,7 @@ async function factory$e() {
                 schema: {
                     dataType: 'string',
                     interface: {
-                        type: AXPWidgetsCatalog.text,
+                        type: AXPWidgetsCatalog$1.text,
                         options: {
                             readonly: true,
                         },
@@ -5412,15 +5694,14 @@ async function factory$e() {
     return entityDef;
 }
 
-var index = /*#__PURE__*/Object.freeze({
+//#endregion
+
+var index$e = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    activityTypeResourceEntityFactory: factory$e
+    factoryActivityTypeResource: factoryActivityTypeResource
 });
 
-//#region ----   Types   ----
-//#endregion
-
-async function factory$d() {
+async function factoryFailureCause() {
     const entityDef = {
         module: RootConfig.module.name,
         name: RootConfig.entities.failureCause.name,
@@ -5452,7 +5733,7 @@ async function factory$d() {
                 schema: {
                     dataType: 'string',
                     interface: {
-                        type: AXPWidgetsCatalog.text,
+                        type: AXPWidgetsCatalog$1.text,
                         options: {
                             placeholder: '@maintenance-management:failure-causes.entities.failure-cause.fields.code.placeholder',
                         },
@@ -5474,7 +5755,7 @@ async function factory$d() {
                 schema: {
                     dataType: 'string',
                     interface: {
-                        type: AXPWidgetsCatalog.text,
+                        type: AXPWidgetsCatalog$1.text,
                         options: {
                             placeholder: '@maintenance-management:failure-causes.entities.failure-cause.fields.title.placeholder',
                         },
@@ -5496,7 +5777,7 @@ async function factory$d() {
                 schema: {
                     dataType: 'string',
                     interface: {
-                        type: AXPWidgetsCatalog.largeText,
+                        type: AXPWidgetsCatalog$1.largeText,
                         options: {
                             placeholder: '@maintenance-management:failure-causes.entities.failure-cause.fields.description.placeholder',
                         },
@@ -5517,7 +5798,7 @@ async function factory$d() {
                 schema: {
                     dataType: 'object',
                     interface: {
-                        type: AXPWidgetsCatalog.lookup,
+                        type: AXPWidgetsCatalog$1.lookup,
                         options: {
                             look: 'select',
                             entity: `${RootConfig.module.name}.${RootConfig.entities.failureCause.name}`,
@@ -5701,15 +5982,14 @@ async function factory$d() {
     return entityDef;
 }
 
-var failureCause_entity = /*#__PURE__*/Object.freeze({
+//#endregion
+
+var index$d = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    factory: factory$d
+    factoryFailureCause: factoryFailureCause
 });
 
-//#region ----   Types   ----
-//#endregion
-
-async function factory$c() {
+async function factoryFailureMechanism() {
     const entityDef = {
         module: RootConfig.module.name,
         name: RootConfig.entities.failureMechanism.name,
@@ -5741,7 +6021,7 @@ async function factory$c() {
                 schema: {
                     dataType: 'string',
                     interface: {
-                        type: AXPWidgetsCatalog.text,
+                        type: AXPWidgetsCatalog$1.text,
                         options: {
                             placeholder: '@maintenance-management:failure-mechanisms.entities.failure-mechanism.fields.code.placeholder',
                         },
@@ -5763,7 +6043,7 @@ async function factory$c() {
                 schema: {
                     dataType: 'string',
                     interface: {
-                        type: AXPWidgetsCatalog.text,
+                        type: AXPWidgetsCatalog$1.text,
                         options: {
                             placeholder: '@maintenance-management:failure-mechanisms.entities.failure-mechanism.fields.title.placeholder',
                         },
@@ -5785,7 +6065,7 @@ async function factory$c() {
                 schema: {
                     dataType: 'string',
                     interface: {
-                        type: AXPWidgetsCatalog.largeText,
+                        type: AXPWidgetsCatalog$1.largeText,
                         options: {
                             placeholder: '@maintenance-management:failure-mechanisms.entities.failure-mechanism.fields.description.placeholder',
                         },
@@ -5806,7 +6086,7 @@ async function factory$c() {
                 schema: {
                     dataType: 'object',
                     interface: {
-                        type: AXPWidgetsCatalog.lookup,
+                        type: AXPWidgetsCatalog$1.lookup,
                         options: {
                             look: 'select',
                             entity: `${RootConfig.module.name}.${RootConfig.entities.failureMechanism.name}`,
@@ -5990,15 +6270,14 @@ async function factory$c() {
     return entityDef;
 }
 
-var failureMechanism_entity = /*#__PURE__*/Object.freeze({
+//#endregion
+
+var index$c = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    factory: factory$c
+    factoryFailureMechanism: factoryFailureMechanism
 });
 
-//#region ----   Types   ----
-//#endregion
-
-async function factory$b() {
+async function factoryFailureDetection() {
     const entityDef = {
         module: RootConfig.module.name,
         name: RootConfig.entities.failureDetection.name,
@@ -6030,7 +6309,7 @@ async function factory$b() {
                 schema: {
                     dataType: 'string',
                     interface: {
-                        type: AXPWidgetsCatalog.text,
+                        type: AXPWidgetsCatalog$1.text,
                         options: {
                             placeholder: '@maintenance-management:failure-detections.entities.failure-detection.fields.code.placeholder',
                         },
@@ -6052,7 +6331,7 @@ async function factory$b() {
                 schema: {
                     dataType: 'string',
                     interface: {
-                        type: AXPWidgetsCatalog.text,
+                        type: AXPWidgetsCatalog$1.text,
                         options: {
                             placeholder: '@maintenance-management:failure-detections.entities.failure-detection.fields.title.placeholder',
                         },
@@ -6074,7 +6353,7 @@ async function factory$b() {
                 schema: {
                     dataType: 'string',
                     interface: {
-                        type: AXPWidgetsCatalog.largeText,
+                        type: AXPWidgetsCatalog$1.largeText,
                         options: {
                             placeholder: '@maintenance-management:failure-detections.entities.failure-detection.fields.description.placeholder',
                         },
@@ -6095,7 +6374,7 @@ async function factory$b() {
                 schema: {
                     dataType: 'object',
                     interface: {
-                        type: AXPWidgetsCatalog.lookup,
+                        type: AXPWidgetsCatalog$1.lookup,
                         options: {
                             look: 'select',
                             entity: `${RootConfig.module.name}.${RootConfig.entities.failureDetection.name}`,
@@ -6279,15 +6558,14 @@ async function factory$b() {
     return entityDef;
 }
 
-var failureDetection_entity = /*#__PURE__*/Object.freeze({
+//#endregion
+
+var index$b = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    factory: factory$b
+    factoryFailureDetection: factoryFailureDetection
 });
 
-//#region ----   Types   ----
-//#endregion
-
-async function factory$a() {
+async function factoryFailureType() {
     const entityDef = {
         module: RootConfig.module.name,
         name: RootConfig.entities.failureType.name,
@@ -6324,7 +6602,7 @@ async function factory$a() {
                 schema: {
                     dataType: 'string',
                     interface: {
-                        type: AXPWidgetsCatalog.text,
+                        type: AXPWidgetsCatalog$1.text,
                         options: {
                             placeholder: '@maintenance-management:failure-types.entities.failure-type.fields.code.placeholder',
                         },
@@ -6346,7 +6624,7 @@ async function factory$a() {
                 schema: {
                     dataType: 'string',
                     interface: {
-                        type: AXPWidgetsCatalog.text,
+                        type: AXPWidgetsCatalog$1.text,
                         options: {
                             placeholder: '@maintenance-management:failure-types.entities.failure-type.fields.title.placeholder',
                         },
@@ -6368,7 +6646,7 @@ async function factory$a() {
                 schema: {
                     dataType: 'string',
                     interface: {
-                        type: AXPWidgetsCatalog.largeText,
+                        type: AXPWidgetsCatalog$1.largeText,
                         options: {
                             placeholder: '@maintenance-management:failure-types.entities.failure-type.fields.description.placeholder',
                         },
@@ -6389,7 +6667,7 @@ async function factory$a() {
                 schema: {
                     dataType: 'object',
                     interface: {
-                        type: AXPWidgetsCatalog.lookup,
+                        type: AXPWidgetsCatalog$1.lookup,
                         options: {
                             look: 'select',
                             entity: `${RootConfig.module.name}.${RootConfig.entities.failureType.name}`,
@@ -6573,21 +6851,20 @@ async function factory$a() {
     return entityDef;
 }
 
-var failureType_entity = /*#__PURE__*/Object.freeze({
+//#endregion
+
+var index$a = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    factory: factory$a
+    factoryFailureType: factoryFailureType
 });
 
-//#region ----   Types   ----
-//#endregion
-
 const prioritySelectDataSource$2 = [
     { id: 'critical', title: '@maintenance-management:failure-modes.priorities.critical' },
     { id: 'high', title: '@maintenance-management:failure-modes.priorities.high' },
     { id: 'medium', title: '@maintenance-management:failure-modes.priorities.medium' },
     { id: 'low', title: '@maintenance-management:failure-modes.priorities.low' },
 ];
-async function factory$9() {
+async function factoryFailureMode() {
     const entityDef = {
         module: RootConfig.module.name,
         name: RootConfig.entities.failureMode.name,
@@ -6686,7 +6963,7 @@ async function factory$9() {
                 schema: {
                     dataType: 'string',
                     interface: {
-                        type: AXPWidgetsCatalog.text,
+                        type: AXPWidgetsCatalog$1.text,
                         options: {
                             placeholder: '@maintenance-management:failure-modes.entities.failure-mode.fields.code.placeholder',
                         },
@@ -6708,7 +6985,7 @@ async function factory$9() {
                 schema: {
                     dataType: 'string',
                     interface: {
-                        type: AXPWidgetsCatalog.text,
+                        type: AXPWidgetsCatalog$1.text,
                         options: {
                             placeholder: '@maintenance-management:failure-modes.entities.failure-mode.fields.title.placeholder',
                         },
@@ -6730,7 +7007,7 @@ async function factory$9() {
                 schema: {
                     dataType: 'object',
                     interface: {
-                        type: AXPWidgetsCatalog.lookup,
+                        type: AXPWidgetsCatalog$1.lookup,
                         options: {
                             look: 'select',
                             entity: `${RootConfig.module.name}.${RootConfig.entities.failureType.name}`,
@@ -6757,7 +7034,7 @@ async function factory$9() {
                 schema: {
                     dataType: 'string',
                     interface: {
-                        type: AXPWidgetsCatalog.select,
+                        type: AXPWidgetsCatalog$1.select,
                         options: {
                             valueField: 'id',
                             textField: 'title',
@@ -6782,7 +7059,7 @@ async function factory$9() {
                 schema: {
                     dataType: 'array',
                     interface: {
-                        type: AXPWidgetsCatalog.lookup,
+                        type: AXPWidgetsCatalog$1.lookup,
                         options: {
                             look: 'drop-down',
                             multiple: true,
@@ -6807,7 +7084,7 @@ async function factory$9() {
                 schema: {
                     dataType: 'number',
                     interface: {
-                        type: AXPWidgetsCatalog.number,
+                        type: AXPWidgetsCatalog$1.number,
                         options: {
                             minValue: 0,
                             step: 1,
@@ -6830,7 +7107,7 @@ async function factory$9() {
                 schema: {
                     dataType: 'boolean',
                     interface: {
-                        type: AXPWidgetsCatalog.toggle,
+                        type: AXPWidgetsCatalog$1.toggle,
                         options: {
                             trueText: '@general:terms.common.yes-no.yes',
                             falseText: '@general:terms.common.yes-no.no',
@@ -6852,7 +7129,7 @@ async function factory$9() {
                 schema: {
                     dataType: 'string',
                     interface: {
-                        type: AXPWidgetsCatalog.largeText,
+                        type: AXPWidgetsCatalog$1.largeText,
                         options: {
                             placeholder: '@maintenance-management:failure-modes.entities.failure-mode.fields.description.placeholder',
                         },
@@ -7094,15 +7371,14 @@ async function factory$9() {
     return entityDef;
 }
 
-var failureMode_entity = /*#__PURE__*/Object.freeze({
+//#endregion
+
+var index$9 = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    factory: factory$9
+    factoryFailureMode: factoryFailureMode
 });
 
-//#region ----   Types   ----
-//#endregion
-
-async function factory$8() {
+async function factoryFailureEffect() {
     const entityDef = {
         module: RootConfig.module.name,
         name: RootConfig.entities.failureEffect.name,
@@ -7134,7 +7410,7 @@ async function factory$8() {
                 schema: {
                     dataType: 'string',
                     interface: {
-                        type: AXPWidgetsCatalog.text,
+                        type: AXPWidgetsCatalog$1.text,
                         options: {
                             placeholder: '@maintenance-management:failure-effects.entities.failure-effect.fields.code.placeholder',
                         },
@@ -7156,7 +7432,7 @@ async function factory$8() {
                 schema: {
                     dataType: 'string',
                     interface: {
-                        type: AXPWidgetsCatalog.text,
+                        type: AXPWidgetsCatalog$1.text,
                         options: {
                             placeholder: '@maintenance-management:failure-effects.entities.failure-effect.fields.title.placeholder',
                         },
@@ -7178,7 +7454,7 @@ async function factory$8() {
                 schema: {
                     dataType: 'string',
                     interface: {
-                        type: AXPWidgetsCatalog.largeText,
+                        type: AXPWidgetsCatalog$1.largeText,
                         options: {
                             placeholder: '@maintenance-management:failure-effects.entities.failure-effect.fields.description.placeholder',
                         },
@@ -7199,7 +7475,7 @@ async function factory$8() {
                 schema: {
                     dataType: 'object',
                     interface: {
-                        type: AXPWidgetsCatalog.lookup,
+                        type: AXPWidgetsCatalog$1.lookup,
                         options: {
                             look: 'select',
                             entity: `${RootConfig.module.name}.${RootConfig.entities.failureEffect.name}`,
@@ -7263,15 +7539,14 @@ async function factory$8() {
     return entityDef;
 }
 
-var failureEffect_entity = /*#__PURE__*/Object.freeze({
+//#endregion
+
+var index$8 = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    factory: factory$8
+    factoryFailureEffect: factoryFailureEffect
 });
 
-//#region ----   Types   ----
-//#endregion
-
-async function factory$7() {
+async function factoryFailureSeverity() {
     const entityDef = {
         module: RootConfig.module.name,
         name: RootConfig.entities.failureSeverity.name,
@@ -7304,7 +7579,7 @@ async function factory$7() {
                     unique: { enabled: true },
                     readonly: '{{ context.eval("id") }}',
                     interface: {
-                        type: AXPWidgetsCatalog.text,
+                        type: AXPWidgetsCatalog$1.text,
                         options: {
                             disabled: '{{ context.eval("id") }}',
                             placeholder: '@maintenance-management:failure-severities.entities.failure-severity.fields.name.placeholder',
@@ -7327,7 +7602,7 @@ async function factory$7() {
                 schema: {
                     dataType: 'string',
                     interface: {
-                        type: AXPWidgetsCatalog.text,
+                        type: AXPWidgetsCatalog$1.text,
                         options: {
                             placeholder: '@maintenance-management:failure-severities.entities.failure-severity.fields.title.placeholder',
                         },
@@ -7349,7 +7624,7 @@ async function factory$7() {
                 schema: {
                     dataType: 'string',
                     interface: {
-                        type: AXPWidgetsCatalog.largeText,
+                        type: AXPWidgetsCatalog$1.largeText,
                         options: {
                             placeholder: '@maintenance-management:failure-severities.entities.failure-severity.fields.description.placeholder',
                         },
@@ -7400,14 +7675,13 @@ async function factory$7() {
     return entityDef;
 }
 
-var failureSeverity_entity = /*#__PURE__*/Object.freeze({
+//#endregion
+
+var index$7 = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    factory: factory$7
+    factoryFailureSeverity: factoryFailureSeverity
 });
 
-//#region ----   Types   ----
-//#endregion
-
 const riskLevelSelectDataSource = [
     { id: 'low', title: '@maintenance-management:failure-mode-solutions.risk-levels.low' },
     { id: 'medium', title: '@maintenance-management:failure-mode-solutions.risk-levels.medium' },
@@ -7420,7 +7694,7 @@ const solutionTypeSelectDataSource = [
     { id: 'workaround', title: '@maintenance-management:failure-mode-solutions.solution-types.workaround' },
     { id: 'preventive', title: '@maintenance-management:failure-mode-solutions.solution-types.preventive' },
 ];
-async function factory$6() {
+async function factoryFailureModeSolution() {
     const entityDef = {
         module: RootConfig.module.name,
         name: RootConfig.entities.failureModeSolution.name,
@@ -7453,7 +7727,7 @@ async function factory$6() {
                 schema: {
                     dataType: 'string',
                     interface: {
-                        type: AXPWidgetsCatalog.text,
+                        type: AXPWidgetsCatalog$1.text,
                         options: {
                             placeholder: '@maintenance-management:failure-mode-solutions.entities.failure-mode-solution.fields.code.placeholder',
                         },
@@ -7475,7 +7749,7 @@ async function factory$6() {
                 schema: {
                     dataType: 'string',
                     interface: {
-                        type: AXPWidgetsCatalog.text,
+                        type: AXPWidgetsCatalog$1.text,
                         options: {
                             placeholder: '@maintenance-management:failure-mode-solutions.entities.failure-mode-solution.fields.title.placeholder',
                         },
@@ -7499,7 +7773,7 @@ async function factory$6() {
                     visible: false,
                     readonly: true,
                     interface: {
-                        type: AXPWidgetsCatalog.lookup,
+                        type: AXPWidgetsCatalog$1.lookup,
                         options: {
                             look: 'select',
                             entity: `${RootConfig.module.name}.${RootConfig.entities.failureMode.name}`,
@@ -7528,7 +7802,7 @@ async function factory$6() {
                 schema: {
                     dataType: 'string',
                     interface: {
-                        type: AXPWidgetsCatalog.largeText,
+                        type: AXPWidgetsCatalog$1.largeText,
                         options: {
                             placeholder: '@maintenance-management:failure-mode-solutions.entities.failure-mode-solution.fields.description.placeholder',
                         },
@@ -7549,7 +7823,7 @@ async function factory$6() {
                 schema: {
                     dataType: 'string',
                     interface: {
-                        type: AXPWidgetsCatalog.select,
+                        type: AXPWidgetsCatalog$1.select,
                         options: {
                             valueField: 'id',
                             textField: 'title',
@@ -7573,7 +7847,7 @@ async function factory$6() {
                 schema: {
                     dataType: 'string',
                     interface: {
-                        type: AXPWidgetsCatalog.select,
+                        type: AXPWidgetsCatalog$1.select,
                         options: {
                             valueField: 'id',
                             textField: 'title',
@@ -7597,7 +7871,7 @@ async function factory$6() {
                 schema: {
                     dataType: 'number',
                     interface: {
-                        type: AXPWidgetsCatalog.number,
+                        type: AXPWidgetsCatalog$1.number,
                         options: {
                             minValue: 0,
                             maxValue: 100,
@@ -7621,7 +7895,7 @@ async function factory$6() {
                 schema: {
                     dataType: 'number',
                     interface: {
-                        type: AXPWidgetsCatalog.number,
+                        type: AXPWidgetsCatalog$1.number,
                         options: {
                             minValue: 0,
                             step: 0.01,
@@ -7694,14 +7968,13 @@ async function factory$6() {
     return entityDef;
 }
 
-var failureModeSolution_entity = /*#__PURE__*/Object.freeze({
+//#endregion
+
+var index$6 = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    factory: factory$6
+    factoryFailureModeSolution: factoryFailureModeSolution
 });
 
-//#region ----   Types   ----
-//#endregion
-
 const prioritySelectDataSource$1 = [
     {
         id: 'critical',
@@ -7720,7 +7993,7 @@ const prioritySelectDataSource$1 = [
         title: '@maintenance-management:failure-modes.priority.low',
     },
 ];
-async function factory$5() {
+async function factoryFailureModeAssetType() {
     const entityDef = {
         module: RootConfig.module.name,
         name: RootConfig.entities.failureModeAssetType.name,
@@ -7756,7 +8029,7 @@ async function factory$5() {
                 schema: {
                     dataType: 'string',
                     interface: {
-                        type: AXPWidgetsCatalog.lookup,
+                        type: AXPWidgetsCatalog$1.lookup,
                         options: {
                             look: 'select',
                             entity: `${RootConfig.module.name}.${RootConfig.entities.failureMode.name}`,
@@ -7785,7 +8058,7 @@ async function factory$5() {
                 schema: {
                     dataType: 'string',
                     interface: {
-                        type: AXPWidgetsCatalog.lookup,
+                        type: AXPWidgetsCatalog$1.lookup,
                         options: {
                             look: 'select',
                             entity: `AssetManagement.AssetType`,
@@ -7814,7 +8087,7 @@ async function factory$5() {
                 schema: {
                     dataType: 'string',
                     interface: {
-                        type: AXPWidgetsCatalog.select,
+                        type: AXPWidgetsCatalog$1.select,
                         options: {
                             valueField: 'id',
                             textField: 'title',
@@ -7838,7 +8111,7 @@ async function factory$5() {
                 schema: {
                     dataType: 'boolean',
                     interface: {
-                        type: AXPWidgetsCatalog.toggle,
+                        type: AXPWidgetsCatalog$1.toggle,
                         options: {
                             trueText: '@general:terms.common.yes-no.yes',
                             falseText: '@general:terms.common.yes-no.no',
@@ -7860,7 +8133,7 @@ async function factory$5() {
                 schema: {
                     dataType: 'boolean',
                     interface: {
-                        type: AXPWidgetsCatalog.toggle,
+                        type: AXPWidgetsCatalog$1.toggle,
                         options: {
                             trueText: '@general:terms.common.yes-no.yes',
                             falseText: '@general:terms.common.yes-no.no',
@@ -7882,7 +8155,7 @@ async function factory$5() {
                 schema: {
                     dataType: 'string',
                     interface: {
-                        type: AXPWidgetsCatalog.largeText,
+                        type: AXPWidgetsCatalog$1.largeText,
                         options: {
                             placeholder: '@maintenance-management:failure-mode-asset-types.entities.failure-mode-asset-type.fields.description.placeholder',
                         },
@@ -7945,15 +8218,14 @@ async function factory$5() {
     return entityDef;
 }
 
-var failureModeAssetType_entity = /*#__PURE__*/Object.freeze({
+//#endregion
+
+var index$5 = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    factory: factory$5
+    factoryFailureModeAssetType: factoryFailureModeAssetType
 });
 
-//#region ----   Types   ----
-//#endregion
-
-async function factory$4() {
+async function factoryFailureModeMechanism() {
     const entityDef = {
         module: RootConfig.module.name,
         name: RootConfig.entities.failureModeMechanism.name,
@@ -7983,7 +8255,7 @@ async function factory$4() {
                 schema: {
                     dataType: 'string',
                     interface: {
-                        type: AXPWidgetsCatalog.lookup,
+                        type: AXPWidgetsCatalog$1.lookup,
                         options: {
                             look: 'select',
                             entity: `${RootConfig.module.name}.${RootConfig.entities.failureMode.name}`,
@@ -8012,7 +8284,7 @@ async function factory$4() {
                 schema: {
                     dataType: 'string',
                     interface: {
-                        type: AXPWidgetsCatalog.lookup,
+                        type: AXPWidgetsCatalog$1.lookup,
                         options: {
                             look: 'select',
                             entity: `${RootConfig.module.name}.${RootConfig.entities.failureMechanism.name}`,
@@ -8071,14 +8343,13 @@ async function factory$4() {
     return entityDef;
 }
 
-var failureModeMechanism_entity = /*#__PURE__*/Object.freeze({
+//#endregion
+
+var index$4 = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    factory: factory$4
+    factoryFailureModeMechanism: factoryFailureModeMechanism
 });
 
-//#region ----   Types   ----
-//#endregion
-
 const prioritySelectDataSource = [
     { id: 'critical', title: '@maintenance-management:failure-modes.priorities.critical' },
     { id: 'high', title: '@maintenance-management:failure-modes.priorities.high' },
@@ -8091,7 +8362,7 @@ const defaultFailureRegisterValues = {
     priorityId: 'medium',
     failureSeverityId: 'failure-severity-moderate',
 };
-async function factory$3() {
+async function factoryFailureRegister() {
     const entityDef = {
         module: RootConfig.module.name,
         name: RootConfig.entities.failureRegister.name,
@@ -8149,7 +8420,7 @@ async function factory$3() {
                     dataType: 'string',
                     unique: { enabled: true },
                     interface: {
-                        type: AXPWidgetsCatalog.text,
+                        type: AXPWidgetsCatalog$1.text,
                         options: {
                             disabled: true,
                             placeholder: '@maintenance-management:failure-registers.entities.failure-register.fields.code.placeholder',
@@ -8173,7 +8444,7 @@ async function factory$3() {
                     dataType: 'date',
                     defaultValue: '{{ context.eval("date") ? context.eval("date") : new Date().toISOString() }}',
                     interface: {
-                        type: AXPWidgetsCatalog.dateTime,
+                        type: AXPWidgetsCatalog$1.dateTime,
                         options: {
                             format: 'date',
                         },
@@ -8195,7 +8466,7 @@ async function factory$3() {
                 schema: {
                     dataType: 'string',
                     interface: {
-                        type: AXPWidgetsCatalog.lookup,
+                        type: AXPWidgetsCatalog$1.lookup,
                         options: {
                             look: 'select',
                             entity: `AssetManagement.Asset`,
@@ -8232,7 +8503,7 @@ async function factory$3() {
                 schema: {
                     dataType: 'string',
                     interface: {
-                        type: AXPWidgetsCatalog.lookup,
+                        type: AXPWidgetsCatalog$1.lookup,
                         options: {
                             look: 'select',
                             entity: `AssetManagement.AssetSystem`,
@@ -8261,7 +8532,7 @@ async function factory$3() {
                     dataType: 'string',
                     defaultValue: defaultFailureRegisterValues.failureModeId,
                     interface: {
-                        type: AXPWidgetsCatalog.lookup,
+                        type: AXPWidgetsCatalog$1.lookup,
                         options: {
                             look: 'select',
                             entity: `${RootConfig.module.name}.${RootConfig.entities.failureMode.name}`,
@@ -8291,7 +8562,7 @@ async function factory$3() {
                     dataType: 'string',
                     defaultValue: defaultFailureRegisterValues.failureDetectionId,
                     interface: {
-                        type: AXPWidgetsCatalog.lookup,
+                        type: AXPWidgetsCatalog$1.lookup,
                         options: {
                             look: 'select',
                             entity: `${RootConfig.module.name}.${RootConfig.entities.failureDetection.name}`,
@@ -8321,7 +8592,7 @@ async function factory$3() {
                     dataType: 'string',
                     defaultValue: defaultFailureRegisterValues.priorityId,
                     interface: {
-                        type: AXPWidgetsCatalog.select,
+                        type: AXPWidgetsCatalog$1.select,
                         options: {
                             valueField: 'id',
                             textField: 'title',
@@ -8347,7 +8618,7 @@ async function factory$3() {
                     dataType: 'string',
                     defaultValue: defaultFailureRegisterValues.failureSeverityId,
                     interface: {
-                        type: AXPWidgetsCatalog.lookup,
+                        type: AXPWidgetsCatalog$1.lookup,
                         options: {
                             look: 'select',
                             entity: `${RootConfig.module.name}.${RootConfig.entities.failureSeverity.name}`,
@@ -8376,7 +8647,7 @@ async function factory$3() {
                 schema: {
                     dataType: 'array',
                     interface: {
-                        type: AXPWidgetsCatalog.lookup,
+                        type: AXPWidgetsCatalog$1.lookup,
                         options: {
                             look: 'drop-down',
                             multiple: true,
@@ -8401,7 +8672,7 @@ async function factory$3() {
                 schema: {
                     dataType: 'array',
                     interface: {
-                        type: AXPWidgetsCatalog.lookup,
+                        type: AXPWidgetsCatalog$1.lookup,
                         options: {
                             look: 'drop-down',
                             multiple: true,
@@ -8426,7 +8697,7 @@ async function factory$3() {
                 schema: {
                     dataType: 'array',
                     interface: {
-                        type: AXPWidgetsCatalog.lookup,
+                        type: AXPWidgetsCatalog$1.lookup,
                         options: {
                             look: 'drop-down',
                             multiple: true,
@@ -8451,7 +8722,7 @@ async function factory$3() {
                 schema: {
                     dataType: 'string',
                     interface: {
-                        type: AXPWidgetsCatalog.largeText,
+                        type: AXPWidgetsCatalog$1.largeText,
                         options: {
                             placeholder: '@maintenance-management:failure-registers.entities.failure-register.fields.description.placeholder',
                         },
@@ -8540,15 +8811,14 @@ async function factory$3() {
     return entityDef;
 }
 
-var failureRegister_entity = /*#__PURE__*/Object.freeze({
+//#endregion
+
+var index$3 = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    factory: factory$3
+    factoryFailureRegister: factoryFailureRegister
 });
 
-//#region ----   Types   ----
-//#endregion
-
-async function factory$2() {
+async function factoryFailureRegisterCause() {
     const entityDef = {
         module: RootConfig.module.name,
         name: RootConfig.entities.failureRegisterCause.name,
@@ -8578,7 +8848,7 @@ async function factory$2() {
                 schema: {
                     dataType: 'string',
                     interface: {
-                        type: AXPWidgetsCatalog.lookup,
+                        type: AXPWidgetsCatalog$1.lookup,
                         options: {
                             look: 'select',
                             entity: `${RootConfig.module.name}.${RootConfig.entities.failureRegister.name}`,
@@ -8607,7 +8877,7 @@ async function factory$2() {
                 schema: {
                     dataType: 'string',
                     interface: {
-                        type: AXPWidgetsCatalog.lookup,
+                        type: AXPWidgetsCatalog$1.lookup,
                         options: {
                             look: 'select',
                             entity: `${RootConfig.module.name}.${RootConfig.entities.failureCause.name}`,
@@ -8666,15 +8936,14 @@ async function factory$2() {
     return entityDef;
 }
 
-var failureRegisterCause_entity = /*#__PURE__*/Object.freeze({
+//#endregion
+
+var index$2 = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    factory: factory$2
+    factoryFailureRegisterCause: factoryFailureRegisterCause
 });
 
-//#region ----   Types   ----
-//#endregion
-
-async function factory$1() {
+async function factoryFailureRegisterEffect() {
     const entityDef = {
         module: RootConfig.module.name,
         name: RootConfig.entities.failureRegisterEffect.name,
@@ -8704,7 +8973,7 @@ async function factory$1() {
                 schema: {
                     dataType: 'string',
                     interface: {
-                        type: AXPWidgetsCatalog.lookup,
+                        type: AXPWidgetsCatalog$1.lookup,
                         options: {
                             look: 'select',
                             entity: `${RootConfig.module.name}.${RootConfig.entities.failureRegister.name}`,
@@ -8733,7 +9002,7 @@ async function factory$1() {
                 schema: {
                     dataType: 'string',
                     interface: {
-                        type: AXPWidgetsCatalog.lookup,
+                        type: AXPWidgetsCatalog$1.lookup,
                         options: {
                             look: 'select',
                             entity: `${RootConfig.module.name}.${RootConfig.entities.failureEffect.name}`,
@@ -8792,15 +9061,14 @@ async function factory$1() {
     return entityDef;
 }
 
-var failureRegisterEffect_entity = /*#__PURE__*/Object.freeze({
+//#endregion
+
+var index$1 = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    factory: factory$1
+    factoryFailureRegisterEffect: factoryFailureRegisterEffect
 });
 
-//#region ----   Types   ----
-//#endregion
-
-async function factory() {
+async function factoryFailureRegisterMechanism() {
     const entityDef = {
         module: RootConfig.module.name,
         name: RootConfig.entities.failureRegisterMechanism.name,
@@ -8830,7 +9098,7 @@ async function factory() {
                 schema: {
                     dataType: 'string',
                     interface: {
-                        type: AXPWidgetsCatalog.lookup,
+                        type: AXPWidgetsCatalog$1.lookup,
                         options: {
                             look: 'select',
                             entity: `${RootConfig.module.name}.${RootConfig.entities.failureRegister.name}`,
@@ -8859,7 +9127,7 @@ async function factory() {
                 schema: {
                     dataType: 'string',
                     interface: {
-                        type: AXPWidgetsCatalog.lookup,
+                        type: AXPWidgetsCatalog$1.lookup,
                         options: {
                             look: 'select',
                             entity: `${RootConfig.module.name}.${RootConfig.entities.failureMechanism.name}`,
@@ -8918,14 +9186,16 @@ async function factory() {
     return entityDef;
 }
 
-var failureRegisterMechanism_entity = /*#__PURE__*/Object.freeze({
+//#endregion
+
+var index = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    factory: factory
+    factoryFailureRegisterMechanism: factoryFailureRegisterMechanism
 });
 
 /**
  * Generated bundle index. Do not edit.
  */
 
-export { AXMMaintenanceManagementDataSourceKeys, AXMMaintenanceManagementEntityProvider, AXMMaintenanceManagementFeatureKeys, AXMMaintenanceManagementMenuKeys, AXMMaintenanceManagementMenuProvider, AXMMaintenanceManagementModule, AXMMaintenanceManagementPermissionDefinitionProvider, AXMMaintenanceManagementPermissionKeys, AXMMaintenanceManagementSearchCommandProvider, AXMWorkOrderStatus, RootConfig, factory$f as activityTypeAssetTypeEntityFactory, factory$g as activityTypeEntityFactory, factory$e as activityTypeResourceEntityFactory, factory$d as failureCauseEntityFactory, factory$b as failureDetectionEntityFactory, factory$8 as failureEffectEntityFactory, factory$c as failureMechanismEntityFactory, factory$5 as failureModeAssetTypeEntityFactory, factory$9 as failureModeEntityFactory, factory$4 as failureModeMechanismEntityFactory, factory$6 as failureModeSolutionEntityFactory, factory$2 as failureRegisterCauseEntityFactory, factory$1 as failureRegisterEffectEntityFactory, factory$3 as failureRegisterEntityFactory, factory as failureRegisterMechanismEntityFactory, factory$7 as failureSeverityEntityFactory, factory$a as failureTypeEntityFactory, maintenancePlanEntityFactory, factory$h as maintenanceTemplateActivityTypeEntityFactory, maintenanceTemplateFailureModeEntityFactory, maintenanceTemplateResourceEntityFactory, factory$i as maintenanceTypeEntityFactory, workOrderEntityFactory, workPackageEntityFactory, workReportEntityFactory };
+export { AXMMaintenanceManagementDataSourceKeys, AXMMaintenanceManagementEntityProvider, AXMMaintenanceManagementFeatureKeys, AXMMaintenanceManagementMenuKeys, AXMMaintenanceManagementMenuProvider, AXMMaintenanceManagementModule, AXMMaintenanceManagementPermissionDefinitionProvider, AXMMaintenanceManagementPermissionKeys, AXMMaintenanceManagementSearchCommandProvider, AXMWorkOrderStatus, RootConfig, factoryActivityType, factoryActivityTypeAssetType, factoryActivityTypeResource, factoryFailureCause, factoryFailureDetection, factoryFailureEffect, factoryFailureMechanism, factoryFailureMode, factoryFailureModeAssetType, factoryFailureModeMechanism, factoryFailureModeSolution, factoryFailureRegister, factoryFailureRegisterCause, factoryFailureRegisterEffect, factoryFailureRegisterMechanism, factoryFailureSeverity, factoryFailureType, factoryMaintenanceTemplate, factoryMaintenanceTemplateActivityType, factoryMaintenanceType, maintenancePlanEntityFactory, maintenanceTemplateFailureModeEntityFactory, maintenanceTemplateResourceEntityFactory, workOrderEntityFactory, workPackageEntityFactory, workReportEntityFactory };
 //# sourceMappingURL=acorex-modules-maintenance-management.mjs.map