@acorex/connectivity 20.0.4 → 20.0.6

package/fesm2022/acorex-connectivity-mock.mjs

@@ -10,23 +10,25 @@ import { inject, Injectable, NgModule } from '@angular/core';
 import { AXPLockService, AXPRegionalService, AXPFileStorageStatus, AXPFileStorageService, AXP_SEARCH_PROVIDER } from '@acorex/platform/common';
 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';
 import { RootConfig as RootConfig$2, AXMFolderServiceImpl, AXMDocumentServiceImpl, AXMFolderService, AXMDocumentService } from '@acorex/modules/document-management';
-import { AXPMyNotificationDashboardWidget, RootConfig as RootConfig$7, AXMNotificationEntityService } from '@acorex/modules/notification-management';
-import { RootConfig as RootConfig$6, AXMDeviceSessionsServiceImpl, AXMSessionStatusTypes, AXMDeviceSessionsService } from '@acorex/modules/security-management';
+import { AXPMyNotificationDashboardWidget, RootConfig as RootConfig$8, AXMNotificationEntityService } from '@acorex/modules/notification-management';
+import { RootConfig as RootConfig$7, AXMDeviceSessionsServiceImpl, AXMSessionStatusTypes, AXMDeviceSessionsService } from '@acorex/modules/security-management';
 import { of, delay, firstValueFrom } from 'rxjs';
 import { AXMPermissionsKeys, AXMFormTemplateTypes, RootConfig as RootConfig$3 } from '@acorex/modules/form-template-management';
 import { RootConfig } from '@acorex/modules/conversation';
 import { AXPBarChartWidget, AXPAnalogClockWidget, AXPMinimalWeatherWidget, AXPAdvancedWeatherWidget, AXPStickyNoteWidget, AXPDonutChartWidget, AXPGaugeChartWidget, AXPLineChartWidget, AXPTaskListWidget, RootConfig as RootConfig$1 } from '@acorex/modules/dashboard-management';
 import { RootConfig as RootConfig$4 } from '@acorex/modules/issue-management';
-import { RootConfig as RootConfig$5 } from '@acorex/modules/log-management';
-import { AXMOrganizationNodeType, RootConfig as RootConfig$8 } from '@acorex/modules/organization-management';
-import { RootConfig as RootConfig$9, AXMMetaDataDefinitionCategoryServiceImpl, AXMMetaDataDefinitionService, AXMMetaDataDefinitionCategoryService } from '@acorex/modules/platform-management';
+import { RootConfig as RootConfig$5 } from '@acorex/modules/report-management';
+import { AXPWidgetsList } from '@acorex/modules/common';
+import { RootConfig as RootConfig$6 } from '@acorex/modules/log-management';
+import { AXMOrganizationNodeType, RootConfig as RootConfig$9 } from '@acorex/modules/organization-management';
+import { RootConfig as RootConfig$a, AXMMetaDataDefinitionCategoryServiceImpl, AXMMetaDataDefinitionService, AXMMetaDataDefinitionCategoryService } from '@acorex/modules/platform-management';
 import { AXTranslationService } from '@acorex/core/translation';
 import { AXFileService } from '@acorex/core/file';
-import { RootConfig as RootConfig$a } from '@acorex/modules/project-management';
-import { RootConfig as RootConfig$b } from '@acorex/modules/scheduler-job-management';
+import { RootConfig as RootConfig$b } from '@acorex/modules/project-management';
+import { RootConfig as RootConfig$c } from '@acorex/modules/scheduler-job-management';
 import { convertArrayToDataSource } from '@acorex/cdk/common';
-import { RootConfig as RootConfig$c } from '@acorex/modules/text-template-management';
-import { RootConfig as RootConfig$d } from '@acorex/modules/training-management';
+import { RootConfig as RootConfig$d } from '@acorex/modules/text-template-management';
+import { RootConfig as RootConfig$e } from '@acorex/modules/training-management';
 import { AXSafePipe } from '@acorex/core/pipes';
 
 class AXPDexieEntityStorageService extends Dexie {
@@ -50,7 +52,7 @@ class AXPDexieEntityStorageService extends Dexie {
                     const oldArray = Array.isArray(oldObj[key]) ? oldObj[key] : [];
                     const newArray = Array.isArray(value) ? value : [];
                     // Check if array items have id property
-                    const hasId = newArray.length > 0 && 'id' in newArray[0];
+                    const hasId = newArray.length > 0 && typeof newArray[0] === 'object' && newArray[0] !== null && 'id' in newArray[0];
                     if (hasId) {
                         // Compare by id for objects with id
                         const added = newArray.filter(item => !oldArray.some(oldItem => oldItem.id === item.id));
@@ -512,11 +514,11 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.0.4", ngImpor
 class MockFeatureLoader {
     constructor() {
         this.list = [
-            {
-                name: 'entity-comment',
-                title: 'Feature Title',
-                value: true,
-            },
+            // {
+            //   name: 'entity-comment',
+            //   title: 'Feature Title',
+            //   value: true,
+            // },
             {
                 name: 'axp-entity-list-advance-filter',
                 title: 'Filters',
@@ -789,7 +791,7 @@ function getUserByIndex(index) {
     };
 }
 // Generate an array of rooms
-const ROOMS = Array.from({ length: 15 }).map((_, index) => {
+const ROOMS = Array.from({ length: 3 }).map((_, index) => {
     const roomTypes = ['personal', 'group', 'channel', 'support'];
     const roomNames = [
         'General Discussion',
@@ -2685,7 +2687,7 @@ class EntitySearchProvider {
     }
 }
 
-function generateCategories() {
+function generateCategories$1() {
     const categories = [];
     const rootCategories = [
         'Risk Assessment',
@@ -2749,7 +2751,7 @@ function generateCategories() {
     });
     return categories;
 }
-const TEMPLATE_CATEGORIES = generateCategories();
+const TEMPLATE_CATEGORIES = generateCategories$1();
 function generateTemplates() {
     const templates = [];
     AXPDataGenerator.pick(TEMPLATE_CATEGORIES, 5).forEach((category) => {
@@ -2908,6 +2910,1237 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.0.4", ngImpor
             type: Injectable
         }] });
 
+//#region ----   Mock Categories   ----
+function generateCategories() {
+    const categories = [];
+    // Root categories
+    const rootCategories = [
+        { title: 'Financial Reports', description: 'Financial analysis and accounting reports', hasChild: true, hasReport: false },
+        { title: 'Operations Reports', description: 'Operational metrics and performance reports', hasChild: true, hasReport: false },
+        { title: 'Human Resources', description: 'HR analytics and employee reports', hasChild: true, hasReport: false },
+        { title: 'Sales & Marketing', description: 'Sales performance and marketing analytics', hasChild: true, hasReport: false },
+        { title: 'Quality Assurance', description: 'Quality control and compliance reports', hasChild: false, hasReport: true },
+        { title: 'Custom Reports', description: 'User-defined custom report templates', hasChild: true, hasReport: false },
+        { title: 'Workplace Health and Safety', description: 'Workplace Health & Safety', hasChild: true, hasReport: false },
+        { title: 'Occupational Health and Safety', description: 'Occupational Health & Safety', hasChild: true, hasReport: false },
+        { title: 'Environmental Health and Safety', description: 'Environmental Health & Safety', hasChild: true, hasReport: false },
+        { title: 'Human Resource Safety', description: 'Human Resource Safety', hasChild: true, hasReport: false },
+    ];
+    rootCategories.forEach(({ title, description, hasChild, hasReport }) => {
+        const categoryId = AXPDataGenerator.uuid();
+        categories.push({
+            id: categoryId,
+            title,
+            description,
+            parentId: undefined,
+            hasChild,
+            hasReport
+        });
+    });
+    // Child categories
+    const childCategories = [
+        {
+            parent: 'Financial Reports',
+            children: [
+                { title: 'Balance Sheet', description: 'Asset, liability, and equity reports', hasChild: false, hasReport: true },
+                { title: 'Income Statement', description: 'Revenue and expense analysis', hasChild: false, hasReport: true },
+                { title: 'Cash Flow', description: 'Cash flow analysis and forecasting', hasChild: false, hasReport: true },
+                { title: 'Budget Analysis', description: 'Budget vs actual performance', hasChild: false, hasReport: true },
+            ],
+        },
+        {
+            parent: 'Operations Reports',
+            children: [
+                { title: 'Production Metrics', description: 'Manufacturing and production KPIs', hasChild: false, hasReport: true },
+                { title: 'Inventory Management', description: 'Stock levels and inventory turnover', hasChild: false, hasReport: true },
+                { title: 'Supply Chain', description: 'Supplier performance and logistics', hasChild: false, hasReport: true },
+                { title: 'Quality Control', description: 'Quality metrics and defect analysis', hasChild: false, hasReport: true },
+            ],
+        },
+        {
+            parent: 'Human Resources',
+            children: [
+                { title: 'Employee Performance', description: 'Performance reviews and ratings', hasChild: false, hasReport: true },
+                { title: 'Attendance & Leave', description: 'Time tracking and leave management', hasChild: false, hasReport: true },
+                { title: 'Payroll Reports', description: 'Salary, benefits, and compensation', hasChild: false, hasReport: true },
+                { title: 'Training & Development', description: 'Learning progress and skill development', hasChild: false, hasReport: true },
+            ],
+        },
+        {
+            parent: 'Sales & Marketing',
+            children: [
+                { title: 'Sales Performance', description: 'Revenue, targets, and conversion rates', hasChild: false, hasReport: true },
+                { title: 'Customer Analytics', description: 'Customer behavior and satisfaction', hasChild: false, hasReport: true },
+                { title: 'Marketing Campaigns', description: 'Campaign performance and ROI', hasChild: false, hasReport: true },
+                { title: 'Lead Generation', description: 'Lead quality and conversion funnel', hasChild: false, hasReport: true },
+            ],
+        },
+        {
+            parent: 'Custom Reports',
+            children: [
+                { title: 'Executive Dashboard', description: 'High-level KPIs for management', hasChild: false, hasReport: true },
+                { title: 'Compliance Reports', description: 'Regulatory and audit reports', hasChild: false, hasReport: true },
+                { title: 'Risk Assessment', description: 'Risk analysis and mitigation reports', hasChild: false, hasReport: true },
+            ],
+        },
+        {
+            parent: 'Workplace Health and Safety',
+            children: [
+                { title: 'Incident Management', description: 'Manage and report workplace incidents', hasChild: false, hasReport: true },
+                { title: 'Risk Assessment', description: 'Assess and mitigate workplace risks', hasChild: false, hasReport: true },
+                { title: 'Safety Audits', description: 'Conduct and review safety audits', hasChild: false, hasReport: true },
+            ],
+        },
+        {
+            parent: 'Occupational Health and Safety',
+            children: [
+                { title: 'Compliance Reports', description: 'Track OHS compliance', hasChild: false, hasReport: true },
+                { title: 'Training Records', description: 'Manage safety training records', hasChild: false, hasReport: true },
+                { title: 'Hazard Identification', description: 'Identify and report hazards', hasChild: false, hasReport: true },
+            ],
+        },
+        {
+            parent: 'Environmental Health and Safety',
+            children: [
+                { title: 'Environmental Monitoring', description: 'Monitor environmental factors', hasChild: false, hasReport: true },
+                { title: 'Waste Management', description: 'Track and manage waste', hasChild: false, hasReport: true },
+                { title: 'Sustainability Metrics', description: 'Report on sustainability KPIs', hasChild: false, hasReport: true },
+            ],
+        },
+        {
+            parent: 'Human Resource Safety',
+            children: [
+                { title: 'Employee Health Records', description: 'Manage employee health data', hasChild: false, hasReport: true },
+                { title: 'Wellness Programs', description: 'Track wellness initiatives', hasChild: false, hasReport: true },
+                { title: 'Ergonomics Assessments', description: 'Assess workplace ergonomics', hasChild: false, hasReport: true },
+            ],
+        },
+    ];
+    childCategories.forEach(({ parent, children }) => {
+        const parentCat = categories.find((c) => c.title === parent);
+        if (parentCat) {
+            children.forEach(({ title, description, hasChild, hasReport }) => {
+                categories.push({
+                    id: AXPDataGenerator.uuid(),
+                    title,
+                    description,
+                    parentId: parentCat.id,
+                    hasChild,
+                    hasReport
+                });
+            });
+        }
+    });
+    return categories;
+}
+const REPORT_CATEGORIES = generateCategories();
+//#endregion
+//#region ----   Mock Parameter Groups   ----
+const commonParameterGroups = [
+    {
+        name: 'dateRange',
+        title: 'Date Range',
+        description: 'Select the reporting period',
+        parameters: [
+            {
+                path: 'startDate',
+                title: 'Start Date',
+                description: 'Beginning of the reporting period',
+                widget: {
+                    type: AXPWidgetsList.Editors.DateTimeBox,
+                    options: {
+                        showTime: false,
+                        format: 'yyyy-MM-dd'
+                    }
+                },
+            },
+            {
+                path: 'endDate',
+                title: 'End Date',
+                description: 'End of the reporting period',
+                widget: {
+                    type: AXPWidgetsList.Editors.DateTimeBox,
+                    options: {
+                        showTime: false,
+                        format: 'yyyy-MM-dd'
+                    }
+                },
+            },
+        ],
+    },
+    {
+        name: 'filters',
+        title: 'Filters',
+        description: 'Additional filtering options',
+        parameters: [
+            {
+                path: 'department',
+                title: 'Department',
+                description: 'Filter by specific department',
+                widget: {
+                    type: AXPWidgetsList.Editors.SelectBox,
+                    options: {
+                        dataSource: [
+                            'All Departments',
+                            'Finance',
+                            'Operations',
+                            'Human Resources',
+                            'Sales',
+                            'Marketing',
+                            'IT',
+                            'Legal'
+                        ]
+                    },
+                },
+            },
+            {
+                path: 'status',
+                title: 'Status',
+                description: 'Filter by status',
+                widget: {
+                    type: AXPWidgetsList.Editors.SelectBox,
+                    options: {
+                        dataSource: ['All', 'Active', 'Inactive', 'Pending', 'Completed']
+                    },
+                },
+            },
+        ],
+    },
+];
+const financialParameterGroups = [
+    {
+        name: 'financial',
+        title: 'Financial Parameters',
+        description: 'Financial reporting specific options',
+        parameters: [
+            {
+                path: 'currency',
+                title: 'Currency',
+                description: 'Report currency',
+                widget: {
+                    type: AXPWidgetsList.Editors.SelectBox,
+                    options: {
+                        dataSource: ['USD', 'EUR', 'GBP', 'JPY', 'CAD', 'AUD', 'IRR']
+                    },
+                },
+            },
+            {
+                path: 'consolidation',
+                title: 'Consolidation Level',
+                description: 'Level of financial consolidation',
+                widget: {
+                    type: AXPWidgetsList.Editors.SelectBox,
+                    options: {
+                        dataSource: ['Company', 'Division', 'Department', 'Cost Center']
+                    },
+                },
+            },
+            {
+                path: 'includeAdjustments',
+                title: 'Include Adjustments',
+                description: 'Include manual journal adjustments',
+                widget: {
+                    type: AXPWidgetsList.Editors.ToggleSwitch,
+                },
+            },
+        ],
+    },
+];
+const hrParameterGroups = [
+    {
+        name: 'employee',
+        title: 'Employee Parameters',
+        description: 'Employee-specific filtering options',
+        parameters: [
+            {
+                path: 'employeeType',
+                title: 'Employee Type',
+                description: 'Type of employment',
+                widget: {
+                    type: AXPWidgetsList.Editors.SelectBox,
+                    options: {
+                        dataSource: ['All', 'Full-time', 'Part-time', 'Contract', 'Intern']
+                    },
+                },
+            },
+            {
+                path: 'location',
+                title: 'Office Location',
+                description: 'Physical office location',
+                widget: {
+                    type: AXPWidgetsList.Editors.SelectBox,
+                    options: {
+                        dataSource: ['All Locations', 'New York', 'London', 'Tokyo', 'Sydney', 'Toronto', 'Tehran']
+                    },
+                },
+            },
+            {
+                path: 'includeTerminated',
+                title: 'Include Terminated',
+                description: 'Include terminated employees in the period',
+                widget: {
+                    type: AXPWidgetsList.Editors.ToggleSwitch,
+                },
+            },
+        ],
+    },
+];
+const whsIncidentParameterGroups = [
+    {
+        name: 'incidentDetails',
+        title: 'Incident Details',
+        description: 'Specify details about the incident',
+        parameters: [
+            {
+                path: 'incidentType',
+                title: 'Incident Type',
+                description: 'Type of incident',
+                widget: {
+                    type: AXPWidgetsList.Editors.SelectBox,
+                    options: {
+                        dataSource: ['All', 'Injury', 'Near Miss', 'Property Damage', 'Environmental', 'Fire', 'Chemical Spill', 'Other']
+                    }
+                }
+            },
+            {
+                path: 'incidentDate',
+                title: 'Incident Date Range',
+                description: 'Date range for incidents',
+                widget: {
+                    type: AXPWidgetsList.Editors.DateTimeBox,
+                    options: {
+                        showTime: false,
+                        format: 'yyyy-MM-dd'
+                    }
+                }
+            },
+            {
+                path: 'reportedBy',
+                title: 'Reported By',
+                description: 'Name of the person reporting',
+                widget: {
+                    type: AXPWidgetsList.Editors.TextBox,
+                    options: {
+                        placeholder: 'Enter reporter name'
+                    }
+                }
+            },
+            {
+                path: 'departmentsInvolved',
+                title: 'Departments Involved',
+                description: 'Departments involved in the incident',
+                widget: {
+                    type: AXPWidgetsList.Editors.SelectBox,
+                    options: {
+                        dataSource: ['Production', 'Maintenance', 'Logistics', 'HR', 'IT', 'Security', 'Quality Control'],
+                        multiple: true
+                    }
+                }
+            },
+            {
+                path: 'severityLevel',
+                title: 'Severity Level',
+                description: 'Minimum severity level to include',
+                widget: {
+                    type: AXPWidgetsList.Editors.SelectBox,
+                    options: {
+                        dataSource: ['All', 'Low', 'Medium', 'High', 'Critical']
+                    }
+                }
+            },
+            {
+                path: 'includeClosedCases',
+                title: 'Include Closed Cases',
+                description: 'Include incidents that are already closed',
+                widget: {
+                    type: AXPWidgetsList.Editors.ToggleSwitch
+                }
+            }
+        ]
+    }
+];
+const riskAssessmentParameterGroups = [
+    {
+        name: 'riskCriteria',
+        title: 'Risk Criteria',
+        description: 'Define risk assessment parameters',
+        parameters: [
+            {
+                path: 'riskCategory',
+                title: 'Risk Category',
+                description: 'Category of risk to assess',
+                widget: {
+                    type: AXPWidgetsList.Editors.SelectBox,
+                    options: {
+                        dataSource: ['All', 'Physical', 'Chemical', 'Biological', 'Ergonomic', 'Psychosocial', 'Environmental']
+                    }
+                }
+            },
+            {
+                path: 'riskLevel',
+                title: 'Risk Level',
+                description: 'Minimum risk level to include',
+                widget: {
+                    type: AXPWidgetsList.Editors.SelectBox,
+                    options: {
+                        dataSource: ['All', 'Very Low', 'Low', 'Medium', 'High', 'Very High']
+                    }
+                }
+            },
+            {
+                path: 'assessedBy',
+                title: 'Assessed By',
+                description: 'Person who conducted the assessment',
+                widget: {
+                    type: AXPWidgetsList.Editors.TextBox,
+                    options: {
+                        placeholder: 'Enter assessor name'
+                    }
+                }
+            },
+            {
+                path: 'controlMeasures',
+                title: 'Control Measures Status',
+                description: 'Status of control measures',
+                widget: {
+                    type: AXPWidgetsList.Editors.SelectBox,
+                    options: {
+                        dataSource: ['All', 'Not Started', 'In Progress', 'Completed', 'Overdue']
+                    }
+                }
+            },
+            {
+                path: 'includeReviewDue',
+                title: 'Include Reviews Due',
+                description: 'Include assessments due for review',
+                widget: {
+                    type: AXPWidgetsList.Editors.ToggleSwitch
+                }
+            }
+        ]
+    }
+];
+const auditParameterGroups = [
+    {
+        name: 'auditDetails',
+        title: 'Audit Details',
+        description: 'Specify audit parameters',
+        parameters: [
+            {
+                path: 'auditType',
+                title: 'Audit Type',
+                description: 'Type of safety audit',
+                widget: {
+                    type: AXPWidgetsList.Editors.SelectBox,
+                    options: {
+                        dataSource: ['All', 'Internal', 'External', 'Regulatory', 'Management Review', 'Compliance']
+                    }
+                }
+            },
+            {
+                path: 'auditor',
+                title: 'Auditor',
+                description: 'Person conducting the audit',
+                widget: {
+                    type: AXPWidgetsList.Editors.TextBox,
+                    options: {
+                        placeholder: 'Enter auditor name'
+                    }
+                }
+            },
+            {
+                path: 'findingsCount',
+                title: 'Minimum Findings Count',
+                description: 'Minimum number of findings to include',
+                widget: {
+                    type: AXPWidgetsList.Editors.NumberBox,
+                    options: {
+                        minValue: 0,
+                        maxValue: 100
+                    }
+                }
+            },
+            {
+                path: 'correctiveActions',
+                title: 'Corrective Actions Status',
+                description: 'Status of corrective actions',
+                widget: {
+                    type: AXPWidgetsList.Editors.SelectBox,
+                    options: {
+                        dataSource: ['All', 'Open', 'In Progress', 'Completed', 'Overdue']
+                    }
+                }
+            },
+            {
+                path: 'attachAuditReport',
+                title: 'Attach Audit Report',
+                description: 'Upload audit documentation',
+                widget: {
+                    type: AXPWidgetsList.Editors.DocumentAttachment,
+                    options: {
+                        accept: ['.pdf', '.doc', '.docx'],
+                        maxSize: 10 * 1024 * 1024,
+                        multiple: true
+                    }
+                }
+            }
+        ]
+    }
+];
+const complianceParameterGroups = [
+    {
+        name: 'complianceDetails',
+        title: 'Compliance Details',
+        description: 'Compliance reporting parameters',
+        parameters: [
+            {
+                path: 'regulatoryFramework',
+                title: 'Regulatory Framework',
+                description: 'Applicable regulatory framework',
+                widget: {
+                    type: AXPWidgetsList.Editors.SelectBox,
+                    options: {
+                        dataSource: ['All', 'OSHA', 'ISO 45001', 'ISO 14001', 'Local Regulations', 'Industry Standards']
+                    }
+                }
+            },
+            {
+                path: 'complianceStatus',
+                title: 'Compliance Status',
+                description: 'Current compliance status',
+                widget: {
+                    type: AXPWidgetsList.Editors.SelectBox,
+                    options: {
+                        dataSource: ['All', 'Compliant', 'Non-Compliant', 'Partially Compliant', 'Under Review']
+                    }
+                }
+            },
+            {
+                path: 'inspectionDate',
+                title: 'Last Inspection Date',
+                description: 'Date of last compliance inspection',
+                widget: {
+                    type: AXPWidgetsList.Editors.DateTimeBox,
+                    options: {
+                        showTime: false,
+                        format: 'yyyy-MM-dd'
+                    }
+                }
+            },
+            {
+                path: 'certificationsExpiring',
+                title: 'Include Expiring Certifications',
+                description: 'Include certifications expiring within the period',
+                widget: {
+                    type: AXPWidgetsList.Editors.ToggleSwitch
+                }
+            }
+        ]
+    }
+];
+const trainingParameterGroups = [
+    {
+        name: 'trainingDetails',
+        title: 'Training Details',
+        description: 'Safety training parameters',
+        parameters: [
+            {
+                path: 'trainingType',
+                title: 'Training Type',
+                description: 'Type of safety training',
+                widget: {
+                    type: AXPWidgetsList.Editors.SelectBox,
+                    options: {
+                        dataSource: ['All', 'Induction', 'Refresher', 'Specialized', 'Emergency Response', 'Equipment Specific'],
+                        multiple: true
+                    }
+                }
+            },
+            {
+                path: 'trainingStatus',
+                title: 'Training Status',
+                description: 'Completion status of training',
+                widget: {
+                    type: AXPWidgetsList.Editors.SelectBox,
+                    options: {
+                        dataSource: ['All', 'Completed', 'In Progress', 'Not Started', 'Expired', 'Overdue']
+                    }
+                }
+            },
+            {
+                path: 'instructor',
+                title: 'Instructor',
+                description: 'Training instructor name',
+                widget: {
+                    type: AXPWidgetsList.Editors.TextBox,
+                    options: {
+                        placeholder: 'Enter instructor name'
+                    }
+                }
+            },
+            {
+                path: 'passingScore',
+                title: 'Minimum Passing Score',
+                description: 'Minimum score to consider as passed',
+                widget: {
+                    type: AXPWidgetsList.Editors.NumberBox,
+                    options: {
+                        minValue: 0,
+                        maxValue: 100,
+                        step: 5
+                    }
+                }
+            },
+            {
+                path: 'includeRetakes',
+                title: 'Include Retakes',
+                description: 'Include training retakes in the report',
+                widget: {
+                    type: AXPWidgetsList.Editors.ToggleSwitch
+                }
+            }
+        ]
+    }
+];
+const environmentalParameterGroups = [
+    {
+        name: 'environmentalDetails',
+        title: 'Environmental Details',
+        description: 'Environmental monitoring parameters',
+        parameters: [
+            {
+                path: 'monitoringType',
+                title: 'Monitoring Type',
+                description: 'Type of environmental monitoring',
+                widget: {
+                    type: AXPWidgetsList.Editors.SelectBox,
+                    options: {
+                        dataSource: ['All', 'Air Quality', 'Water Quality', 'Noise Levels', 'Soil Contamination', 'Emissions', 'Waste Discharge']
+                    }
+                }
+            },
+            {
+                path: 'measurementLocation',
+                title: 'Measurement Location',
+                description: 'Location where measurements were taken',
+                widget: {
+                    type: AXPWidgetsList.Editors.TextBox,
+                    options: {
+                        placeholder: 'Enter location'
+                    }
+                }
+            },
+            {
+                path: 'exceedanceThreshold',
+                title: 'Exceedance Threshold',
+                description: 'Threshold value for regulatory limits',
+                widget: {
+                    type: AXPWidgetsList.Editors.NumberBox,
+                    options: {
+                        minValue: 0,
+                        step: 0.1
+                    }
+                }
+            },
+            {
+                path: 'includeExceedances',
+                title: 'Include Exceedances Only',
+                description: 'Show only measurements exceeding limits',
+                widget: {
+                    type: AXPWidgetsList.Editors.ToggleSwitch
+                }
+            },
+            {
+                path: 'calibrationStatus',
+                title: 'Equipment Calibration Status',
+                description: 'Calibration status of monitoring equipment',
+                widget: {
+                    type: AXPWidgetsList.Editors.SelectBox,
+                    options: {
+                        dataSource: ['All', 'Calibrated', 'Due for Calibration', 'Overdue', 'Out of Service']
+                    }
+                }
+            }
+        ]
+    }
+];
+const wasteManagementParameterGroups = [
+    {
+        name: 'wasteDetails',
+        title: 'Waste Management Details',
+        description: 'Waste management parameters',
+        parameters: [
+            {
+                path: 'wasteType',
+                title: 'Waste Type',
+                description: 'Type of waste',
+                widget: {
+                    type: AXPWidgetsList.Editors.SelectBox,
+                    options: {
+                        dataSource: ['All', 'Hazardous', 'Non-Hazardous', 'Recyclable', 'Electronic', 'Medical', 'Chemical'],
+                        multiple: true
+                    }
+                }
+            },
+            {
+                path: 'disposalMethod',
+                title: 'Disposal Method',
+                description: 'Method of waste disposal',
+                widget: {
+                    type: AXPWidgetsList.Editors.SelectBox,
+                    options: {
+                        dataSource: ['All', 'Landfill', 'Incineration', 'Recycling', 'Treatment', 'Recovery', 'Reuse']
+                    }
+                }
+            },
+            {
+                path: 'wasteQuantity',
+                title: 'Minimum Waste Quantity (kg)',
+                description: 'Minimum quantity of waste to include',
+                widget: {
+                    type: AXPWidgetsList.Editors.NumberBox,
+                    options: {
+                        minValue: 0,
+                        step: 0.1
+                    }
+                }
+            },
+            {
+                path: 'contractor',
+                title: 'Waste Contractor',
+                description: 'Waste management contractor',
+                widget: {
+                    type: AXPWidgetsList.Editors.TextBox,
+                    options: {
+                        placeholder: 'Enter contractor name'
+                    }
+                }
+            },
+            {
+                path: 'includeManifests',
+                title: 'Include Waste Manifests',
+                description: 'Include waste manifests in the report',
+                widget: {
+                    type: AXPWidgetsList.Editors.ToggleSwitch
+                }
+            }
+        ]
+    }
+];
+const healthParameterGroups = [
+    {
+        name: 'healthDetails',
+        title: 'Employee Health Details',
+        description: 'Employee health parameters',
+        parameters: [
+            {
+                path: 'healthScreeningType',
+                title: 'Health Screening Type',
+                description: 'Type of health screening',
+                widget: {
+                    type: AXPWidgetsList.Editors.SelectBox,
+                    options: {
+                        dataSource: ['All', 'Pre-employment', 'Annual', 'Post-incident', 'Return-to-work', 'Fitness for duty']
+                    }
+                }
+            },
+            {
+                path: 'healthProvider',
+                title: 'Health Provider',
+                description: 'Healthcare provider conducting screening',
+                widget: {
+                    type: AXPWidgetsList.Editors.TextBox,
+                    options: {
+                        placeholder: 'Enter provider name'
+                    }
+                }
+            },
+            {
+                path: 'ageRange',
+                title: 'Age Range',
+                description: 'Employee age range',
+                widget: {
+                    type: AXPWidgetsList.Editors.SelectBox,
+                    options: {
+                        dataSource: ['All', '18-25', '26-35', '36-45', '46-55', '56-65', '65+']
+                    }
+                }
+            },
+            {
+                path: 'includeAbsenteeism',
+                title: 'Include Absenteeism Data',
+                description: 'Include health-related absenteeism',
+                widget: {
+                    type: AXPWidgetsList.Editors.ToggleSwitch
+                }
+            },
+            {
+                path: 'confidentialityLevel',
+                title: 'Confidentiality Level',
+                description: 'Level of data confidentiality',
+                widget: {
+                    type: AXPWidgetsList.Editors.SelectBox,
+                    options: {
+                        dataSource: ['Aggregated Only', 'Department Level', 'Individual (Authorized Only)']
+                    }
+                }
+            }
+        ]
+    }
+];
+const ergonomicsParameterGroups = [
+    {
+        name: 'ergonomicsDetails',
+        title: 'Ergonomics Assessment Details',
+        description: 'Ergonomics assessment parameters',
+        parameters: [
+            {
+                path: 'assessmentMethod',
+                title: 'Assessment Method',
+                description: 'Ergonomics assessment methodology',
+                widget: {
+                    type: AXPWidgetsList.Editors.SelectBox,
+                    options: {
+                        dataSource: ['All', 'RULA', 'REBA', 'NIOSH', 'HAL', 'Custom Checklist']
+                    }
+                }
+            },
+            {
+                path: 'workstationType',
+                title: 'Workstation Type',
+                description: 'Type of workstation assessed',
+                widget: {
+                    type: AXPWidgetsList.Editors.SelectBox,
+                    options: {
+                        dataSource: ['All', 'Office Desk', 'Production Line', 'Laboratory', 'Warehouse', 'Vehicle', 'Mobile']
+                    }
+                }
+            },
+            {
+                path: 'riskScore',
+                title: 'Minimum Risk Score',
+                description: 'Minimum ergonomic risk score to include',
+                widget: {
+                    type: AXPWidgetsList.Editors.NumberBox,
+                    options: {
+                        minValue: 1,
+                        maxValue: 10
+                    }
+                }
+            },
+            {
+                path: 'interventionsRequired',
+                title: 'Interventions Required',
+                description: 'Level of interventions needed',
+                widget: {
+                    type: AXPWidgetsList.Editors.SelectBox,
+                    options: {
+                        dataSource: ['All', 'None', 'Low Priority', 'Medium Priority', 'High Priority', 'Immediate']
+                    }
+                }
+            },
+            {
+                path: 'includeRecommendations',
+                title: 'Include Recommendations',
+                description: 'Include ergonomic recommendations in report',
+                widget: {
+                    type: AXPWidgetsList.Editors.ToggleSwitch
+                }
+            }
+        ]
+    }
+];
+//#endregion
+//#region ----   Mock Report Definitions   ----
+function generateReportDefinitions() {
+    const reports = [];
+    // Get categories that have reports
+    const categoriesWithReports = REPORT_CATEGORIES.filter(cat => cat.hasReport);
+    categoriesWithReports.forEach((category) => {
+        let reportsForCategory = [];
+        switch (category.title) {
+            case 'Balance Sheet':
+                reportsForCategory = [
+                    {
+                        title: 'Consolidated Balance Sheet',
+                        description: 'Complete balance sheet with all assets, liabilities, and equity',
+                        parameterGroups: [...commonParameterGroups, ...financialParameterGroups],
+                    },
+                    {
+                        title: 'Comparative Balance Sheet',
+                        description: 'Year-over-year balance sheet comparison',
+                        parameterGroups: [...commonParameterGroups, ...financialParameterGroups],
+                    },
+                ];
+                break;
+            case 'Income Statement':
+                reportsForCategory = [
+                    {
+                        title: 'Profit & Loss Statement',
+                        description: 'Detailed income statement with revenue and expenses',
+                        parameterGroups: [...commonParameterGroups, ...financialParameterGroups],
+                    },
+                    {
+                        title: 'Monthly Income Trends',
+                        description: 'Monthly trending of income and expenses',
+                        parameterGroups: [...commonParameterGroups, ...financialParameterGroups],
+                    },
+                ];
+                break;
+            case 'Cash Flow':
+                reportsForCategory = [
+                    {
+                        title: 'Cash Flow Statement',
+                        description: 'Operating, investing, and financing cash flows',
+                        parameterGroups: [...commonParameterGroups, ...financialParameterGroups],
+                    },
+                ];
+                break;
+            case 'Budget Analysis':
+                reportsForCategory = [
+                    {
+                        title: 'Budget vs Actual',
+                        description: 'Comparison of budgeted vs actual performance',
+                        parameterGroups: [...commonParameterGroups, ...financialParameterGroups],
+                    },
+                ];
+                break;
+            case 'Employee Performance':
+                reportsForCategory = [
+                    {
+                        title: 'Performance Review Summary',
+                        description: 'Employee performance ratings and feedback',
+                        parameterGroups: [...commonParameterGroups, ...hrParameterGroups],
+                    },
+                    {
+                        title: 'Goal Achievement Report',
+                        description: 'Employee goal completion and progress tracking',
+                        parameterGroups: [...commonParameterGroups, ...hrParameterGroups],
+                    },
+                ];
+                break;
+            case 'Attendance & Leave':
+                reportsForCategory = [
+                    {
+                        title: 'Attendance Summary',
+                        description: 'Employee attendance patterns and statistics',
+                        parameterGroups: [...commonParameterGroups, ...hrParameterGroups],
+                    },
+                    {
+                        title: 'Leave Balance Report',
+                        description: 'Current leave balances and usage',
+                        parameterGroups: [...commonParameterGroups, ...hrParameterGroups],
+                    },
+                ];
+                break;
+            case 'Sales Performance':
+                reportsForCategory = [
+                    {
+                        title: 'Sales Revenue Report',
+                        description: 'Revenue by sales rep, region, and product',
+                        parameterGroups: [...commonParameterGroups, {
+                                name: 'sales',
+                                title: 'Sales Parameters',
+                                parameters: [
+                                    {
+                                        path: 'salesRep',
+                                        title: 'Sales Representative',
+                                        widget: { type: AXPWidgetsList.Editors.SelectBox, options: { dataSource: ['All', 'John Smith', 'Sarah Johnson', 'Mike Wilson'] } },
+                                    },
+                                    {
+                                        path: 'region',
+                                        title: 'Sales Region',
+                                        widget: { type: AXPWidgetsList.Editors.SelectBox, options: { dataSource: ['All', 'North', 'South', 'East', 'West'] } },
+                                    },
+                                ],
+                            }],
+                    },
+                    {
+                        title: 'Sales Pipeline Report',
+                        description: 'Current sales opportunities and pipeline health',
+                        parameterGroups: [...commonParameterGroups],
+                    },
+                ];
+                break;
+            case 'Quality Assurance':
+                reportsForCategory = [
+                    {
+                        title: 'Quality Metrics Dashboard',
+                        description: 'Overall quality KPIs and trends',
+                        parameterGroups: [...commonParameterGroups, {
+                                name: 'quality',
+                                title: 'Quality Parameters',
+                                parameters: [
+                                    {
+                                        path: 'productLine',
+                                        title: 'Product Line',
+                                        widget: { type: AXPWidgetsList.Editors.SelectBox, options: { dataSource: ['All', 'Product A', 'Product B', 'Product C'] } },
+                                    },
+                                    {
+                                        path: 'severity',
+                                        title: 'Issue Severity',
+                                        widget: { type: AXPWidgetsList.Editors.SelectBox, options: { dataSource: ['All', 'Critical', 'High', 'Medium', 'Low'] } },
+                                    },
+                                ],
+                            }],
+                    },
+                    {
+                        title: 'Defect Analysis Report',
+                        description: 'Detailed analysis of product defects and root causes',
+                        parameterGroups: [...commonParameterGroups],
+                    },
+                ];
+                break;
+            case 'Incident Management':
+                reportsForCategory = [
+                    {
+                        title: 'Incident Summary Report',
+                        description: 'Summary of all reported workplace incidents',
+                        parameterGroups: [...commonParameterGroups, ...whsIncidentParameterGroups],
+                    },
+                    {
+                        title: 'Lost Time Injury Report',
+                        description: 'Analysis of lost time injuries in the workplace',
+                        parameterGroups: [...commonParameterGroups, ...whsIncidentParameterGroups],
+                    },
+                ];
+                break;
+            case 'Risk Assessment':
+                reportsForCategory = [
+                    {
+                        title: 'Risk Register Report',
+                        description: 'Comprehensive risk register and mitigation actions',
+                        parameterGroups: [...commonParameterGroups, ...riskAssessmentParameterGroups],
+                    },
+                    {
+                        title: 'Risk Assessment Matrix',
+                        description: 'Matrix of identified risks and their severity',
+                        parameterGroups: [...commonParameterGroups, ...riskAssessmentParameterGroups],
+                    },
+                ];
+                break;
+            case 'Safety Audits':
+                reportsForCategory = [
+                    {
+                        title: 'Safety Audit Findings',
+                        description: 'Summary of safety audit findings and recommendations',
+                        parameterGroups: [...commonParameterGroups, ...auditParameterGroups],
+                    },
+                    {
+                        title: 'Audit Compliance Report',
+                        description: 'Compliance status based on recent safety audits',
+                        parameterGroups: [...commonParameterGroups, ...auditParameterGroups],
+                    },
+                ];
+                break;
+            case 'Compliance Reports':
+                reportsForCategory = [
+                    {
+                        title: 'Regulatory Compliance Checklist',
+                        description: 'Checklist of OHS regulatory compliance items',
+                        parameterGroups: [...commonParameterGroups, ...complianceParameterGroups],
+                    },
+                    {
+                        title: 'PPE Usage Report',
+                        description: 'Report on personal protective equipment usage',
+                        parameterGroups: [...commonParameterGroups, ...complianceParameterGroups],
+                    },
+                ];
+                break;
+            case 'Training Records':
+                reportsForCategory = [
+                    {
+                        title: 'Training Completion Report',
+                        description: 'Summary of completed safety trainings',
+                        parameterGroups: [...commonParameterGroups, ...trainingParameterGroups],
+                    },
+                    {
+                        title: 'Training Expiry Report',
+                        description: 'Upcoming and expired safety training records',
+                        parameterGroups: [...commonParameterGroups, ...trainingParameterGroups],
+                    },
+                ];
+                break;
+            case 'Hazard Identification':
+                reportsForCategory = [
+                    {
+                        title: 'Hazard Register',
+                        description: 'Register of identified workplace hazards',
+                        parameterGroups: [...commonParameterGroups, ...riskAssessmentParameterGroups],
+                    },
+                    {
+                        title: 'Hazard Trend Analysis',
+                        description: 'Analysis of hazard trends over time',
+                        parameterGroups: [...commonParameterGroups, ...riskAssessmentParameterGroups],
+                    },
+                ];
+                break;
+            case 'Environmental Monitoring':
+                reportsForCategory = [
+                    {
+                        title: 'Air Quality Monitoring Report',
+                        description: 'Report on workplace air quality measurements',
+                        parameterGroups: [...commonParameterGroups, ...environmentalParameterGroups],
+                    },
+                    {
+                        title: 'Emissions Summary',
+                        description: 'Summary of environmental emissions data',
+                        parameterGroups: [...commonParameterGroups, ...environmentalParameterGroups],
+                    },
+                ];
+                break;
+            case 'Waste Management':
+                reportsForCategory = [
+                    {
+                        title: 'Waste Disposal Report',
+                        description: 'Details of waste disposal and recycling activities',
+                        parameterGroups: [...commonParameterGroups, ...wasteManagementParameterGroups],
+                    },
+                    {
+                        title: 'Hazardous Waste Tracking',
+                        description: 'Tracking of hazardous waste generation and disposal',
+                        parameterGroups: [...commonParameterGroups, ...wasteManagementParameterGroups],
+                    },
+                ];
+                break;
+            case 'Sustainability Metrics':
+                reportsForCategory = [
+                    {
+                        title: 'Sustainability KPI Report',
+                        description: 'Key performance indicators for sustainability initiatives',
+                        parameterGroups: [...commonParameterGroups, ...environmentalParameterGroups],
+                    },
+                    {
+                        title: 'Resource Consumption Analysis',
+                        description: 'Analysis of resource consumption and efficiency',
+                        parameterGroups: [...commonParameterGroups, ...environmentalParameterGroups],
+                    },
+                ];
+                break;
+            case 'Employee Health Records':
+                reportsForCategory = [
+                    {
+                        title: 'Health Screening Summary',
+                        description: 'Summary of employee health screenings and results',
+                        parameterGroups: [...commonParameterGroups, ...healthParameterGroups],
+                    },
+                    {
+                        title: 'Absenteeism Analysis',
+                        description: 'Analysis of employee absenteeism due to health reasons',
+                        parameterGroups: [...commonParameterGroups, ...healthParameterGroups],
+                    },
+                ];
+                break;
+            case 'Wellness Programs':
+                reportsForCategory = [
+                    {
+                        title: 'Wellness Program Participation',
+                        description: 'Participation rates in wellness programs',
+                        parameterGroups: [...commonParameterGroups, ...healthParameterGroups],
+                    },
+                    {
+                        title: 'Wellness Outcomes Report',
+                        description: 'Outcomes and effectiveness of wellness initiatives',
+                        parameterGroups: [...commonParameterGroups, ...healthParameterGroups],
+                    },
+                ];
+                break;
+            case 'Ergonomics Assessments':
+                reportsForCategory = [
+                    {
+                        title: 'Ergonomics Assessment Results',
+                        description: 'Results of workplace ergonomics assessments',
+                        parameterGroups: [...commonParameterGroups, ...ergonomicsParameterGroups],
+                    },
+                    {
+                        title: 'Ergonomics Improvement Tracking',
+                        description: 'Tracking of ergonomics-related improvements',
+                        parameterGroups: [...commonParameterGroups, ...ergonomicsParameterGroups],
+                    },
+                ];
+                break;
+            default:
+                // Generate generic reports for other categories
+                reportsForCategory = [
+                    {
+                        title: `${category.title} Summary`,
+                        description: `Comprehensive ${category.title.toLowerCase()} report with key metrics`,
+                        parameterGroups: commonParameterGroups,
+                    },
+                ];
+                break;
+        }
+        reportsForCategory.forEach((report) => {
+            reports.push({
+                id: AXPDataGenerator.uuid(),
+                title: report.title,
+                description: report.description,
+                categoryIds: [category.id],
+                parameterGroups: report.parameterGroups,
+            });
+        });
+    });
+    return reports;
+}
+const REPORT_DEFINITIONS = generateReportDefinitions();
+//#endregion
+//#region ----   Category-Report Mapping   ----
+// Create a mapping of categories to their reports for easy lookup
+const CATEGORY_REPORT_MAPPING = new Map();
+REPORT_CATEGORIES.filter(cat => cat.hasReport).forEach(category => {
+    const categoryReports = REPORT_DEFINITIONS.filter(report => {
+        // Simple matching based on category title and report title
+        return report.title.toLowerCase().includes(category.title.toLowerCase()) ||
+            report.description?.toLowerCase().includes(category.title.toLowerCase());
+    });
+    CATEGORY_REPORT_MAPPING.set(category.id, categoryReports);
+});
+//#endregion
+
+class AXPReportManagementDataSeeder {
+    constructor() {
+        this.storageService = inject(AXPEntityStorageService);
+    }
+    async seed() {
+        // Seed report categories
+        await this.storageService.initial(`${RootConfig$5.module.name}.${RootConfig$5.entities.category.name}`, REPORT_CATEGORIES);
+        // Seed report definitions
+        await this.storageService.initial(`${RootConfig$5.module.name}.${RootConfig$5.entities.report.name}`, REPORT_DEFINITIONS);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.0.4", ngImport: i0, type: AXPReportManagementDataSeeder, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.0.4", ngImport: i0, type: AXPReportManagementDataSeeder }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.0.4", ngImport: i0, type: AXPReportManagementDataSeeder, decorators: [{
+            type: Injectable
+        }] });
+
+class AXCReportManagementMockModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.0.4", ngImport: i0, type: AXCReportManagementMockModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "20.0.4", ngImport: i0, type: AXCReportManagementMockModule }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "20.0.4", ngImport: i0, type: AXCReportManagementMockModule, providers: [
+            {
+                provide: AXP_DATA_SEEDER_TOKEN,
+                useClass: AXPReportManagementDataSeeder,
+                multi: true,
+            },
+        ] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.0.4", ngImport: i0, type: AXCReportManagementMockModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [],
+                    exports: [],
+                    declarations: [],
+                    providers: [
+                        {
+                            provide: AXP_DATA_SEEDER_TOKEN,
+                            useClass: AXPReportManagementDataSeeder,
+                            multi: true,
+                        },
+                    ],
+                }]
+        }] });
+
 const projectMock$1 = [
     {
         id: AXPDataGenerator.uuid(),
@@ -2974,7 +4207,7 @@ class AXMLogDataSeeder {
         this.storageService = inject(AXPEntityStorageService);
     }
     async seed() {
-        await this.storageService.initial(`${RootConfig$5.module.name}.${RootConfig$5.entities.axpLog.name}`, projectMock$1);
+        await this.storageService.initial(`${RootConfig$6.module.name}.${RootConfig$6.entities.axpLog.name}`, projectMock$1);
     }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.0.4", ngImport: i0, type: AXMLogDataSeeder, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
     static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.0.4", ngImport: i0, type: AXMLogDataSeeder }); }
@@ -2991,7 +4224,7 @@ class MOCKStrategy {
         return 'user-pass';
     }
     async signin(credentials) {
-        const entityRef = await this.entityRegistery.resolve(RootConfig$6.module.name, RootConfig$6.entities.users.name);
+        const entityRef = await this.entityRegistery.resolve(RootConfig$7.module.name, RootConfig$7.entities.users.name);
         const accessToken = 'access_token';
         const refreshToken = 'refresh_token';
         try {
@@ -3160,7 +4393,7 @@ class AXCNotificationTemplateDataSeeder {
         this.storageService = inject(AXPEntityStorageService);
     }
     async seed() {
-        await this.storageService.initial(`${RootConfig$7.module.name}.${RootConfig$7.entities.template.name}`, NOTIFICATION_TEMPLATES);
+        await this.storageService.initial(`${RootConfig$8.module.name}.${RootConfig$8.entities.template.name}`, NOTIFICATION_TEMPLATES);
     }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.0.4", ngImport: i0, type: AXCNotificationTemplateDataSeeder, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
     static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.0.4", ngImport: i0, type: AXCNotificationTemplateDataSeeder }); }
@@ -4316,7 +5549,7 @@ class AXCOrganizationManagementDataSeeder {
     async seed() {
         const uuid = AXPDataGenerator.uuid;
         // Departments
-        await this.storageService.initial(RootConfig$8.entities.department.source, [
+        await this.storageService.initial(RootConfig$9.entities.department.source, [
             {
                 id: uuid(),
                 title: 'Software Development',
@@ -4375,7 +5608,7 @@ class AXCOrganizationManagementDataSeeder {
             },
         ]);
         // Divisions
-        await this.storageService.initial(RootConfig$8.entities.division.source, [
+        await this.storageService.initial(RootConfig$9.entities.division.source, [
             {
                 id: uuid(),
                 title: 'Technology Division',
@@ -4420,7 +5653,7 @@ class AXCOrganizationManagementDataSeeder {
             },
         ]);
         // Branches
-        await this.storageService.initial(RootConfig$8.entities.branch.source, [
+        await this.storageService.initial(RootConfig$9.entities.branch.source, [
             {
                 id: uuid(),
                 title: 'Headquarters',
@@ -4468,15 +5701,15 @@ class AXCOrganizationManagementDataSeeder {
             },
         ]);
         // Positions Category
-        await this.storageService.initial(RootConfig$8.entities.positionCategory.source, POSITIONS_CATEGORY_MOCK);
+        await this.storageService.initial(RootConfig$9.entities.positionCategory.source, POSITIONS_CATEGORY_MOCK);
         // Positions
-        await this.storageService.initial(RootConfig$8.entities.position.source, POSITIONS_MOCK);
+        await this.storageService.initial(RootConfig$9.entities.position.source, POSITIONS_MOCK);
         // Role Category
-        await this.storageService.initial(RootConfig$8.entities.roleCategory.source, ROLES_CATEGORY_MOCK);
+        await this.storageService.initial(RootConfig$9.entities.roleCategory.source, ROLES_CATEGORY_MOCK);
         // Role
-        await this.storageService.initial(RootConfig$8.entities.role.source, ROLES_MOCK);
+        await this.storageService.initial(RootConfig$9.entities.role.source, ROLES_MOCK);
         // Employment Types
-        await this.storageService.initial(RootConfig$8.entities.employmentType.source, [
+        await this.storageService.initial(RootConfig$9.entities.employmentType.source, [
             {
                 id: uuid(),
                 title: 'Full-Time',
@@ -4504,7 +5737,7 @@ class AXCOrganizationManagementDataSeeder {
             },
         ]);
         // Teams
-        await this.storageService.initial(RootConfig$8.entities.team.source, [
+        await this.storageService.initial(RootConfig$9.entities.team.source, [
             {
                 id: uuid(),
                 title: 'Backend Development Team',
@@ -4551,7 +5784,7 @@ class AXCOrganizationManagementDataSeeder {
             },
         ]);
         // Employees
-        await this.storageService.initial(RootConfig$8.entities.employee.source, [
+        await this.storageService.initial(RootConfig$9.entities.employee.source, [
             {
                 id: uuid(),
                 firstname: 'Jane',
@@ -4674,7 +5907,7 @@ class AXCOrganizationManagementDataSeeder {
             },
         ]);
         // Store Chart Data
-        await this.storageService.initial(RootConfig$8.entities.chart.source, [
+        await this.storageService.initial(RootConfig$9.entities.chart.source, [
             {
                 id: uuid(),
                 version: '1.0',
@@ -4682,13 +5915,13 @@ class AXCOrganizationManagementDataSeeder {
             },
         ]);
         // Skill Category
-        await this.storageService.initial(RootConfig$8.entities.skillCategory.source, SKILLS_CATEGORY_MOCK);
+        await this.storageService.initial(RootConfig$9.entities.skillCategory.source, SKILLS_CATEGORY_MOCK);
         // Skill
-        await this.storageService.initial(RootConfig$8.entities.skill.source, SKILLS_MOCK);
+        await this.storageService.initial(RootConfig$9.entities.skill.source, SKILLS_MOCK);
         // Responsibility Category
-        await this.storageService.initial(RootConfig$8.entities.responsibilityCategory.source, RESPONSIBILITIES_CATEGORY_MOCK);
+        await this.storageService.initial(RootConfig$9.entities.responsibilityCategory.source, RESPONSIBILITIES_CATEGORY_MOCK);
         // Responsibility
-        await this.storageService.initial(RootConfig$8.entities.responsibility.source, RESPONSIBILITIES_MOCK);
+        await this.storageService.initial(RootConfig$9.entities.responsibility.source, RESPONSIBILITIES_MOCK);
     }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.0.4", ngImport: i0, type: AXCOrganizationManagementDataSeeder, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
     static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.0.4", ngImport: i0, type: AXCOrganizationManagementDataSeeder }); }
@@ -4764,7 +5997,7 @@ class AXCAppTermDataSeeder {
         this.storageService = inject(AXPEntityStorageService);
     }
     async seed() {
-        await this.storageService.initial(`${RootConfig$9.module.name}.${RootConfig$9.entities.appTerm.name}`, APP_TERMS);
+        await this.storageService.initial(`${RootConfig$a.module.name}.${RootConfig$a.entities.appTerm.name}`, APP_TERMS);
     }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.0.4", ngImport: i0, type: AXCAppTermDataSeeder, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
     static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.0.4", ngImport: i0, type: AXCAppTermDataSeeder }); }
@@ -4799,7 +6032,7 @@ class AXCAppVersionDataSeeder {
         this.storageService = inject(AXPEntityStorageService);
     }
     async seed() {
-        await this.storageService.initial(`${RootConfig$9.module.name}.${RootConfig$9.entities.appVersion.name}`, APP_VERSIONS);
+        await this.storageService.initial(`${RootConfig$a.module.name}.${RootConfig$a.entities.appVersion.name}`, APP_VERSIONS);
     }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.0.4", ngImport: i0, type: AXCAppVersionDataSeeder, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
     static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.0.4", ngImport: i0, type: AXCAppVersionDataSeeder }); }
@@ -4830,7 +6063,7 @@ class AXCGlobalVariablesDataSeeder {
         this.storageService = inject(AXPEntityStorageService);
     }
     async seed() {
-        await this.storageService.initial(`${RootConfig$9.module.name}.${RootConfig$9.entities.globalVariable.name}`, GLOBAL_VARIABLES);
+        await this.storageService.initial(`${RootConfig$a.module.name}.${RootConfig$a.entities.globalVariable.name}`, GLOBAL_VARIABLES);
     }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.0.4", ngImport: i0, type: AXCGlobalVariablesDataSeeder, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
     static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.0.4", ngImport: i0, type: AXCGlobalVariablesDataSeeder }); }
@@ -5164,8 +6397,8 @@ class AXCMetaDataDefinitionDataSeeder {
         this.storageService = inject(AXPEntityStorageService);
     }
     async seed() {
-        await this.storageService.initial(`${RootConfig$9.module.name}.${RootConfig$9.entities.metaDataDefinitionCategory.name}`, METADATA_CATEGORY_MOCK);
-        await this.storageService.initial(`${RootConfig$9.module.name}.${RootConfig$9.entities.metaDataDefinition.name}`, METADATA_MOCK);
+        await this.storageService.initial(`${RootConfig$a.module.name}.${RootConfig$a.entities.metaDataDefinitionCategory.name}`, METADATA_CATEGORY_MOCK);
+        await this.storageService.initial(`${RootConfig$a.module.name}.${RootConfig$a.entities.metaDataDefinition.name}`, METADATA_MOCK);
     }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.0.4", ngImport: i0, type: AXCMetaDataDefinitionDataSeeder, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
     static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.0.4", ngImport: i0, type: AXCMetaDataDefinitionDataSeeder }); }
@@ -5203,7 +6436,7 @@ class AXCProjectclientDataSeeder {
         this.storageService = inject(AXPEntityStorageService);
     }
     async seed() {
-        await this.storageService.initial(`${RootConfig$a.module.name}.${RootConfig$a.entities.client.name}`, ClientMock);
+        await this.storageService.initial(`${RootConfig$b.module.name}.${RootConfig$b.entities.client.name}`, ClientMock);
     }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.0.4", ngImport: i0, type: AXCProjectclientDataSeeder, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
     static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.0.4", ngImport: i0, type: AXCProjectclientDataSeeder }); }
@@ -5305,7 +6538,7 @@ class AXCProjectMemberDataSeeder {
         this.storageService = inject(AXPEntityStorageService);
     }
     async seed() {
-        await this.storageService.initial(`${RootConfig$a.module.name}.${RootConfig$a.entities.projectMemeber.name}`, projectMemberMock);
+        await this.storageService.initial(`${RootConfig$b.module.name}.${RootConfig$b.entities.projectMemeber.name}`, projectMemberMock);
     }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.0.4", ngImport: i0, type: AXCProjectMemberDataSeeder, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
     static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.0.4", ngImport: i0, type: AXCProjectMemberDataSeeder }); }
@@ -5319,8 +6552,8 @@ class AXCProjectRoleMemberDataSeeder {
         this.storageService = inject(AXPEntityStorageService);
     }
     async seed() {
-        await this.storageService.initial(`${RootConfig$a.module.name}.${RootConfig$a.entities.projectType.name}`, projectTypeMock);
-        await this.storageService.initial(`${RootConfig$a.module.name}.${RootConfig$a.entities.projectRoleMember.name}`, projectRoleMemberMock);
+        await this.storageService.initial(`${RootConfig$b.module.name}.${RootConfig$b.entities.projectType.name}`, projectTypeMock);
+        await this.storageService.initial(`${RootConfig$b.module.name}.${RootConfig$b.entities.projectRoleMember.name}`, projectRoleMemberMock);
     }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.0.4", ngImport: i0, type: AXCProjectRoleMemberDataSeeder, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
     static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.0.4", ngImport: i0, type: AXCProjectRoleMemberDataSeeder }); }
@@ -5334,7 +6567,7 @@ class AXCProjectDataSeeder {
         this.storageService = inject(AXPEntityStorageService);
     }
     async seed() {
-        await this.storageService.initial(`${RootConfig$a.module.name}.${RootConfig$a.entities.project.name}`, projectMock);
+        await this.storageService.initial(`${RootConfig$b.module.name}.${RootConfig$b.entities.project.name}`, projectMock);
     }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.0.4", ngImport: i0, type: AXCProjectDataSeeder, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
     static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.0.4", ngImport: i0, type: AXCProjectDataSeeder }); }
@@ -5378,7 +6611,7 @@ class AXCsprintDataSeeder {
         this.storageService = inject(AXPEntityStorageService);
     }
     async seed() {
-        await this.storageService.initial(`${RootConfig$a.module.name}.${RootConfig$a.entities.sprint.name}`, sprintMock);
+        await this.storageService.initial(`${RootConfig$b.module.name}.${RootConfig$b.entities.sprint.name}`, sprintMock);
     }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.0.4", ngImport: i0, type: AXCsprintDataSeeder, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
     static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.0.4", ngImport: i0, type: AXCsprintDataSeeder }); }
@@ -5416,7 +6649,7 @@ class AXCTaskTypeDataSeeder {
         this.storageService = inject(AXPEntityStorageService);
     }
     async seed() {
-        await this.storageService.initial(`${RootConfig$a.module.name}.${RootConfig$a.entities.taskType.name}`, taskTypeMock);
+        await this.storageService.initial(`${RootConfig$b.module.name}.${RootConfig$b.entities.taskType.name}`, taskTypeMock);
     }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.0.4", ngImport: i0, type: AXCTaskTypeDataSeeder, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
     static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.0.4", ngImport: i0, type: AXCTaskTypeDataSeeder }); }
@@ -5485,7 +6718,7 @@ class AXCTaskDataSeeder {
         this.storageService = inject(AXPEntityStorageService);
     }
     async seed() {
-        await this.storageService.initial(`${RootConfig$a.module.name}.${RootConfig$a.entities.task.name}`, taskMock);
+        await this.storageService.initial(`${RootConfig$b.module.name}.${RootConfig$b.entities.task.name}`, taskMock);
     }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.0.4", ngImport: i0, type: AXCTaskDataSeeder, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
     static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.0.4", ngImport: i0, type: AXCTaskDataSeeder }); }
@@ -5499,7 +6732,7 @@ class AXCWorkSiteSeeder {
         this.storageService = inject(AXPEntityStorageService);
     }
     async seed() {
-        await this.storageService.initial(`${RootConfig$a.module.name}.${RootConfig$a.entities.workSite.name}`, workSiteMock);
+        await this.storageService.initial(`${RootConfig$b.module.name}.${RootConfig$b.entities.workSite.name}`, workSiteMock);
     }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.0.4", ngImport: i0, type: AXCWorkSiteSeeder, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
     static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.0.4", ngImport: i0, type: AXCWorkSiteSeeder }); }
@@ -5530,7 +6763,7 @@ class AXCSchedulerJobDataSeeder {
         this.storageService = inject(AXPEntityStorageService);
     }
     async seed() {
-        await this.storageService.initial(`${RootConfig$b.module.name}.${RootConfig$b.entities.schedulerJob.name}`, SCHEDULER_JOB);
+        await this.storageService.initial(`${RootConfig$c.module.name}.${RootConfig$c.entities.schedulerJob.name}`, SCHEDULER_JOB);
     }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.0.4", ngImport: i0, type: AXCSchedulerJobDataSeeder, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
     static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.0.4", ngImport: i0, type: AXCSchedulerJobDataSeeder }); }
@@ -5648,7 +6881,7 @@ class AXPSecurityManagementRoleDataSeeder {
             ...role,
             // permissions: this.getRandomPermissions(permissionKeys, 2, 5), // Get 2-5 random permissions
         }));
-        await this.storageService.initial(`${RootConfig$6.module.name}.${RootConfig$6.entities.roles.name}`, roles);
+        await this.storageService.initial(`${RootConfig$7.module.name}.${RootConfig$7.entities.roles.name}`, roles);
     }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.0.4", ngImport: i0, type: AXPSecurityManagementRoleDataSeeder, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
     static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.0.4", ngImport: i0, type: AXPSecurityManagementRoleDataSeeder }); }
@@ -5662,7 +6895,7 @@ class AXPSecurityManagementUserDataSeeder {
         this.storageService = inject(AXPEntityStorageService);
     }
     async seed() {
-        await this.storageService.initial(`${RootConfig$6.module.name}.${RootConfig$6.entities.users.name}`, this.generateUsers());
+        await this.storageService.initial(`${RootConfig$7.module.name}.${RootConfig$7.entities.users.name}`, this.generateUsers());
     }
     generateUsers() {
         return mockUsers.map((user) => ({
@@ -5711,7 +6944,7 @@ class AXPSecurityManagementDeviceSessionDataSeeder {
         this.sessionService = inject(AXPSessionService);
     }
     async seed() {
-        await this.storageService.initial(`${RootConfig$6.module.name}.${RootConfig$6.entities.deviceSessions.name}`, this.generateDeviceSessions());
+        await this.storageService.initial(`${RootConfig$7.module.name}.${RootConfig$7.entities.deviceSessions.name}`, this.generateDeviceSessions());
     }
     generateDeviceSessions() {
         const deviceSessions = [];
@@ -5932,7 +7165,7 @@ class AXCTextTemplateCategoryDataSeeder {
         this.storageService = inject(AXPEntityStorageService);
     }
     async seed() {
-        await this.storageService.initial(`${RootConfig$c.module.name}.${RootConfig$c.entities.category.name}`, TEXT_TEMPLATE_CATEGORY);
+        await this.storageService.initial(`${RootConfig$d.module.name}.${RootConfig$d.entities.category.name}`, TEXT_TEMPLATE_CATEGORY);
     }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.0.4", ngImport: i0, type: AXCTextTemplateCategoryDataSeeder, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
     static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.0.4", ngImport: i0, type: AXCTextTemplateCategoryDataSeeder }); }
@@ -5946,7 +7179,7 @@ class AXCTextTemplateDataSeeder {
         this.storageService = inject(AXPEntityStorageService);
     }
     async seed() {
-        await this.storageService.initial(`${RootConfig$c.module.name}.${RootConfig$c.entities.template.name}`, TEXT_TEMPLATES);
+        await this.storageService.initial(`${RootConfig$d.module.name}.${RootConfig$d.entities.template.name}`, TEXT_TEMPLATES);
     }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.0.4", ngImport: i0, type: AXCTextTemplateDataSeeder, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
     static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.0.4", ngImport: i0, type: AXCTextTemplateDataSeeder }); }
@@ -6038,7 +7271,7 @@ class AXCCertificateDataSeeder {
         this.storageService = inject(AXPEntityStorageService);
     }
     async seed() {
-        await this.storageService.initial(`${RootConfig$d.module.name}.${RootConfig$d.entities.certificate.name}`, certificateMock);
+        await this.storageService.initial(`${RootConfig$e.module.name}.${RootConfig$e.entities.certificate.name}`, certificateMock);
     }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.0.4", ngImport: i0, type: AXCCertificateDataSeeder, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
     static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.0.4", ngImport: i0, type: AXCCertificateDataSeeder }); }
@@ -6205,10 +7438,10 @@ class AXCCourseDataSeeder {
         this.storageService = inject(AXPEntityStorageService);
     }
     async seed() {
-        await this.storageService.initial(`${RootConfig$d.module.name}.${RootConfig$d.entities.courseType.name}`, courseTypeMock);
-        await this.storageService.initial(`${RootConfig$d.module.name}.${RootConfig$d.entities.course.name}`, courseMock);
-        await this.storageService.initial(`${RootConfig$d.module.name}.${RootConfig$d.entities.courseLocation.name}`, courseLocationMock);
-        await this.storageService.initial(`${RootConfig$d.module.name}.${RootConfig$d.entities.coursePeriod.name}`, coursePeriodMockData);
+        await this.storageService.initial(`${RootConfig$e.module.name}.${RootConfig$e.entities.courseType.name}`, courseTypeMock);
+        await this.storageService.initial(`${RootConfig$e.module.name}.${RootConfig$e.entities.course.name}`, courseMock);
+        await this.storageService.initial(`${RootConfig$e.module.name}.${RootConfig$e.entities.courseLocation.name}`, courseLocationMock);
+        await this.storageService.initial(`${RootConfig$e.module.name}.${RootConfig$e.entities.coursePeriod.name}`, coursePeriodMockData);
     }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.0.4", ngImport: i0, type: AXCCourseDataSeeder, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
     static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.0.4", ngImport: i0, type: AXCCourseDataSeeder }); }
@@ -6222,7 +7455,7 @@ class AXCLocationDataSeeder {
         this.storageService = inject(AXPEntityStorageService);
     }
     async seed() {
-        await this.storageService.initial(`${RootConfig$d.module.name}.${RootConfig$d.entities.location.name}`, locationMockData);
+        await this.storageService.initial(`${RootConfig$e.module.name}.${RootConfig$e.entities.location.name}`, locationMockData);
     }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.0.4", ngImport: i0, type: AXCLocationDataSeeder, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
     static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.0.4", ngImport: i0, type: AXCLocationDataSeeder }); }
@@ -6236,7 +7469,7 @@ class AXCPeriodDataSeeder {
         this.storageService = inject(AXPEntityStorageService);
     }
     async seed() {
-        await this.storageService.initial(`${RootConfig$d.module.name}.${RootConfig$d.entities.period.name}`, periodMock);
+        await this.storageService.initial(`${RootConfig$e.module.name}.${RootConfig$e.entities.period.name}`, periodMock);
     }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.0.4", ngImport: i0, type: AXCPeriodDataSeeder, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
     static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.0.4", ngImport: i0, type: AXCPeriodDataSeeder }); }
@@ -6303,7 +7536,7 @@ class AXCTrainingFacilitatorDataSeeder {
         this.storageService = inject(AXPEntityStorageService);
     }
     async seed() {
-        await this.storageService.initial(`${RootConfig$d.module.name}.${RootConfig$d.entities.trainingFacilitator.name}`, trainingFacilitatorMock);
+        await this.storageService.initial(`${RootConfig$e.module.name}.${RootConfig$e.entities.trainingFacilitator.name}`, trainingFacilitatorMock);
     }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.0.4", ngImport: i0, type: AXCTrainingFacilitatorDataSeeder, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
     static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.0.4", ngImport: i0, type: AXCTrainingFacilitatorDataSeeder }); }
@@ -6336,7 +7569,7 @@ class AXCTrainingParticipantDataSeeder {
         this.storageService = inject(AXPEntityStorageService);
     }
     async seed() {
-        await this.storageService.initial(`${RootConfig$d.module.name}.${RootConfig$d.entities.trainingParticipant.name}`, trainingParticipantMockData);
+        await this.storageService.initial(`${RootConfig$e.module.name}.${RootConfig$e.entities.trainingParticipant.name}`, trainingParticipantMockData);
     }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.0.4", ngImport: i0, type: AXCTrainingParticipantDataSeeder, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
     static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.0.4", ngImport: i0, type: AXCTrainingParticipantDataSeeder }); }
@@ -6350,7 +7583,7 @@ class AXCTrainigTypeDataSeeder {
         this.storageService = inject(AXPEntityStorageService);
     }
     async seed() {
-        await this.storageService.initial(`${RootConfig$d.module.name}.${RootConfig$d.entities.trainingType.name}`, trainingTypeMockData);
+        await this.storageService.initial(`${RootConfig$e.module.name}.${RootConfig$e.entities.trainingType.name}`, trainingTypeMockData);
     }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.0.4", ngImport: i0, type: AXCTrainigTypeDataSeeder, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
     static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.0.4", ngImport: i0, type: AXCTrainigTypeDataSeeder }); }
@@ -6364,7 +7597,7 @@ class AXCTrainingDataSeeder {
         this.storageService = inject(AXPEntityStorageService);
     }
     async seed() {
-        await this.storageService.initial(`${RootConfig$d.module.name}.${RootConfig$d.entities.training.name}`, trainingMock);
+        await this.storageService.initial(`${RootConfig$e.module.name}.${RootConfig$e.entities.training.name}`, trainingMock);
     }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.0.4", ngImport: i0, type: AXCTrainingDataSeeder, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
     static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.0.4", ngImport: i0, type: AXCTrainingDataSeeder }); }
@@ -6665,7 +7898,8 @@ class AXCMockModule {
     }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.0.4", ngImport: i0, type: AXCMockModule, deps: [{ token: i1.AXPAppStartUpService }, { token: i0.Injector }], target: i0.ɵɵFactoryTarget.NgModule }); }
     static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "20.0.4", ngImport: i0, type: AXCMockModule, imports: [i2.AXPAuthModule, AXCFormTemplateManagementMockModule,
-            AXCFOrganizationManagementMockModule] }); }
+            AXCFOrganizationManagementMockModule,
+            AXCReportManagementMockModule] }); }
     static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "20.0.4", ngImport: i0, type: AXCMockModule, providers: [
             {
                 provide: AXMNotificationEntityService,
@@ -6913,7 +8147,8 @@ class AXCMockModule {
                 strategies: [MOCKStrategy],
             }),
             AXCFormTemplateManagementMockModule,
-            AXCFOrganizationManagementMockModule] }); }
+            AXCFOrganizationManagementMockModule,
+            AXCReportManagementMockModule] }); }
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.0.4", ngImport: i0, type: AXCMockModule, decorators: [{
             type: NgModule,
@@ -6924,6 +8159,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.0.4", ngImpor
                         }),
                         AXCFormTemplateManagementMockModule,
                         AXCFOrganizationManagementMockModule,
+                        AXCReportManagementMockModule,
                     ],
                     exports: [],
                     declarations: [],