@acorex/platform 21.0.0-next.2 → 21.0.0-next.5

package/fesm2022/acorex-platform-common.mjs

@@ -4,23 +4,15 @@ import { kebabCase, merge, sortBy, cloneDeep, get, omit } from 'lodash-es';
 import { Router, ROUTES, RouterModule } from '@angular/router';
 import { AXPSessionService, AXPSessionStatus } from '@acorex/platform/auth';
 import { Subject, distinctUntilChanged, merge as merge$1 } from 'rxjs';
-import * as i1$1 from '@acorex/platform/core';
-import { AXPPlatformScope, AXPBroadcastEventService, objectKeyValueTransforms, AXPComponentLogoConfig, AXPImageUrlLogoConfig, AXPSystemActionType, AXPAppStartUpProvider, AXP_EXPRESSION_EVALUATOR_SCOPE_PROVIDER } from '@acorex/platform/core';
+import { AXPPlatformScope, AXPBroadcastEventService, objectKeyValueTransforms, AXPSystemActionType, AXPModuleManifestModule, AXPAppStartUpProvider, AXP_EXPRESSION_EVALUATOR_SCOPE_PROVIDER, AXPModuleManifestRegistry } from '@acorex/platform/core';
 import { AXTranslationService } from '@acorex/core/translation';
 import { AXPWidgetsCatalog } from '@acorex/platform/layout/widget-core';
 import { AXPopupModule, AXPopupService } from '@acorex/components/popup';
 import { AXToastService, AXToastModule } from '@acorex/components/toast';
 import { AXDateTimeModule } from '@acorex/core/date-time';
-import * as i3 from '@acorex/platform/workflow';
+import * as i1 from '@acorex/platform/workflow';
 import { AXPWorkflowService, createWorkFlowEvent, AXPWorkflowAction, AXPWorkflowError, AXPWorkflowModule } from '@acorex/platform/workflow';
-import * as i4 from '@acorex/components/decorators';
-import { AXDecoratorModule } from '@acorex/components/decorators';
-import * as i2 from '@acorex/components/image';
-import { AXImageModule } from '@acorex/components/image';
-import { AXPlatform } from '@acorex/core/platform';
-import * as i1 from '@angular/common';
-import { CommonModule } from '@angular/common';
-import { AXPCommandExecutor } from '@acorex/platform/runtime';
+import { AXPCommandExecutor, AXPCommandService } from '@acorex/platform/runtime';
 import { signalStore, withState, withMethods, patchState, withHooks } from '@ngrx/signals';
 import { AXFormatService } from '@acorex/core/format';
 import { AXDialogService } from '@acorex/components/dialog';
@@ -29,13 +21,15 @@ import { AXButtonModule } from '@acorex/components/button';
 import { AXCheckBoxModule } from '@acorex/components/check-box';
 import * as i6 from '@acorex/components/color-box';
 import { AXColorBoxModule } from '@acorex/components/color-box';
-import * as i3$1 from '@acorex/components/label';
+import * as i4 from '@acorex/components/decorators';
+import { AXDecoratorModule } from '@acorex/components/decorators';
+import * as i3 from '@acorex/components/label';
 import { AXLabelModule } from '@acorex/components/label';
-import * as i2$1 from '@acorex/components/number-box';
+import * as i2 from '@acorex/components/number-box';
 import { AXNumberBoxModule } from '@acorex/components/number-box';
 import { AXBasePageComponent } from '@acorex/components/page';
 import { AXTextBoxModule } from '@acorex/components/text-box';
-import * as i1$2 from '@angular/forms';
+import * as i1$1 from '@angular/forms';
 import { FormsModule } from '@angular/forms';
 
 const AXP_APP_VERSION_PROVIDER = new InjectionToken('AXP_APP_VERSION_PROVIDER', {
@@ -133,24 +127,24 @@ function createAllQueryView(params = {
     });
 }
 
-const EQ_OPER = { name: 'equal', title: 'Equal', hasValue: true };
-const NOT_EQ_OPER = { name: 'notEqual', title: 'Not Equal', hasValue: true };
-const GT_OPER = { name: 'greaterThan', title: 'Greater Than', hasValue: true };
-const LT_OPER = { name: 'lessThan', title: 'Less Than', hasValue: true };
+const EQ_OPER = { name: 'equal', title: '@general:terms.operators.equal', hasValue: true };
+const NOT_EQ_OPER = { name: 'notEqual', title: '@general:terms.operators.not-equal', hasValue: true };
+const GT_OPER = { name: 'greaterThan', title: '@general:terms.operators.greater-than', hasValue: true };
+const LT_OPER = { name: 'lessThan', title: '@general:terms.operators.less-than', hasValue: true };
 const GTE_OPER = {
     name: 'greaterThanOrEqual',
-    title: 'Greater Than or Equal',
+    title: '@general:terms.operators.greater-than-or-equal',
     hasValue: true,
 };
-const LTE_OPER = { name: 'lessThanOrEqual', title: 'Less Than or Equal', hasValue: true };
-const CONTAINS_OPER = { name: 'contains', title: 'Contains', hasValue: true };
-const NOT_CONTAINS_OPER = { name: 'notContains', title: 'Does Not Contain', hasValue: true };
-const IN_OPER = { name: 'in', title: 'In', hasValue: true };
-const STARTS_WITH_OPER = { name: 'startsWith', title: 'Starts With', hasValue: true };
-const ENDS_WITH_OPER = { name: 'endsWith', title: 'Ends With', hasValue: true };
-const IS_EMPTY_OPER = { name: 'isEmpty', title: 'Is Empty', hasValue: false };
-const IS_NOT_EMPTY_OPER = { name: 'isNotEmpty', title: 'Is Not Empty', hasValue: false };
-const BETWEEN_OPER = { name: 'between', title: 'Between', hasValue: true };
+const LTE_OPER = { name: 'lessThanOrEqual', title: '@general:terms.operators.less-than-or-equal', hasValue: true };
+const CONTAINS_OPER = { name: 'contains', title: '@general:terms.operators.contains', hasValue: true };
+const NOT_CONTAINS_OPER = { name: 'notContains', title: '@general:terms.operators.not-contains', hasValue: true };
+const IN_OPER = { name: 'in', title: '@general:terms.operators.in', hasValue: true };
+const STARTS_WITH_OPER = { name: 'startsWith', title: '@general:terms.operators.starts-with', hasValue: true };
+const ENDS_WITH_OPER = { name: 'endsWith', title: '@general:terms.operators.ends-with', hasValue: true };
+const IS_EMPTY_OPER = { name: 'isEmpty', title: '@general:terms.operators.is-empty', hasValue: false };
+const IS_NOT_EMPTY_OPER = { name: 'isNotEmpty', title: '@general:terms.operators.is-not-empty', hasValue: false };
+const BETWEEN_OPER = { name: 'between', title: '@general:terms.operators.between', hasValue: true };
 const STRING_OPERATORS = [
     EQ_OPER,
     NOT_EQ_OPER,
@@ -334,6 +328,7 @@ class AXPSettingDefinitionProviderService {
             return;
         }
         const context = new AXPSettingDefinitionProviderContext();
+        // Load providers from DI tokens
         if (Array.isArray(this.providers)) {
             for (const provider of this.providers) {
                 if (provider instanceof Promise) {
@@ -556,7 +551,7 @@ class AXPSettingValueProviderDefault {
     }
 }
 
-class AXPSettingService {
+class AXPSettingsService {
     constructor() {
         this.providers = inject(AXP_SETTING_VALUE_PROVIDER);
         this.injector = inject(Injector);
@@ -676,10 +671,10 @@ class AXPSettingService {
         this.onChanged.next(event);
         this.eventService.publish('AXPSettingChangedEvent', event);
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPSettingService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPSettingService, providedIn: 'root' }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPSettingsService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPSettingsService, providedIn: 'root' }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPSettingService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPSettingsService, decorators: [{
             type: Injectable,
             args: [{
                     providedIn: 'root',
@@ -735,9 +730,38 @@ class ScopedSettingService {
     }
 }
 
+/**
+ * Regional settings keys for date, time, and locale formatting.
+ * These keys are used by platform widgets and components to access regional settings.
+ * The actual setting definitions and providers are implemented in the locale-management module.
+ */
+var AXPRegionalSetting;
+(function (AXPRegionalSetting) {
+    AXPRegionalSetting["LocaleProfile"] = "LocaleManagement:Setting:Regional.LocaleProfile";
+    AXPRegionalSetting["TimeZone"] = "LocaleManagement:Setting:Regional.TimeZone";
+    AXPRegionalSetting["Language"] = "LocaleManagement:Setting:Regional.Language";
+    AXPRegionalSetting["Country"] = "LocaleManagement:Setting:Regional.Country";
+    AXPRegionalSetting["Calendar"] = "LocaleManagement:Setting:Regional.Calendar";
+    AXPRegionalSetting["FirstDayOfWeek"] = "LocaleManagement:Setting:Regional.FirstDayOfWeek";
+    AXPRegionalSetting["WeekendDays"] = "LocaleManagement:Setting:Regional.WeekendDays";
+    AXPRegionalSetting["ShortDate"] = "LocaleManagement:Setting:Regional.ShortDate";
+    AXPRegionalSetting["MediumDate"] = "LocaleManagement:Setting:Regional.MediumDate";
+    AXPRegionalSetting["LongDate"] = "LocaleManagement:Setting:Regional.LongDate";
+    AXPRegionalSetting["ShortTime"] = "LocaleManagement:Setting:Regional.ShortTime";
+    AXPRegionalSetting["MediumTime"] = "LocaleManagement:Setting:Regional.MediumTime";
+    AXPRegionalSetting["LongTime"] = "LocaleManagement:Setting:Regional.LongTime";
+    AXPRegionalSetting["MeasurementUnits"] = "LocaleManagement:Setting:Regional.MeasurementUnits";
+    AXPRegionalSetting["TemperatureUnits"] = "LocaleManagement:Setting:Regional.TemperatureUnits";
+    AXPRegionalSetting["DistanceUnits"] = "LocaleManagement:Setting:Regional.DistanceUnits";
+    AXPRegionalSetting["WeightUnits"] = "LocaleManagement:Setting:Regional.WeightUnits";
+    AXPRegionalSetting["VolumeUnits"] = "LocaleManagement:Setting:Regional.VolumeUnits";
+    AXPRegionalSetting["SpeedUnits"] = "LocaleManagement:Setting:Regional.SpeedUnits";
+    AXPRegionalSetting["AreaUnits"] = "LocaleManagement:Setting:Regional.AreaUnits";
+})(AXPRegionalSetting || (AXPRegionalSetting = {}));
+
 var AXPHomePageSettings;
 (function (AXPHomePageSettings) {
-    AXPHomePageSettings["UserHomePath"] = "general:startup:home-page";
+    AXPHomePageSettings["UserHomePath"] = "Common:Setting:Startup.HomePage";
 })(AXPHomePageSettings || (AXPHomePageSettings = {}));
 
 class AXPHomePageService {
@@ -748,7 +772,7 @@ class AXPHomePageService {
         this.defaultHomePageKey = inject(AXP_HOME_PAGE_DEFAULT_KEY, { optional: true }) ?? 'home';
         this.userHomePageKey = null;
         this.candidates = inject(AXP_HOME_PAGES, { optional: true }) ?? [];
-        this.settingsService = inject(AXPSettingService);
+        this.settingsService = inject(AXPSettingsService);
         this.sessionService = inject(AXPSessionService);
         this.injector = inject(Injector);
         this.originalConfig = null;
@@ -1081,43 +1105,61 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImpo
             args: [{ providedIn: 'root' }]
         }], ctorParameters: () => [{ type: i0.Injector }, { type: AXPErrorHandlerRegistryService }] });
 
-const AXP_GLOBAL_VARIABLE_DEFINITION_PROVIDER = new InjectionToken('AXP_GLOBAL_VARIABLE_DEFINITION_PROVIDER', {
+const AXP_TOKEN_DEFINITION_PROVIDER = new InjectionToken('AXP_TOKEN_DEFINITION_PROVIDER', {
     factory: () => [],
 });
 
 //#region ----   Imports   ----
 //#endregion
-class AXPGlobalVariableDefinitionService {
+class AXPTokenDefinitionService {
     constructor() {
         //#region ----   Providers & Caches   ----
-        this.definitionProviders = inject(AXP_GLOBAL_VARIABLE_DEFINITION_PROVIDER, { optional: true }) || [];
+        this.definitionProviders = inject(AXP_TOKEN_DEFINITION_PROVIDER, { optional: true }) || [];
         /** Cache for definitions by name. */
         this.definitionsByName = new Map();
     }
     //#endregion
     //#region ----   Public API   ----
     /**
-     * Returns a report definition by its id.
+     * Returns a token definition by its name.
      * First checks the cache, then queries all providers if not found.
-     * @param name The global variable name.
-     * @returns The global variable definition if found, undefined otherwise.
+     * @param name The token name.
+     * @returns The token definition if found, undefined otherwise.
      */
-    async getByName(name) {
+    async getDefinition(name) {
         // Check cache first
         if (this.definitionsByName.has(name)) {
             return this.definitionsByName.get(name);
         }
-        // Not in cache, query providers (each provider is itself a global variable definition)
+        // Not in cache, query providers
+        // Resolve all providers (some may be promises, some may be arrays)
         const resolvedProviders = await Promise.all(this.definitionProviders);
-        const match = resolvedProviders.find(def => def?.name === name);
+        // Flatten the array - some providers may be arrays of providers (e.g., dynamic token providers)
+        const flattenedProviders = [];
+        for (const provider of resolvedProviders) {
+            if (Array.isArray(provider)) {
+                // If provider is an array, add all items
+                flattenedProviders.push(...provider);
+            }
+            else if (provider) {
+                // If provider is a single provider, add it
+                flattenedProviders.push(provider);
+            }
+        }
+        const match = flattenedProviders.find(def => def?.name === name);
         if (match) {
             this.definitionsByName.set(name, match);
             return match;
         }
         return undefined;
     }
-    async execute(name) {
-        const definition = await this.getByName(name);
+    /**
+     * Gets the resolved value of a token by its name.
+     * @param name The token name.
+     * @returns The resolved token value, or undefined if the token is not found.
+     */
+    async getValue(name) {
+        const definition = await this.getDefinition(name);
         if (definition) {
             return await definition.execute();
         }
@@ -1129,24 +1171,24 @@ class AXPGlobalVariableDefinitionService {
     clearDefinitionsCache() {
         this.definitionsByName.clear();
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPGlobalVariableDefinitionService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPGlobalVariableDefinitionService, providedIn: 'root' }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPTokenDefinitionService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPTokenDefinitionService, providedIn: 'root' }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPGlobalVariableDefinitionService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPTokenDefinitionService, decorators: [{
             type: Injectable,
             args: [{
                     providedIn: 'root',
                 }]
         }] });
 
-class AXPGlobalVariableEvaluatorScopeProvider {
+class AXPTokenEvaluatorScopeProvider {
     constructor() {
-        this.globalVariableService = inject(AXPGlobalVariableDefinitionService);
+        this.tokenService = inject(AXPTokenDefinitionService);
     }
     async provide(context) {
-        context.addScope('variables', {
-            execute: async (name) => {
-                return await this.globalVariableService.execute(name);
+        context.addScope('tokens', {
+            get: async (name) => {
+                return await this.tokenService.getValue(name);
             }
         });
     }
@@ -1256,46 +1298,6 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImpo
                 type: Input
             }] } });
 
-class AXPLogoComponent {
-    constructor() {
-        this.platform = inject(AXPlatform);
-    }
-    ngOnInit() {
-        this.setLogoType();
-        this.platform.themeMode$.subscribe(() => {
-            this.setLogoTheme();
-        });
-    }
-    ngOnChanges() {
-        this.setLogoTheme();
-    }
-    setLogoType() {
-        switch (true) {
-            case this.source instanceof AXPImageUrlLogoConfig:
-                this.logoType = 'url';
-                break;
-            case this.source instanceof AXPComponentLogoConfig:
-                this.logoType = 'component';
-                break;
-            default:
-                break;
-        }
-    }
-    setLogoTheme() {
-        if (this.source && this.source.dark && this.source.light) {
-            this.source = this.platform.isDark() ? this.source.dark : this.source.light;
-        }
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPLogoComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
-    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "20.3.12", type: AXPLogoComponent, isStandalone: true, selector: "axp-logo", inputs: { source: "source" }, host: { classAttribute: "ax-flex ax-justify-center" }, usesOnChanges: true, ngImport: i0, template: "@switch (logoType) { @case ('url') {\n<ax-image [width]=\"source.width\" [height]=\"source.height\" [src]=\"source.url\"></ax-image>\n} @case ('component') {\n<ng-container *ngComponentOutlet=\"source.component\"></ng-container>\n} }\n", dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1.NgComponentOutlet, selector: "[ngComponentOutlet]", inputs: ["ngComponentOutlet", "ngComponentOutletInputs", "ngComponentOutletInjector", "ngComponentOutletEnvironmentInjector", "ngComponentOutletContent", "ngComponentOutletNgModule", "ngComponentOutletNgModuleFactory"], exportAs: ["ngComponentOutlet"] }, { kind: "ngmodule", type: AXImageModule }, { kind: "component", type: i2.AXImageComponent, selector: "ax-image", inputs: ["width", "height", "overlayMode", "src", "alt", "priority", "lazy"], outputs: ["onLoad", "onError"] }, { kind: "ngmodule", type: AXDecoratorModule }] }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPLogoComponent, decorators: [{
-            type: Component,
-            args: [{ selector: 'axp-logo', imports: [CommonModule, AXImageModule, AXDecoratorModule], host: { class: 'ax-flex ax-justify-center' }, template: "@switch (logoType) { @case ('url') {\n<ax-image [width]=\"source.width\" [height]=\"source.height\" [src]=\"source.url\"></ax-image>\n} @case ('component') {\n<ng-container *ngComponentOutlet=\"source.component\"></ng-container>\n} }\n" }]
-        }], propDecorators: { source: [{
-                type: Input
-            }] } });
-
 //#region ----   Menu Context Builder   ----
 /**
  * Creates a rich context for menu manipulation
@@ -1627,6 +1629,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImpo
         }] });
 
 const AXP_MENU_PROVIDER = new InjectionToken('AXP_MENU_PROVIDER');
+//TODO: check performance of this service
 class AXPMenuProviderService {
     constructor() {
         //#region ----   Dependencies   ----
@@ -1658,9 +1661,18 @@ class AXPMenuProviderService {
         }
         const items = [];
         const context = this.createMenuProviderContext(items);
+        // Load providers from DI tokens
         if (Array.isArray(this.providers)) {
             for (const provider of this.providers) {
-                await provider.provide(context);
+                if (provider instanceof Promise) {
+                    // If provider is a promise, resolve it
+                    const resolvedProvider = await provider;
+                    await resolvedProvider.provide(context);
+                }
+                else {
+                    // If provider is a direct instance, use it directly
+                    await provider.provide(context);
+                }
             }
         }
         // Apply pending operations
@@ -1682,9 +1694,18 @@ class AXPMenuProviderService {
     async rawItems() {
         const items = [];
         const context = this.createMenuProviderContext(items);
+        // Load providers from DI tokens
         if (Array.isArray(this.providers)) {
             for (const provider of this.providers) {
-                await provider.provide(context);
+                if (provider instanceof Promise) {
+                    // If provider is a promise, resolve it
+                    const resolvedProvider = await provider;
+                    await resolvedProvider.provide(context);
+                }
+                else {
+                    // If provider is a direct instance, use it directly
+                    await provider.provide(context);
+                }
             }
         }
         // Apply pending operations
@@ -1732,10 +1753,29 @@ class AXPMenuProviderService {
     createMenuProviderContext(items) {
         return {
             addItems: (newItems) => {
-                items.push(...newItems);
+                for (const newItem of newItems) {
+                    if (newItem.name) {
+                        const existingItem = this.findItemByName(items, newItem.name);
+                        if (existingItem) {
+                            // Update existing item, merging properties
+                            this.mergeMenuItem(existingItem, newItem);
+                        }
+                        else {
+                            // Add new item if it doesn't exist
+                            items.push(newItem);
+                        }
+                    }
+                    else {
+                        // Add item without name (no way to check for duplicates)
+                        items.push(newItem);
+                    }
+                }
             },
             find: (target) => {
+                const foundItemInfo = this.findItemWithParent(items, target);
+                const exists = foundItemInfo.foundItem !== null;
                 return {
+                    exists,
                     insert: (newItems, position) => {
                         this.pendingInserts.push({ target, newItems, position });
                     },
@@ -1761,13 +1801,48 @@ class AXPMenuProviderService {
                 items.push(...newItems);
             }
             else {
-                if (position == 'inside') {
-                    foundItem.children?.push(...newItems);
+                if (position === 'inside') {
+                    if (!foundItem.children) {
+                        foundItem.children = [];
+                    }
+                    // Check for duplicates by name and merge or add
+                    for (const newItem of newItems) {
+                        if (newItem.name) {
+                            const existingChild = this.findItemByName(foundItem.children, newItem.name);
+                            if (existingChild) {
+                                this.mergeMenuItem(existingChild, newItem);
+                            }
+                            else {
+                                foundItem.children.push(newItem);
+                            }
+                        }
+                        else {
+                            foundItem.children.push(newItem);
+                        }
+                    }
                 }
                 else {
-                    const index = parentItems.indexOf(foundItem);
-                    const insertPosition = position === 'before' ? index : index + 1;
-                    parentItems.splice(insertPosition, 0, ...newItems);
+                    // For 'before' and 'after', check for duplicates in parent items
+                    const itemsToInsert = [];
+                    for (const newItem of newItems) {
+                        if (newItem.name) {
+                            const existingItem = this.findItemByName(parentItems, newItem.name);
+                            if (existingItem) {
+                                this.mergeMenuItem(existingItem, newItem);
+                            }
+                            else {
+                                itemsToInsert.push(newItem);
+                            }
+                        }
+                        else {
+                            itemsToInsert.push(newItem);
+                        }
+                    }
+                    if (itemsToInsert.length > 0) {
+                        const index = parentItems.indexOf(foundItem);
+                        const insertPosition = position === 'before' ? index : index + 1;
+                        parentItems.splice(insertPosition, 0, ...itemsToInsert);
+                    }
                 }
             }
         }
@@ -1802,7 +1877,21 @@ class AXPMenuProviderService {
                 if (!foundItem.children) {
                     foundItem.children = [];
                 }
-                foundItem.children.push(...newItems);
+                // Check for duplicates by name and merge or add
+                for (const newItem of newItems) {
+                    if (newItem.name) {
+                        const existingChild = this.findItemByName(foundItem.children, newItem.name);
+                        if (existingChild) {
+                            this.mergeMenuItem(existingChild, newItem);
+                        }
+                        else {
+                            foundItem.children.push(newItem);
+                        }
+                    }
+                    else {
+                        foundItem.children.push(newItem);
+                    }
+                }
             }
         }
         // Clear pending operations after applying them
@@ -1825,6 +1914,70 @@ class AXPMenuProviderService {
         }
         return { foundItem: null, parentItems: items };
     }
+    /**
+     * Find menu item by name in the items tree (recursive search)
+     */
+    findItemByName(items, name) {
+        for (const item of items) {
+            if (item.name === name) {
+                return item;
+            }
+            if (item.children) {
+                const found = this.findItemByName(item.children, name);
+                if (found) {
+                    return found;
+                }
+            }
+        }
+        return null;
+    }
+    /**
+     * Merge new item properties into existing item, handling children merge
+     */
+    mergeMenuItem(existingItem, newItem) {
+        // Merge top-level properties (newItem properties override existing only if defined)
+        if (newItem.text !== undefined)
+            existingItem.text = newItem.text;
+        if (newItem.description !== undefined)
+            existingItem.description = newItem.description;
+        if (newItem.icon !== undefined)
+            existingItem.icon = newItem.icon;
+        if (newItem.path !== undefined)
+            existingItem.path = newItem.path;
+        if (newItem.priority !== undefined)
+            existingItem.priority = newItem.priority;
+        if (newItem.type !== undefined)
+            existingItem.type = newItem.type;
+        if (newItem.command !== undefined)
+            existingItem.command = newItem.command;
+        if (newItem.badgeKey !== undefined)
+            existingItem.badgeKey = newItem.badgeKey;
+        if (newItem.data !== undefined)
+            existingItem.data = newItem.data;
+        if (newItem.policy !== undefined)
+            existingItem.policy = newItem.policy;
+        // Merge children if both have children
+        if (newItem.children && newItem.children.length > 0) {
+            if (!existingItem.children) {
+                existingItem.children = [];
+            }
+            // For each child in newItem, check if it exists by name and merge or add
+            for (const newChild of newItem.children) {
+                if (newChild.name) {
+                    const existingChild = this.findItemByName(existingItem.children, newChild.name);
+                    if (existingChild) {
+                        this.mergeMenuItem(existingChild, newChild);
+                    }
+                    else {
+                        existingItem.children.push(newChild);
+                    }
+                }
+                else {
+                    existingItem.children.push(newChild);
+                }
+            }
+        }
+    }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPMenuProviderService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
     static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPMenuProviderService, providedIn: 'root' }); }
 }
@@ -2051,6 +2204,105 @@ withMethods((store, router = inject(Router), workflow = inject(AXPWorkflowServic
     };
 }));
 
+/**
+ * Service for checking menu item visibility based on permissions, features, and children.
+ * This service helps filter out empty menu items that have no visible children.
+ */
+class AXPMenuVisibilityService {
+    constructor() {
+        this.sessionService = inject(AXPSessionService);
+    }
+    /**
+     * Checks if a menu item should be visible based on permissions and features.
+     */
+    isItemVisible(item) {
+        const policy = item.policy;
+        if (!policy) {
+            return true; // No policy means visible
+        }
+        // Check features
+        if (policy.features && policy.features.length > 0) {
+            const featureKeys = Array.isArray(policy.features) ? policy.features : [policy.features];
+            if (!this.sessionService.isFeatureEnabled(...featureKeys)) {
+                return false;
+            }
+        }
+        // Check permissions
+        if (policy.permissions && policy.permissions.length > 0) {
+            const permissionKeys = Array.isArray(policy.permissions) ? policy.permissions : [policy.permissions];
+            if (!this.sessionService.authorize(...permissionKeys)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    /**
+     * Recursively checks if a menu item has any visible children.
+     * @param item The menu item to check
+     * @param getRouterLink Optional function to check if an item has a router link
+     */
+    hasVisibleChildren(item, getRouterLink) {
+        if (!item.children || item.children.length === 0) {
+            return false;
+        }
+        return item.children.some((child) => {
+            // Check if child itself is visible
+            if (!this.isItemVisible(child)) {
+                return false;
+            }
+            // If child has a routerLink, it's visible
+            if (getRouterLink && getRouterLink(child)) {
+                return true;
+            }
+            // If child has visible children, it's visible
+            if (this.hasVisibleChildren(child, getRouterLink)) {
+                return true;
+            }
+            // For items without routerLink, check if they have a command (non-empty menu items)
+            if (child.command) {
+                return true;
+            }
+            return false;
+        });
+    }
+    /**
+     * Determines if a menu item should be rendered.
+     * A menu item should be rendered if:
+     * 1. It has a routerLink, OR
+     * 2. It has visible children, OR
+     * 3. It has a command (for non-router navigation)
+     *
+     * @param item The menu item to check
+     * @param getRouterLink Optional function to check if an item has a router link
+     */
+    shouldRenderMenuItem(item, getRouterLink) {
+        // Check if item itself is visible (permissions/features)
+        if (!this.isItemVisible(item)) {
+            return false;
+        }
+        // If it has a routerLink, render it
+        if (getRouterLink && getRouterLink(item)) {
+            return true;
+        }
+        // If it has visible children, render it
+        if (this.hasVisibleChildren(item, getRouterLink)) {
+            return true;
+        }
+        // If it has a command (for non-router navigation), render it
+        if (item.command) {
+            return true;
+        }
+        // Otherwise, don't render empty menu items
+        return false;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPMenuVisibilityService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPMenuVisibilityService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPMenuVisibilityService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+
 class AXPMenuSearchDefinitionProvider {
     async provide(context) {
         context.addDefinition('menu', 'Menu', 'menu', 'fa-thin fa-bars', 2, {
@@ -2252,11 +2504,14 @@ class AXPSearchDefinitionProviderService {
             return;
         }
         const context = new AXPSearchDefinitionProviderContext();
+        // Load providers from DI tokens (backward compatibility)
         if (Array.isArray(this.providers)) {
             for (const provider of this.providers) {
                 await provider.provide(context);
             }
         }
+        // Note: Search definition providers are different from search command providers
+        // Search command providers are handled separately in search.service.ts
         this.cache = context.getDefinitions();
     }
     async getListAsync() {
@@ -2312,11 +2567,20 @@ class AXPSearchService {
         if (this.definitionService.getList().length == 0) {
             await this.definitionService.getListAsync();
         }
-        if (!this.providers || (this.providers?.length || 0) === 0) {
-            throw new Error('No search providers available'); // No providers available
+        // Collect providers from DI tokens
+        const allProviders = [];
+        // Load from DI tokens
+        if (Array.isArray(this.providers)) {
+            allProviders.push(...this.providers);
+        }
+        else if (this.providers) {
+            allProviders.push(this.providers);
+        }
+        if (allProviders.length === 0) {
+            throw new Error('No search providers available');
         }
         const mergeData = [];
-        const promises = this.providers.map((provider) => provider.search(text));
+        const promises = allProviders.map((provider) => provider.search(text));
         const results = await Promise.all(promises);
         for (const resultArray of results) {
             for (const result of resultArray) {
@@ -2382,8 +2646,8 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImpo
 
 var AXPCommonSettings;
 (function (AXPCommonSettings) {
-    AXPCommonSettings["EnableOperationToasts"] = "general:notifications:enable-operation-toasts";
-    AXPCommonSettings["EntityFilterApplyMode"] = "general:entity:filter-apply-mode";
+    AXPCommonSettings["EnableOperationToasts"] = "Common:Setting:Notifications.EnableOperationToasts";
+    AXPCommonSettings["EntityFilterApplyMode"] = "Common:Setting:Entity.FilterApplyMode";
 })(AXPCommonSettings || (AXPCommonSettings = {}));
 
 //TODO Loading, Redirect, Drawer, Show toast
@@ -2438,10 +2702,10 @@ class AXPToastAction extends AXPWorkflowAction {
         super(...arguments);
         this.toastService = inject(AXToastService);
         this.translationService = inject(AXTranslationService);
-        this.settingService = inject(AXPSettingService);
+        this.settingsService = inject(AXPSettingsService);
     }
     async execute(context) {
-        const showResult = await this.settingService.get(AXPCommonSettings.EnableOperationToasts);
+        const showResult = await this.settingsService.get(AXPCommonSettings.EnableOperationToasts);
         if (showResult) {
             this.toastService.show({
                 color: this.color,
@@ -2577,23 +2841,16 @@ class AXPCommonModule {
     /**
      * @ignore
      */
-    constructor(instances, appInitService, settingsService) {
+    constructor(instances) {
         instances.forEach((f) => {
             f();
         });
-        appInitService.registerTask({
-            name: 'Settings',
-            statusText: 'Loading Settings ...',
-            priority: 2,
-            run: async () => {
-                await settingsService.load();
-            },
-        });
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPCommonModule, deps: [{ token: 'AXPCommonModuleFactory' }, { token: i1$1.AXPAppStartUpService }, { token: AXPSettingService }], target: i0.ɵɵFactoryTarget.NgModule }); }
-    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "20.3.12", ngImport: i0, type: AXPCommonModule, imports: [i3.AXPWorkflowModule, AXPopupModule,
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPCommonModule, deps: [{ token: 'AXPCommonModuleFactory' }], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "20.3.12", ngImport: i0, type: AXPCommonModule, imports: [i1.AXPWorkflowModule, AXPopupModule,
             AXDateTimeModule,
-            AXToastModule], exports: [RouterModule] }); }
+            AXToastModule,
+            AXPModuleManifestModule], exports: [RouterModule] }); }
     static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPCommonModule, providers: [
             AXPAppStartUpProvider,
             {
@@ -2620,7 +2877,7 @@ class AXPCommonModule {
             },
             {
                 provide: AXP_EXPRESSION_EVALUATOR_SCOPE_PROVIDER,
-                useClass: AXPGlobalVariableEvaluatorScopeProvider,
+                useClass: AXPTokenEvaluatorScopeProvider,
                 multi: true,
             },
             {
@@ -2645,7 +2902,8 @@ class AXPCommonModule {
             }),
             AXPopupModule,
             AXDateTimeModule,
-            AXToastModule, RouterModule] }); }
+            AXToastModule,
+            AXPModuleManifestModule, RouterModule] }); }
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPCommonModule, decorators: [{
             type: NgModule,
@@ -2665,6 +2923,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImpo
                         AXPopupModule,
                         AXDateTimeModule,
                         AXToastModule,
+                        AXPModuleManifestModule,
                     ],
                     exports: [RouterModule],
                     providers: [
@@ -2693,7 +2952,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImpo
                         },
                         {
                             provide: AXP_EXPRESSION_EVALUATOR_SCOPE_PROVIDER,
-                            useClass: AXPGlobalVariableEvaluatorScopeProvider,
+                            useClass: AXPTokenEvaluatorScopeProvider,
                             multi: true,
                         },
                         {
@@ -2710,7 +2969,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImpo
         }], ctorParameters: () => [{ type: undefined, decorators: [{
                     type: Inject,
                     args: ['AXPCommonModuleFactory']
-                }] }, { type: i1$1.AXPAppStartUpService }, { type: AXPSettingService }] });
+                }] }] });
 
 const ENVIRONMENT = new InjectionToken('ENVIRONMENT');
 const AXP_PLATFORM_CONFIG_TOKEN = new InjectionToken('AXP_PLATFORM_CONFIG_TOKEN', {
@@ -2782,6 +3041,541 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImpo
             type: Injectable
         }] });
 
+/**
+ * Status Definition Types
+ * Defines the structure for status definitions and their transitions
+ */
+/**
+ * Abstract class for status providers
+ * Similar to AXPTaskBadgeProvider pattern
+ */
+class AXPStatusProvider {
+}
+//#endregion
+
+//#region ----   Injection Token   ----
+/**
+ * Injection token for status providers
+ * Use with multi: true to register multiple providers
+ */
+const AXP_STATUS_PROVIDERS = new InjectionToken('AXP_STATUS_PROVIDERS');
+//#endregion
+//#region ----   Provider Service   ----
+/**
+ * Service for managing status definitions from multiple providers
+ * Similar to AXPTaskBadgeService pattern - no cache, direct access
+ *
+ * @example
+ * ```typescript
+ * // In a module providers array:
+ * {
+ *   provide: AXP_STATUS_PROVIDERS,
+ *   useClass: TaskStatusProvider,
+ *   multi: true,
+ * }
+ *
+ * // Example provider implementation:
+ * export class TaskStatusProvider extends AXPStatusProvider {
+ *   readonly key = 'task-management.status';
+ *   readonly statuses = [
+ *     { name: 'todo', title: 'To Do', color: '#6b7280', icon: 'fa-light fa-circle', isInitial: true },
+ *     { name: 'in-progress', title: 'In Progress', color: '#3b82f6', icon: 'fa-light fa-play' },
+ *     { name: 'done', title: 'Done', color: '#10b981', icon: 'fa-light fa-check-circle', isFinal: true },
+ *   ];
+ *   readonly transitions = [
+ *     { from: 'todo', to: 'in-progress', title: 'Start', condition: '{{user.canEdit}}' },
+ *     { from: 'in-progress', to: 'done', title: 'Complete' },
+ *   ];
+ *   readonly defaultStatus = 'todo';
+ * }
+ *
+ * // Later, get the status:
+ * const status = statusService.getStatus('task-management.status');
+ * if (status) {
+ *   console.log('Statuses:', status.statuses);
+ *   console.log('Transitions:', status.transitions);
+ * }
+ * ```
+ */
+class AXPStatusDefinitionProviderService {
+    //#endregion
+    //#region ----   Initialization   ----
+    constructor() {
+        //#region ----   Dependencies   ----
+        this.providers = inject(AXP_STATUS_PROVIDERS, { optional: true }) ?? [];
+        this.commandService = inject(AXPCommandService);
+        //#endregion
+        //#region ----   State   ----
+        this.statusMap = new Map();
+        this.initializationPromise = null;
+        this.isInitialized = false;
+        this.initialize();
+    }
+    /**
+     * Initialize providers (resolve promises if needed)
+     * Called lazily on first access
+     */
+    async initialize() {
+        if (this.isInitialized) {
+            return;
+        }
+        if (this.initializationPromise) {
+            return this.initializationPromise;
+        }
+        this.initializationPromise = this._doInitialize();
+        await this.initializationPromise;
+    }
+    async _doInitialize() {
+        // Register all providers, resolving promises if needed
+        for (const provider of this.providers) {
+            let resolvedProvider;
+            if (provider instanceof Promise) {
+                // If provider is a promise, resolve it
+                resolvedProvider = await provider;
+            }
+            else {
+                // If provider is a direct instance, use it directly
+                resolvedProvider = provider;
+            }
+            if (this.statusMap.has(resolvedProvider.key)) {
+                console.warn(`Status with key "${resolvedProvider.key}" already exists. Overwriting with new status.`);
+            }
+            this.statusMap.set(resolvedProvider.key, resolvedProvider);
+        }
+        this.isInitialized = true;
+    }
+    //#endregion
+    //#region ----   Public API   ----
+    /**
+     * Get a status provider by key
+     * Direct synchronous access from Map. Providers are initialized in the constructor,
+     * including lazy-loaded providers (promises) which are resolved during initialization.
+     *
+     * @param key - Status key (e.g., 'task-management.status')
+     * @returns Status provider with all statuses and transitions, or undefined if not found
+     *
+     * @example
+     * ```typescript
+     * const status = statusService.getStatus('task-management.status');
+     * if (status) {
+     *   console.log('Statuses:', status.statuses);
+     *   console.log('Transitions:', status.transitions);
+     * }
+     * ```
+     */
+    getStatus(key) {
+        return this.statusMap.get(key);
+    }
+    /**
+     * Execute a status transition workflow action
+     * Uses transition.command if provided, otherwise defaults to Entity:UpdateStatus
+     * Validates the transition is allowed before executing
+     *
+     * @param definitionKey - Status definition key
+     * @param transition - The transition to execute
+     * @param context - Context data for the command (must include entity name and id/ids)
+     * @returns Promise that resolves when the command execution completes
+     *
+     * @example
+     * ```typescript
+     * await statusService.executeTransition(
+     *   'task-management.status',
+     *   { from: 'todo', to: 'in-progress' },
+     *   { entity: 'TaskManagement.Task', id: '123', ...entityData }
+     * );
+     * ```
+     */
+    async executeTransition(definitionKey, transition, context) {
+        await this.initialize();
+        const provider = this.statusMap.get(definitionKey);
+        if (!provider) {
+            throw new Error(`Status provider with key "${definitionKey}" not found.`);
+        }
+        // Validate transition is allowed
+        if (!this.isValidTransition(provider, transition.from, transition.to)) {
+            throw new Error(`Invalid transition from "${transition.from}" to "${transition.to}"`);
+        }
+        // Determine which command to use
+        let commandName;
+        let commandOptions;
+        if (transition.command) {
+            // Use transition's explicit command
+            commandName = transition.command.name;
+            commandOptions = {
+                ...(transition.command.options ?? {}),
+                ...context,
+            };
+        }
+        else {
+            // Use default Entity:UpdateStatus command
+            const entity = context['entityName'] ?? context['__meta__']?.config?.name;
+            if (!entity) {
+                throw new Error('Entity name is required in context when using default status update command');
+            }
+            const id = context['id'];
+            const ids = context['ids'];
+            if (!id && !ids) {
+                throw new Error('Either id or ids must be provided in context');
+            }
+            commandName = 'Entity:UpdateStatus';
+            commandOptions = {
+                entity,
+                status: transition.to,
+                statusField: context['statusField'] ?? 'statusId',
+                ...(id ? { id } : {}),
+                ...(ids ? { ids } : {}),
+            };
+        }
+        // Execute the command
+        const result = await this.commandService.execute(commandName, commandOptions);
+        if (!result?.success) {
+            throw new Error(result?.message?.text || 'Failed to execute status transition command');
+        }
+    }
+    /**
+     * Validate if a transition is allowed
+     * Checks if the transition exists in the provider's transitions list
+     */
+    isValidTransition(provider, from, to) {
+        return provider.transitions.some((transition) => transition.from === from && transition.to === to);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPStatusDefinitionProviderService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPStatusDefinitionProviderService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPStatusDefinitionProviderService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [] });
+
+/**
+ * Standard system status types
+ * These are the predefined status values used across the platform
+ */
+var AXPSystemStatusType;
+(function (AXPSystemStatusType) {
+    AXPSystemStatusType["Todo"] = "todo";
+    AXPSystemStatusType["InProgress"] = "in-progress";
+    AXPSystemStatusType["InReview"] = "in-review";
+    AXPSystemStatusType["Open"] = "open";
+    AXPSystemStatusType["Closed"] = "closed";
+    AXPSystemStatusType["Blocked"] = "blocked";
+    AXPSystemStatusType["Done"] = "done";
+    AXPSystemStatusType["Cancelled"] = "cancelled";
+    AXPSystemStatusType["Draft"] = "draft";
+    AXPSystemStatusType["PendingReview"] = "pending-review";
+    AXPSystemStatusType["Approved"] = "approved";
+    AXPSystemStatusType["Published"] = "published";
+    AXPSystemStatusType["Archived"] = "archived";
+    AXPSystemStatusType["Rejected"] = "rejected";
+    AXPSystemStatusType["Active"] = "active";
+    AXPSystemStatusType["Inactive"] = "inactive";
+    AXPSystemStatusType["Pending"] = "pending";
+    AXPSystemStatusType["Completed"] = "completed";
+    AXPSystemStatusType["Suspended"] = "suspended";
+    AXPSystemStatusType["Failed"] = "failed";
+    AXPSystemStatusType["Review"] = "review";
+    AXPSystemStatusType["Expired"] = "expired";
+})(AXPSystemStatusType || (AXPSystemStatusType = {}));
+const i18n = (key) => `@general:statuses.${key}`;
+/**
+ * Standard system status definitions
+ * Provides consistent status definitions across the platform
+ * Uses AXPStatusDefinition interface from status-definition.types.ts
+ */
+const AXPSystemStatuses = Object.freeze({
+    Open: {
+        name: AXPSystemStatusType.Open,
+        title: i18n('open.title'),
+        icon: 'fa-light fa-circle',
+        color: 'secondary',
+        description: i18n('open.description'),
+        order: 1,
+        isInitial: true,
+        isFinal: false,
+    },
+    Closed: {
+        name: AXPSystemStatusType.Closed,
+        title: i18n('closed.title'),
+        icon: 'fa-light fa-circle',
+        color: 'danger',
+        description: i18n('closed.description'),
+        order: 2,
+        isInitial: false,
+        isFinal: true,
+    },
+    Todo: {
+        name: AXPSystemStatusType.Todo,
+        title: i18n('todo.title'),
+        icon: 'fa-light fa-circle',
+        color: 'secondary',
+        description: i18n('todo.description'),
+        order: 1,
+        isInitial: true,
+        isFinal: false,
+    },
+    InProgress: {
+        name: AXPSystemStatusType.InProgress,
+        title: i18n('in-progress.title'),
+        icon: 'fa-light fa-play',
+        color: 'info',
+        description: i18n('in-progress.description'),
+        order: 2,
+        isInitial: false,
+        isFinal: false,
+    },
+    InReview: {
+        name: AXPSystemStatusType.InReview,
+        title: i18n('in-review.title'),
+        icon: 'fa-light fa-eye',
+        color: 'info',
+        description: i18n('in-review.description'),
+        order: 3,
+        isInitial: false,
+        isFinal: false,
+    },
+    Blocked: {
+        name: AXPSystemStatusType.Blocked,
+        title: i18n('blocked.title'),
+        icon: 'fa-light fa-ban',
+        color: 'danger',
+        description: i18n('blocked.description'),
+        order: 4,
+        isInitial: false,
+        isFinal: false,
+    },
+    Done: {
+        name: AXPSystemStatusType.Done,
+        title: i18n('done.title'),
+        icon: 'fa-light fa-check-circle',
+        color: 'success',
+        description: i18n('done.description'),
+        order: 5,
+        isInitial: false,
+        isFinal: true,
+    },
+    Cancelled: {
+        name: AXPSystemStatusType.Cancelled,
+        title: i18n('cancelled.title'),
+        icon: 'fa-light fa-times-circle',
+        color: 'neutral',
+        description: i18n('cancelled.description'),
+        order: 6,
+        isInitial: false,
+        isFinal: true,
+    },
+    Draft: {
+        name: AXPSystemStatusType.Draft,
+        title: i18n('draft.title'),
+        icon: 'fa-light fa-file-pen',
+        color: 'neutral',
+        description: i18n('draft.description'),
+        order: 1,
+        isInitial: true,
+        isFinal: false,
+    },
+    PendingReview: {
+        name: AXPSystemStatusType.PendingReview,
+        title: i18n('pending-review.title'),
+        icon: 'fa-light fa-clock',
+        color: 'warning',
+        description: i18n('pending-review.description'),
+        order: 2,
+        isInitial: false,
+        isFinal: false,
+    },
+    Approved: {
+        name: AXPSystemStatusType.Approved,
+        title: i18n('approved.title'),
+        icon: 'fa-light fa-check-circle',
+        color: 'success',
+        description: i18n('approved.description'),
+        order: 3,
+        isInitial: false,
+        isFinal: false,
+    },
+    Published: {
+        name: AXPSystemStatusType.Published,
+        title: i18n('published.title'),
+        icon: 'fa-light fa-globe',
+        color: 'primary',
+        description: i18n('published.description'),
+        order: 4,
+        isInitial: false,
+        isFinal: false,
+    },
+    Archived: {
+        name: AXPSystemStatusType.Archived,
+        title: i18n('archived.title'),
+        icon: 'fa-light fa-archive',
+        color: 'danger',
+        description: i18n('archived.description'),
+        order: 5,
+        isInitial: false,
+        isFinal: true,
+    },
+    Rejected: {
+        name: AXPSystemStatusType.Rejected,
+        title: i18n('rejected.title'),
+        icon: 'fa-light fa-times-circle',
+        color: 'danger',
+        description: i18n('rejected.description'),
+        order: 6,
+        isInitial: false,
+        isFinal: true,
+    },
+    Active: {
+        name: AXPSystemStatusType.Active,
+        title: i18n('active.title'),
+        icon: 'fa-light fa-check-circle',
+        color: 'success',
+        description: i18n('active.description'),
+        order: 1,
+        isInitial: false,
+        isFinal: false,
+    },
+    Inactive: {
+        name: AXPSystemStatusType.Inactive,
+        title: i18n('inactive.title'),
+        icon: 'fa-light fa-circle',
+        color: 'secondary',
+        description: i18n('inactive.description'),
+        order: 2,
+        isInitial: false,
+        isFinal: false,
+    },
+    Pending: {
+        name: AXPSystemStatusType.Pending,
+        title: i18n('pending.title'),
+        icon: 'fa-light fa-clock',
+        color: 'warning',
+        description: i18n('pending.description'),
+        order: 1,
+        isInitial: true,
+        isFinal: false,
+    },
+    Completed: {
+        name: AXPSystemStatusType.Completed,
+        title: i18n('completed.title'),
+        icon: 'fa-light fa-check-circle',
+        color: 'success',
+        description: i18n('completed.description'),
+        order: 10,
+        isInitial: false,
+        isFinal: true,
+    },
+    Suspended: {
+        name: AXPSystemStatusType.Suspended,
+        title: i18n('suspended.title'),
+        icon: 'fa-light fa-pause-circle',
+        color: 'neutral',
+        description: i18n('suspended.description'),
+        order: 5,
+        isInitial: false,
+        isFinal: false,
+    },
+    Failed: {
+        name: AXPSystemStatusType.Failed,
+        title: i18n('failed.title'),
+        icon: 'fa-light fa-xmark-circle',
+        color: 'danger',
+        description: i18n('failed.description'),
+        order: 10,
+        isInitial: false,
+        isFinal: true,
+    },
+    Review: {
+        name: AXPSystemStatusType.Review,
+        title: i18n('review.title'),
+        icon: 'fa-light fa-eye',
+        color: 'info',
+        description: i18n('review.description'),
+        order: 3,
+    },
+    Expired: {
+        name: AXPSystemStatusType.Expired,
+        title: i18n('expired.title'),
+        icon: 'fa-light fa-clock',
+        color: 'danger',
+        description: i18n('expired.description'),
+        order: 10,
+        isInitial: false,
+        isFinal: true,
+    },
+});
+/**
+ * Get system status definition by type
+ * @param type - Status type
+ * @returns System status definition or undefined
+ */
+function getSystemStatus(type) {
+    return Object.values(AXPSystemStatuses).find(status => status.name === type);
+}
+/**
+ * Resolves the visual appearance (color and icon) for status
+ * using the system statuses from the core module.
+ * @param statusType - Status type string
+ * @returns Color and icon for the status
+ */
+function resolveStatusLook(statusType) {
+    // Try to get system status first
+    const systemStatusType = statusType;
+    if (systemStatusType) {
+        const systemStatus = getSystemStatus(systemStatusType);
+        if (systemStatus) {
+            // Convert hex color to semantic color type if needed
+            // For now, return as-is and let the UI handle it
+            return {
+                color: systemStatus.color,
+                icon: systemStatus.icon || ''
+            };
+        }
+    }
+    // Fallback for unknown statuses
+    return {
+        color: 'secondary',
+        icon: ''
+    };
+}
+/**
+ * Resolves the complete status information (title, description, icon, color) for a status
+ * using the system statuses from the core module.
+ * @param statusType - Status type string
+ * @returns Complete status information as AXPStatusDefinition
+ */
+function getStatusInfo(statusType) {
+    const systemStatusType = statusType;
+    if (systemStatusType) {
+        const systemStatus = getSystemStatus(systemStatusType);
+        if (systemStatus) {
+            return systemStatus;
+        }
+    }
+    // Fallback for unknown statuses
+    return {
+        name: statusType,
+        title: statusType,
+        description: `Status: ${statusType}`,
+        icon: '',
+        color: 'secondary'
+    };
+}
+/**
+ * Get system status definition directly (no conversion needed since it's already AXPStatusDefinition)
+ * @param statusType - Status type
+ * @param overrides - Optional overrides for the status definition
+ * @returns AXPStatusDefinition
+ */
+function systemStatusToDefinition(statusType, overrides) {
+    const systemStatus = getSystemStatus(statusType);
+    if (!systemStatus) {
+        throw new Error(`System status ${statusType} not found`);
+    }
+    return {
+        ...systemStatus,
+        ...overrides,
+    };
+}
+
 class AXPClipBoardService {
     constructor() {
         this.toast = inject(AXToastService);
@@ -2805,6 +3599,123 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImpo
                 }]
         }] });
 
+//#region ----   Imports   ----
+//#endregion
+//#region ----   Debug Service   ----
+/**
+ * Service for debugging user access information.
+ * Displays loaded modules, features, and permissions for the current user.
+ */
+class AXPDebugService {
+    constructor() {
+        //#region ----   Services & Dependencies   ----
+        this.sessionService = inject(AXPSessionService);
+        this.manifestRegistry = inject(AXPModuleManifestRegistry);
+    }
+    //#endregion
+    //#region ----   Public Methods   ----
+    /**
+     * Display all loaded modules, features, and permissions for the current user.
+     */
+    async displayUserAccessInfo() {
+        try {
+            // Ensure registry is initialized
+            await this.manifestRegistry.initialize();
+            // Get all registered modules
+            const allManifests = this.manifestRegistry.getAll();
+            // Get all feature definitions
+            const allFeatures = this.manifestRegistry.getAllFeatureDefinitions();
+            // Get current user permissions
+            const userPermissions = this.sessionService.permissions;
+            const user = this.sessionService.user;
+            console.group('🔐 User Access Information');
+            console.log(`User: ${user?.name || user?.title || 'Unknown'} (${user?.id || 'N/A'})`);
+            console.log('');
+            if (allManifests.length === 0) {
+                console.log('No modules loaded');
+                console.groupEnd();
+                return;
+            }
+            // Group features by module
+            const featuresByModule = new Map();
+            allFeatures.forEach((feature) => {
+                const moduleName = feature.module;
+                if (!featuresByModule.has(moduleName)) {
+                    featuresByModule.set(moduleName, []);
+                }
+                featuresByModule.get(moduleName).push(feature);
+            });
+            // Group permissions by module (if they follow ModuleName:PermissionKey pattern)
+            const permissionsByModule = new Map();
+            const ungroupedPermissions = [];
+            userPermissions.forEach((permission) => {
+                const parts = permission.split(':');
+                if (parts.length >= 2) {
+                    const moduleName = parts[0];
+                    if (!permissionsByModule.has(moduleName)) {
+                        permissionsByModule.set(moduleName, []);
+                    }
+                    permissionsByModule.get(moduleName).push(permission);
+                }
+                else {
+                    ungroupedPermissions.push(permission);
+                }
+            });
+            // Display modules in tree format
+            allManifests.forEach((manifest) => {
+                const moduleName = manifest.name;
+                const moduleFeatures = featuresByModule.get(moduleName) || [];
+                const modulePermissions = permissionsByModule.get(moduleName) || [];
+                console.group(`📦 ${moduleName}`);
+                // Display Features
+                if (moduleFeatures.length > 0) {
+                    console.log('   --- Features:');
+                    moduleFeatures.forEach((feature) => {
+                        console.log(`      • ${feature.name}`);
+                    });
+                }
+                else {
+                    console.log('   --- Features: (none)');
+                }
+                // Display Permissions
+                if (modulePermissions.length > 0) {
+                    console.log('   --- Permissions:');
+                    modulePermissions.forEach((permission) => {
+                        console.log(`      • ${permission}`);
+                    });
+                }
+                else {
+                    console.log('   --- Permissions: (none)');
+                }
+                console.groupEnd();
+            });
+            // Display ungrouped permissions if any
+            if (ungroupedPermissions.length > 0) {
+                console.group('📁 Other Permissions');
+                ungroupedPermissions.forEach((permission) => {
+                    console.log(`  • ${permission}`);
+                });
+                console.groupEnd();
+            }
+            // Summary
+            console.log('');
+            console.log(`Summary: ${allManifests.length} modules, ${allFeatures.length} features, ${userPermissions.length} permissions`);
+            console.groupEnd();
+        }
+        catch (error) {
+            console.error('[AXPDebugService] Failed to display user access info:', error);
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPDebugService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPDebugService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPDebugService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+
 class AXMOrgChartPrintPage extends AXBasePageComponent {
     constructor() {
         super(...arguments);
@@ -2903,7 +3814,7 @@ class AXMOrgChartPrintPage extends AXBasePageComponent {
           <ax-icon class="fa-solid fa-print"> </ax-icon>
         </ax-button>
       </ax-suffix>
-    </ax-footer>`, isInline: true, dependencies: [{ kind: "ngmodule", type: FormsModule }, { kind: "directive", type: i1$2.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i1$2.NgModel, selector: "[ngModel]:not([formControlName]):not([formControl])", inputs: ["name", "disabled", "ngModel", "ngModelOptions"], outputs: ["ngModelChange"], exportAs: ["ngModel"] }, { kind: "ngmodule", type: AXCheckBoxModule }, { kind: "ngmodule", type: AXNumberBoxModule }, { kind: "component", type: i2$1.AXNumberBoxComponent, selector: "ax-number-box", inputs: ["disabled", "readonly", "tabIndex", "placeholder", "value", "state", "name", "id", "look", "minValue", "maxValue", "showSpinButtons", "thousandsSeparator", "decimals", "changeOnScroll", "step"], outputs: ["valueChange", "stateChange", "onValueChanged", "onBlur", "onFocus", "readonlyChange", "disabledChange", "onKeyDown", "onKeyUp", "onKeyPress", "thousandsSeparatorChange"] }, { kind: "ngmodule", type: AXTextBoxModule }, { kind: "ngmodule", type: AXLabelModule }, { kind: "component", type: i3$1.AXLabelComponent, selector: "ax-label", inputs: ["required", "for"], outputs: ["requiredChange"] }, { kind: "ngmodule", type: AXDecoratorModule }, { kind: "component", type: i4.AXDecoratorIconComponent, selector: "ax-icon", inputs: ["icon"] }, { kind: "component", type: i4.AXDecoratorGenericComponent, selector: "ax-footer, ax-header, ax-content, ax-divider, ax-form-hint, ax-prefix, ax-suffix, ax-text, ax-title, ax-subtitle, ax-placeholder, ax-overlay" }, { kind: "ngmodule", type: AXButtonModule }, { kind: "component", type: i5.AXButtonComponent, selector: "ax-button", inputs: ["disabled", "size", "tabIndex", "color", "look", "text", "toggleable", "selected", "iconOnly", "type", "loadingText"], outputs: ["onBlur", "onFocus", "onClick", "selectedChange", "toggleableChange", "lookChange", "colorChange", "disabledChange", "loadingTextChange"] }, { kind: "ngmodule", type: AXColorBoxModule }, { kind: "component", type: i6.AXColorBoxComponent, selector: "ax-color-box", inputs: ["disabled", "readonly", "tabIndex", "placeholder", "value", "state", "name", "id", "look", "showBadge", "showValue", "showClearButton", "showIcon"], outputs: ["valueChange", "stateChange", "onValueChanged", "onBlur", "onFocus", "readonlyChange", "disabledChange", "onOpened", "onClosed"] }] }); }
+    </ax-footer>`, isInline: true, dependencies: [{ kind: "ngmodule", type: FormsModule }, { kind: "directive", type: i1$1.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i1$1.NgModel, selector: "[ngModel]:not([formControlName]):not([formControl])", inputs: ["name", "disabled", "ngModel", "ngModelOptions"], outputs: ["ngModelChange"], exportAs: ["ngModel"] }, { kind: "ngmodule", type: AXCheckBoxModule }, { kind: "ngmodule", type: AXNumberBoxModule }, { kind: "component", type: i2.AXNumberBoxComponent, selector: "ax-number-box", inputs: ["disabled", "readonly", "tabIndex", "placeholder", "value", "state", "name", "id", "look", "minValue", "maxValue", "showSpinButtons", "thousandsSeparator", "decimals", "changeOnScroll", "step"], outputs: ["valueChange", "stateChange", "onValueChanged", "onBlur", "onFocus", "readonlyChange", "disabledChange", "onKeyDown", "onKeyUp", "onKeyPress", "thousandsSeparatorChange"] }, { kind: "ngmodule", type: AXTextBoxModule }, { kind: "ngmodule", type: AXLabelModule }, { kind: "component", type: i3.AXLabelComponent, selector: "ax-label", inputs: ["required", "for"], outputs: ["requiredChange"] }, { kind: "ngmodule", type: AXDecoratorModule }, { kind: "component", type: i4.AXDecoratorIconComponent, selector: "ax-icon", inputs: ["icon"] }, { kind: "component", type: i4.AXDecoratorGenericComponent, selector: "ax-footer, ax-header, ax-content, ax-divider, ax-form-hint, ax-prefix, ax-suffix, ax-text, ax-title, ax-subtitle, ax-placeholder, ax-overlay" }, { kind: "ngmodule", type: AXButtonModule }, { kind: "component", type: i5.AXButtonComponent, selector: "ax-button", inputs: ["disabled", "size", "tabIndex", "color", "look", "text", "toggleable", "selected", "iconOnly", "type", "loadingText"], outputs: ["onBlur", "onFocus", "onClick", "selectedChange", "toggleableChange", "lookChange", "colorChange", "disabledChange", "loadingTextChange"] }, { kind: "ngmodule", type: AXColorBoxModule }, { kind: "component", type: i6.AXColorBoxComponent, selector: "ax-color-box", inputs: ["disabled", "readonly", "tabIndex", "placeholder", "value", "state", "name", "id", "look", "showBadge", "showValue", "showClearButton", "showIcon"], outputs: ["valueChange", "stateChange", "onValueChanged", "onBlur", "onFocus", "readonlyChange", "disabledChange", "onOpened", "onClosed"] }] }); }
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXMOrgChartPrintPage, decorators: [{
             type: Component,
@@ -3069,5 +3980,5 @@ class AXPVersioningService {
  * Generated bundle index. Do not edit.
  */
 
-export { ALL_DEFAULT_OPERATORS, AXMWorkflowErrorHandler, AXPAppVersionService, AXPCleanNestedFilters, AXPClipBoardService, AXPCommonModule, AXPCommonSettings, AXPCustomOperatorService, AXPCustomOperatorServiceImpl, AXPDataProvider, AXPDialogConfirmAction, AXPEntityCommandScope, AXPEntityQueryType, AXPErrorHandlerRegistryService, AXPExportService, AXPFileStorageService, AXPFileStorageStatus, AXPFileTypeProviderService, AXPFilterOperatorMiddlewareService, AXPFilterOperatorMiddlewareServiceImpl, AXPFooterTextSlotComponent, AXPGlobalErrorHandler, AXPGlobalVariableDefinitionService, AXPGlobalVariableEvaluatorScopeProvider, AXPHomePageModule, AXPHomePageService, AXPLockService, AXPLogoComponent, AXPMenuMiddlewareRegistry, AXPMenuProviderService, AXPMenuSearchDefinitionProvider, AXPMenuSearchProvider, AXPMenuService, AXPNavBarSlotComponent, AXPNavigateWorkflow, AXPPlatformDefaultConfigs, AXPRedirectEvent, AXPRefreshEvent, AXPRelationshipCardinality, AXPRelationshipKind, AXPReloadAction, AXPReloadEvent, AXPSearchCommandProvider, AXPSearchDefinitionActionBuilder, AXPSearchDefinitionBuilder, AXPSearchDefinitionProviderContext, AXPSearchDefinitionProviderService, AXPSearchService, AXPSettingDefaultValuesAggregatorService, AXPSettingDefinitionGroupBuilder, AXPSettingDefinitionProviderContext, AXPSettingDefinitionProviderService, AXPSettingDefinitionSectionBuilder, AXPSettingService, AXPStickyDirective, AXPToastAction, AXPVersioningService, AXPWorkflowNavigateAction, AXPWorkflowRouterNavigateAction, AXP_APP_VERSION_PROVIDER, AXP_FILE_TYPE_INFO_PROVIDER, AXP_GLOBAL_VARIABLE_DEFINITION_PROVIDER, AXP_HOME_PAGES, AXP_HOME_PAGE_DEFAULT_KEY, AXP_MENU_MIDDLEWARE, AXP_MENU_PROVIDER, AXP_PLATFORM_CONFIG_TOKEN, AXP_ROOT_CONFIG_TOKEN, AXP_SEARCH_DEFINITION_PROVIDER, AXP_SEARCH_PROVIDER, AXP_SETTING_DEFAULT_VALUES_PROVIDERS, AXP_SETTING_DEFINITION_PROVIDER, AXP_SETTING_VALUE_PROVIDER, AXVChangeType, BETWEEN_OPER, BOOLEAN_OPERATORS, CONTAINS_OPER, DATE_OPERATORS, ENDS_WITH_OPER, ENVIRONMENT, EQ_OPER, GTE_OPER, GT_OPER, IN_OPER, IS_EMPTY_OPER, IS_NOT_EMPTY_OPER, LTE_OPER, LT_OPER, NOT_CONTAINS_OPER, NOT_EQ_OPER, NUMBER_OPERATORS, STARTS_WITH_OPER, STRING_OPERATORS, configPlatform, createAllQueryView, createMenuContext, createMenuMiddleware, createQueryView, getEntityInfo, provideDynamicHomePage, provideMenuMiddleware };
+export { ALL_DEFAULT_OPERATORS, AXMWorkflowErrorHandler, AXPAppVersionService, AXPCleanNestedFilters, AXPClipBoardService, AXPCommonModule, AXPCommonSettings, AXPCustomOperatorService, AXPCustomOperatorServiceImpl, AXPDataProvider, AXPDebugService, AXPDialogConfirmAction, AXPEntityCommandScope, AXPEntityQueryType, AXPErrorHandlerRegistryService, AXPExportService, AXPFileStorageService, AXPFileStorageStatus, AXPFileTypeProviderService, AXPFilterOperatorMiddlewareService, AXPFilterOperatorMiddlewareServiceImpl, AXPFooterTextSlotComponent, AXPGlobalErrorHandler, AXPHomePageModule, AXPHomePageService, AXPLockService, AXPMenuMiddlewareRegistry, AXPMenuProviderService, AXPMenuSearchDefinitionProvider, AXPMenuSearchProvider, AXPMenuService, AXPMenuVisibilityService, AXPNavBarSlotComponent, AXPNavigateWorkflow, AXPPlatformDefaultConfigs, AXPRedirectEvent, AXPRefreshEvent, AXPRegionalSetting, AXPRelationshipCardinality, AXPRelationshipKind, AXPReloadAction, AXPReloadEvent, AXPSearchCommandProvider, AXPSearchDefinitionActionBuilder, AXPSearchDefinitionBuilder, AXPSearchDefinitionProviderContext, AXPSearchDefinitionProviderService, AXPSearchService, AXPSettingDefaultValuesAggregatorService, AXPSettingDefinitionGroupBuilder, AXPSettingDefinitionProviderContext, AXPSettingDefinitionProviderService, AXPSettingDefinitionSectionBuilder, AXPSettingsService, AXPStatusDefinitionProviderService, AXPStatusProvider, AXPStickyDirective, AXPSystemStatusType, AXPSystemStatuses, AXPToastAction, AXPTokenDefinitionService, AXPTokenEvaluatorScopeProvider, AXPVersioningService, AXPWorkflowNavigateAction, AXPWorkflowRouterNavigateAction, AXP_APP_VERSION_PROVIDER, AXP_FILE_TYPE_INFO_PROVIDER, AXP_HOME_PAGES, AXP_HOME_PAGE_DEFAULT_KEY, AXP_MENU_MIDDLEWARE, AXP_MENU_PROVIDER, AXP_PLATFORM_CONFIG_TOKEN, AXP_ROOT_CONFIG_TOKEN, AXP_SEARCH_DEFINITION_PROVIDER, AXP_SEARCH_PROVIDER, AXP_SETTING_DEFAULT_VALUES_PROVIDERS, AXP_SETTING_DEFINITION_PROVIDER, AXP_SETTING_VALUE_PROVIDER, AXP_STATUS_PROVIDERS, AXP_TOKEN_DEFINITION_PROVIDER, AXVChangeType, BETWEEN_OPER, BOOLEAN_OPERATORS, CONTAINS_OPER, DATE_OPERATORS, ENDS_WITH_OPER, ENVIRONMENT, EQ_OPER, GTE_OPER, GT_OPER, IN_OPER, IS_EMPTY_OPER, IS_NOT_EMPTY_OPER, LTE_OPER, LT_OPER, NOT_CONTAINS_OPER, NOT_EQ_OPER, NUMBER_OPERATORS, STARTS_WITH_OPER, STRING_OPERATORS, configPlatform, createAllQueryView, createMenuContext, createMenuMiddleware, createQueryView, getEntityInfo, getStatusInfo, getSystemStatus, provideDynamicHomePage, provideMenuMiddleware, resolveStatusLook, systemStatusToDefinition };
 //# sourceMappingURL=acorex-platform-common.mjs.map