@acorex/connectivity 20.3.0-next.7 → 20.3.0-next.9

package/fesm2022/acorex-connectivity-mock.mjs

@@ -2,12 +2,12 @@ import { AXSafePipe } from '@acorex/core/pipes';
 import * as i2$1 from '@acorex/platform/auth';
 import { AXPAuthStrategy, AXP_TENANT_LOADER, AXP_APPLICATION_LOADER, AXP_FEATURE_LOADER, AXP_PERMISSION_LOADER, AXPSessionService, AXPAuthModule } from '@acorex/platform/auth';
 import * as i1$1 from '@acorex/platform/core';
-import { AXPDataGenerator, AXPActivityLogProvider, AXP_ACTIVITY_LOG_PROVIDER, AXP_DATASOURCE_DEFINITION_PROVIDER, AXP_DISTRIBUTED_EVENT_LISTENER_PROVIDER, objectKeyValueTransforms, AXPSystemActionType, applySortArray, applyFilterArray } from '@acorex/platform/core';
-import { AXPEntityDefinitionRegistryService, AXPEntityStorageService, AXP_DATA_SEEDER_TOKEN, AXP_ENTITY_STORAGE_BACKEND, AXPMiddlewareEntityStorageService, eventDispatchMiddleware, AXP_ENTITY_STORAGE_MIDDLEWARE, AXPDataSeederService } from '@acorex/platform/layout/entity';
+import { AXPDataGenerator, AXPActivityLogProvider, AXP_ACTIVITY_LOG_PROVIDER, AXP_DATASOURCE_DEFINITION_PROVIDER, AXP_DISTRIBUTED_EVENT_LISTENER_PROVIDER, objectKeyValueTransforms, AXPSystemActionType, applySortArray, applyFilterArray, AXPExpressionEvaluatorService } from '@acorex/platform/core';
+import { AXPEntityDefinitionRegistryService, AXPEntityStorageService, AXP_DATA_SEEDER_TOKEN, AXMEntityCrudServiceImpl, AXP_ENTITY_STORAGE_BACKEND, AXPMiddlewareAbortError, AXPMiddlewareEntityStorageService, AXP_ENTITY_STORAGE_MIDDLEWARE, eventDispatchMiddleware, AXPDataSeederService } from '@acorex/platform/layout/entity';
 import * as i0 from '@angular/core';
-import { inject, Injectable, NgModule, Injector } from '@angular/core';
+import { inject, Injectable, NgModule, Injector, runInInjectionContext } from '@angular/core';
 import { AXMDeviceSessionsService, AXMSessionStatusTypes, AXMDeviceSessionsServiceImpl, AXM_AUTH_CONFIG_TOKEN } from '@acorex/modules/auth';
-import { RootConfig, AXMUsersEntityService } from '@acorex/modules/security-management';
+import { RootConfig, AXMUsersEntityService, AXMPolicyService } from '@acorex/modules/security-management';
 import { Router } from '@angular/router';
 import { of, delay, filter, take, map, throttleTime } from 'rxjs';
 import { AXMPermissionsKeys, RootConfig as RootConfig$7, AXMFormTemplateTypes } from '@acorex/modules/form-template-management';
@@ -21,7 +21,8 @@ import { AXMChatManagementService, AXMChatRealtimeService, AXMCommentManagementS
 import { AXPBarChartWidget, AXPDonutChartWidget, AXPGaugeChartWidget, AXPLineChartWidget, AXPDashboardShortcutWidget, AXPAdvancedWeatherWidget, AXPAnalogClockWidget, AXPMinimalWeatherWidget, AXPStickyNoteWidget, RootConfig as RootConfig$4 } from '@acorex/modules/dashboard-management';
 import { AXPTaskBoardShortcut, AXPTaskBoardWidget, RootConfig as RootConfig$h } from '@acorex/modules/task-management';
 import { AXPMyNotificationDashboardWidget, RootConfig as RootConfig$b, AXMNotificationEntityServiceImpl, AXMNotificationEntityService } from '@acorex/modules/notification-management';
-import { RootConfig as RootConfig$5 } from '@acorex/modules/data-management';
+import { RootConfig as RootConfig$5, AXMMetaDataDefinitionService } from '@acorex/modules/data-management';
+import { get, set } from 'lodash-es';
 import { provideQuerySetups, AXPCommandService, provideCommandSetups, AXPQueryService, AXPRuntimeModule } from '@acorex/platform/runtime';
 import { AXMDistributionServiceImpl, AXMDocumentService, AXMDistributionInteractionService, RootConfig as RootConfig$6, AXMFolderServiceImpl, AXMDocumentServiceImpl, AXMReviewService, AXMReviewServiceImpl, AXMDistributionInteractionServiceImpl, AXMFolderService, AXMDistributionService } from '@acorex/modules/document-management';
 import { AXDataSource } from '@acorex/cdk/common';
@@ -29,10 +30,10 @@ import { AXPWidgetsCatalog } from '@acorex/platform/layout/builder';
 import { RootConfig as RootConfig$8 } from '@acorex/modules/locale-management';
 import { RootConfig as RootConfig$9 } from '@acorex/modules/location-management';
 import { RootConfig as RootConfig$a } from '@acorex/modules/log-management';
+import { AXPWidgetsList } from '@acorex/modules/common';
+import { AXP_REPORT_CATEGORY_PROVIDER, AXP_REPORT_DEFINITION_PROVIDER, RootConfig as RootConfig$g, AXPReportDefinitionService } from '@acorex/modules/report-management';
 import { RootConfig as RootConfig$c, AXMOrgChartNodeType } from '@acorex/modules/organization-management';
 import { RootConfig as RootConfig$d } from '@acorex/modules/human-capital-management';
-import { AXP_REPORT_CATEGORY_PROVIDER, AXP_REPORT_DEFINITION_PROVIDER, RootConfig as RootConfig$g, AXPReportDefinitionService } from '@acorex/modules/report-management';
-import { AXPWidgetsList } from '@acorex/modules/common';
 import { RootConfig as RootConfig$e } from '@acorex/modules/platform-management';
 import { RootConfig as RootConfig$f } from '@acorex/modules/project-management';
 import { RootConfig as RootConfig$i } from '@acorex/modules/training-management';
@@ -44,7 +45,6 @@ import { AXP_IDENTIFIER_RULES, AXPIdentifierService, AXPSimplePatternEngine, bui
 import { RootConfig as RootConfig$l } from '@acorex/modules/meeting-management';
 import * as i1 from '@acorex/components/dialog';
 import * as i2 from '@acorex/core/translation';
-import { get, set } from 'lodash-es';
 import { RootConfig as RootConfig$n } from '@acorex/modules/customer-management';
 import { AXCExternalAuthorizationService } from '@acorex/connectivity/utils';
 import { APPLICATION_SOURCE_NAME, MODULE_SOURCE_NAME, ENTITY_SOURCE_NAME, FEATURE_SOURCE_NAME, PERMISSION_SOURCE_NAME, PROPERTY_SOURCE_NAME, AXPModuleDesignerService } from '@acorex/modules/application-management';
@@ -4404,66 +4404,474 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.8", ngImpor
             type: Injectable
         }] });
 
-// const OHS_ID = AXPDataGenerator.uuid();
-// const child1 = {
-//   id: AXPDataGenerator.uuid(),
-//   title: 'General',
-//   parentId: OHS_ID,
-//   childCount: 0,
-// };
-// const child2 = {
-//   id: AXPDataGenerator.uuid(),
-//   title: 'License',
-//   parentId: OHS_ID,
-//   childCount: 0,
-// };
-// const child3 = {
-//   id: AXPDataGenerator.uuid(),
-//   title: 'Training',
-//   parentId: OHS_ID,
-//   childCount: 0,
-// };
-const METADATA_CATEGORY_MOCK = [
-    {
-        id: AXPDataGenerator.uuid(),
-        title: 'General',
-        childCount: 0,
-    },
-    // {
-    //   id: OHS_ID,
-    //   title: 'OHS',
-    //   childCount: 2,
-    //   children: [child1, child2,child3],
-    // },
-    // child1,
-    // child2,
-    // child3,
-];
-const checkbox$2 = '{"type":"document-layout","children":[{"type":"page-layout","children":[{"type":"checkbox-editor","name":"checkbox-editor1","options":{"label":"i accept","readonly":false,"disabled":false},"defaultValue":false,"path":"accept-check-box"}],"name":"page-layout1"}],"name":"document"}';
-const colorboxInterface = '{"type":"document-layout","children":[{"type":"page-layout","children":[{"type":"block-layout","name":"block-layout1","options":{"flexDirection":{"id":"ax-flex-row"},"flexJustifyContent":{"id":"ax-justify-normal"},"flexAlignItems":{"id":"ax-items-start"},"gap":2,"flexWrap":{"id":"ax-flex-nowrap"},"spacing":{"margin":"0px 0px 0px 0px","padding":"0px 0px 0px 0px"},"border":{"width":"0px","radius":"0px","color":"#000000","style":"none"},"flexOptions":{"gap":"0px","flexDirection":"row","flexWrap":"nowrap","justifyContent":"flex-start","alignItems":"flex-start"}}},"children":[{"type":"color-editor","name":"color-editor1","options":{"readonly":false,"disabled":false,"validations":{"required":{"rule":"required","message":"This field is required."}},"placeholder":"pick color"},"path":"color-box"}]}],"name":"page-layout1"}],"name":"document"}';
-const titleInterface$1 = '{"type":"document-layout","children":[{"type":"page-layout","children":[{"type":"text-editor","name":"title-editor1","meta":{"header":true},"options":{"multiple":false,"disabled":false,"hasClearButton":false,"validations":{"regex":null,"required":{"rule":"required","message":"This field is required."}}},"defaultValue":"","path":"title"}],"name":"page-layout1"}],"name":"document"}';
-const descriptionInterface$1 = '{"type":"document-layout","children":[{"type":"page-layout","children":[{"type":"text-editor","name":"description-editor1","meta":{"header":true},"options":{"multiple":false,"disabled":false,"hasClearButton":false},"defaultValue":"","path":"description"}],"name":"page-layout1"}],"name":"document"}';
-const contractNumberInterface$1 = '{"type":"document-layout","children":[{"type":"page-layout","children":[{"type":"number-editor","name":"number-editor1","meta":{"header":true},"options":{"multiple":false,"disabled":false,"hasClearButton":false},"defaultValue":"","path":"contract-number"}],"name":"page-layout1"}],"name":"document"}';
-const evaluatorInterface$1 = '{"type":"document-layout","children":[{"type":"page-layout","children":[{"type":"text-editor","name":"text-editor1","meta":{"header":true},"options":{"multiple":false,"disabled":false,"hasClearButton":false},"defaultValue":"","path":"evaluator"}],"name":"page-layout1"}],"name":"document"}';
-const companyInterface$1 = '{"type":"document-layout","children":[{"type":"page-layout","children":[{"type":"select-editor","name":"select-editor1"}],"name":"page-layout1"}],"name":"document"}';
+function generateMetadataCategories() {
+    const categories = [];
+    const roots = ['General', 'Document Management', 'Quality Control', 'Compliance', 'Project Management'];
+    const ids = new Map();
+    roots.forEach((title) => {
+        const id = AXPDataGenerator.uuid();
+        ids.set(title, id);
+        categories.push({
+            id,
+            title,
+            description: title === 'General'
+                ? 'Common metadata fields used across all document types'
+                : title === 'Document Management'
+                    ? 'Document creation, storage, and retrieval metadata'
+                    : title === 'Quality Control'
+                        ? 'Quality assurance and control metadata'
+                        : title === 'Compliance'
+                            ? 'Regulatory compliance and audit metadata'
+                            : 'Project planning and execution metadata',
+            childCount: 0,
+        });
+    });
+    const children = [
+        { parent: 'Document Management', children: ['Version Control', 'Access Control', 'Document Types'] },
+        { parent: 'Quality Control', children: ['Standards', 'Testing', 'Validation'] },
+        { parent: 'Compliance', children: ['Regulations', 'Audit Trail', 'Certifications'] },
+        { parent: 'Project Management', children: ['Planning', 'Resources', 'Timeline'] },
+    ];
+    children.forEach(({ parent, children }) => {
+        const parentId = ids.get(parent);
+        if (!parentId)
+            return;
+        children.forEach((title) => {
+            const id = AXPDataGenerator.uuid();
+            ids.set(title, id);
+            const descriptionMap = {
+                'Version Control': 'Document versioning and change tracking',
+                'Access Control': 'User permissions and access management',
+                'Document Types': 'Classification and categorization of documents',
+                Standards: 'Quality standards and specifications',
+                Testing: 'Test procedures and results tracking',
+                Validation: 'Data validation and verification processes',
+                Regulations: 'Regulatory requirements and compliance rules',
+                'Audit Trail': 'Activity logging and audit documentation',
+                Certifications: 'Certification and accreditation tracking',
+                Planning: 'Project planning and scheduling metadata',
+                Resources: 'Resource allocation and management',
+                Timeline: 'Project timeline and milestone tracking',
+            };
+            categories.push({ id, title, description: descriptionMap[title] ?? '', parentId, childCount: 0 });
+        });
+        const parentObj = categories.find((c) => c.id === parentId);
+        if (parentObj)
+            parentObj.childCount = children.length;
+    });
+    return categories;
+}
+const METADATA_CATEGORY_MOCK = generateMetadataCategories();
+// Interface definitions for different metadata types
+const titleInterface = '{"type":"text-editor","path":"title","options":{"validations":[{"rule":"required","message":"This field is required."}]}}';
+const descriptionInterface = '{"type":"large-text-editor","path":"description","options":{}}';
+const versionInterface = '{"type":"text-editor","path":"version","options":{"validations":[{"rule":"required","message":"This field is required."}]}}';
+const dateInterface = '{"type":"date-time-editor","path":"date","options":{"validations":[{"rule":"required","message":"This field is required."}]}}';
+const numberInterface = '{"type":"number-editor","path":"number","options":{"validations":[{"rule":"required","message":"This field is required."}]}}';
+const selectInterface = '{"type":"select-editor","path":"select","options":{"dataSource":"languages","validations":[{"rule":"required","message":"This field is required."}]}}';
+const checkboxInterface = '{"type":"checkbox-editor","path":"checkbox","options":{"label":"Checkbox"}}';
+const textAreaInterface = '{"type":"large-text-editor","path":"textarea","options":{}}';
+const textInterface = '{"type":"text-editor","path":"text","options":{"validations":[{"rule":"required","message":"This field is required."}]}}';
 const METADATA_MOCK = [
+    // General - Common metadata fields
     {
         id: AXPDataGenerator.uuid(),
         name: 'title',
         title: 'Title',
         defaultValue: '',
-        interface: titleInterface$1,
-        categoryIds: [METADATA_CATEGORY_MOCK[0].id],
-        categories: [METADATA_CATEGORY_MOCK[0]],
+        interface: titleInterface,
+        categoryIds: [METADATA_CATEGORY_MOCK.find((c) => c.title === 'General').id],
+        categories: [METADATA_CATEGORY_MOCK.find((c) => c.title === 'General')],
     },
     {
         id: AXPDataGenerator.uuid(),
         name: 'description',
         title: 'Description',
         defaultValue: '',
-        interface: descriptionInterface$1,
-        categoryIds: [METADATA_CATEGORY_MOCK[0].id],
-        categories: [METADATA_CATEGORY_MOCK[0]],
+        interface: descriptionInterface,
+        categoryIds: [METADATA_CATEGORY_MOCK.find((c) => c.title === 'General').id],
+        categories: [METADATA_CATEGORY_MOCK.find((c) => c.title === 'General')],
+    },
+    {
+        id: AXPDataGenerator.uuid(),
+        name: 'created-date',
+        title: 'Created Date',
+        defaultValue: '',
+        interface: dateInterface,
+        categoryIds: [METADATA_CATEGORY_MOCK.find((c) => c.title === 'General').id],
+        categories: [METADATA_CATEGORY_MOCK.find((c) => c.title === 'General')],
+    },
+    {
+        id: AXPDataGenerator.uuid(),
+        name: 'status',
+        title: 'Status',
+        defaultValue: 'Draft',
+        interface: selectInterface,
+        categoryIds: [METADATA_CATEGORY_MOCK.find((c) => c.title === 'General').id],
+        categories: [METADATA_CATEGORY_MOCK.find((c) => c.title === 'General')],
+    },
+    {
+        id: AXPDataGenerator.uuid(),
+        name: 'priority',
+        title: 'Priority',
+        defaultValue: 'Medium',
+        interface: selectInterface,
+        categoryIds: [METADATA_CATEGORY_MOCK.find((c) => c.title === 'General').id],
+        categories: [METADATA_CATEGORY_MOCK.find((c) => c.title === 'General')],
+    },
+    {
+        id: AXPDataGenerator.uuid(),
+        name: 'tags',
+        title: 'Tags',
+        defaultValue: '',
+        interface: textAreaInterface,
+        categoryIds: [METADATA_CATEGORY_MOCK.find((c) => c.title === 'General').id],
+        categories: [METADATA_CATEGORY_MOCK.find((c) => c.title === 'General')],
+    },
+    {
+        id: AXPDataGenerator.uuid(),
+        name: 'keywords',
+        title: 'Keywords',
+        defaultValue: '',
+        interface: textAreaInterface,
+        categoryIds: [METADATA_CATEGORY_MOCK.find((c) => c.title === 'General').id],
+        categories: [METADATA_CATEGORY_MOCK.find((c) => c.title === 'General')],
+    },
+    {
+        id: AXPDataGenerator.uuid(),
+        name: 'language',
+        title: 'Language',
+        defaultValue: 'English',
+        interface: selectInterface,
+        categoryIds: [METADATA_CATEGORY_MOCK.find((c) => c.title === 'General').id],
+        categories: [METADATA_CATEGORY_MOCK.find((c) => c.title === 'General')],
+    },
+    {
+        id: AXPDataGenerator.uuid(),
+        name: 'is-confidential',
+        title: 'Confidential',
+        defaultValue: 'false',
+        interface: checkboxInterface,
+        categoryIds: [METADATA_CATEGORY_MOCK.find((c) => c.title === 'General').id],
+        categories: [METADATA_CATEGORY_MOCK.find((c) => c.title === 'General')],
+    },
+    // Document Management - Version Control
+    {
+        id: AXPDataGenerator.uuid(),
+        name: 'document-title',
+        title: 'Document Title',
+        defaultValue: '',
+        interface: titleInterface,
+        categoryIds: [METADATA_CATEGORY_MOCK.find((c) => c.title === 'Version Control').id],
+        categories: [METADATA_CATEGORY_MOCK.find((c) => c.title === 'Version Control')],
+    },
+    {
+        id: AXPDataGenerator.uuid(),
+        name: 'document-version',
+        title: 'Document Version',
+        defaultValue: '1.0',
+        interface: versionInterface,
+        categoryIds: [METADATA_CATEGORY_MOCK.find((c) => c.title === 'Version Control').id],
+        categories: [METADATA_CATEGORY_MOCK.find((c) => c.title === 'Version Control')],
+    },
+    {
+        id: AXPDataGenerator.uuid(),
+        name: 'last-modified',
+        title: 'Last Modified',
+        defaultValue: '',
+        interface: dateInterface,
+        categoryIds: [METADATA_CATEGORY_MOCK.find((c) => c.title === 'Version Control').id],
+        categories: [METADATA_CATEGORY_MOCK.find((c) => c.title === 'Version Control')],
+    },
+    {
+        id: AXPDataGenerator.uuid(),
+        name: 'change-log',
+        title: 'Change Log',
+        defaultValue: '',
+        interface: textAreaInterface,
+        categoryIds: [METADATA_CATEGORY_MOCK.find((c) => c.title === 'Version Control').id],
+        categories: [METADATA_CATEGORY_MOCK.find((c) => c.title === 'Version Control')],
+    },
+    // Document Management - Access Control
+    {
+        id: AXPDataGenerator.uuid(),
+        name: 'access-level',
+        title: 'Access Level',
+        defaultValue: 'Public',
+        interface: selectInterface,
+        categoryIds: [METADATA_CATEGORY_MOCK.find((c) => c.title === 'Access Control').id],
+        categories: [METADATA_CATEGORY_MOCK.find((c) => c.title === 'Access Control')],
+    },
+    {
+        id: AXPDataGenerator.uuid(),
+        name: 'permissions',
+        title: 'Permissions',
+        defaultValue: '',
+        interface: textAreaInterface,
+        categoryIds: [METADATA_CATEGORY_MOCK.find((c) => c.title === 'Access Control').id],
+        categories: [METADATA_CATEGORY_MOCK.find((c) => c.title === 'Access Control')],
+    },
+    // Document Management - Document Types
+    {
+        id: AXPDataGenerator.uuid(),
+        name: 'document-type',
+        title: 'Document Type',
+        defaultValue: '',
+        interface: selectInterface,
+        categoryIds: [METADATA_CATEGORY_MOCK.find((c) => c.title === 'Document Types').id],
+        categories: [METADATA_CATEGORY_MOCK.find((c) => c.title === 'Document Types')],
+    },
+    {
+        id: AXPDataGenerator.uuid(),
+        name: 'document-category',
+        title: 'Document Category',
+        defaultValue: '',
+        interface: selectInterface,
+        categoryIds: [METADATA_CATEGORY_MOCK.find((c) => c.title === 'Document Types').id],
+        categories: [METADATA_CATEGORY_MOCK.find((c) => c.title === 'Document Types')],
+    },
+    {
+        id: AXPDataGenerator.uuid(),
+        name: 'file-format',
+        title: 'File Format',
+        defaultValue: '',
+        interface: selectInterface,
+        categoryIds: [METADATA_CATEGORY_MOCK.find((c) => c.title === 'Document Types').id],
+        categories: [METADATA_CATEGORY_MOCK.find((c) => c.title === 'Document Types')],
+    },
+    // Quality Control - Standards
+    {
+        id: AXPDataGenerator.uuid(),
+        name: 'quality-standard',
+        title: 'Quality Standard',
+        defaultValue: '',
+        interface: selectInterface,
+        categoryIds: [METADATA_CATEGORY_MOCK.find((c) => c.title === 'Standards').id],
+        categories: [METADATA_CATEGORY_MOCK.find((c) => c.title === 'Standards')],
+    },
+    {
+        id: AXPDataGenerator.uuid(),
+        name: 'compliance-level',
+        title: 'Compliance Level',
+        defaultValue: '',
+        interface: selectInterface,
+        categoryIds: [METADATA_CATEGORY_MOCK.find((c) => c.title === 'Standards').id],
+        categories: [METADATA_CATEGORY_MOCK.find((c) => c.title === 'Standards')],
+    },
+    {
+        id: AXPDataGenerator.uuid(),
+        name: 'standard-version',
+        title: 'Standard Version',
+        defaultValue: '',
+        interface: versionInterface,
+        categoryIds: [METADATA_CATEGORY_MOCK.find((c) => c.title === 'Standards').id],
+        categories: [METADATA_CATEGORY_MOCK.find((c) => c.title === 'Standards')],
+    },
+    // Quality Control - Testing
+    {
+        id: AXPDataGenerator.uuid(),
+        name: 'test-status',
+        title: 'Test Status',
+        defaultValue: 'Pending',
+        interface: selectInterface,
+        categoryIds: [METADATA_CATEGORY_MOCK.find((c) => c.title === 'Testing').id],
+        categories: [METADATA_CATEGORY_MOCK.find((c) => c.title === 'Testing')],
+    },
+    {
+        id: AXPDataGenerator.uuid(),
+        name: 'test-results',
+        title: 'Test Results',
+        defaultValue: '',
+        interface: textAreaInterface,
+        categoryIds: [METADATA_CATEGORY_MOCK.find((c) => c.title === 'Testing').id],
+        categories: [METADATA_CATEGORY_MOCK.find((c) => c.title === 'Testing')],
+    },
+    {
+        id: AXPDataGenerator.uuid(),
+        name: 'test-date',
+        title: 'Test Date',
+        defaultValue: '',
+        interface: dateInterface,
+        categoryIds: [METADATA_CATEGORY_MOCK.find((c) => c.title === 'Testing').id],
+        categories: [METADATA_CATEGORY_MOCK.find((c) => c.title === 'Testing')],
+    },
+    // Quality Control - Validation
+    {
+        id: AXPDataGenerator.uuid(),
+        name: 'validation-status',
+        title: 'Validation Status',
+        defaultValue: 'Not Validated',
+        interface: selectInterface,
+        categoryIds: [METADATA_CATEGORY_MOCK.find((c) => c.title === 'Validation').id],
+        categories: [METADATA_CATEGORY_MOCK.find((c) => c.title === 'Validation')],
+    },
+    {
+        id: AXPDataGenerator.uuid(),
+        name: 'validation-notes',
+        title: 'Validation Notes',
+        defaultValue: '',
+        interface: textAreaInterface,
+        categoryIds: [METADATA_CATEGORY_MOCK.find((c) => c.title === 'Validation').id],
+        categories: [METADATA_CATEGORY_MOCK.find((c) => c.title === 'Validation')],
+    },
+    // Compliance - Regulations
+    {
+        id: AXPDataGenerator.uuid(),
+        name: 'regulatory-framework',
+        title: 'Regulatory Framework',
+        defaultValue: '',
+        interface: selectInterface,
+        categoryIds: [METADATA_CATEGORY_MOCK.find((c) => c.title === 'Regulations').id],
+        categories: [METADATA_CATEGORY_MOCK.find((c) => c.title === 'Regulations')],
+    },
+    {
+        id: AXPDataGenerator.uuid(),
+        name: 'compliance-status',
+        title: 'Compliance Status',
+        defaultValue: 'Under Review',
+        interface: selectInterface,
+        categoryIds: [METADATA_CATEGORY_MOCK.find((c) => c.title === 'Regulations').id],
+        categories: [METADATA_CATEGORY_MOCK.find((c) => c.title === 'Regulations')],
+    },
+    {
+        id: AXPDataGenerator.uuid(),
+        name: 'regulation-reference',
+        title: 'Regulation Reference',
+        defaultValue: '',
+        interface: textAreaInterface,
+        categoryIds: [METADATA_CATEGORY_MOCK.find((c) => c.title === 'Regulations').id],
+        categories: [METADATA_CATEGORY_MOCK.find((c) => c.title === 'Regulations')],
+    },
+    // Compliance - Audit Trail
+    {
+        id: AXPDataGenerator.uuid(),
+        name: 'audit-trail',
+        title: 'Audit Trail',
+        defaultValue: '',
+        interface: textAreaInterface,
+        categoryIds: [METADATA_CATEGORY_MOCK.find((c) => c.title === 'Audit Trail').id],
+        categories: [METADATA_CATEGORY_MOCK.find((c) => c.title === 'Audit Trail')],
+    },
+    {
+        id: AXPDataGenerator.uuid(),
+        name: 'audit-date',
+        title: 'Audit Date',
+        defaultValue: '',
+        interface: dateInterface,
+        categoryIds: [METADATA_CATEGORY_MOCK.find((c) => c.title === 'Audit Trail').id],
+        categories: [METADATA_CATEGORY_MOCK.find((c) => c.title === 'Audit Trail')],
+    },
+    // Compliance - Certifications
+    {
+        id: AXPDataGenerator.uuid(),
+        name: 'certification-type',
+        title: 'Certification Type',
+        defaultValue: '',
+        interface: selectInterface,
+        categoryIds: [METADATA_CATEGORY_MOCK.find((c) => c.title === 'Certifications').id],
+        categories: [METADATA_CATEGORY_MOCK.find((c) => c.title === 'Certifications')],
+    },
+    {
+        id: AXPDataGenerator.uuid(),
+        name: 'certification-number',
+        title: 'Certification Number',
+        defaultValue: '',
+        interface: textInterface,
+        categoryIds: [METADATA_CATEGORY_MOCK.find((c) => c.title === 'Certifications').id],
+        categories: [METADATA_CATEGORY_MOCK.find((c) => c.title === 'Certifications')],
+    },
+    {
+        id: AXPDataGenerator.uuid(),
+        name: 'certification-expiry',
+        title: 'Certification Expiry',
+        defaultValue: '',
+        interface: dateInterface,
+        categoryIds: [METADATA_CATEGORY_MOCK.find((c) => c.title === 'Certifications').id],
+        categories: [METADATA_CATEGORY_MOCK.find((c) => c.title === 'Certifications')],
+    },
+    // Project Management - Planning
+    {
+        id: AXPDataGenerator.uuid(),
+        name: 'project-phase',
+        title: 'Project Phase',
+        defaultValue: 'Planning',
+        interface: selectInterface,
+        categoryIds: [METADATA_CATEGORY_MOCK.find((c) => c.title === 'Planning').id],
+        categories: [METADATA_CATEGORY_MOCK.find((c) => c.title === 'Planning')],
+    },
+    {
+        id: AXPDataGenerator.uuid(),
+        name: 'project-milestone',
+        title: 'Project Milestone',
+        defaultValue: '',
+        interface: textAreaInterface,
+        categoryIds: [METADATA_CATEGORY_MOCK.find((c) => c.title === 'Planning').id],
+        categories: [METADATA_CATEGORY_MOCK.find((c) => c.title === 'Planning')],
+    },
+    {
+        id: AXPDataGenerator.uuid(),
+        name: 'project-objectives',
+        title: 'Project Objectives',
+        defaultValue: '',
+        interface: textAreaInterface,
+        categoryIds: [METADATA_CATEGORY_MOCK.find((c) => c.title === 'Planning').id],
+        categories: [METADATA_CATEGORY_MOCK.find((c) => c.title === 'Planning')],
+    },
+    // Project Management - Resources
+    {
+        id: AXPDataGenerator.uuid(),
+        name: 'resource-allocation',
+        title: 'Resource Allocation',
+        defaultValue: '',
+        interface: textAreaInterface,
+        categoryIds: [METADATA_CATEGORY_MOCK.find((c) => c.title === 'Resources').id],
+        categories: [METADATA_CATEGORY_MOCK.find((c) => c.title === 'Resources')],
+    },
+    {
+        id: AXPDataGenerator.uuid(),
+        name: 'budget',
+        title: 'Budget',
+        defaultValue: '',
+        interface: numberInterface,
+        categoryIds: [METADATA_CATEGORY_MOCK.find((c) => c.title === 'Resources').id],
+        categories: [METADATA_CATEGORY_MOCK.find((c) => c.title === 'Resources')],
+    },
+    {
+        id: AXPDataGenerator.uuid(),
+        name: 'team-members',
+        title: 'Team Members',
+        defaultValue: '',
+        interface: textAreaInterface,
+        categoryIds: [METADATA_CATEGORY_MOCK.find((c) => c.title === 'Resources').id],
+        categories: [METADATA_CATEGORY_MOCK.find((c) => c.title === 'Resources')],
+    },
+    // Project Management - Timeline
+    {
+        id: AXPDataGenerator.uuid(),
+        name: 'start-date',
+        title: 'Start Date',
+        defaultValue: '',
+        interface: dateInterface,
+        categoryIds: [METADATA_CATEGORY_MOCK.find((c) => c.title === 'Timeline').id],
+        categories: [METADATA_CATEGORY_MOCK.find((c) => c.title === 'Timeline')],
+    },
+    {
+        id: AXPDataGenerator.uuid(),
+        name: 'end-date',
+        title: 'End Date',
+        defaultValue: '',
+        interface: dateInterface,
+        categoryIds: [METADATA_CATEGORY_MOCK.find((c) => c.title === 'Timeline').id],
+        categories: [METADATA_CATEGORY_MOCK.find((c) => c.title === 'Timeline')],
+    },
+    {
+        id: AXPDataGenerator.uuid(),
+        name: 'deadline',
+        title: 'Deadline',
+        defaultValue: '',
+        interface: dateInterface,
+        categoryIds: [METADATA_CATEGORY_MOCK.find((c) => c.title === 'Timeline').id],
+        categories: [METADATA_CATEGORY_MOCK.find((c) => c.title === 'Timeline')],
     },
 ];
 
@@ -4482,6 +4890,141 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.8", ngImpor
             type: Injectable
         }] });
 
+class AXCQueryCategoryMetadataInheritanceQuery {
+    constructor() {
+        this.injector = inject(Injector);
+        this.metaDataService = inject(AXMMetaDataDefinitionService);
+    }
+    async fetch(params) {
+        const { entityName, categoryId } = params;
+        //1a25158a-3e0f-4e9c-bdc2-d6cc0ece86ba
+        const service = runInInjectionContext(this.injector, () => new AXMEntityCrudServiceImpl(`${params.entityName}Category`));
+        // Find the category by ID
+        const category = await this.findCategoryById(categoryId, service);
+        if (!category) {
+            throw new Error(`Category with ID ${categoryId} not found`);
+        }
+        // Build the hierarchy (traverse up to root)
+        const hierarchy = await this.buildCategoryHierarchy(category, service);
+        // Collect all metadata fields from the hierarchy
+        //const inheritedMetadata = await this.collectInheritedMetadata(hierarchy);
+        const result = hierarchy.map(cat => get(cat, 'metaData')).flat() ?? [];
+        return result;
+    }
+    async findCategoryById(categoryId, service) {
+        try {
+            const result = await service.query({
+                filter: {
+                    logic: 'and',
+                    filters: [
+                        {
+                            field: 'id',
+                            operator: {
+                                type: 'equal',
+                            },
+                            value: categoryId,
+                        },
+                    ],
+                },
+                take: 1,
+                skip: 0,
+            });
+            return result.items.length > 0 ? result.items[0] : null;
+        }
+        catch (error) {
+            console.error('Error finding category by ID:', error);
+            return null;
+        }
+    }
+    async buildCategoryHierarchy(category, service) {
+        const hierarchy = [category];
+        let currentCategory = category;
+        // Traverse up the parent hierarchy
+        while (currentCategory.parentId) {
+            try {
+                const parentResult = await service.query({
+                    filter: {
+                        logic: 'and',
+                        filters: [
+                            {
+                                field: 'id',
+                                operator: {
+                                    type: 'equal',
+                                },
+                                value: currentCategory.parentId,
+                            },
+                        ],
+                    },
+                    take: 1,
+                    skip: 0,
+                });
+                if (parentResult.items.length > 0) {
+                    const parent = parentResult.items[0];
+                    hierarchy.unshift(parent); // Add to beginning to maintain hierarchy order
+                    currentCategory = parent;
+                }
+                else {
+                    break; // Parent not found, stop traversal
+                }
+            }
+            catch (error) {
+                console.error('Error finding parent category:', error);
+                break;
+            }
+        }
+        return hierarchy;
+    }
+    async collectInheritedMetadata(hierarchy) {
+        const allMetadata = [];
+        const seenMetadataIds = new Set();
+        // Collect metadata from each level in the hierarchy
+        for (const category of hierarchy) {
+            try {
+                const metadataResult = await this.metaDataService.query({
+                    filter: {
+                        logic: 'and',
+                        filters: [
+                            {
+                                field: 'categoryIds',
+                                operator: {
+                                    type: 'contains',
+                                },
+                                value: category.id,
+                            },
+                        ],
+                    },
+                    take: 1000,
+                    skip: 0,
+                });
+                // Add metadata fields that haven't been seen before (avoid duplicates)
+                for (const metadata of metadataResult.items) {
+                    if (!seenMetadataIds.has(metadata.id)) {
+                        allMetadata.push(metadata);
+                        seenMetadataIds.add(metadata.id);
+                    }
+                }
+            }
+            catch (error) {
+                console.error(`Error collecting metadata for category ${category.id}:`, error);
+            }
+        }
+        return allMetadata;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.8", ngImport: i0, type: AXCQueryCategoryMetadataInheritanceQuery, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.8", ngImport: i0, type: AXCQueryCategoryMetadataInheritanceQuery, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.8", ngImport: i0, type: AXCQueryCategoryMetadataInheritanceQuery, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+
+var categoryMetadataInheritance_query = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    AXCQueryCategoryMetadataInheritanceQuery: AXCQueryCategoryMetadataInheritanceQuery
+});
+
 class AXCDataManagementMockModule {
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.8", ngImport: i0, type: AXCDataManagementMockModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
     static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "20.1.8", ngImport: i0, type: AXCDataManagementMockModule }); }
@@ -4498,8 +5041,12 @@ class AXCDataManagementMockModule {
             },
             provideQuerySetups([
                 {
-                    key: 'category-with-items',
+                    key: 'DataManagement:Metadata:GetCategoryWithItems',
                     loader: () => import('./acorex-connectivity-mock-category-with-items.query-DEY9R9q2.mjs').then(m => m.AXCQueryCategoryWithItemsQuery),
+                },
+                {
+                    key: 'DataManagement:Metadata:GetCategoryInheritance',
+                    loader: () => Promise.resolve().then(function () { return categoryMetadataInheritance_query; }).then(m => m.AXCQueryCategoryMetadataInheritanceQuery),
                 }
             ])
         ] }); }
@@ -4523,8 +5070,12 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.8", ngImpor
                         },
                         provideQuerySetups([
                             {
-                                key: 'category-with-items',
+                                key: 'DataManagement:Metadata:GetCategoryWithItems',
                                 loader: () => import('./acorex-connectivity-mock-category-with-items.query-DEY9R9q2.mjs').then(m => m.AXCQueryCategoryWithItemsQuery),
+                            },
+                            {
+                                key: 'DataManagement:Metadata:GetCategoryInheritance',
+                                loader: () => Promise.resolve().then(function () { return categoryMetadataInheritance_query; }).then(m => m.AXCQueryCategoryMetadataInheritanceQuery),
                             }
                         ])
                     ],
@@ -4643,119 +5194,6 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.8", ngImpor
             type: Injectable
         }] });
 
-const checkbox$1 = '{"type":"document-layout","children":[{"type":"page-layout","children":[{"type":"checkbox-editor","name":"checkbox-editor1","options":{"label":"i accept","readonly":false,"disabled":false},"defaultValue":false,"path":"accept-check-box"}],"name":"page-layout1"}],"name":"document"}';
-const color = '{"type":"document-layout","children":[{"type":"page-layout","children":[{"type":"block-layout","name":"block-layout1","options":{"flexDirection":{"id":"ax-flex-row"},"flexJustifyContent":{"id":"ax-justify-normal"},"flexAlignItems":{"id":"ax-items-start"},"gap":2,"flexWrap":{"id":"ax-flex-nowrap"},"spacing":{"margin":"0px 0px 0px 0px","padding":"0px 0px 0px 0px"},"border":{"width":"0px","radius":"0px","color":"#000000","style":"none"},"flexOptions":{"gap":"0px","flexDirection":"row","flexWrap":"nowrap","justifyContent":"flex-start","alignItems":"flex-start"}}},"children":[{"type":"color-editor","name":"color-editor1","options":{"readonly":false,"disabled":false,"validations":{"required":{"rule":"required","message":"This field is required."}},"placeholder":"pick color"},"path":"color-box"}]}],"name":"page-layout1"}],"name":"document"}';
-const titleInterface = `{
-  "type": "document-layout",
-  "children": [
-    {
-      "type": "page-layout",
-      "children": [
-        {
-          "type": "title-editor",
-          "name": "title-editor1",
-          "meta": {
-            "header": true
-          },
-          "options": {
-            "multiple": false,
-            "disabled": false,
-            "hasClearButton": false,
-            "validations": {
-              "regex": null,
-              "required": {
-                "rule": "required",
-                "message": "This field is required."
-              }
-            }
-          },
-          "defaultValue": "",
-          "path": "title"
-        }
-      ],
-      "name": "page-layout1"
-    }
-  ],
-  "name": "document"
-}`;
-const descriptionInterface = `{
-  "type": "document-layout",
-  "children": [
-    {
-      "type": "page-layout",
-      "children": [
-        {
-          "type": "description-editor",
-          "name": "description-editor1",
-          "meta": {
-            "header": true
-          },
-          "options": {
-            "multiple": false,
-            "disabled": false,
-            "hasClearButton": false,
-          },
-          "defaultValue": "",
-          "path": "description"
-        }
-      ],
-      "name": "page-layout1"
-    }
-  ],
-  "name": "document"
-}`;
-const contractNumberInterface = `{
-  "type": "document-layout",
-  "children": [
-    {
-      "type": "page-layout",
-      "children": [
-        {
-          "type": "number-editor",
-          "name": "number-editor1",
-          "meta": {
-            "header": true
-          },
-          "options": {
-            "multiple": false,
-            "disabled": false,
-            "hasClearButton": false,
-          },
-          "defaultValue": "",
-          "path": "contract-number"
-        }
-      ],
-      "name": "page-layout1"
-    }
-  ],
-  "name": "document"
-}`;
-const evaluatorInterface = `{
-  "type": "document-layout",
-  "children": [
-    {
-      "type": "page-layout",
-      "children": [
-        {
-          "type": "text-editor",
-          "name": "text-editor1",
-          "meta": {
-            "header": true
-          },
-          "options": {
-            "multiple": false,
-            "disabled": false,
-            "hasClearButton": false,
-          },
-          "defaultValue": "",
-          "path": "evaluator"
-        }
-      ],
-      "name": "page-layout1"
-    }
-  ],
-  "name": "document"
-}`;
 const DOCUMENT_TYPES = [
     {
         id: AXPDataGenerator.uuid(),
@@ -4767,14 +5205,14 @@ const DOCUMENT_TYPES = [
         enableExpiration: false,
         requiresReview: true,
         requiresDistribution: false,
-        meta: [
+        metaData: [
             {
                 id: AXPDataGenerator.uuid(),
                 text: 'Description',
                 //  "parentId": "9e3c7586-4722-4170-bc55-e612ca2ab4b5",
                 hasCheckbox: true,
                 isSelected: true,
-                interface: '{"type":"document-layout","children":[{"type":"page-layout","children":[{"type":"text-editor","name":"description-editor1","meta":{"header":true},"options":{"multiple":false,"disabled":false,"hasClearButton":false},"defaultValue":"","path":"description"}],"name":"page-layout1"}],"name":"document"}',
+                interface: '{"type":"text-editor","name":"description-editor1","meta":{"header":true},"options":{"multiple":false,"disabled":false,"hasClearButton":false},"defaultValue":"","path":"description"}',
                 name: 'description',
                 title: 'Description',
                 isRequired: true,
@@ -4821,7 +5259,8 @@ const DOCUMENT_TYPES = [
         enableExpiration: false,
         requiresReview: false,
         requiresDistribution: false,
-        meta: [],
+        control: { isSystem: true },
+        metaData: [],
         type: {
             selectedItems: [],
             context: {
@@ -4842,14 +5281,14 @@ const DOCUMENT_TYPES = [
         enableExpiration: true,
         requiresReview: true,
         requiresDistribution: true,
-        meta: [
+        metaData: [
             {
                 id: AXPDataGenerator.uuid(),
                 text: 'Description',
                 //  "parentId": "9e3c7586-4722-4170-bc55-e612ca2ab4b5",
                 hasCheckbox: true,
                 isSelected: true,
-                interface: '{"type":"document-layout","children":[{"type":"page-layout","children":[{"type":"text-editor","name":"description-editor1","meta":{"header":true},"options":{"multiple":false,"disabled":false,"hasClearButton":false},"defaultValue":"","path":"description"}],"name":"page-layout1"}],"name":"document"}',
+                interface: '{"type":"text-editor","name":"description-editor1","meta":{"header":true},"options":{"multiple":false,"disabled":false,"hasClearButton":false},"defaultValue":"","path":"description"}',
                 name: 'description',
                 title: 'Description',
                 isRequired: true,
@@ -20846,11 +21285,739 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.8", ngImpor
             type: Injectable
         }] });
 
+//#region ----   Imports   ----
+//#endregion
+//#region ----   Category & Report Data (Log Management)   ----
+const LOG_REPORT_ROOT_CATEGORY_ID = 'log-management.reports.root';
+const LOG_REPORT_AUDIT_CATEGORY_ID = 'log-management.reports.audit';
+const LOG_REPORT_IDENTITY_CATEGORY_ID = 'log-management.reports.identity-audit-log';
+const LOG_REPORT_CATEGORIES = [
+    {
+        id: LOG_REPORT_ROOT_CATEGORY_ID,
+        title: 'Log Management',
+        description: 'Reports related to application logs',
+        hasChild: true,
+    },
+    {
+        id: LOG_REPORT_AUDIT_CATEGORY_ID,
+        parentId: LOG_REPORT_ROOT_CATEGORY_ID,
+        title: 'Audit Logs',
+        description: 'User actions and system audit trail',
+        hasReport: true,
+    },
+    {
+        id: LOG_REPORT_IDENTITY_CATEGORY_ID,
+        parentId: LOG_REPORT_ROOT_CATEGORY_ID,
+        title: 'Identity Audit Log',
+        description: 'Authentication and identity management logs',
+        hasReport: true,
+    },
+];
+const LOG_REPORT_DEFINITIONS = [
+    {
+        id: 'log-management.report.audit-trail-by-user',
+        title: 'Audit Trail by User',
+        description: 'Comprehensive audit trail showing user actions, system events, and entity changes',
+        categoryIds: [LOG_REPORT_AUDIT_CATEGORY_ID],
+        parameterGroups: [
+            {
+                name: 'period',
+                title: 'Period',
+                parameters: [
+                    {
+                        path: 'startDate',
+                        title: 'Start Date',
+                        widget: { type: AXPWidgetsList.Editors.DateTimeBox, options: { format: 'date' } },
+                    },
+                    {
+                        path: 'endDate',
+                        title: 'End Date',
+                        widget: { type: AXPWidgetsList.Editors.DateTimeBox, options: { format: 'date' } },
+                    },
+                ],
+            },
+            {
+                name: 'filters',
+                title: 'Filters',
+                parameters: [
+                    {
+                        path: 'userName',
+                        title: 'User Name',
+                        widget: { type: AXPWidgetsList.Editors.TextBox, options: { placeholder: 'Filter by username' } },
+                    },
+                    {
+                        path: 'httpMethod',
+                        title: 'HTTP Method',
+                        widget: {
+                            type: AXPWidgetsList.Editors.SelectBox,
+                            options: {
+                                dataSource: ['GET', 'POST', 'PUT', 'DELETE', 'PATCH'],
+                                multiple: true,
+                            },
+                        },
+                    },
+                    {
+                        path: 'httpStatusCode',
+                        title: 'HTTP Status',
+                        widget: {
+                            type: AXPWidgetsList.Editors.SelectBox,
+                            options: {
+                                dataSource: ['200', '201', '400', '401', '403', '404', '500'],
+                                multiple: true,
+                            },
+                        },
+                    },
+                ],
+            },
+        ],
+        layouts: [
+            {
+                id: 'table',
+                title: 'Table View',
+                layout: {
+                    type: 'table',
+                    columns: [
+                        {
+                            field: 'executionTime',
+                            title: 'Date',
+                            visible: true,
+                            width: 180,
+                            align: 'left',
+                            widget: {
+                                type: AXPWidgetsList.Editors.DateTimeBox,
+                                options: { format: 'datetime' },
+                                path: 'executionTime',
+                            },
+                        },
+                        {
+                            field: 'userName',
+                            title: 'User Name',
+                            visible: true,
+                            width: 150,
+                            align: 'left',
+                            widget: { type: AXPWidgetsList.Editors.TextBox, path: 'userName' },
+                        },
+                        {
+                            field: 'tenantName',
+                            title: 'Tenant',
+                            visible: true,
+                            width: 120,
+                            align: 'left',
+                            widget: { type: AXPWidgetsList.Editors.TextBox, path: 'tenantName' },
+                        },
+                        {
+                            field: 'httpMethod',
+                            title: 'Method',
+                            visible: true,
+                            width: 80,
+                            align: 'center',
+                            widget: { type: AXPWidgetsList.Editors.TextBox, path: 'httpMethod' },
+                        },
+                        {
+                            field: 'url',
+                            title: 'URL',
+                            visible: true,
+                            width: 300,
+                            align: 'left',
+                            widget: { type: AXPWidgetsList.Editors.TextBox, path: 'url' },
+                        },
+                        {
+                            field: 'httpStatusCode',
+                            title: 'Status',
+                            visible: true,
+                            width: 80,
+                            align: 'center',
+                            widget: { type: AXPWidgetsList.Editors.TextBox, path: 'httpStatusCode' },
+                        },
+                        {
+                            field: 'httpStatus',
+                            title: 'HTTP Status',
+                            visible: true,
+                            width: 100,
+                            align: 'center',
+                            widget: { type: AXPWidgetsList.Editors.TextBox, path: 'httpStatus' },
+                        },
+                        {
+                            field: 'executionDuration',
+                            title: 'Duration (ms)',
+                            visible: true,
+                            width: 120,
+                            align: 'right',
+                            widget: { type: AXPWidgetsList.Editors.NumberBox, path: 'executionDuration' },
+                        },
+                        {
+                            field: 'clientIpAddress',
+                            title: 'Client IP',
+                            visible: true,
+                            width: 120,
+                            align: 'left',
+                            widget: { type: AXPWidgetsList.Editors.TextBox, path: 'clientIpAddress' },
+                        },
+                        {
+                            field: 'clientName',
+                            title: 'Client',
+                            visible: true,
+                            width: 120,
+                            align: 'left',
+                            widget: { type: AXPWidgetsList.Editors.TextBox, path: 'clientName' },
+                        },
+                        {
+                            field: 'correlationId',
+                            title: 'Correlation ID',
+                            visible: true,
+                            width: 200,
+                            align: 'left',
+                            widget: { type: AXPWidgetsList.Editors.TextBox, path: 'correlationId' },
+                        },
+                        {
+                            field: 'comments',
+                            title: 'Comments',
+                            visible: true,
+                            width: 200,
+                            align: 'left',
+                            widget: { type: AXPWidgetsList.Editors.TextBox, path: 'comments' },
+                        },
+                        {
+                            field: 'exceptions',
+                            title: 'Exceptions',
+                            visible: false,
+                            width: 200,
+                            align: 'left',
+                            widget: { type: AXPWidgetsList.Editors.TextBox, path: 'exceptions' },
+                        },
+                        {
+                            field: 'impersonatorUserName',
+                            title: 'Impersonated By',
+                            visible: false,
+                            width: 150,
+                            align: 'left',
+                            widget: { type: AXPWidgetsList.Editors.TextBox, path: 'impersonatorUserName' },
+                        },
+                    ],
+                    options: {
+                        pagination: true,
+                    },
+                },
+                dataSource: {
+                    type: 'custom',
+                    provider: 'mock-data',
+                },
+                export: {
+                    fileNameTemplate: 'AuditTrailByUser_{date}_{user}',
+                    pdf: {
+                        enabled: true,
+                        pageSize: 'A4',
+                        headerEnabled: true,
+                        footerEnabled: true,
+                        showPageNumbers: true,
+                    },
+                },
+            },
+        ],
+        defaultLayoutId: 'table',
+    },
+    {
+        id: 'log-management.report.login-logs',
+        title: 'Login Logs',
+        description: 'Authentication and login activity reports',
+        categoryIds: [LOG_REPORT_IDENTITY_CATEGORY_ID],
+        parameterGroups: [
+            {
+                name: 'period',
+                title: 'Period',
+                parameters: [
+                    {
+                        path: 'startDate',
+                        title: 'Start Date',
+                        widget: { type: AXPWidgetsList.Editors.DateTimeBox, options: { format: 'date' } },
+                    },
+                    {
+                        path: 'endDate',
+                        title: 'End Date',
+                        widget: { type: AXPWidgetsList.Editors.DateTimeBox, options: { format: 'date' } },
+                    },
+                ],
+            },
+            {
+                name: 'filters',
+                title: 'Filters',
+                parameters: [
+                    {
+                        path: 'userName',
+                        title: 'User Name',
+                        widget: { type: AXPWidgetsList.Editors.TextBox, options: { placeholder: 'Filter by username' } },
+                    },
+                    {
+                        path: 'status',
+                        title: 'Login Status',
+                        widget: {
+                            type: AXPWidgetsList.Editors.SelectBox,
+                            options: {
+                                dataSource: ['Success', 'Failed'],
+                                multiple: true,
+                            },
+                        },
+                    },
+                ],
+            },
+        ],
+        layouts: [
+            {
+                id: 'table',
+                title: 'Table View',
+                layout: {
+                    type: 'table',
+                    columns: [
+                        {
+                            field: 'userName',
+                            title: 'User Name',
+                            visible: true,
+                            width: 150,
+                            align: 'left',
+                            widget: { type: AXPWidgetsList.Editors.TextBox, path: 'userName' },
+                        },
+                        {
+                            field: 'httpStatus',
+                            title: 'HTTP Status',
+                            visible: true,
+                            width: 100,
+                            align: 'center',
+                            widget: { type: AXPWidgetsList.Editors.TextBox, path: 'httpStatus' },
+                        },
+                        {
+                            field: 'clientName',
+                            title: 'Client',
+                            visible: true,
+                            width: 120,
+                            align: 'left',
+                            widget: { type: AXPWidgetsList.Editors.TextBox, path: 'clientName' },
+                        },
+                        {
+                            field: 'tenantName',
+                            title: 'Tenant',
+                            visible: true,
+                            width: 120,
+                            align: 'left',
+                            widget: { type: AXPWidgetsList.Editors.TextBox, path: 'tenantName' },
+                        },
+                        {
+                            field: 'applicationName',
+                            title: 'Application',
+                            visible: true,
+                            width: 150,
+                            align: 'left',
+                            widget: { type: AXPWidgetsList.Editors.TextBox, path: 'applicationName' },
+                        },
+                        {
+                            field: 'impersonatorUserName',
+                            title: 'Impersonated By',
+                            visible: false,
+                            width: 200,
+                            align: 'left',
+                            widget: { type: AXPWidgetsList.Editors.TextBox, path: 'impersonatorUserName' },
+                        },
+                        {
+                            field: 'executionTime',
+                            title: 'Execution Time',
+                            visible: true,
+                            width: 180,
+                            align: 'right',
+                            widget: {
+                                type: AXPWidgetsList.Editors.DateTimeBox,
+                                options: { format: 'datetime' },
+                                path: 'executionTime',
+                            },
+                        },
+                    ],
+                    options: {
+                        pagination: true,
+                    },
+                },
+                dataSource: {
+                    type: 'custom',
+                    provider: 'mock-data',
+                },
+                export: {
+                    fileNameTemplate: 'LoginLogs_{date}_{user}',
+                    pdf: {
+                        enabled: true,
+                        pageSize: 'A4',
+                        headerEnabled: true,
+                        footerEnabled: true,
+                        showPageNumbers: true,
+                    },
+                },
+            },
+        ],
+        defaultLayoutId: 'table',
+    },
+    {
+        id: 'log-management.report.change-password-logs',
+        title: 'Change Password Logs',
+        description: 'Password change activity and security events',
+        categoryIds: [LOG_REPORT_IDENTITY_CATEGORY_ID],
+        parameterGroups: [
+            {
+                name: 'period',
+                title: 'Period',
+                parameters: [
+                    {
+                        path: 'startDate',
+                        title: 'Start Date',
+                        widget: { type: AXPWidgetsList.Editors.DateTimeBox, options: { format: 'date' } },
+                    },
+                    {
+                        path: 'endDate',
+                        title: 'End Date',
+                        widget: { type: AXPWidgetsList.Editors.DateTimeBox, options: { format: 'date' } },
+                    },
+                ],
+            },
+            {
+                name: 'filters',
+                title: 'Filters',
+                parameters: [
+                    {
+                        path: 'userName',
+                        title: 'User Name',
+                        widget: { type: AXPWidgetsList.Editors.TextBox, options: { placeholder: 'Filter by username' } },
+                    },
+                    {
+                        path: 'status',
+                        title: 'Change Status',
+                        widget: {
+                            type: AXPWidgetsList.Editors.SelectBox,
+                            options: {
+                                dataSource: ['Success', 'Failed'],
+                                multiple: true,
+                            },
+                        },
+                    },
+                ],
+            },
+        ],
+        layouts: [
+            {
+                id: 'table',
+                title: 'Table View',
+                layout: {
+                    type: 'table',
+                    columns: [
+                        {
+                            field: 'userName',
+                            title: 'User Name',
+                            visible: true,
+                            width: 150,
+                            align: 'left',
+                            widget: { type: AXPWidgetsList.Editors.TextBox, path: 'userName' },
+                        },
+                        {
+                            field: 'httpStatus',
+                            title: 'HTTP Status',
+                            visible: true,
+                            width: 100,
+                            align: 'center',
+                            widget: { type: AXPWidgetsList.Editors.TextBox, path: 'httpStatus' },
+                        },
+                        {
+                            field: 'clientName',
+                            title: 'Client',
+                            visible: true,
+                            width: 120,
+                            align: 'left',
+                            widget: { type: AXPWidgetsList.Editors.TextBox, path: 'clientName' },
+                        },
+                        {
+                            field: 'tenantName',
+                            title: 'Tenant',
+                            visible: true,
+                            width: 120,
+                            align: 'left',
+                            widget: { type: AXPWidgetsList.Editors.TextBox, path: 'tenantName' },
+                        },
+                        {
+                            field: 'applicationName',
+                            title: 'Application',
+                            visible: true,
+                            width: 150,
+                            align: 'left',
+                            widget: { type: AXPWidgetsList.Editors.TextBox, path: 'applicationName' },
+                        },
+                        {
+                            field: 'impersonatorUserName',
+                            title: 'Impersonated By',
+                            visible: false,
+                            width: 150,
+                            align: 'left',
+                            widget: { type: AXPWidgetsList.Editors.TextBox, path: 'impersonatorUserName' },
+                        },
+                        {
+                            field: 'executionTime',
+                            title: 'Date',
+                            visible: true,
+                            width: 180,
+                            align: 'left',
+                            widget: {
+                                type: AXPWidgetsList.Editors.DateTimeBox,
+                                options: { format: 'datetime' },
+                                path: 'executionTime',
+                            },
+                        },
+                    ],
+                    options: {
+                        pagination: true,
+                    },
+                },
+                dataSource: {
+                    type: 'custom',
+                    provider: 'mock-data',
+                },
+                export: {
+                    fileNameTemplate: 'ChangePasswordLogs_{date}_{user}',
+                    pdf: {
+                        enabled: true,
+                        pageSize: 'A4',
+                        headerEnabled: true,
+                        footerEnabled: true,
+                        showPageNumbers: true,
+                    },
+                },
+            },
+        ],
+        defaultLayoutId: 'table',
+    },
+    {
+        id: 'log-management.report.identity-error-logs',
+        title: 'Identity Error Logs',
+        description: 'Authentication errors, token failures, and security violations',
+        categoryIds: [LOG_REPORT_IDENTITY_CATEGORY_ID],
+        parameterGroups: [
+            {
+                name: 'period',
+                title: 'Period',
+                parameters: [
+                    {
+                        path: 'startDate',
+                        title: 'Start Date',
+                        widget: { type: AXPWidgetsList.Editors.DateTimeBox, options: { format: 'date' } },
+                    },
+                    {
+                        path: 'endDate',
+                        title: 'End Date',
+                        widget: { type: AXPWidgetsList.Editors.DateTimeBox, options: { format: 'date' } },
+                    },
+                ],
+            },
+            {
+                name: 'filters',
+                title: 'Filters',
+                parameters: [
+                    {
+                        path: 'userName',
+                        title: 'User Name',
+                        widget: { type: AXPWidgetsList.Editors.TextBox, options: { placeholder: 'Filter by username' } },
+                    },
+                    {
+                        path: 'errorType',
+                        title: 'Error Type',
+                        widget: {
+                            type: AXPWidgetsList.Editors.SelectBox,
+                            options: {
+                                dataSource: ['Token Expired', 'Invalid Credentials', 'Rate Limited', 'User Not Found'],
+                                multiple: true,
+                            },
+                        },
+                    },
+                ],
+            },
+        ],
+        layouts: [
+            {
+                id: 'table',
+                title: 'Table View',
+                layout: {
+                    type: 'table',
+                    columns: [
+                        {
+                            field: 'executionTime',
+                            title: 'Date',
+                            visible: true,
+                            width: 180,
+                            align: 'left',
+                            widget: {
+                                type: AXPWidgetsList.Editors.DateTimeBox,
+                                options: { format: 'datetime' },
+                                path: 'executionTime',
+                            },
+                        },
+                        {
+                            field: 'userName',
+                            title: 'User Name',
+                            visible: true,
+                            width: 150,
+                            align: 'left',
+                            widget: { type: AXPWidgetsList.Editors.TextBox, path: 'userName' },
+                        },
+                        {
+                            field: 'tenantName',
+                            title: 'Tenant',
+                            visible: true,
+                            width: 120,
+                            align: 'left',
+                            widget: { type: AXPWidgetsList.Editors.TextBox, path: 'tenantName' },
+                        },
+                        {
+                            field: 'httpMethod',
+                            title: 'Method',
+                            visible: true,
+                            width: 80,
+                            align: 'center',
+                            widget: { type: AXPWidgetsList.Editors.TextBox, path: 'httpMethod' },
+                        },
+                        {
+                            field: 'url',
+                            title: 'URL',
+                            visible: true,
+                            width: 300,
+                            align: 'left',
+                            widget: { type: AXPWidgetsList.Editors.TextBox, path: 'url' },
+                        },
+                        {
+                            field: 'httpStatusCode',
+                            title: 'Status',
+                            visible: true,
+                            width: 80,
+                            align: 'center',
+                            widget: { type: AXPWidgetsList.Editors.TextBox, path: 'httpStatusCode' },
+                        },
+                        {
+                            field: 'executionDuration',
+                            title: 'Duration (ms)',
+                            visible: true,
+                            width: 120,
+                            align: 'right',
+                            widget: { type: AXPWidgetsList.Editors.NumberBox, path: 'executionDuration' },
+                        },
+                        {
+                            field: 'clientIpAddress',
+                            title: 'Client IP',
+                            visible: true,
+                            width: 120,
+                            align: 'left',
+                            widget: { type: AXPWidgetsList.Editors.TextBox, path: 'clientIpAddress' },
+                        },
+                        {
+                            field: 'clientName',
+                            title: 'Client',
+                            visible: true,
+                            width: 120,
+                            align: 'left',
+                            widget: { type: AXPWidgetsList.Editors.TextBox, path: 'clientName' },
+                        },
+                        {
+                            field: 'correlationId',
+                            title: 'Correlation ID',
+                            visible: true,
+                            width: 200,
+                            align: 'left',
+                            widget: { type: AXPWidgetsList.Editors.TextBox, path: 'correlationId' },
+                        },
+                        {
+                            field: 'comments',
+                            title: 'Comments',
+                            visible: true,
+                            width: 200,
+                            align: 'left',
+                            widget: { type: AXPWidgetsList.Editors.TextBox, path: 'comments' },
+                        },
+                        {
+                            field: 'exceptions',
+                            title: 'Exceptions',
+                            visible: true,
+                            width: 200,
+                            align: 'left',
+                            widget: { type: AXPWidgetsList.Editors.TextBox, path: 'exceptions' },
+                        },
+                        {
+                            field: 'impersonatorUserName',
+                            title: 'Impersonated By',
+                            visible: false,
+                            width: 150,
+                            align: 'left',
+                            widget: { type: AXPWidgetsList.Editors.TextBox, path: 'impersonatorUserName' },
+                        },
+                    ],
+                    options: {
+                        pagination: true,
+                    },
+                },
+                dataSource: {
+                    type: 'custom',
+                    provider: 'mock-data',
+                },
+                export: {
+                    fileNameTemplate: 'IdentityErrorLogs_{date}_{user}',
+                    pdf: {
+                        enabled: true,
+                        pageSize: 'A4',
+                        headerEnabled: true,
+                        footerEnabled: true,
+                        showPageNumbers: true,
+                    },
+                },
+            },
+        ],
+        defaultLayoutId: 'table',
+    },
+];
+//#endregion
+//#region ----   Providers   ----
+class AXCLogReportCategoryProvider {
+    async getList(parentId) {
+        if (!parentId)
+            return LOG_REPORT_CATEGORIES.filter((c) => !c.parentId);
+        return LOG_REPORT_CATEGORIES.filter((c) => c.parentId === parentId);
+    }
+    async getById(id) {
+        return LOG_REPORT_CATEGORIES.find((c) => c.id === id);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.8", ngImport: i0, type: AXCLogReportCategoryProvider, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.8", ngImport: i0, type: AXCLogReportCategoryProvider }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.8", ngImport: i0, type: AXCLogReportCategoryProvider, decorators: [{
+            type: Injectable
+        }] });
+class AXCLogReportDefinitionProvider {
+    async getList(categoryId) {
+        return LOG_REPORT_DEFINITIONS.filter((r) => r.categoryIds.includes(categoryId));
+    }
+    async getById(id) {
+        return LOG_REPORT_DEFINITIONS.find((r) => r.id === id);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.8", ngImport: i0, type: AXCLogReportDefinitionProvider, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.8", ngImport: i0, type: AXCLogReportDefinitionProvider }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.8", ngImport: i0, type: AXCLogReportDefinitionProvider, decorators: [{
+            type: Injectable
+        }] });
+const AXC_LOG_REPORT_CATEGORY_PROVIDER = {
+    provide: AXP_REPORT_CATEGORY_PROVIDER,
+    useClass: AXCLogReportCategoryProvider,
+    multi: true,
+};
+const AXC_LOG_REPORT_DEFINITION_PROVIDER = {
+    provide: AXP_REPORT_DEFINITION_PROVIDER,
+    useClass: AXCLogReportDefinitionProvider,
+    multi: true,
+};
+
 class AXCLogManagementMockModule {
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.8", ngImport: i0, type: AXCLogManagementMockModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
     static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "20.1.8", ngImport: i0, type: AXCLogManagementMockModule }); }
     static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "20.1.8", ngImport: i0, type: AXCLogManagementMockModule, providers: [
             { provide: AXP_DATA_SEEDER_TOKEN, useClass: AXMLogDataSeeder, multi: true },
+            AXC_LOG_REPORT_CATEGORY_PROVIDER,
+            AXC_LOG_REPORT_DEFINITION_PROVIDER,
         ] }); }
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.8", ngImport: i0, type: AXCLogManagementMockModule, decorators: [{
@@ -20861,6 +22028,8 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.8", ngImpor
                     declarations: [],
                     providers: [
                         { provide: AXP_DATA_SEEDER_TOKEN, useClass: AXMLogDataSeeder, multi: true },
+                        AXC_LOG_REPORT_CATEGORY_PROVIDER,
+                        AXC_LOG_REPORT_DEFINITION_PROVIDER,
                     ],
                 }]
         }] });
@@ -21070,6 +22239,177 @@ const BUSINESS_UNIT_TYPES_MOCK = [
     { id: uuid$i(), title: 'Branch', code: 'branch', isLocationBased: true },
 ];
 
+function generatePositionsCategory() {
+    const categories = [];
+    const roots = ['Engineering Positions', 'Technical Leadership', 'Product Positions', 'Operations', 'Business Functions', 'Executive Leadership'];
+    const ids = new Map();
+    roots.forEach((title) => {
+        const id = AXPDataGenerator.uuid();
+        ids.set(title, id);
+        const descriptionMap = {
+            'Engineering Positions': 'All engineering role families',
+            'Technical Leadership': 'Leadership tracks within technology',
+            'Product Positions': 'Roles related to product management & design',
+            Operations: 'IT, Support and Security positions',
+            'Business Functions': 'Sales, Marketing and BD roles',
+            'Executive Leadership': 'C-level and executive roles',
+        };
+        categories.push({ id, title, description: descriptionMap[title] ?? '', childCount: 0 });
+    });
+    const children = [
+        { parent: 'Engineering Positions', children: ['Frontend Engineering', 'Backend Engineering', 'Mobile Engineering', 'Quality Engineering'] },
+        { parent: 'Technical Leadership', children: ['Engineering Management', 'Technical Architecture', 'DevOps Leadership'] },
+        { parent: 'Product Positions', children: ['Product Management', 'UX/UI Design', 'Product Analytics'] },
+        { parent: 'Operations', children: ['IT Operations', 'Technical Support', 'Security Operations', 'Health, Safety & Environment'] },
+        { parent: 'Business Functions', children: ['Sales', 'Marketing', 'Business Development'] },
+        { parent: 'Executive Leadership', children: ['C-Suite', 'Board Members', 'Corporate Strategy'] },
+    ];
+    children.forEach(({ parent, children }) => {
+        const parentId = ids.get(parent);
+        if (!parentId)
+            return;
+        children.forEach((title) => {
+            const id = AXPDataGenerator.uuid();
+            ids.set(title, id);
+            const descriptionMap = {
+                'Frontend Engineering': 'Client-side engineering track',
+                'Backend Engineering': 'Server-side engineering track',
+                'Mobile Engineering': 'Mobile application engineering track',
+                'Quality Engineering': 'Testing and QA track',
+                'Engineering Management': 'People and delivery leadership track',
+                'Technical Architecture': 'Architecture and system design track',
+                'DevOps Leadership': 'Reliability and platform engineering track',
+                'Product Management': 'Product strategy and delivery track',
+                'UX/UI Design': 'User experience and interface design track',
+                'Product Analytics': 'Data-driven product insights track',
+                'IT Operations': 'IT and infrastructure operations track',
+                'Technical Support': 'Customer and internal support track',
+                'Security Operations': 'Cybersecurity and defense track',
+                Sales: 'Sales roles and career track',
+                Marketing: 'Marketing roles and career track',
+                'Business Development': 'Partnerships and growth roles',
+                'C-Suite': 'Executive leadership team',
+                'Board Members': 'Corporate board members',
+                'Corporate Strategy': 'Corporate planning and strategy',
+            };
+            categories.push({ id, title, description: descriptionMap[title] ?? '', parentId, childCount: 0 });
+        });
+        const parentObj = categories.find((c) => c.id === parentId);
+        if (parentObj)
+            parentObj.childCount = children.length;
+    });
+    return categories;
+}
+const POSITIONS_CATEGORY_MOCK = generatePositionsCategory();
+function generatePositions() {
+    const positions = [];
+    const categories = POSITIONS_CATEGORY_MOCK;
+    const childPositions = [
+        { parent: 'Frontend Engineering', children: ['Junior Frontend Engineer', 'Frontend Engineer'] },
+        { parent: 'Backend Engineering', children: ['Junior Backend Engineer', 'Backend Engineer'] },
+        { parent: 'Mobile Engineering', children: ['Junior Mobile Developer', 'Mobile Developer', 'Senior Mobile Developer', 'Mobile Architect'] },
+        { parent: 'Quality Engineering', children: ['QA Analyst', 'QA Engineer', 'Senior QA Engineer', 'QA Manager'] },
+        { parent: 'Engineering Management', children: ['Engineering Team Lead', 'Engineering Manager', 'Director of Engineering', 'VP of Engineering'] },
+        { parent: 'Product Management', children: ['Associate Product Manager', 'Product Manager', 'Senior Product Manager', 'Director of Product'] },
+        { parent: 'UX/UI Design', children: ['UX Designer', 'UI Designer', 'Senior UX Designer', 'UX Design Manager'] },
+        { parent: 'IT Operations', children: ['IT Support Specialist', 'Systems Administrator'] },
+        { parent: 'Sales', children: ['Sales Associate', 'Account Executive', 'Sales Manager', 'VP of Sales'] },
+        { parent: 'C-Suite', children: ['CTO', 'CEO', 'CFO', 'COO'] },
+        { parent: 'DevOps Leadership', children: ['DevOps Engineer', 'Senior DevOps Engineer', 'DevOps Manager', 'Director of DevOps'] },
+        { parent: 'Health, Safety & Environment', children: ['HSE Officer', 'Safety Officer', 'Environmental Specialist', 'HSE Manager'] },
+        { parent: 'Engineering Management', children: ['Production Supervisor'] },
+        { parent: 'Operations', children: ['Maintenance Technician', 'Maintenance Engineer', 'Quality Inspector', 'Quality Engineer', 'Procurement Specialist', 'Warehouse Associate', 'Warehouse Supervisor', 'Production Planner'] },
+    ];
+    // Position descriptions mapping
+    const positionDescriptions = {
+        // Frontend Engineering
+        'Junior Frontend Engineer': 'Entry-level frontend developer responsible for building user interfaces using HTML, CSS, and JavaScript frameworks. Focuses on learning best practices and contributing to team projects.',
+        'Frontend Engineer': 'Mid-level frontend developer who builds responsive web applications, implements UI/UX designs, and collaborates with design and backend teams.',
+        'Senior Frontend Engineer': 'Experienced frontend developer who leads technical decisions, mentors junior developers, and architects scalable frontend solutions.',
+        'Frontend Architect': 'Senior technical leader responsible for frontend architecture decisions, performance optimization, and setting technical standards for the frontend team.',
+        // Backend Engineering
+        'Junior Backend Engineer': 'Entry-level backend developer focused on building server-side logic, APIs, and database interactions. Learns backend technologies and best practices.',
+        'Backend Engineer': 'Mid-level backend developer who designs and implements server-side applications, APIs, and database schemas.',
+        'Senior Backend Engineer': 'Experienced backend developer who leads technical decisions, optimizes system performance, and mentors junior developers.',
+        'Backend Architect': 'Senior technical leader responsible for backend architecture, system design, and technical strategy for server-side systems.',
+        // Mobile Engineering
+        'Junior Mobile Developer': 'Entry-level mobile developer focused on building native or cross-platform mobile applications. Learns mobile development frameworks and best practices.',
+        'Mobile Developer': 'Mid-level mobile developer who creates mobile apps, implements features, and ensures app performance and user experience.',
+        'Senior Mobile Developer': 'Experienced mobile developer who leads mobile development initiatives, optimizes app performance, and mentors junior developers.',
+        'Mobile Architect': 'Senior technical leader responsible for mobile architecture decisions, platform strategy, and technical standards for mobile development.',
+        // Quality Engineering
+        'QA Analyst': 'Entry-level quality assurance professional who executes test plans, reports bugs, and ensures software quality through systematic testing.',
+        'QA Engineer': 'Mid-level QA professional who designs test strategies, automates testing processes, and collaborates with development teams.',
+        'Senior QA Engineer': 'Experienced QA professional who leads testing initiatives, implements quality processes, and mentors junior QA team members.',
+        'QA Manager': 'Senior leader responsible for managing the QA team, establishing quality standards, and ensuring overall software quality.',
+        // Engineering Management
+        'Engineering Team Lead': 'Technical leader who manages a small engineering team, provides technical guidance, and ensures project delivery.',
+        'Engineering Manager': 'People manager responsible for team development, project planning, and technical decision-making for engineering teams.',
+        'Director of Engineering': 'Senior leader who manages multiple engineering teams, sets technical strategy, and drives engineering excellence.',
+        'VP of Engineering': 'Executive leader responsible for overall engineering strategy, team growth, and technical direction across the organization.',
+        // Product Management
+        'Associate Product Manager': 'Entry-level product professional who supports product development, conducts research, and assists with product strategy.',
+        'Product Manager': 'Mid-level product professional who defines product vision, prioritizes features, and collaborates with cross-functional teams.',
+        'Senior Product Manager': 'Experienced product professional who leads product strategy, mentors junior PMs, and drives product success.',
+        'Director of Product': 'Senior leader responsible for product portfolio strategy, team leadership, and product vision across multiple products.',
+        // UX/UI Design
+        'UX Designer': 'Design professional focused on user experience research, user flows, and creating intuitive user interfaces.',
+        'UI Designer': 'Visual designer who creates user interface designs, design systems, and ensures visual consistency across products.',
+        'Senior UX Designer': 'Experienced UX professional who leads design initiatives, mentors junior designers, and drives user experience strategy.',
+        'UX Design Manager': 'Senior leader responsible for managing the design team, establishing design processes, and ensuring design quality.',
+        // IT Operations
+        'IT Support Specialist': 'Entry-level IT professional who provides technical support, troubleshoots issues, and maintains IT systems.',
+        'Systems Administrator': 'Mid-level IT professional who manages server infrastructure, implements security measures, and ensures system reliability.',
+        // Sales
+        'Sales Associate': 'Entry-level sales professional who supports sales activities, qualifies leads, and assists with customer relationships.',
+        'Account Executive': 'Mid-level sales professional who manages customer accounts, drives sales growth, and builds client relationships.',
+        'Sales Manager': 'Senior sales professional who leads sales teams, develops sales strategies, and drives revenue growth.',
+        'VP of Sales': 'Executive leader responsible for overall sales strategy, team leadership, and revenue generation across the organization.',
+        // C-Suite
+        'CTO': 'Chief Technology Officer responsible for technology strategy, innovation, and technical leadership across the organization.',
+        'CEO': 'Chief Executive Officer responsible for overall company strategy, leadership, and business success.',
+        'CFO': 'Chief Financial Officer responsible for financial strategy, planning, and financial operations.',
+        'COO': 'Chief Operating Officer responsible for operational excellence, process optimization, and day-to-day business operations.',
+        // DevOps Leadership
+        'DevOps Engineer': 'Mid-level DevOps professional who automates deployment processes, manages infrastructure, and ensures system reliability.',
+        'Senior DevOps Engineer': 'Experienced DevOps professional who leads infrastructure initiatives, optimizes deployment processes, and mentors junior team members.',
+        'DevOps Manager': 'Senior leader responsible for managing DevOps teams, establishing best practices, and driving operational excellence.',
+        'Director of DevOps': 'Senior leader responsible for DevOps strategy, infrastructure planning, and technical leadership for operations teams.',
+        // Core Industrial Operations
+        'Production Supervisor': 'Leads production lines and teams, manages shift performance, and ensures production targets and quality standards are met.',
+        'Maintenance Technician': 'Executes routine and corrective maintenance tasks to ensure equipment uptime.',
+        'Maintenance Engineer': 'Plans maintenance strategies, analyzes failures, and drives reliability improvements.',
+        'Quality Inspector': 'Performs incoming, in-process, and final inspections to ensure product conformance.',
+        'Quality Engineer': 'Develops control plans, handles nonconformances, and leads continuous improvement initiatives.',
+        'Procurement Specialist': 'Sources materials, negotiates contracts, and manages purchase orders.',
+        'Warehouse Associate': 'Handles receiving, storage, picking, packing, and shipping operations.',
+        'Warehouse Supervisor': 'Oversees warehouse staff and processes, ensuring accuracy and on-time shipments.',
+        'Production Planner': 'Creates production schedules, coordinates materials and capacity, and monitors adherence.',
+        // Health, Safety & Environment
+        'HSE Officer': 'Professional supporting health and safety initiatives, audits, and safety training across operations.',
+        'Safety Officer': 'Specialist enforcing safety standards, conducting inspections, and coordinating incident investigations.',
+        'Environmental Specialist': 'Professional overseeing environmental compliance, waste management, and sustainability reporting.',
+        'HSE Manager': 'Leader managing HSE programs, regulatory compliance, and continuous improvement in safety performance.'
+    };
+    childPositions.forEach(({ parent, children }) => {
+        const parentObj = categories.find((c) => c.title === parent);
+        if (!parentObj)
+            return;
+        children.forEach((title) => {
+            positions.push({
+                id: AXPDataGenerator.uuid(),
+                title,
+                description: positionDescriptions[title] || 'Professional position with specific responsibilities and requirements.',
+                categoryIds: [parentObj.id],
+                categories: [{ id: parentObj.id, title: parentObj.title }],
+                isManager: /(Manager|Director|Lead|VP|Chief|Head)/i.test(title),
+            });
+        });
+    });
+    return positions;
+}
+const POSITIONS_MOCK = generatePositions();
+
 const uuid$h = AXPDataGenerator.uuid;
 const TYPE = {
     division: BUSINESS_UNIT_TYPES_MOCK.find(t => t.code === 'division'),
@@ -21094,6 +22434,13 @@ const DE_BAV = regionBy('state', 'BAV');
 const MUNICH = regionBy('city', 'MUNICH');
 const BUSINESS_UNITS_MOCK = (() => {
     const items = [];
+    function positionsByTitles(titles) {
+        const map = new Map();
+        POSITIONS_MOCK.forEach(p => map.set(p.title, { id: p.id, title: p.title }));
+        const refs = titles.map(t => map.get(t)).filter(Boolean);
+        const ids = refs.map(r => r.id);
+        return { positionIds: ids, positions: refs };
+    }
     // Divisions (top-level)
     const divisionOps = {
         id: uuid$h(),
@@ -21109,6 +22456,7 @@ const BUSINESS_UNITS_MOCK = (() => {
         country: US,
         state: US_CA,
         city: LA,
+        ...positionsByTitles(['Maintenance Engineer', 'Maintenance Technician', 'Quality Engineer', 'Quality Inspector', 'Production Supervisor', 'HSE Manager'])
     };
     const divisionSales = {
         id: uuid$h(),
@@ -21124,6 +22472,7 @@ const BUSINESS_UNITS_MOCK = (() => {
         country: AU,
         state: AU_NSW,
         city: SYDNEY,
+        ...positionsByTitles(['Sales Associate', 'Account Executive', 'Sales Manager', 'VP of Sales'])
     };
     const divisionEngineering = {
         id: uuid$h(),
@@ -21139,6 +22488,7 @@ const BUSINESS_UNITS_MOCK = (() => {
         country: DE,
         state: DE_BAV,
         city: MUNICH,
+        ...positionsByTitles(['Frontend Engineer', 'Backend Engineer', 'Engineering Manager', 'Director of Engineering'])
     };
     items.push(divisionOps, divisionSales, divisionEngineering);
     // Departments under Operations
@@ -21150,6 +22500,7 @@ const BUSINESS_UNITS_MOCK = (() => {
         type: { id: TYPE.department.id, title: TYPE.department.title },
         parentId: divisionOps.id,
         parent: { id: divisionOps.id, title: divisionOps.title },
+        ...positionsByTitles(['HSE Officer', 'Safety Officer', 'Environmental Specialist', 'HSE Manager'])
     };
     const depQuality = {
         id: uuid$h(),
@@ -21159,6 +22510,7 @@ const BUSINESS_UNITS_MOCK = (() => {
         type: { id: TYPE.department.id, title: TYPE.department.title },
         parentId: divisionOps.id,
         parent: { id: divisionOps.id, title: divisionOps.title },
+        ...positionsByTitles(['QA Analyst', 'QA Engineer', 'Senior QA Engineer', 'QA Manager', 'Quality Inspector', 'Quality Engineer'])
     };
     const depMaintenance = {
         id: uuid$h(),
@@ -21168,6 +22520,7 @@ const BUSINESS_UNITS_MOCK = (() => {
         type: { id: TYPE.department.id, title: TYPE.department.title },
         parentId: divisionOps.id,
         parent: { id: divisionOps.id, title: divisionOps.title },
+        ...positionsByTitles(['Maintenance Technician', 'Maintenance Engineer'])
     };
     items.push(depHSE, depQuality, depMaintenance);
     // Departments under Engineering
@@ -21179,6 +22532,7 @@ const BUSINESS_UNITS_MOCK = (() => {
         type: { id: TYPE.department.id, title: TYPE.department.title },
         parentId: divisionEngineering.id,
         parent: { id: divisionEngineering.id, title: divisionEngineering.title },
+        ...positionsByTitles(['DevOps Engineer', 'Senior DevOps Engineer', 'Engineering Team Lead', 'Director of DevOps'])
     };
     const depProduct = {
         id: uuid$h(),
@@ -21188,6 +22542,7 @@ const BUSINESS_UNITS_MOCK = (() => {
         type: { id: TYPE.department.id, title: TYPE.department.title },
         parentId: divisionEngineering.id,
         parent: { id: divisionEngineering.id, title: divisionEngineering.title },
+        ...positionsByTitles(['Associate Product Manager', 'Product Manager', 'Senior Product Manager', 'UX Designer'])
     };
     items.push(depPlatform, depProduct);
     // Branches (location-based) under cities
@@ -21205,6 +22560,7 @@ const BUSINESS_UNITS_MOCK = (() => {
         country: US,
         state: US_CA,
         city: LA,
+        ...positionsByTitles(['Sales Associate', 'Account Executive'])
     };
     const branchSF = {
         id: uuid$h(),
@@ -21220,6 +22576,7 @@ const BUSINESS_UNITS_MOCK = (() => {
         country: US,
         state: US_CA,
         city: SF,
+        ...positionsByTitles(['Sales Associate', 'Account Executive'])
     };
     const branchSydney = {
         id: uuid$h(),
@@ -21235,6 +22592,7 @@ const BUSINESS_UNITS_MOCK = (() => {
         country: AU,
         state: AU_NSW,
         city: SYDNEY,
+        ...positionsByTitles(['Sales Associate', 'Account Executive'])
     };
     items.push(branchLA, branchSF, branchSydney);
     return items;
@@ -21254,6 +22612,171 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.8", ngImpor
             type: Injectable
         }] });
 
+class LocationOrgChartBuilder {
+    build(context) {
+        const { root, indices, helpers, includeEmployees, orgRootConfig } = context;
+        for (const bu of context.data.businessUnits) {
+            const type = indices.buTypeById.get(bu.typeId);
+            const typeCode = type?.code ?? '';
+            const buNodeType = typeCode === 'division' ? AXMOrgChartNodeType.Division :
+                typeCode === 'department' ? AXMOrgChartNodeType.Department :
+                    AXMOrgChartNodeType.Branch;
+            const countryNode = helpers.ensureCountry(bu.country);
+            const stateNode = helpers.ensureState(countryNode, bu.state);
+            const cityNode = helpers.ensureCity(stateNode, bu.city);
+            const buAssignments = indices.assignmentsByBU.get(String(bu.id)) || [];
+            const children = includeEmployees ? helpers.buildPositionNodes(buAssignments) : [];
+            const buNode = {
+                id: AXPDataGenerator.uuid(),
+                title: bu.title,
+                description: bu.description,
+                type: buNodeType,
+                icon: typeCode === 'division' ? 'fa-sitemap' : typeCode === 'department' ? 'fa-building-user' : 'fa-network-wired',
+                entity: { id: bu.id, source: orgRootConfig.entities.businessUnit.source },
+                children,
+            };
+            if (cityNode) {
+                cityNode.children = cityNode.children || [];
+                cityNode.children.push(buNode);
+            }
+            else {
+                root.children.push(buNode);
+            }
+        }
+        return root;
+    }
+}
+
+class StructureOrgChartBuilder {
+    build(context) {
+        const { root, indices, helpers, includeEmployees, orgRootConfig } = context;
+        // Build BU hierarchy by parent reference if exists; otherwise group by type
+        const childrenByParent = new Map();
+        for (const bu of context.data.businessUnits) {
+            const parentId = bu.parentId ?? undefined;
+            const list = childrenByParent.get(parentId) || [];
+            list.push(bu);
+            childrenByParent.set(parentId, list);
+        }
+        const createBuNode = (bu) => {
+            const type = indices.buTypeById.get(bu.typeId);
+            const typeCode = type?.code ?? '';
+            const buNodeType = typeCode === 'division' ? AXMOrgChartNodeType.Division :
+                typeCode === 'department' ? AXMOrgChartNodeType.Department :
+                    AXMOrgChartNodeType.Branch;
+            const buAssignments = indices.assignmentsByBU.get(String(bu.id)) || [];
+            const children = includeEmployees ? helpers.buildPositionNodes(buAssignments) : [];
+            const node = {
+                id: AXPDataGenerator.uuid(),
+                title: bu.title,
+                description: bu.description,
+                type: buNodeType,
+                icon: typeCode === 'division' ? 'fa-sitemap' : typeCode === 'department' ? 'fa-building-user' : 'fa-network-wired',
+                entity: { id: bu.id, source: orgRootConfig.entities.businessUnit.source },
+                children,
+            };
+            const childrenList = childrenByParent.get(String(bu.id)) || [];
+            for (const childBu of childrenList) {
+                node.children = node.children || [];
+                node.children.push(createBuNode(childBu));
+            }
+            return node;
+        };
+        // Roots: undefined parent or explicit null
+        const rootCandidates = childrenByParent.get(undefined) || childrenByParent.get(null) || [];
+        if (rootCandidates.length) {
+            for (const top of rootCandidates) {
+                root.children.push(createBuNode(top));
+            }
+        }
+        else {
+            // Fallback: group by type order Division -> Department -> Branch
+            const divisions = context.data.businessUnits.filter(bu => (indices.buTypeById.get(bu.typeId)?.code ?? '') === 'division');
+            const departments = context.data.businessUnits.filter(bu => (indices.buTypeById.get(bu.typeId)?.code ?? '') === 'department');
+            const branches = context.data.businessUnits.filter(bu => (indices.buTypeById.get(bu.typeId)?.code ?? '') === 'branch');
+            const addAll = (list) => list.forEach(bu => root.children.push(createBuNode(bu)));
+            addAll(divisions);
+            addAll(departments);
+            addAll(branches);
+        }
+        return root;
+    }
+}
+
+/**
+ * Reporting builder: builds a tree based on position reporting chain.
+ * Assumptions:
+ * - Prefer using `position.reportsToPositionId` if exists.
+ * - Fallback: derive manager from assignments by `managerPositionId` or similar if present; otherwise flat under BU.
+ */
+class ReportingOrgChartBuilder {
+    build(context) {
+        const { root, indices } = context;
+        // Map child positions by manager position id
+        const childrenByManager = new Map();
+        for (const position of context.data.positions) {
+            const reportsTo = position.reportsToPositionId ?? undefined;
+            const list = childrenByManager.get(reportsTo) || [];
+            list.push(position.id);
+            childrenByManager.set(reportsTo, list);
+        }
+        const createPositionNode = (positionId) => {
+            const pos = indices.positionById.get(positionId);
+            const assignmentsInAllBU = this.collectAssignmentsForPosition(context, positionId);
+            const rep = context.helpers.chooseRepresentativeAssignment(assignmentsInAllBU);
+            const employee = rep ? context.indices.employeeById.get(rep.employeeId) : null;
+            const employeeName = employee?.party?.displayName ?? employee?.fullName ?? null;
+            const employeeRole = employee?.role?.title ?? null;
+            const node = {
+                id: AXPDataGenerator.uuid(),
+                title: pos?.title ?? 'Position',
+                subtitle: employeeName ?? 'Vacant',
+                description: employeeName && employeeRole ? employeeRole : undefined,
+                type: AXMOrgChartNodeType.Position,
+                icon: 'fa-user-tie',
+                entity: { id: positionId, source: context.orgRootConfig.entities.position.source },
+                children: [],
+            };
+            const children = childrenByManager.get(positionId) || [];
+            for (const childPosId of children) {
+                node.children.push(createPositionNode(childPosId));
+            }
+            return node;
+        };
+        // Top managers: positions without a manager
+        const tops = childrenByManager.get(undefined) || [];
+        for (const posId of tops) {
+            root.children.push(createPositionNode(posId));
+        }
+        return root;
+    }
+    collectAssignmentsForPosition(context, positionId) {
+        const result = [];
+        for (const [_buId, list] of context.indices.assignmentsByBU.entries()) {
+            for (const a of list) {
+                if (String(a.positionId) !== String(positionId))
+                    continue;
+                if (!context.helpers.isActiveAssignment(a, context.now, context.preferPrimary))
+                    continue;
+                result.push(a);
+            }
+        }
+        return result;
+    }
+}
+
+const createBuilder = (mode) => {
+    switch (mode) {
+        case 'structure':
+            return new StructureOrgChartBuilder();
+        case 'reporting':
+            return new ReportingOrgChartBuilder();
+        case 'location':
+        default:
+            return new LocationOrgChartBuilder();
+    }
+};
+
 class AXMOrgChartGenerateCommand {
     constructor() {
         //#region ----   Services & Dependencies   ----
@@ -21265,6 +22788,7 @@ class AXMOrgChartGenerateCommand {
     async execute(input) {
         const includeEmployees = input?.includeEmployees !== false;
         const preferPrimary = input?.preferPrimary !== false;
+        const mode = input?.mode ?? 'location';
         const now = new Date();
         // Build root from tenant (virtual root)
         const tenant = this.session.tenant;
@@ -21396,35 +22920,39 @@ class AXMOrgChartGenerateCommand {
             }
             return nodes;
         };
-        // Place BusinessUnits under Country/State/City (virtual), then attach position nodes
-        for (const bu of businessUnits) {
-            const type = buTypeById.get(bu.typeId);
-            const typeCode = type?.code ?? '';
-            const buNodeType = typeCode === 'division' ? AXMOrgChartNodeType.Division :
-                typeCode === 'department' ? AXMOrgChartNodeType.Department :
-                    AXMOrgChartNodeType.Branch;
-            const countryNode = ensureCountry(bu.country);
-            const stateNode = ensureState(countryNode, bu.state);
-            const cityNode = ensureCity(stateNode, bu.city);
-            const buAssignments = assignmentsByBU.get(String(bu.id)) || [];
-            const children = includeEmployees ? buildPositionNodes(buAssignments) : [];
-            const buNode = {
-                id: AXPDataGenerator.uuid(),
-                title: bu.title,
-                description: bu.description,
-                type: buNodeType,
-                icon: typeCode === 'division' ? 'fa-sitemap' : typeCode === 'department' ? 'fa-building-user' : 'fa-network-wired',
-                entity: { id: bu.id, source: RootConfig$c.entities.businessUnit.source },
-                children,
-            };
-            if (cityNode) {
-                cityNode.children = cityNode.children || [];
-                cityNode.children.push(buNode);
-            }
-            else {
-                root.children.push(buNode);
-            }
-        }
+        // Build context for selected builder
+        const ctx = {
+            now,
+            includeEmployees,
+            preferPrimary,
+            orgRootConfig: RootConfig$c,
+            hcmRootConfig: RootConfig$d,
+            root,
+            data: {
+                businessUnits: businessUnits,
+                businessUnitTypes: businessUnitTypes,
+                positions: positions,
+                employees: employees,
+                assignments: assignments,
+            },
+            indices: {
+                businessUnitById,
+                buTypeById,
+                positionById,
+                employeeById,
+                assignmentsByBU,
+            },
+            helpers: {
+                isActiveAssignment: this.isActiveAssignment.bind(this),
+                chooseRepresentativeAssignment,
+                ensureCountry,
+                ensureState,
+                ensureCity,
+                buildPositionNodes,
+            },
+        };
+        const builder = createBuilder(mode);
+        builder.build(ctx);
         // Persist as a new version
         const version = this.generateVersion();
         const id = await this.storage.insertOne(RootConfig$c.entities.chart.source, {
@@ -21842,177 +23370,6 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.8", ngImpor
             type: Injectable
         }] });
 
-function generatePositionsCategory() {
-    const categories = [];
-    const roots = ['Engineering Positions', 'Technical Leadership', 'Product Positions', 'Operations', 'Business Functions', 'Executive Leadership'];
-    const ids = new Map();
-    roots.forEach((title) => {
-        const id = AXPDataGenerator.uuid();
-        ids.set(title, id);
-        const descriptionMap = {
-            'Engineering Positions': 'All engineering role families',
-            'Technical Leadership': 'Leadership tracks within technology',
-            'Product Positions': 'Roles related to product management & design',
-            Operations: 'IT, Support and Security positions',
-            'Business Functions': 'Sales, Marketing and BD roles',
-            'Executive Leadership': 'C-level and executive roles',
-        };
-        categories.push({ id, title, description: descriptionMap[title] ?? '', childCount: 0 });
-    });
-    const children = [
-        { parent: 'Engineering Positions', children: ['Frontend Engineering', 'Backend Engineering', 'Mobile Engineering', 'Quality Engineering'] },
-        { parent: 'Technical Leadership', children: ['Engineering Management', 'Technical Architecture', 'DevOps Leadership'] },
-        { parent: 'Product Positions', children: ['Product Management', 'UX/UI Design', 'Product Analytics'] },
-        { parent: 'Operations', children: ['IT Operations', 'Technical Support', 'Security Operations', 'Health, Safety & Environment'] },
-        { parent: 'Business Functions', children: ['Sales', 'Marketing', 'Business Development'] },
-        { parent: 'Executive Leadership', children: ['C-Suite', 'Board Members', 'Corporate Strategy'] },
-    ];
-    children.forEach(({ parent, children }) => {
-        const parentId = ids.get(parent);
-        if (!parentId)
-            return;
-        children.forEach((title) => {
-            const id = AXPDataGenerator.uuid();
-            ids.set(title, id);
-            const descriptionMap = {
-                'Frontend Engineering': 'Client-side engineering track',
-                'Backend Engineering': 'Server-side engineering track',
-                'Mobile Engineering': 'Mobile application engineering track',
-                'Quality Engineering': 'Testing and QA track',
-                'Engineering Management': 'People and delivery leadership track',
-                'Technical Architecture': 'Architecture and system design track',
-                'DevOps Leadership': 'Reliability and platform engineering track',
-                'Product Management': 'Product strategy and delivery track',
-                'UX/UI Design': 'User experience and interface design track',
-                'Product Analytics': 'Data-driven product insights track',
-                'IT Operations': 'IT and infrastructure operations track',
-                'Technical Support': 'Customer and internal support track',
-                'Security Operations': 'Cybersecurity and defense track',
-                Sales: 'Sales roles and career track',
-                Marketing: 'Marketing roles and career track',
-                'Business Development': 'Partnerships and growth roles',
-                'C-Suite': 'Executive leadership team',
-                'Board Members': 'Corporate board members',
-                'Corporate Strategy': 'Corporate planning and strategy',
-            };
-            categories.push({ id, title, description: descriptionMap[title] ?? '', parentId, childCount: 0 });
-        });
-        const parentObj = categories.find((c) => c.id === parentId);
-        if (parentObj)
-            parentObj.childCount = children.length;
-    });
-    return categories;
-}
-const POSITIONS_CATEGORY_MOCK = generatePositionsCategory();
-function generatePositions() {
-    const positions = [];
-    const categories = POSITIONS_CATEGORY_MOCK;
-    const childPositions = [
-        { parent: 'Frontend Engineering', children: ['Junior Frontend Engineer', 'Frontend Engineer'] },
-        { parent: 'Backend Engineering', children: ['Junior Backend Engineer', 'Backend Engineer'] },
-        { parent: 'Mobile Engineering', children: ['Junior Mobile Developer', 'Mobile Developer', 'Senior Mobile Developer', 'Mobile Architect'] },
-        { parent: 'Quality Engineering', children: ['QA Analyst', 'QA Engineer', 'Senior QA Engineer', 'QA Manager'] },
-        { parent: 'Engineering Management', children: ['Engineering Team Lead', 'Engineering Manager', 'Director of Engineering', 'VP of Engineering'] },
-        { parent: 'Product Management', children: ['Associate Product Manager', 'Product Manager', 'Senior Product Manager', 'Director of Product'] },
-        { parent: 'UX/UI Design', children: ['UX Designer', 'UI Designer', 'Senior UX Designer', 'UX Design Manager'] },
-        { parent: 'IT Operations', children: ['IT Support Specialist', 'Systems Administrator'] },
-        { parent: 'Sales', children: ['Sales Associate', 'Account Executive', 'Sales Manager', 'VP of Sales'] },
-        { parent: 'C-Suite', children: ['CTO', 'CEO', 'CFO', 'COO'] },
-        { parent: 'DevOps Leadership', children: ['DevOps Engineer', 'Senior DevOps Engineer', 'DevOps Manager', 'Director of DevOps'] },
-        { parent: 'Health, Safety & Environment', children: ['HSE Officer', 'Safety Officer', 'Environmental Specialist', 'HSE Manager'] },
-        { parent: 'Engineering Management', children: ['Production Supervisor'] },
-        { parent: 'Operations', children: ['Maintenance Technician', 'Maintenance Engineer', 'Quality Inspector', 'Quality Engineer', 'Procurement Specialist', 'Warehouse Associate', 'Warehouse Supervisor', 'Production Planner'] },
-    ];
-    // Position descriptions mapping
-    const positionDescriptions = {
-        // Frontend Engineering
-        'Junior Frontend Engineer': 'Entry-level frontend developer responsible for building user interfaces using HTML, CSS, and JavaScript frameworks. Focuses on learning best practices and contributing to team projects.',
-        'Frontend Engineer': 'Mid-level frontend developer who builds responsive web applications, implements UI/UX designs, and collaborates with design and backend teams.',
-        'Senior Frontend Engineer': 'Experienced frontend developer who leads technical decisions, mentors junior developers, and architects scalable frontend solutions.',
-        'Frontend Architect': 'Senior technical leader responsible for frontend architecture decisions, performance optimization, and setting technical standards for the frontend team.',
-        // Backend Engineering
-        'Junior Backend Engineer': 'Entry-level backend developer focused on building server-side logic, APIs, and database interactions. Learns backend technologies and best practices.',
-        'Backend Engineer': 'Mid-level backend developer who designs and implements server-side applications, APIs, and database schemas.',
-        'Senior Backend Engineer': 'Experienced backend developer who leads technical decisions, optimizes system performance, and mentors junior developers.',
-        'Backend Architect': 'Senior technical leader responsible for backend architecture, system design, and technical strategy for server-side systems.',
-        // Mobile Engineering
-        'Junior Mobile Developer': 'Entry-level mobile developer focused on building native or cross-platform mobile applications. Learns mobile development frameworks and best practices.',
-        'Mobile Developer': 'Mid-level mobile developer who creates mobile apps, implements features, and ensures app performance and user experience.',
-        'Senior Mobile Developer': 'Experienced mobile developer who leads mobile development initiatives, optimizes app performance, and mentors junior developers.',
-        'Mobile Architect': 'Senior technical leader responsible for mobile architecture decisions, platform strategy, and technical standards for mobile development.',
-        // Quality Engineering
-        'QA Analyst': 'Entry-level quality assurance professional who executes test plans, reports bugs, and ensures software quality through systematic testing.',
-        'QA Engineer': 'Mid-level QA professional who designs test strategies, automates testing processes, and collaborates with development teams.',
-        'Senior QA Engineer': 'Experienced QA professional who leads testing initiatives, implements quality processes, and mentors junior QA team members.',
-        'QA Manager': 'Senior leader responsible for managing the QA team, establishing quality standards, and ensuring overall software quality.',
-        // Engineering Management
-        'Engineering Team Lead': 'Technical leader who manages a small engineering team, provides technical guidance, and ensures project delivery.',
-        'Engineering Manager': 'People manager responsible for team development, project planning, and technical decision-making for engineering teams.',
-        'Director of Engineering': 'Senior leader who manages multiple engineering teams, sets technical strategy, and drives engineering excellence.',
-        'VP of Engineering': 'Executive leader responsible for overall engineering strategy, team growth, and technical direction across the organization.',
-        // Product Management
-        'Associate Product Manager': 'Entry-level product professional who supports product development, conducts research, and assists with product strategy.',
-        'Product Manager': 'Mid-level product professional who defines product vision, prioritizes features, and collaborates with cross-functional teams.',
-        'Senior Product Manager': 'Experienced product professional who leads product strategy, mentors junior PMs, and drives product success.',
-        'Director of Product': 'Senior leader responsible for product portfolio strategy, team leadership, and product vision across multiple products.',
-        // UX/UI Design
-        'UX Designer': 'Design professional focused on user experience research, user flows, and creating intuitive user interfaces.',
-        'UI Designer': 'Visual designer who creates user interface designs, design systems, and ensures visual consistency across products.',
-        'Senior UX Designer': 'Experienced UX professional who leads design initiatives, mentors junior designers, and drives user experience strategy.',
-        'UX Design Manager': 'Senior leader responsible for managing the design team, establishing design processes, and ensuring design quality.',
-        // IT Operations
-        'IT Support Specialist': 'Entry-level IT professional who provides technical support, troubleshoots issues, and maintains IT systems.',
-        'Systems Administrator': 'Mid-level IT professional who manages server infrastructure, implements security measures, and ensures system reliability.',
-        // Sales
-        'Sales Associate': 'Entry-level sales professional who supports sales activities, qualifies leads, and assists with customer relationships.',
-        'Account Executive': 'Mid-level sales professional who manages customer accounts, drives sales growth, and builds client relationships.',
-        'Sales Manager': 'Senior sales professional who leads sales teams, develops sales strategies, and drives revenue growth.',
-        'VP of Sales': 'Executive leader responsible for overall sales strategy, team leadership, and revenue generation across the organization.',
-        // C-Suite
-        'CTO': 'Chief Technology Officer responsible for technology strategy, innovation, and technical leadership across the organization.',
-        'CEO': 'Chief Executive Officer responsible for overall company strategy, leadership, and business success.',
-        'CFO': 'Chief Financial Officer responsible for financial strategy, planning, and financial operations.',
-        'COO': 'Chief Operating Officer responsible for operational excellence, process optimization, and day-to-day business operations.',
-        // DevOps Leadership
-        'DevOps Engineer': 'Mid-level DevOps professional who automates deployment processes, manages infrastructure, and ensures system reliability.',
-        'Senior DevOps Engineer': 'Experienced DevOps professional who leads infrastructure initiatives, optimizes deployment processes, and mentors junior team members.',
-        'DevOps Manager': 'Senior leader responsible for managing DevOps teams, establishing best practices, and driving operational excellence.',
-        'Director of DevOps': 'Senior leader responsible for DevOps strategy, infrastructure planning, and technical leadership for operations teams.',
-        // Core Industrial Operations
-        'Production Supervisor': 'Leads production lines and teams, manages shift performance, and ensures production targets and quality standards are met.',
-        'Maintenance Technician': 'Executes routine and corrective maintenance tasks to ensure equipment uptime.',
-        'Maintenance Engineer': 'Plans maintenance strategies, analyzes failures, and drives reliability improvements.',
-        'Quality Inspector': 'Performs incoming, in-process, and final inspections to ensure product conformance.',
-        'Quality Engineer': 'Develops control plans, handles nonconformances, and leads continuous improvement initiatives.',
-        'Procurement Specialist': 'Sources materials, negotiates contracts, and manages purchase orders.',
-        'Warehouse Associate': 'Handles receiving, storage, picking, packing, and shipping operations.',
-        'Warehouse Supervisor': 'Oversees warehouse staff and processes, ensuring accuracy and on-time shipments.',
-        'Production Planner': 'Creates production schedules, coordinates materials and capacity, and monitors adherence.',
-        // Health, Safety & Environment
-        'HSE Officer': 'Professional supporting health and safety initiatives, audits, and safety training across operations.',
-        'Safety Officer': 'Specialist enforcing safety standards, conducting inspections, and coordinating incident investigations.',
-        'Environmental Specialist': 'Professional overseeing environmental compliance, waste management, and sustainability reporting.',
-        'HSE Manager': 'Leader managing HSE programs, regulatory compliance, and continuous improvement in safety performance.'
-    };
-    childPositions.forEach(({ parent, children }) => {
-        const parentObj = categories.find((c) => c.title === parent);
-        if (!parentObj)
-            return;
-        children.forEach((title) => {
-            positions.push({
-                id: AXPDataGenerator.uuid(),
-                title,
-                description: positionDescriptions[title] || 'Professional position with specific responsibilities and requirements.',
-                categoryIds: [parentObj.id],
-                categories: [{ id: parentObj.id, title: parentObj.title }],
-                isManager: /(Manager|Director|Lead|VP|Chief|Head)/i.test(title),
-            });
-        });
-    });
-    return positions;
-}
-const POSITIONS_MOCK = generatePositions();
-
 class AXMPositionDataSeeder {
     constructor() {
         this.storageService = inject(AXPEntityStorageService);
@@ -23110,8 +24467,10 @@ const AXCMockOrgChartEventListener = {
             return;
         // Relevant entities that should trigger org chart regeneration
         const relevantEntities = [
+            // Organization Management
             `${RootConfig$c.module.name}.${RootConfig$c.entities.businessUnit.name}`,
             `${RootConfig$c.module.name}.${RootConfig$c.entities.position.name}`,
+            // Human Capital Management
             `${RootConfig$d.module.name}.${RootConfig$d.entities.employee.name}`,
             `${RootConfig$d.module.name}.${RootConfig$d.entities.positionAssignment.name}`
         ];
@@ -23121,7 +24480,7 @@ const AXCMockOrgChartEventListener = {
         try {
             // Execute org chart generation command via command service
             const commandService = inject(AXPCommandService);
-            const result = await commandService.execute('organization.chart.generate', {
+            const result = await commandService.execute('OrganizationManagement.OrgChart:Generate', {
                 includeEmployees: true,
                 preferPrimary: true
             });
@@ -23188,7 +24547,7 @@ class AXCOrganizationManagementMockModule {
             },
             // Commands
             provideCommandSetups([
-                { key: 'organization.chart.generate', command: () => AXMOrgChartGenerateCommand },
+                { key: 'OrganizationManagement.OrgChart:Generate', command: () => AXMOrgChartGenerateCommand },
             ]),
         ] }); }
 }
@@ -23235,7 +24594,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.8", ngImpor
                         },
                         // Commands
                         provideCommandSetups([
-                            { key: 'organization.chart.generate', command: () => AXMOrgChartGenerateCommand },
+                            { key: 'OrganizationManagement.OrgChart:Generate', command: () => AXMOrgChartGenerateCommand },
                         ]),
                     ],
                 }]
@@ -23516,7 +24875,12 @@ const POSITION_ASSIGNMENTS_MOCK = (() => {
         if (assignedEmployeeIds.has(candidate.id)) {
             return; // skip creating another active primary assignment for the same employee
         }
-        const position = managerPositions.length ? pick(managerPositions) : pick(POSITIONS_MOCK);
+        // Prefer a position that is listed for this business unit if available
+        const buPositions = bu.positionIds ?? [];
+        const candidatePositions = (buPositions.length
+            ? POSITIONS_MOCK.filter(p => buPositions.includes(p.id))
+            : managerPositions.length ? managerPositions : POSITIONS_MOCK);
+        const position = pick(candidatePositions);
         rows.push({
             id: uuid$c(),
             employeeId: candidate.id,
@@ -27251,11 +28615,11 @@ class AXMReportMockDataService {
     generateMockDataForReport(reportDefinition, parameters, pageSize) {
         const reportTitle = reportDefinition.title.toLowerCase();
         const reportId = reportDefinition.id;
-        // Generate data based on report type
+        // Generate data based on report type - check reportId first for log management reports
         if (reportId.includes('log-management.report.audit-trail') ||
             reportId.includes('log-management.report.login-logs') ||
             reportId.includes('log-management.report.change-password-logs') ||
-            reportId.includes('log-management.report.identity-audit-log-error-logs')) {
+            reportId.includes('log-management.report.identity-error-logs')) {
             return this.generateAuditTrailData(reportDefinition, parameters, pageSize);
         }
         else if (reportTitle.includes('balance sheet') || reportTitle.includes('financial')) {
@@ -27282,14 +28646,41 @@ class AXMReportMockDataService {
         // Use imported log mock data
         const baseData = logMock;
         const data = [];
+        // For Identity Error Logs, filter to only include failed operations
+        let filteredBaseData = baseData;
+        if (reportDefinition.id.includes('identity-error-logs')) {
+            filteredBaseData = baseData.filter(item => item['httpStatus'] === 'failed' ||
+                item['httpStatusCode'] >= 400);
+        }
+        // If no filtered data available, use all data
+        if (filteredBaseData.length === 0) {
+            filteredBaseData = baseData;
+        }
         // Duplicate base data to reach pageSize
         for (let i = 0; i < pageSize; i++) {
-            const baseItem = baseData[i % baseData.length];
+            const baseItem = filteredBaseData[i % filteredBaseData.length];
             const duplicatedItem = {
-                ...baseItem,
-                id: AXPDataGenerator.uuid(), // Generate new ID for each item
-                executionTime: this.getRandomPastDate(30), // Randomize execution time
-                correlationId: AXPDataGenerator.uuid(), // Generate new correlation ID
+                id: AXPDataGenerator.uuid(),
+                executionTime: this.getRandomPastDate(30),
+                userName: baseItem['userName'] || 'Unknown User',
+                tenantName: baseItem['tenantName'] || 'ark',
+                httpMethod: baseItem['httpMethod'] || 'GET',
+                url: baseItem['url'] || '/unknown',
+                httpStatusCode: baseItem['httpStatusCode'] || 200,
+                executionDuration: baseItem['executionDuration'] || 0,
+                clientIpAddress: baseItem['clientIpAddress'] || '0.0.0.0',
+                clientName: baseItem['clientName'] || 'Unknown Client',
+                correlationId: AXPDataGenerator.uuid(),
+                comments: baseItem['comments'] || '',
+                exceptions: baseItem['exceptions'] || '',
+                httpStatus: baseItem['httpStatus'] || 'unknown',
+                applicationName: baseItem['applicationName'] || 'DemoApp',
+                impersonatorUserName: baseItem['impersonatorUserName'] || null,
+                // Include any other fields from baseItem
+                ...Object.fromEntries(Object.entries(baseItem).filter(([key]) => !['id', 'executionTime', 'userName', 'tenantName', 'httpMethod', 'url',
+                    'httpStatusCode', 'executionDuration', 'clientIpAddress', 'clientName',
+                    'correlationId', 'comments', 'exceptions', 'httpStatus', 'applicationName',
+                    'impersonatorUserName'].includes(key)))
             };
             data.push(duplicatedItem);
         }
@@ -27529,7 +28920,7 @@ class AXMReportExecuteCommand {
         else if (reportDefinition.id.includes('log-management.report.change-password-logs')) {
             filteredData = this.applyChangePasswordLogsFilters(allData, parameters);
         }
-        else if (reportDefinition.id.includes('log-management.report.identity-audit-log-error-logs')) {
+        else if (reportDefinition.id.includes('log-management.report.identity-error-logs')) {
             filteredData = this.applyIdentityAuditLogErrorLogsFilters(allData, parameters);
         }
         // Debug logging
@@ -28057,7 +29448,7 @@ class AXMReportExecuteCommand {
             }
         }
         // Debug logging
-        console.log('🔍 Identity Audit Log Error Logs Filter Debug:', {
+        console.log('🔍 Identity Error Logs Filter Debug:', {
             startDate,
             endDate,
             userNameFilter,
@@ -28609,6 +30000,56 @@ class AXCDeviceSessionService extends AXMDeviceSessionsServiceImpl {
     }
 }
 
+/**
+ * Mock policies for seeding into the Mock (IndexedDB) backend.
+ * This policy enforces readonly on entire records when control.isSystem === true.
+ * Note: The policy record itself is marked as system via control.isSystem = true.
+ */
+const mockPolicyDefinitions = [
+    {
+        id: AXPDataGenerator.uuid(),
+        control: { isSystem: true },
+        name: 'system-record-readonly',
+        title: 'System Records Readonly',
+        description: 'Make whole record readonly when control.isSystem is true.',
+        permission: 'policy.system.readonly',
+        scope: 'system',
+        resource: {
+            type: 'entity',
+            target: '*',
+        },
+        rules: [
+            {
+                // Evaluated in middleware using AXPExpressionEvaluatorService
+                // Available scope: context.{ op, entity, id, data, existing, result, eval }
+                // Use context.eval to access data fields
+                conditions: '{{ context.eval("control.isSystem") == true }}',
+                effects: [
+                    // Apply readonly to the entire record (blocks write fields)
+                    { effect: 'readonly', target: '*' },
+                    // Block delete/update entirely for system records
+                    { effect: 'immutable', target: '*' },
+                ],
+            },
+        ],
+    },
+];
+
+class AXPSecurityManagementPolicyDataSeeder {
+    constructor() {
+        this.storageService = inject(AXPEntityStorageService);
+    }
+    async seed() {
+        // Seed the predefined policies. The policy records themselves are marked as system.
+        await this.storageService.initial(`${RootConfig.module.name}.${RootConfig.entities.policy.name}`, mockPolicyDefinitions);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.8", ngImport: i0, type: AXPSecurityManagementPolicyDataSeeder, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.8", ngImport: i0, type: AXPSecurityManagementPolicyDataSeeder }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.8", ngImport: i0, type: AXPSecurityManagementPolicyDataSeeder, decorators: [{
+            type: Injectable
+        }] });
+
 class AXCSecurityManagementMockModule {
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.8", ngImport: i0, type: AXCSecurityManagementMockModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
     static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "20.1.8", ngImport: i0, type: AXCSecurityManagementMockModule }); }
@@ -28628,6 +30069,11 @@ class AXCSecurityManagementMockModule {
                 useClass: AXPSecurityManagementUserDataSeeder,
                 multi: true,
             },
+            {
+                provide: AXP_DATA_SEEDER_TOKEN,
+                useClass: AXPSecurityManagementPolicyDataSeeder,
+                multi: true,
+            },
             {
                 provide: AXMDeviceSessionsService,
                 useClass: AXCDeviceSessionService,
@@ -28656,6 +30102,11 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.8", ngImpor
                             useClass: AXPSecurityManagementUserDataSeeder,
                             multi: true,
                         },
+                        {
+                            provide: AXP_DATA_SEEDER_TOKEN,
+                            useClass: AXPSecurityManagementPolicyDataSeeder,
+                            multi: true,
+                        },
                         {
                             provide: AXMDeviceSessionsService,
                             useClass: AXCDeviceSessionService,
@@ -34088,12 +35539,129 @@ class AXCDexieEntityStorageService extends Dexie {
         if (request.sort && request.sort.length) {
             result = applySortArray(result, request.sort);
         }
-        result = applyFilterArray(result, request.filter ? [request.filter] : []);
+        // Handle recursive category filtering
+        if (request.filter && this.isCategoryFilter(request.filter)) {
+            result = await this.applyRecursiveCategoryFilter(result, request.filter, entityName);
+        }
+        else {
+            result = applyFilterArray(result, request.filter ? [request.filter] : []);
+        }
+        // Calculate childCount for category entities
+        if (this.isCategoryEntity(entityName)) {
+            result = await this.calculateChildCounts(result, entityName);
+        }
         return Promise.resolve({
             total: result.length,
             items: result.slice(request.skip, (request.skip ?? 0) + (request.take ?? 0)),
         });
     }
+    //#region ----   Private Helper Methods   ----
+    /**
+     * Check if the entity is a category entity (ends with 'Category')
+     */
+    isCategoryEntity(entityName) {
+        return entityName.endsWith('Category');
+    }
+    /**
+     * Calculate childCount for each category entity
+     */
+    async calculateChildCounts(items, entityName) {
+        return Promise.all(items.map(async (item) => {
+            const childCount = await this.getDirectChildCount(item.id, entityName);
+            return {
+                ...item,
+                childCount
+            };
+        }));
+    }
+    /**
+     * Get the count of direct children for a category
+     */
+    async getDirectChildCount(categoryId, entityName) {
+        const children = await this.table('entity-store')
+            .where({ entityName })
+            .filter((item) => item.parentId === categoryId)
+            .toArray();
+        return children.length;
+    }
+    /**
+     * Check if the filter is a category filter (contains operator on categoryIds field)
+     * Handles both simple filters and compound filters
+     */
+    isCategoryFilter(filter) {
+        // Handle simple filter
+        if (filter?.operator?.type === 'contains' &&
+            (filter.field === 'categoryIds' || filter.field?.endsWith('Ids'))) {
+            return true;
+        }
+        // Handle compound filter - check if any nested filter is a category filter
+        if (filter?.logic && filter?.filters && Array.isArray(filter.filters)) {
+            return filter.filters.some((nestedFilter) => nestedFilter?.operator?.type === 'contains' &&
+                (nestedFilter.field === 'categoryIds' || nestedFilter.field?.endsWith('Ids')));
+        }
+        return false;
+    }
+    /**
+     * Apply recursive category filtering - finds entities that belong to the category or any of its children
+     */
+    async applyRecursiveCategoryFilter(result, filter, entityName) {
+        // Handle compound filter - find the category filter within it
+        let categoryFilter = filter;
+        let otherFilters = [];
+        if (filter?.logic && filter?.filters && Array.isArray(filter.filters)) {
+            // Find the category filter and collect other filters
+            const categoryFilterIndex = filter.filters.findIndex((f) => f?.operator?.type === 'contains' &&
+                (f.field === 'categoryIds' || f.field?.endsWith('Ids')));
+            if (categoryFilterIndex !== -1) {
+                categoryFilter = filter.filters[categoryFilterIndex];
+                // Get all other filters (excluding the category filter)
+                otherFilters = filter.filters.filter((_, index) => index !== categoryFilterIndex);
+            }
+        }
+        if (!categoryFilter) {
+            // Fallback to regular filtering if no category filter found
+            return applyFilterArray(result, [filter]);
+        }
+        const categoryId = categoryFilter.value;
+        const categoryField = categoryFilter.field;
+        // Get all child category IDs recursively
+        const allCategoryIds = await this.getAllChildCategoryIds(categoryId, entityName);
+        // Filter results to include entities that belong to any of the collected category IDs
+        let filteredResult = result.filter((item) => {
+            const categoryIds = item[categoryField];
+            if (!categoryIds)
+                return false;
+            // Handle both string and array formats
+            const itemCategoryIds = Array.isArray(categoryIds) ? categoryIds : [categoryIds];
+            // Check if any of the item's categories match any of the collected category IDs
+            return itemCategoryIds.some((itemCategoryId) => allCategoryIds.includes(itemCategoryId));
+        });
+        // Apply other filters if they exist
+        if (otherFilters.length > 0) {
+            filteredResult = applyFilterArray(filteredResult, otherFilters);
+        }
+        return filteredResult;
+    }
+    /**
+     * Recursively gets all child category IDs including the parent category itself
+     */
+    async getAllChildCategoryIds(categoryId, entityName) {
+        const allIds = [categoryId];
+        // Extract module name and entity name from entityName (e.g., "module.entity" -> "module" and "entity")
+        const [moduleName, entityNameOnly] = entityName.split('.');
+        const categoryEntityName = `${moduleName}.${entityNameOnly}Category`;
+        // Get direct children
+        const childrenResult = await this.table('entity-store').where({
+            entityName: categoryEntityName
+        }).toArray();
+        const directChildren = childrenResult.filter((child) => child.parentId === categoryId);
+        // Recursively get children of children
+        for (const child of directChildren) {
+            const childIds = await this.getAllChildCategoryIds(child.id, entityName);
+            allIds.push(...childIds);
+        }
+        return allIds;
+    }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.8", ngImport: i0, type: AXCDexieEntityStorageService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
     static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.8", ngImport: i0, type: AXCDexieEntityStorageService }); }
 }
@@ -34119,7 +35687,13 @@ const auditLoggerMiddleware = {
                         type: 'user',
                         fullName: session.user?.title,
                     }
-                }
+                },
+                /////
+                isReadOnly: false,
+                isHidden: false,
+                isSystem: false,
+                isImmutable: false,
+                /////
             };
         }
         else if (ctx.op === 'update') {
@@ -34133,6 +35707,70 @@ const auditLoggerMiddleware = {
     },
 };
 
+const childCountMiddleware = {
+    target: { ops: ['create', 'delete'], order: 20 },
+    execute: async (ctx, next) => {
+        // Check if entity name ends with "Category"
+        if (!ctx.entityName.endsWith('Category')) {
+            await next();
+            return;
+        }
+        // For delete operations, get the entity data before deletion
+        let entityDataBeforeDelete = null;
+        if (ctx.op === 'delete') {
+            try {
+                entityDataBeforeDelete = await ctx.backend.getOne(ctx.entityName, ctx.id);
+            }
+            catch (error) {
+                // Entity might not exist, continue anyway
+                console.warn('Could not fetch entity before delete:', error);
+            }
+        }
+        // Execute the operation first
+        await next();
+        // After successful operation, update childCount for parent categories
+        await updateChildCountForParent(ctx, entityDataBeforeDelete);
+    },
+};
+/**
+ * Updates childCount for parent categories when a category entity is created, updated, or deleted
+ */
+async function updateChildCountForParent(ctx, entityDataBeforeDelete) {
+    try {
+        let currentEntity = null;
+        if (ctx.op === 'delete' && entityDataBeforeDelete) {
+            // For delete operations, use the data we fetched before deletion
+            currentEntity = entityDataBeforeDelete;
+        }
+        else {
+            // For create operations, get the entity data after creation
+            const id = ctx.result ?? ctx.data?.id ?? ctx.id;
+            currentEntity = await ctx.backend.getOne(ctx.entityName, id);
+        }
+        if (!currentEntity || !currentEntity.parentId) {
+            return; // No parent to update
+        }
+        // Count children for the parent category
+        const childrenResult = await ctx.backend.query(ctx.entityName, {
+            skip: 0,
+            take: 1000, // Reasonable limit for counting
+            filter: {
+                field: 'parentId',
+                operator: { type: 'equal' },
+                value: currentEntity.parentId
+            }
+        });
+        // Update parent's childCount
+        await ctx.backend.updateOne(ctx.entityName, currentEntity.parentId, {
+            childCount: childrenResult.items.length
+        });
+    }
+    catch (error) {
+        // Log error but don't fail the operation
+        console.warn('Failed to update childCount:', error);
+    }
+}
+
 /**
  * File Cast Middleware - Handles file operations in entity storage
  *
@@ -34919,6 +36557,439 @@ const mergeDetailRelationMiddleware = {
     },
 };
 
+/**
+ * resolve whether a policy matches current entity by wildcard (*) or exact name
+ */
+function matchesEntity(target, entityName) {
+    if (!target || target === '*')
+        return true;
+    return target === entityName;
+}
+/**
+ * apply masking to a value using a simple standard mask
+ */
+function maskValue(value) {
+    if (value == null)
+        return value;
+    const str = String(value);
+    if (str.length <= 4)
+        return '****';
+    return `${'*'.repeat(Math.max(0, str.length - 4))}${str.slice(-4)}`;
+}
+/**
+ * remove fields from an object by dotted paths; supports single-level for now
+ */
+function removeFields(obj, paths) {
+    if (!obj || !paths?.length)
+        return;
+    // Helper: delete by dotted path (e.g., "a.b.c")
+    const deleteByPath = (target, path) => {
+        const parts = path.split('.');
+        let cursor = target;
+        for (let i = 0; i < parts.length - 1; i++) {
+            const key = parts[i];
+            if (cursor == null || typeof cursor !== 'object')
+                return;
+            cursor = cursor[key];
+        }
+        const lastKey = parts[parts.length - 1];
+        if (cursor && typeof cursor === 'object' && Object.prototype.hasOwnProperty.call(cursor, lastKey)) {
+            delete cursor[lastKey];
+        }
+    };
+    // If wildcard present, remove all top-level fields
+    if (paths.includes('*')) {
+        for (const key of Object.keys(obj)) {
+            delete obj[key];
+        }
+    }
+    for (const p of paths) {
+        if (!p || p === '*')
+            continue;
+        if (p.includes('.')) {
+            deleteByPath(obj, p);
+        }
+        else if (Object.prototype.hasOwnProperty.call(obj, p)) {
+            delete obj[p];
+        }
+    }
+}
+/**
+ * set masked fields in object by dotted paths; supports single-level for now
+ */
+function setMasked(obj, paths) {
+    if (!obj || !paths?.length)
+        return;
+    // Helper: set mask by dotted path (e.g., "a.b.c")
+    const maskByPath = (target, path) => {
+        const parts = path.split('.');
+        let cursor = target;
+        for (let i = 0; i < parts.length - 1; i++) {
+            const key = parts[i];
+            if (cursor == null || typeof cursor !== 'object')
+                return;
+            cursor = cursor[key];
+        }
+        const lastKey = parts[parts.length - 1];
+        if (cursor && typeof cursor === 'object' && Object.prototype.hasOwnProperty.call(cursor, lastKey)) {
+            cursor[lastKey] = maskValue(cursor[lastKey]);
+        }
+    };
+    // If wildcard present, mask all top-level primitive fields
+    if (paths.includes('*')) {
+        for (const key of Object.keys(obj)) {
+            if (Object.prototype.hasOwnProperty.call(obj, key)) {
+                const val = obj[key];
+                if (val == null || typeof val !== 'object') {
+                    obj[key] = maskValue(val);
+                }
+            }
+        }
+    }
+    for (const p of paths) {
+        if (!p || p === '*')
+            continue;
+        if (p.includes('.')) {
+            maskByPath(obj, p);
+        }
+        else if (Object.prototype.hasOwnProperty.call(obj, p)) {
+            obj[p] = maskValue(obj[p]);
+        }
+    }
+}
+/**
+ * collect effect targets from a list of rules filtered by effect name
+ */
+function collectTargets(rules, effect) {
+    return rules.filter(r => r.effect === effect).map(r => r.target).filter(Boolean);
+}
+/**
+ * Evaluate a policy's rules against the provided scope
+ */
+async function isRuleActive(conditions, evaluator, extraScope) {
+    // Note: conditions is AXPExpression and may be a template string {{ ... }} or boolean
+    const result = await evaluator.evaluate(conditions, extraScope);
+    return Boolean(result);
+}
+const policyEnforceMiddleware = {
+    target: { ops: ['create', 'update', 'delete', 'getOne', 'getAll', 'query'], order: 5 },
+    execute: async (ctx, next) => {
+        //  try { console.warn('[policy] enter-middleware', ctx.op, ctx.entityName, ctx.id); } catch {}
+        // Prevent recursion: skip enforcement when querying the Policy entity itself
+        const policyEntityFullName = `${RootConfig.module.name}.${RootConfig.entities.policy.name}`;
+        if (ctx.entityName === policyEntityFullName) {
+            await next();
+            return;
+        }
+        const policyService = inject(AXMPolicyService);
+        const evaluator = inject(AXPExpressionEvaluatorService);
+        const backend = inject(AXP_ENTITY_STORAGE_BACKEND);
+        // Load all policies (could be cached later); filter by resource.type === 'entity' and target match
+        let policies = [];
+        try {
+            const res = await policyService.query({ skip: 0, take: 1000 });
+            policies = (res?.items ?? []);
+        }
+        catch {
+            policies = [];
+        }
+        const applicable = policies.filter(p => p?.resource?.type === 'entity' && matchesEntity(p.resource?.target, ctx.entityName));
+        if (applicable.length === 0) {
+            await next();
+            return;
+        }
+        // Build evaluation scope per operation
+        const buildScope = (overrides) => {
+            const existing = overrides?.existing;
+            const result = overrides?.result ?? ctx.result;
+            return {
+                // Additional scopes are provided via providers (session, permission). Here we add op-specific context.
+                context: {
+                    op: ctx.op,
+                    entity: ctx.entityName,
+                    id: ctx.id,
+                    data: ctx.data,
+                    existing: existing,
+                    result: result,
+                    // Add eval function to access data fields
+                    eval: (key) => {
+                        // Helper function to get nested property
+                        const getNestedProperty = (obj, path) => {
+                            if (!obj || !path)
+                                return undefined;
+                            const parts = path.split('.');
+                            let current = obj;
+                            for (const part of parts) {
+                                if (current && typeof current === 'object' && part in current) {
+                                    current = current[part];
+                                }
+                                else {
+                                    return undefined;
+                                }
+                            }
+                            return current;
+                        };
+                        // For delete operations, use existing data
+                        if (ctx.op === 'delete' && existing) {
+                            return getNestedProperty(existing, key);
+                        }
+                        // For create/update operations, use data
+                        if (ctx.data) {
+                            const dataValue = getNestedProperty(ctx.data, key);
+                            if (dataValue !== undefined) {
+                                return dataValue;
+                            }
+                        }
+                        // Fallback to existing for update operations
+                        if (existing) {
+                            return getNestedProperty(existing, key);
+                        }
+                        return undefined;
+                    }
+                }
+            };
+        };
+        // Helper: evaluate active rules for a given scope
+        const evaluateActiveRules = async (scope) => {
+            const list = [];
+            for (const pol of applicable) {
+                for (const rule of pol.rules ?? []) {
+                    const active = await isRuleActive(rule.conditions, evaluator, scope);
+                    if (active) {
+                        for (const eff of rule.effects ?? []) {
+                            list.push(eff);
+                        }
+                    }
+                }
+            }
+            return list;
+        };
+        // Resolve effects per operation following simple standard semantics
+        const deriveTargets = (rules) => ({
+            readonlyTargets: collectTargets(rules, 'readonly'),
+            immutableTargets: collectTargets(rules, 'immutable'),
+            hiddenTargets: collectTargets(rules, 'hidden'),
+            maskedTargets: collectTargets(rules, 'masked'),
+            editableTargets: collectTargets(rules, 'editable'),
+        });
+        let activeRules = [];
+        let readonlyTargets = [];
+        let immutableTargets = [];
+        let hiddenTargets = [];
+        let maskedTargets = [];
+        let editableTargets = [];
+        // Conflict resolution (standard): editable overrides readonly (not immutable), hidden beats everything in output, immutable strongest on write
+        const isEditable = (t) => editableTargets.includes(t) || editableTargets.includes('*');
+        // WRITE PATH
+        if (ctx.op === 'create' || ctx.op === 'update') {
+            // For update, load existing to allow conditions to reference current record state
+            let existing;
+            if (ctx.op === 'update' && ctx.id && backend?.getOne) {
+                try {
+                    existing = await backend.getOne(ctx.entityName, ctx.id);
+                }
+                catch {
+                    existing = undefined;
+                }
+            }
+            // Re-evaluate rules with existing in scope
+            activeRules = await evaluateActiveRules(buildScope({ existing }));
+            ({ readonlyTargets, immutableTargets, hiddenTargets, maskedTargets, editableTargets } = deriveTargets(activeRules));
+            if (ctx.data && typeof ctx.data === 'object') {
+                // Check if entire object is immutable
+                const immutableAll = immutableTargets.includes('*');
+                if (immutableAll) {
+                    throw new AXPMiddlewareAbortError('Update forbidden by policy: Record is marked as system and cannot be modified', {
+                        status: 409,
+                        code: 'POLICY_IMMUTABLE_RECORD',
+                        details: { entity: ctx.entityName, id: ctx.id },
+                    });
+                }
+                // For specific immutable/readonly fields, remove them from payload
+                const forbiddenPaths = [];
+                const addForbiddenFromTargets = (targets) => {
+                    for (const t of targets) {
+                        if (t === '*') {
+                            // This case is handled above
+                            continue;
+                        }
+                        else if (!isEditable(t)) {
+                            forbiddenPaths.push(t);
+                        }
+                    }
+                };
+                // readonly and immutable (excluding '*')
+                addForbiddenFromTargets(readonlyTargets);
+                addForbiddenFromTargets(immutableTargets);
+                // Remove forbidden fields from payload
+                const uniqueForbidden = Array.from(new Set(forbiddenPaths));
+                if (uniqueForbidden.length > 0) {
+                    removeFields(ctx.data, uniqueForbidden);
+                    // Log which fields were removed
+                    // try { 
+                    //   console.warn('[policy] fields-removed', { 
+                    //     entity: ctx.entityName, 
+                    //     id: ctx.id, 
+                    //     removedFields: uniqueForbidden 
+                    //   }); 
+                    // } catch {}
+                }
+            }
+        }
+        // DELETE PATH
+        if (ctx.op === 'delete') {
+            // Load existing to evaluate conditions based on record's current state
+            let existing;
+            if (ctx.id && backend?.getOne) {
+                try {
+                    existing = await backend.getOne(ctx.entityName, ctx.id);
+                }
+                catch {
+                    existing = undefined;
+                }
+            }
+            activeRules = await evaluateActiveRules(buildScope({ existing }));
+            ({ readonlyTargets, immutableTargets, hiddenTargets, maskedTargets, editableTargets } = deriveTargets(activeRules));
+            // If immutable '*' exists, block delete by short-circuiting
+            const immutableAll = immutableTargets.includes('*');
+            // Temporary debug logs for troubleshooting policy delete enforcement
+            try {
+                // eslint-disable-next-line no-console
+                console.warn('[policy] delete-check', {
+                    entity: ctx.entityName,
+                    id: ctx.id,
+                    existingIsSystem: existing?.control?.isSystem,
+                    immutableTargets,
+                    readonlyTargets,
+                    editableTargets,
+                    immutableAll,
+                });
+            }
+            catch { }
+            if (immutableAll) {
+                // Block delete and throw error to notify frontend
+                try {
+                    console.warn('[policy] delete-blocked', { entity: ctx.entityName, id: ctx.id });
+                }
+                catch { }
+                throw new AXPMiddlewareAbortError('Delete forbidden by policy: Record is marked as system and cannot be deleted', {
+                    status: 409,
+                    code: 'POLICY_IMMUTABLE_RECORD',
+                    details: { entity: ctx.entityName, id: ctx.id },
+                });
+            }
+        }
+        await next();
+        // try { console.warn('[policy] after-next', ctx.op, ctx.entityName); } catch {}
+        // READ PATH (after next to transform response)
+        if (ctx.op === 'getOne' || ctx.op === 'getAll' || ctx.op === 'query') {
+            // Re-evaluate rules with result in scope (read conditions can depend on returned data)
+            activeRules = await evaluateActiveRules(buildScope({ result: ctx.result }));
+            ({ readonlyTargets, immutableTargets, hiddenTargets, maskedTargets, editableTargets } = deriveTargets(activeRules));
+            const applyReadTransforms = (obj) => {
+                if (!obj || typeof obj !== 'object')
+                    return;
+                // hidden ⇒ remove field
+                removeFields(obj, hiddenTargets);
+                // masked ⇒ mask value
+                setMasked(obj, maskedTargets);
+            };
+            if (Array.isArray(ctx.result)) {
+                ctx.result.forEach(applyReadTransforms);
+            }
+            else {
+                applyReadTransforms(ctx.result);
+            }
+        }
+    },
+};
+
+const primaryMiddleware = {
+    target: { ops: ['create', 'update'], order: 70 },
+    execute: async (ctx, next) => {
+        const backend = inject(AXP_ENTITY_STORAGE_BACKEND);
+        // Check if this is a primary-related operation
+        const isSettingPrimary = ctx.data && ctx.data.isPrimary === true;
+        if (isSettingPrimary) {
+            // Before setting a record as primary, unset all other primary records for this entity
+            try {
+                // Query all records for this entity to find existing primary records
+                const queryResult = await ctx.backend.query(ctx.entityName, {
+                    filter: {
+                        field: null,
+                        logic: 'and',
+                        operator: null,
+                        filters: [
+                            {
+                                field: 'isPrimary',
+                                operator: { type: 'equal' },
+                                value: true
+                            }
+                        ]
+                    },
+                    skip: 0,
+                    take: 1000 // Get all primary records
+                });
+                // Update all existing primary records to set isPrimary = false
+                if (queryResult.items && queryResult.items.length > 0) {
+                    for (const item of queryResult.items) {
+                        // Skip the current record being updated
+                        if (ctx.op === 'update' && item.id === ctx.id) {
+                            continue;
+                        }
+                        // Update the record to set isPrimary = false
+                        await ctx.backend.updateOne(ctx.entityName, item.id, { isPrimary: false });
+                    }
+                }
+            }
+            catch (error) {
+                console.error('Failed to unset existing primary records:', error);
+                // Continue with the operation even if this fails
+            }
+        }
+        // Execute the main operation
+        await next();
+        // After the operation, ensure only one primary record exists
+        if (isSettingPrimary) {
+            try {
+                // Double-check: query again to ensure only one primary record exists
+                const queryResult = await ctx.backend.query(ctx.entityName, {
+                    filter: {
+                        field: null,
+                        logic: 'and',
+                        operator: null,
+                        filters: [
+                            {
+                                field: 'isPrimary',
+                                operator: { type: 'equal' },
+                                value: true
+                            }
+                        ]
+                    },
+                    skip: 0,
+                    take: 1000
+                });
+                // If multiple primary records exist, keep only the most recent one
+                if (queryResult.items && queryResult.items.length > 1) {
+                    // Sort by creation/update date to keep the most recent
+                    const sortedItems = queryResult.items.sort((a, b) => {
+                        const dateA = new Date(a.createdAt || a.updatedAt || 0);
+                        const dateB = new Date(b.createdAt || b.updatedAt || 0);
+                        return dateB.getTime() - dateA.getTime();
+                    });
+                    // Set all but the first (most recent) to isPrimary = false
+                    for (let i = 1; i < sortedItems.length; i++) {
+                        await ctx.backend.updateOne(ctx.entityName, sortedItems[i].id, { isPrimary: false });
+                    }
+                }
+            }
+            catch (error) {
+                console.error('Failed to ensure single primary record:', error);
+            }
+        }
+    },
+};
+
 class AXCMiddlewaresModule {
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.8", ngImport: i0, type: AXCMiddlewaresModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
     static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "20.1.8", ngImport: i0, type: AXCMiddlewaresModule }); }
@@ -34928,11 +36999,14 @@ class AXCMiddlewaresModule {
             // Provide the concrete backend and middlewares
             { provide: AXP_ENTITY_STORAGE_BACKEND, useClass: AXCDexieEntityStorageService },
             // Middlewares
+            { provide: AXP_ENTITY_STORAGE_MIDDLEWARE, multi: true, useValue: policyEnforceMiddleware },
             { provide: AXP_ENTITY_STORAGE_MIDDLEWARE, multi: true, useValue: eventDispatchMiddleware },
             { provide: AXP_ENTITY_STORAGE_MIDDLEWARE, multi: true, useValue: mergeDetailRelationMiddleware },
             { provide: AXP_ENTITY_STORAGE_MIDDLEWARE, multi: true, useValue: identifierCommitMiddleware },
+            { provide: AXP_ENTITY_STORAGE_MIDDLEWARE, multi: true, useValue: childCountMiddleware },
             { provide: AXP_ENTITY_STORAGE_MIDDLEWARE, multi: true, useValue: auditLoggerMiddleware },
             { provide: AXP_ENTITY_STORAGE_MIDDLEWARE, multi: true, useValue: createFileCastMiddleware },
+            { provide: AXP_ENTITY_STORAGE_MIDDLEWARE, multi: true, useValue: primaryMiddleware },
             // Sample entity event listener to show logs for all entity.* events
             //{ provide: AXP_DISTRIBUTED_EVENT_LISTENER_PROVIDER, multi: true, useValue: AXCMockEntityLogListener },
         ] }); }
@@ -34949,11 +37023,14 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.8", ngImpor
                         // Provide the concrete backend and middlewares
                         { provide: AXP_ENTITY_STORAGE_BACKEND, useClass: AXCDexieEntityStorageService },
                         // Middlewares
+                        { provide: AXP_ENTITY_STORAGE_MIDDLEWARE, multi: true, useValue: policyEnforceMiddleware },
                         { provide: AXP_ENTITY_STORAGE_MIDDLEWARE, multi: true, useValue: eventDispatchMiddleware },
                         { provide: AXP_ENTITY_STORAGE_MIDDLEWARE, multi: true, useValue: mergeDetailRelationMiddleware },
                         { provide: AXP_ENTITY_STORAGE_MIDDLEWARE, multi: true, useValue: identifierCommitMiddleware },
+                        { provide: AXP_ENTITY_STORAGE_MIDDLEWARE, multi: true, useValue: childCountMiddleware },
                         { provide: AXP_ENTITY_STORAGE_MIDDLEWARE, multi: true, useValue: auditLoggerMiddleware },
                         { provide: AXP_ENTITY_STORAGE_MIDDLEWARE, multi: true, useValue: createFileCastMiddleware },
+                        { provide: AXP_ENTITY_STORAGE_MIDDLEWARE, multi: true, useValue: primaryMiddleware },
                         // Sample entity event listener to show logs for all entity.* events
                         //{ provide: AXP_DISTRIBUTED_EVENT_LISTENER_PROVIDER, multi: true, useValue: AXCMockEntityLogListener },
                     ],
@@ -36011,5 +38088,5 @@ const AXCMockEntityLogListener = {
  * Generated bundle index. Do not edit.
  */
 
-export { APPLICATIONS, APPLICATIONS_MODULES, AXCAppTermDataSeeder, AXCAppVersionDataSeeder, AXCApplicationManagementMockModule, AXCApplicationTemplateDataSeeder, AXCAuthMockModule, AXCCalendarDataSeeder, AXCCalendarEventDataSeeder, AXCCalendarManagementMockModule, AXCCommonMockModule, AXCContactManagementMockModule, AXCContentManagementMockModule, AXCConversationMockModule, AXCCustomerManagementMockModule, AXCDashboardManagementMockModule, AXCDataManagementMockModule, AXCDexieEntityStorageService, AXCDocumentManagementMockModule, AXCFileStorageService, AXCFormTemplateManagementMockModule, AXCGlobalVariablesDataSeeder, AXCGoogleStrategyMock, AXCHelpDeskMockModule, AXCHumanCapitalManagementMockModule, AXCIdentifierManagementMockModule, AXCJsaSeeder, AXCLocaleManagementMockModule, AXCLocationManagementMockModule, AXCLockService, AXCLogManagementMockModule, AXCMeetingManagementMockModule, AXCMetaDataDefinitionDataSeeder, AXCMiddlewaresModule, AXCMockEntityLogListener, AXCMockModule, AXCNotificationManagementMockModule, AXCOrganizationManagementMockModule, AXCPartyManagementMockModule, AXCPlatformManagementMockModule, AXCProjectManagementMockModule, AXCReportManagementMockModule, AXCSchedulerJobDataSeeder, AXCSchedulerJobManagementMockModule, AXCSecurityManagementMockModule, AXCTaskManagementMockModule, AXCTextTemplateCategoryDataSeeder, AXCTextTemplateDataSeeder, AXCTextTemplateManagementMockModule, AXCTrainingManagementMockModule, AXCUserPassStrategyMock, AXCWorkflowManagementMockModule, AXMAiResponderService, AXMBusinessUnitDataSeeder, AXMCalendarEventTypeSeeder, AXMEmployeeDataSeeder, AXMEmployeeSkillDataSeeder, AXMEmployeeSkillsCategoryProvider, AXMEmployeeSkillsReportDefinitionProvider, AXMEmploymentTypeDataSeeder, AXMFormDataSourcesProvider, AXMIndustryDataSeeder, AXMLeaveRequestDataSeeder, AXMMeetingDataSeeder, AXMMeetingFilesDataSeeder, AXMMeetingParticipantDataSeeder, AXMMeetingRoleTypeDataSeeder, AXMMeetingSessionDataSeeder, AXMMeetingTypeDataSeeder, AXMMeetingTypeFileTemplateDataSeeder, AXMPositionAssignmentDataSeeder, AXMPositionDataSeeder, AXMReportCategoryDataSeeder, AXMReportDefinitionDataSeeder, AXMReportExecuteCommand, AXMReportMockDataService, AXMResponsibilityDataSeeder, AXMRoleDataSeeder, AXMSkillDataSeeder, AXMSkillLevelDataSeeder, AXMTeamDataSeeder, AXM_EMPLOYEE_SKILLS_CATEGORY_PROVIDER, AXM_EMPLOYEE_SKILLS_DEFINITION_PROVIDER, AXPDashboardDataSeeder, AXPIdentifierDB, AXPMessageDataSeeder, AXPMockChecksumProvider, AXPMockClockProvider, AXPMockIdentifierService, AXPMockLookupProvider, AXPMockPolicyProvider, AXPMockSequenceProvider, AXPRoomDataSeeder, AXPSecurityManagementRoleDataSeeder, AXPSecurityManagementUserDataSeeder, AXPTaskBoardPlatformManagementTaskProvider, AXPTaskBoardProjectManagementTaskProvider, AXQEmployeeSkillsLevelPercentagesQuery, AXQEmployeeSkillsLevelsQuery, AXQEmployeeSkillsListQuery, AXQEmployeeSkillsSkillPercentagesQuery, AXQEmployeeSkillsStatsQuery, AXQEmployeeSkillsTrendQuery, BUSINESS_UNITS_MOCK, DASHBOARDS, EDITIONS, EMPLOYEES_MOCK, EMPLOYEE_SKILLS_MOCK, EMPLOYMENT_TYPES_MOCK, ENTITIES, FEATURES, GLOBAL_VARIABLES, LEAVE_REQUESTS_MOCK, MODULES, PERMISSIONS, POSITIONS_CATEGORY_MOCK, POSITIONS_MOCK, POSITION_ASSIGNMENTS_MOCK, PROPERTIES, RESPONSIBILITIES_CATEGORY_MOCK, RESPONSIBILITIES_MOCK, ROLES_CATEGORY_MOCK, ROLES_MOCK, SKILLS_CATEGORY_MOCK, SKILLS_MOCK, SKILL_LEVELS_MOCK, TASKS, TASK_STATUSES, TASK_TEMPLATES, TASK_TYPES, TEAMS_MOCK, TEXT_TEMPLATES, TEXT_TEMPLATE_CATEGORY, applications, auditLoggerMiddleware, calendarEventMock, calendarEventTypeMockData, calendarMock, createAndSaveDashboardForUser, createDashboardForUser, createFileCastMiddleware, findContactMethod, findEmployeeById, findPartyById, generateUserDashboard, identifierCommitMiddleware, meetingFilesMock, meetingIds, meetingMock, meetingParticipantMock, meetingRoleTypeMock, meetingSessionMock, meetingTimeSlotMock, meetingTypeFileTemplateMock, meetingTypeMock, mergeDetailRelationMiddleware, mockRoleDefinitions, mockUsers, participantIds, tenantsMock };
+export { APPLICATIONS, APPLICATIONS_MODULES, AXCAppTermDataSeeder, AXCAppVersionDataSeeder, AXCApplicationManagementMockModule, AXCApplicationTemplateDataSeeder, AXCAuthMockModule, AXCCalendarDataSeeder, AXCCalendarEventDataSeeder, AXCCalendarManagementMockModule, AXCCommonMockModule, AXCContactManagementMockModule, AXCContentManagementMockModule, AXCConversationMockModule, AXCCustomerManagementMockModule, AXCDashboardManagementMockModule, AXCDataManagementMockModule, AXCDexieEntityStorageService, AXCDocumentManagementMockModule, AXCFileStorageService, AXCFormTemplateManagementMockModule, AXCGlobalVariablesDataSeeder, AXCGoogleStrategyMock, AXCHelpDeskMockModule, AXCHumanCapitalManagementMockModule, AXCIdentifierManagementMockModule, AXCJsaSeeder, AXCLocaleManagementMockModule, AXCLocationManagementMockModule, AXCLockService, AXCLogManagementMockModule, AXCLogReportCategoryProvider, AXCLogReportDefinitionProvider, AXCMeetingManagementMockModule, AXCMetaDataDefinitionDataSeeder, AXCMiddlewaresModule, AXCMockEntityLogListener, AXCMockModule, AXCNotificationManagementMockModule, AXCOrganizationManagementMockModule, AXCPartyManagementMockModule, AXCPlatformManagementMockModule, AXCProjectManagementMockModule, AXCQueryCategoryMetadataInheritanceQuery, AXCReportManagementMockModule, AXCSchedulerJobDataSeeder, AXCSchedulerJobManagementMockModule, AXCSecurityManagementMockModule, AXCTaskManagementMockModule, AXCTextTemplateCategoryDataSeeder, AXCTextTemplateDataSeeder, AXCTextTemplateManagementMockModule, AXCTrainingManagementMockModule, AXCUserPassStrategyMock, AXCWorkflowManagementMockModule, AXC_LOG_REPORT_CATEGORY_PROVIDER, AXC_LOG_REPORT_DEFINITION_PROVIDER, AXMAiResponderService, AXMBusinessUnitDataSeeder, AXMCalendarEventTypeSeeder, AXMEmployeeDataSeeder, AXMEmployeeSkillDataSeeder, AXMEmployeeSkillsCategoryProvider, AXMEmployeeSkillsReportDefinitionProvider, AXMEmploymentTypeDataSeeder, AXMFormDataSourcesProvider, AXMIndustryDataSeeder, AXMLeaveRequestDataSeeder, AXMMeetingDataSeeder, AXMMeetingFilesDataSeeder, AXMMeetingParticipantDataSeeder, AXMMeetingRoleTypeDataSeeder, AXMMeetingSessionDataSeeder, AXMMeetingTypeDataSeeder, AXMMeetingTypeFileTemplateDataSeeder, AXMPositionAssignmentDataSeeder, AXMPositionDataSeeder, AXMReportCategoryDataSeeder, AXMReportDefinitionDataSeeder, AXMReportExecuteCommand, AXMReportMockDataService, AXMResponsibilityDataSeeder, AXMRoleDataSeeder, AXMSkillDataSeeder, AXMSkillLevelDataSeeder, AXMTeamDataSeeder, AXM_EMPLOYEE_SKILLS_CATEGORY_PROVIDER, AXM_EMPLOYEE_SKILLS_DEFINITION_PROVIDER, AXPDashboardDataSeeder, AXPIdentifierDB, AXPMessageDataSeeder, AXPMockChecksumProvider, AXPMockClockProvider, AXPMockIdentifierService, AXPMockLookupProvider, AXPMockPolicyProvider, AXPMockSequenceProvider, AXPRoomDataSeeder, AXPSecurityManagementRoleDataSeeder, AXPSecurityManagementUserDataSeeder, AXPTaskBoardPlatformManagementTaskProvider, AXPTaskBoardProjectManagementTaskProvider, AXQEmployeeSkillsLevelPercentagesQuery, AXQEmployeeSkillsLevelsQuery, AXQEmployeeSkillsListQuery, AXQEmployeeSkillsSkillPercentagesQuery, AXQEmployeeSkillsStatsQuery, AXQEmployeeSkillsTrendQuery, BUSINESS_UNITS_MOCK, DASHBOARDS, EDITIONS, EMPLOYEES_MOCK, EMPLOYEE_SKILLS_MOCK, EMPLOYMENT_TYPES_MOCK, ENTITIES, FEATURES, GLOBAL_VARIABLES, LEAVE_REQUESTS_MOCK, MODULES, PERMISSIONS, POSITIONS_CATEGORY_MOCK, POSITIONS_MOCK, POSITION_ASSIGNMENTS_MOCK, PROPERTIES, RESPONSIBILITIES_CATEGORY_MOCK, RESPONSIBILITIES_MOCK, ROLES_CATEGORY_MOCK, ROLES_MOCK, SKILLS_CATEGORY_MOCK, SKILLS_MOCK, SKILL_LEVELS_MOCK, TASKS, TASK_STATUSES, TASK_TEMPLATES, TASK_TYPES, TEAMS_MOCK, TEXT_TEMPLATES, TEXT_TEMPLATE_CATEGORY, applications, auditLoggerMiddleware, calendarEventMock, calendarEventTypeMockData, calendarMock, childCountMiddleware, createAndSaveDashboardForUser, createDashboardForUser, createFileCastMiddleware, findContactMethod, findEmployeeById, findPartyById, generateUserDashboard, identifierCommitMiddleware, meetingFilesMock, meetingIds, meetingMock, meetingParticipantMock, meetingRoleTypeMock, meetingSessionMock, meetingTimeSlotMock, meetingTypeFileTemplateMock, meetingTypeMock, mergeDetailRelationMiddleware, mockRoleDefinitions, mockUsers, participantIds, primaryMiddleware, tenantsMock };
 //# sourceMappingURL=acorex-connectivity-mock.mjs.map