@acorex/platform 21.0.0-next.7 → 21.0.0-next.70

package/fesm2022/acorex-platform-common.mjs

@@ -1,21 +1,23 @@
 import * as i0 from '@angular/core';
-import { InjectionToken, inject, Injectable, Injector, makeEnvironmentProviders, NgModule, ErrorHandler, EventEmitter, Input, Output, Directive, Component, ViewEncapsulation, Inject, signal, model, linkedSignal, afterNextRender } from '@angular/core';
+import { InjectionToken, inject, Injectable, Injector, signal, makeEnvironmentProviders, NgModule, ErrorHandler, EventEmitter, Input, Output, Directive, ChangeDetectionStrategy, Component, ViewEncapsulation, Inject, runInInjectionContext, model, linkedSignal, afterNextRender } from '@angular/core';
 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 { AXPPlatformScope, AXPBroadcastEventService, objectKeyValueTransforms, AXPSystemActionType, AXPModuleManifestModule, AXPAppStartUpProvider, AXP_EXPRESSION_EVALUATOR_SCOPE_PROVIDER, AXPModuleManifestRegistry } from '@acorex/platform/core';
-import { AXTranslationService } from '@acorex/core/translation';
+import { unwrapValueProperty, coerceUnknownToDate, coerceUnknownToFiniteNumber, coerceUnknownToBoolean, coerceUnknownToTrimmedString, AXPPlatformScope, AXPBroadcastEventService, objectKeyValueTransforms, AXPSystemActionType, searchInMultiLanguageString, AXPModuleManifestModule, AXPAppStartUpProvider, AXP_EXPRESSION_EVALUATOR_SCOPE_PROVIDER, AXPHookService, AXPDataGenerator, AXPModuleManifestRegistry } from '@acorex/platform/core';
 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 i1 from '@acorex/platform/workflow';
 import { AXPWorkflowService, createWorkFlowEvent, AXPWorkflowAction, AXPWorkflowError, AXPWorkflowModule } from '@acorex/platform/workflow';
+import { AXDataSource } from '@acorex/cdk/common';
 import { AXPCommandExecutor, AXPCommandService } from '@acorex/platform/runtime';
 import { signalStore, withState, withMethods, patchState, withHooks } from '@ngrx/signals';
+import { AXTranslationService } from '@acorex/core/translation';
 import { AXFormatService } from '@acorex/core/format';
 import { AXDialogService } from '@acorex/components/dialog';
+import { AXFileService } from '@acorex/core/file';
 import * as i5 from '@acorex/components/button';
 import { AXButtonModule } from '@acorex/components/button';
 import { AXCheckBoxModule } from '@acorex/components/check-box';
@@ -32,6 +34,84 @@ import { AXTextBoxModule } from '@acorex/components/text-box';
 import * as i1$1 from '@angular/forms';
 import { FormsModule } from '@angular/forms';
 
+//#region ---- Output kind & segment ----
+/** Default structured retry count when `structuredRetries` is omitted on structured kinds. */
+const AXP_AGENT_OUTPUT_CONTRACT_DEFAULT_STRUCTURED_RETRIES = 2;
+//#endregion
+
+const AXP_OUTPUT_CONTRACT_TRANSCRIPT_SEGMENT_PROVIDER = new InjectionToken('AXP_OUTPUT_CONTRACT_TRANSCRIPT_SEGMENT_PROVIDER', {
+    factory: () => [],
+});
+//#endregion
+
+//#region ---- Imports ----
+//#endregion
+class AXPOutputContractTranscriptSegmentService {
+    constructor() {
+        //#region ---- Dependencies & cache ----
+        this.segmentProviders = inject(AXP_OUTPUT_CONTRACT_TRANSCRIPT_SEGMENT_PROVIDER, { optional: true }) ?? [];
+        this.definitionsByName = new Map();
+        this.loadPromise = null;
+    }
+    //#endregion
+    //#region ---- Public API ----
+    /** All registered transcript segment definitions (deduped by `name`). */
+    async getAll() {
+        await this.ensureLoaded();
+        return [...this.definitionsByName.values()];
+    }
+    /** Lookup by segment id (`text`, `node`, `followUp`). */
+    async get(name) {
+        await this.ensureLoaded();
+        return this.definitionsByName.get(name);
+    }
+    /** Default `outputContract` for a segment, or `undefined` when not registered. */
+    async getContractPreset(name) {
+        const definition = await this.get(name);
+        return definition?.contract;
+    }
+    /** Clears the in-memory registry (e.g. after hot reload in dev). */
+    clearCache() {
+        this.definitionsByName.clear();
+        this.loadPromise = null;
+    }
+    //#endregion
+    //#region ---- Load ----
+    async ensureLoaded() {
+        if (this.loadPromise) {
+            return this.loadPromise;
+        }
+        this.loadPromise = this.loadDefinitions();
+        return this.loadPromise;
+    }
+    async loadDefinitions() {
+        const resolvedProviders = await Promise.all(this.segmentProviders);
+        for (const provider of resolvedProviders) {
+            if (!provider) {
+                continue;
+            }
+            const definitions = await Promise.resolve(provider.provide());
+            for (const definition of definitions) {
+                if (!definition?.name) {
+                    continue;
+                }
+                if (this.definitionsByName.has(definition.name)) {
+                    console.warn(`[AXPOutputContractTranscriptSegmentService] Segment "${definition.name}" already registered; overwriting.`);
+                }
+                this.definitionsByName.set(definition.name, definition);
+            }
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPOutputContractTranscriptSegmentService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPOutputContractTranscriptSegmentService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPOutputContractTranscriptSegmentService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+
 const AXP_APP_VERSION_PROVIDER = new InjectionToken('AXP_APP_VERSION_PROVIDER', {
     providedIn: 'root',
     factory: () => {
@@ -54,10 +134,10 @@ class AXPAppVersionService {
     async getAppVersion() {
         return this.provider.provider();
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPAppVersionService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPAppVersionService, providedIn: 'root' }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPAppVersionService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPAppVersionService, providedIn: 'root' }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPAppVersionService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPAppVersionService, decorators: [{
             type: Injectable,
             args: [{
                     providedIn: 'root',
@@ -88,6 +168,23 @@ var AXPEntityQueryType;
     AXPEntityQueryType["Single"] = "single";
     AXPEntityQueryType["List"] = "list";
 })(AXPEntityQueryType || (AXPEntityQueryType = {}));
+/** Whether the card field is shown as a header badge (not in the card body). */
+function isCardFieldBadgeDisplay(display) {
+    if (display === 'badge') {
+        return true;
+    }
+    return typeof display === 'object' && display !== null && display.type === 'badge';
+}
+/** Resolves static badge color config from {@link AXPCardField.display} and legacy {@link AXPCardField.badgeColor}. */
+function resolveCardFieldBadgeColor(field) {
+    if (typeof field.display === 'object' && field.display.type === 'badge') {
+        return field.display.options?.color ?? field.badgeColor;
+    }
+    if (field.display === 'badge') {
+        return field.badgeColor;
+    }
+    return undefined;
+}
 function getEntityInfo(entity) {
     return {
         source: `${entity.module}.${entity.name}`,
@@ -126,6 +223,31 @@ function createAllQueryView(params = {
         sorts: params.sorts ?? [],
     });
 }
+/** Resolves master list layouts that are currently enabled. */
+function resolveEnabledMasterListLayouts(layouts) {
+    if (!layouts) {
+        return ['table'];
+    }
+    const enabled = [];
+    if (layouts.table?.enabled !== false) {
+        enabled.push('table');
+    }
+    if (layouts.card && layouts.card.enabled !== false) {
+        enabled.push('card');
+    }
+    return enabled.length > 0 ? enabled : ['table'];
+}
+/** First enabled layout; used as the default when no user preference is stored. */
+function resolveDefaultMasterListLayout(layouts) {
+    return resolveEnabledMasterListLayouts(layouts)[0];
+}
+// new version
+var AXPEntityType;
+(function (AXPEntityType) {
+    AXPEntityType[AXPEntityType["Entity"] = 0] = "Entity";
+    AXPEntityType[AXPEntityType["AggregateRoot"] = 1] = "AggregateRoot";
+    AXPEntityType[AXPEntityType["ValueObject"] = 2] = "ValueObject";
+})(AXPEntityType || (AXPEntityType = {}));
 
 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 };
@@ -171,6 +293,7 @@ const BOOLEAN_OPERATORS = [EQ_OPER];
 const DATE_OPERATORS = [
     EQ_OPER,
     NOT_EQ_OPER,
+    BETWEEN_OPER,
     GT_OPER,
     GTE_OPER,
     LT_OPER,
@@ -195,22 +318,183 @@ const ALL_DEFAULT_OPERATORS = [
     BETWEEN_OPER,
 ];
 
+const DEFAULT_DATE_FILTER_PRESETS = [
+    { id: 'today', title: '@general:terms.date-presets.today', kind: 'computed' },
+    { id: 'this-week', title: '@general:terms.date-presets.this-week', kind: 'computed' },
+    { id: 'this-month', title: '@general:terms.date-presets.this-month', kind: 'computed' },
+    { id: 'yesterday', title: '@general:terms.date-presets.yesterday', kind: 'computed' },
+    { id: 'last-week', title: '@general:terms.date-presets.last-week', kind: 'computed' },
+    { id: 'last-month', title: '@general:terms.date-presets.last-month', kind: 'computed' },
+    { id: 'tomorrow', title: '@general:terms.date-presets.tomorrow', kind: 'computed' },
+    { id: 'next-week', title: '@general:terms.date-presets.next-week', kind: 'computed' },
+    { id: 'next-month', title: '@general:terms.date-presets.next-month', kind: 'computed' },
+    { id: 'between', title: BETWEEN_OPER.title, kind: 'manual', operationType: 'between' },
+    { id: 'greater-than', title: '@general:terms.operators.greater-than', kind: 'manual', operationType: 'greaterThan' },
+    { id: 'less-than', title: '@general:terms.operators.less-than', kind: 'manual', operationType: 'lessThan' },
+];
+function resolveDateFilterPresets(customPresets, presetIds) {
+    let presets = customPresets?.length ? customPresets : DEFAULT_DATE_FILTER_PRESETS;
+    if (presetIds?.length) {
+        presets = presets.filter((p) => presetIds.includes(p.id));
+    }
+    return presets;
+}
+function applyDateFilterPreset(presetId, calendarService) {
+    const currentDate = calendarService.now().date;
+    const calendar = calendarService.calendar;
+    switch (presetId) {
+        case 'today':
+            return {
+                operation: { type: 'between' },
+                value: {
+                    from: calendar.startOf(currentDate, 'day').date.toISOString(),
+                    to: calendar.endOf(currentDate, 'day').date.toISOString(),
+                },
+            };
+        case 'this-week':
+            return {
+                operation: { type: 'between' },
+                value: {
+                    from: calendar.startOf(currentDate, 'week').date.toISOString(),
+                    to: calendar.endOf(currentDate, 'week').date.toISOString(),
+                },
+            };
+        case 'this-month':
+            return {
+                operation: { type: 'between' },
+                value: {
+                    from: calendar.startOf(currentDate, 'month').date.toISOString(),
+                    to: calendar.endOf(currentDate, 'month').date.toISOString(),
+                },
+            };
+        case 'yesterday': {
+            const yesterday = calendar.add(currentDate, 'day', -1);
+            return {
+                operation: { type: 'between' },
+                value: {
+                    from: yesterday.startOf('day').date.toISOString(),
+                    to: yesterday.endOf('day').date.toISOString(),
+                },
+            };
+        }
+        case 'last-week': {
+            const lastWeek = calendar.add(currentDate, 'week', -1);
+            return {
+                operation: { type: 'between' },
+                value: {
+                    from: lastWeek.startOf('week').date.toISOString(),
+                    to: lastWeek.endOf('week').date.toISOString(),
+                },
+            };
+        }
+        case 'last-month': {
+            const lastMonth = calendar.add(currentDate, 'month', -1);
+            return {
+                operation: { type: 'between' },
+                value: {
+                    from: lastMonth.startOf('month').date.toISOString(),
+                    to: lastMonth.endOf('month').date.toISOString(),
+                },
+            };
+        }
+        case 'tomorrow': {
+            const tomorrow = calendar.add(currentDate, 'day', 1);
+            return {
+                operation: { type: 'between' },
+                value: {
+                    from: tomorrow.startOf('day').date.toISOString(),
+                    to: tomorrow.endOf('day').date.toISOString(),
+                },
+            };
+        }
+        case 'next-week': {
+            const nextWeek = calendar.add(currentDate, 'week', 1);
+            return {
+                operation: { type: 'between' },
+                value: {
+                    from: nextWeek.startOf('week').date.toISOString(),
+                    to: nextWeek.endOf('week').date.toISOString(),
+                },
+            };
+        }
+        case 'next-month': {
+            const nextMonth = calendar.add(currentDate, 'month', 1);
+            return {
+                operation: { type: 'between' },
+                value: {
+                    from: nextMonth.startOf('month').date.toISOString(),
+                    to: nextMonth.endOf('month').date.toISOString(),
+                },
+            };
+        }
+        case 'between':
+            return undefined;
+        case 'greater-than':
+            return { operation: { type: 'greaterThan' } };
+        case 'less-than':
+            return { operation: { type: 'lessThan' } };
+        default:
+            return {
+                operation: { type: 'between' },
+                value: { from: '', to: '' },
+            };
+    }
+}
+function findManualPresetIdByOperation(operationType, presets) {
+    if (!operationType) {
+        return undefined;
+    }
+    return presets.find((p) => p.kind === 'manual' && p.operationType === operationType)?.id;
+}
+
 const AXP_HOME_PAGES = new InjectionToken('AXP_HOME_PAGES');
 const AXP_HOME_PAGE_DEFAULT_KEY = new InjectionToken('AXP_HOME_PAGE_DEFAULT_KEY', {
     factory: () => 'home'
 });
 
+/**
+ * Regional and locale-related setting keys used by platform widgets and components.
+ * Most values use the `LocaleManagement:Setting:Regional.*` prefix; definitions live in the locale-management module where applicable.
+ */
+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";
+    /** Default multi-language behavior for standard text field names; defined in locale-management `AXMRegionalSettingProvider`. */
+    AXPRegionalSetting["MultiLanguageSupport"] = "LocaleManagement:Setting:Regional.MultiLanguageSupport";
+})(AXPRegionalSetting || (AXPRegionalSetting = {}));
+
 class AXPSettingDefinitionProviderContext {
     constructor() {
         this.rootGroups = [];
         this.groupMap = new Map();
     }
-    addGroup(name, title, description, icon) {
+    addGroup(name, title, description, icon, pageTitle, priority) {
         const newGroup = {
             name,
             title,
+            pageTitle,
             description,
             icon,
+            priority,
             groups: [],
             sections: [],
         };
@@ -259,12 +543,14 @@ class AXPSettingDefinitionGroupBuilder {
         }
         return new AXPSettingDefinitionSectionBuilder(this, foundSection);
     }
-    addGroup(name, title, description, icon) {
+    addGroup(name, title, description, icon, pageTitle, priority) {
         const newGroup = {
             name,
             title,
+            pageTitle,
             description: description,
             icon,
+            priority,
             groups: [],
             sections: [],
         };
@@ -289,11 +575,12 @@ class AXPSettingDefinitionSectionBuilder {
             name: setting.key,
             title: setting.title,
             description: setting.description,
+            searchTagKeys: setting.searchTagKeys,
             isRequired: setting.isRequired ?? false,
             isInherited: setting.isInherited ?? false,
             isEncrypted: setting.isEncrypted ?? false,
             defaultValue: setting.defaultValue,
-            scope: setting.scope ?? 'G',
+            scope: setting.scope ?? 'P',
             layout: setting.widget.layout,
             widget: {
                 type: setting.widget.type,
@@ -356,13 +643,14 @@ class AXPSettingDefinitionProviderService {
         if (!this.cache) {
             return [];
         }
-        const scopeOrder = ['C', 'G', 'T', 'U']; // Scopes hierarchy in ascending order
+        const scopeOrder = ['P', 'T', 'U']; // Scopes hierarchy in ascending order
         const filterByScope = (groups, currentScope) => {
             const currentScopeIndex = scopeOrder.indexOf(currentScope);
             return groups
                 .map((group) => ({
                 ...group,
-                sections: group.sections.map((section) => ({
+                sections: group.sections
+                    .map((section) => ({
                     ...section,
                     settings: section.settings.filter((setting) => {
                         const settingScopeIndex = scopeOrder.indexOf(setting.scope);
@@ -379,12 +667,13 @@ class AXPSettingDefinitionProviderService {
                         // 3. Exclude settings with a lower or irrelevant scope.
                         return false;
                     }),
-                })).filter((section) => section.settings.length > 0), // Keep only sections with settings
+                }))
+                    .filter((section) => section.settings.length > 0), // Keep only sections with settings
                 groups: filterByScope(group.groups, currentScope), // Recursively filter nested groups
             }))
                 .filter((group) => group.sections.length > 0 || group.groups.length > 0); // Keep groups with valid sections or nested groups
         };
-        return sortBy(filterByScope(this.cache, scope), 'title');
+        return sortBy(filterByScope(this.cache, scope), [(group) => group.priority ?? 1000, 'title']);
     }
     async defaultValues() {
         const defaults = {};
@@ -406,12 +695,33 @@ class AXPSettingDefinitionProviderService {
         collectDefaults(this.cache);
         return defaults;
     }
+    async settingScopeByKey() {
+        const scopes = {};
+        const collect = (groups) => {
+            groups.forEach((group) => {
+                group.sections.forEach((section) => {
+                    section.settings.forEach((setting) => {
+                        scopes[setting.name] = setting.scope;
+                    });
+                });
+                collect(group.groups);
+            });
+        };
+        if (!this.cache) {
+            await this.load();
+        }
+        collect(this.cache);
+        return scopes;
+    }
     findGroup(scope, groupName) {
         return this.searchRecursive(this.getList(scope), groupName, []); // Initialize with an empty breadcrumb
     }
     searchRecursive(groups, groupName, breadcrumb) {
         for (const group of groups) {
-            const currentBreadcrumb = [...breadcrumb, { name: group.name, title: group.title, description: group.description }];
+            const currentBreadcrumb = [
+                ...breadcrumb,
+                { name: group.name, title: group.title, description: group.description },
+            ];
             // If the group name matches, return its details
             if (group.name === groupName) {
                 return {
@@ -430,13 +740,13 @@ class AXPSettingDefinitionProviderService {
         return {
             breadcrumb: [],
             groups: [],
-            sections: []
+            sections: [],
         };
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPSettingDefinitionProviderService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPSettingDefinitionProviderService, providedIn: 'root' }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPSettingDefinitionProviderService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPSettingDefinitionProviderService, providedIn: 'root' }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPSettingDefinitionProviderService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPSettingDefinitionProviderService, decorators: [{
             type: Injectable,
             args: [{ providedIn: 'root' }]
         }] });
@@ -451,38 +761,113 @@ class AXPSettingDefaultValuesAggregatorService {
         this.definitionService = inject(AXPSettingDefinitionProviderService);
         this.providers = inject(AXP_SETTING_DEFAULT_VALUES_PROVIDERS, { optional: true }) ?? [];
     }
-    async getDefaults() {
+    async getMerged() {
         const baseDefaults = await this.definitionService.defaultValues();
         const ordered = [...this.providers].sort((a, b) => (a.priority ?? 0) - (b.priority ?? 0));
         const merged = { ...baseDefaults };
+        const seedScopeByKey = {};
         for (const provider of ordered) {
             try {
                 const overrideMap = await provider.provide();
                 Object.assign(merged, overrideMap);
+                if (provider.scope) {
+                    for (const key of Object.keys(overrideMap)) {
+                        seedScopeByKey[key] = provider.scope;
+                    }
+                }
             }
             catch (err) {
                 console.error('AXPSettingDefaultValuesProvider failed:', err);
             }
         }
-        return merged;
+        return { defaults: merged, seedScopeByKey };
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPSettingDefaultValuesAggregatorService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPSettingDefaultValuesAggregatorService, providedIn: 'root' }); }
+    async getDefaults() {
+        const { defaults } = await this.getMerged();
+        return defaults;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPSettingDefaultValuesAggregatorService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPSettingDefaultValuesAggregatorService, providedIn: 'root' }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPSettingDefaultValuesAggregatorService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPSettingDefaultValuesAggregatorService, decorators: [{
             type: Injectable,
             args: [{ providedIn: 'root' }]
         }] });
 
+//#region ---- Imports ----
+//#endregion
+//#region ---- Kind inference ----
+/**
+ * If the payload uses the common `{ value: T }` shape from setting widgets, returns the inner value; otherwise returns `raw`.
+ */
+function peelSettingValueKey(raw) {
+    return unwrapValueProperty(raw);
+}
+function coercionKindFromScalarSample(v) {
+    if (v === null || v === undefined) {
+        return null;
+    }
+    if (typeof v === 'boolean') {
+        return 'boolean';
+    }
+    if (typeof v === 'number' && Number.isFinite(v)) {
+        return 'number';
+    }
+    if (v instanceof Date) {
+        return 'date';
+    }
+    if (typeof v === 'string') {
+        if (v === 'true' || v === 'false') {
+            return 'boolean';
+        }
+        return 'string';
+    }
+    return null;
+}
+/**
+ * Picks a primitive coercion kind from the setting definition default and/or the effective stored value.
+ * Type argument `T` on the settings service `get` method is compile-time only; runtime behavior follows this inference.
+ */
+function inferSettingCoercionKind(defaultSample, effective) {
+    const fromDefault = coercionKindFromScalarSample(defaultSample);
+    if (fromDefault) {
+        return fromDefault;
+    }
+    return coercionKindFromScalarSample(unwrapValueProperty(effective));
+}
+//#endregion
+//#region ---- Value coercion ----
+function coerceAXPSettingRawValueByKind(raw, kind) {
+    switch (kind) {
+        case 'string':
+            return coerceUnknownToTrimmedString(raw);
+        case 'boolean':
+            return coerceUnknownToBoolean(raw);
+        case 'number':
+            return coerceUnknownToFiniteNumber(raw);
+        case 'date':
+            return coerceUnknownToDate(raw);
+        default: {
+            const _exhaustive = kind;
+            return _exhaustive;
+        }
+    }
+}
+function coerceAXPSettingRawValue(raw, kind) {
+    return coerceAXPSettingRawValueByKind(raw, kind);
+}
+//#endregion
+
 const AXP_SETTING_VALUE_PROVIDER = new InjectionToken('AXP_SETTING_VALUE_PROVIDER', {
     providedIn: 'root',
     factory: () => {
         const injector = inject(Injector);
         return [
+            new AXPSettingValueProviderDefault(AXPPlatformScope.Platform, injector),
             new AXPSettingValueProviderDefault(AXPPlatformScope.Tenant, injector),
-            new AXPSettingValueProviderDefault(AXPPlatformScope.User, injector)
+            new AXPSettingValueProviderDefault(AXPPlatformScope.User, injector),
         ];
-    }
+    },
 });
 class AXPSettingValueProviderDefault {
     constructor(_scope, injector) {
@@ -491,16 +876,22 @@ class AXPSettingValueProviderDefault {
         this.cache = new Map();
         this.localStorageKey = null;
         this.sessionService = this.injector.get(AXPSessionService);
-        this.sessionService.status$.subscribe((status) => {
-            if (status === AXPSessionStatus.Authorized || status === AXPSessionStatus.Authenticated) {
-                if (this.scope === AXPPlatformScope.User) {
-                    this.localStorageKey = `AXP_SETTINGS_SCOPE(${this.sessionService.user?.id ?? 'U'})`;
-                }
-                else {
-                    this.localStorageKey = `AXP_SETTINGS_SCOPE(${this.sessionService.tenant?.id ?? 'T'})`;
+        // Platform scope doesn't depend on session, initialize immediately
+        if (this.scope === AXPPlatformScope.Platform) {
+            this.localStorageKey = `AXP_SETTINGS_SCOPE(P)`;
+        }
+        else {
+            this.sessionService.status$.subscribe((status) => {
+                if (status === AXPSessionStatus.Authorized || status === AXPSessionStatus.Authenticated) {
+                    if (this.scope === AXPPlatformScope.User) {
+                        this.localStorageKey = `AXP_SETTINGS_SCOPE(${this.sessionService.user?.id ?? 'U'})`;
+                    }
+                    else if (this.scope === AXPPlatformScope.Tenant) {
+                        this.localStorageKey = `AXP_SETTINGS_SCOPE(${this.sessionService.tenant?.id ?? 'T'})`;
+                    }
                 }
-            }
-        });
+            });
+        }
     }
     get scope() {
         return this._scope;
@@ -516,7 +907,7 @@ class AXPSettingValueProviderDefault {
             Object.entries(parsedSettings).forEach(([key, value]) => {
                 this.cache.set(key, value);
             });
-            return Promise.resolve(Array.from(this.cache.entries()).map(c => ({ key: c[0], value: c[1] })));
+            return Promise.resolve(Array.from(this.cache.entries()).map((c) => ({ key: c[0], value: c[1] })));
         }
         return Promise.resolve([]);
     }
@@ -561,12 +952,7 @@ class AXPSettingsService {
         this.onChanged = new Subject();
         this.onLoaded = new Subject();
         // Initialize scoped caches for dynamic scopes
-        const staticScopes = [
-            AXPPlatformScope.Environment,
-            AXPPlatformScope.Global,
-            AXPPlatformScope.Tenant,
-            AXPPlatformScope.User,
-        ];
+        const staticScopes = [AXPPlatformScope.Platform, AXPPlatformScope.Tenant, AXPPlatformScope.User];
         staticScopes.forEach((scope) => {
             if (!this.scopedSettingsCache.has(scope)) {
                 this.scopedSettingsCache.set(scope, new Map());
@@ -601,6 +987,7 @@ class AXPSettingsService {
                 });
                 settingsList.push(...providerSettings);
             }
+            await this.seedMissingDefaults();
             this.onLoaded.next();
             return settingsList;
         }
@@ -609,35 +996,45 @@ class AXPSettingsService {
             throw error;
         }
     }
+    /**
+     * Returns the effective setting value. Primitive coercion (string, boolean, number, date) is inferred from the
+     * definition default and/or the stored shape (including `{ value: ... }`). Type argument `T` is compile-time only;
+     * it is not read at runtime—use it to document the expected result (e.g. `get<boolean>(key)`).
+     */
     async get(key) {
+        const { effective, defaultSample } = await this.resolveEffectiveAndDefault(key);
+        const kind = inferSettingCoercionKind(defaultSample, effective);
+        if (kind !== null) {
+            return coerceAXPSettingRawValueByKind(effective, kind);
+        }
+        if (effective === undefined) {
+            return effective;
+        }
+        return cloneDeep(effective);
+    }
+    /**
+     * Effective value (user → tenant → platform) when set; otherwise the definition default. Used for reads and coercion hints.
+     */
+    async resolveEffectiveAndDefault(key) {
         if (this.scopedSettingsCache.size === 0) {
             await this.load();
         }
-        const scopeOrder = [
-            AXPPlatformScope.User,
-            AXPPlatformScope.Tenant,
-            AXPPlatformScope.Global,
-            AXPPlatformScope.Environment,
-        ];
+        const defaults = await this.injector.get(AXPSettingDefaultValuesAggregatorService).getDefaults();
+        const defaultSample = get(defaults, key);
+        const scopeOrder = [AXPPlatformScope.User, AXPPlatformScope.Tenant, AXPPlatformScope.Platform];
         for (const scope of scopeOrder) {
             const scopeCache = this.scopedSettingsCache.get(scope);
             if (scopeCache && scopeCache.has(key)) {
                 const value = scopeCache.get(key);
                 if (value !== undefined && value !== null) {
-                    return cloneDeep(value);
+                    return { effective: value, defaultSample };
                 }
             }
         }
-        const defaults = await this.injector.get(AXPSettingDefaultValuesAggregatorService).getDefaults();
-        return get(defaults, key); // Fallback if no value is found
+        return { effective: defaultSample, defaultSample };
     }
     async defaultValues(scope) {
-        let scopeOrder = [
-            AXPPlatformScope.Environment,
-            AXPPlatformScope.Global,
-            AXPPlatformScope.Tenant,
-            AXPPlatformScope.User,
-        ].reverse();
+        let scopeOrder = [AXPPlatformScope.Platform, AXPPlatformScope.Tenant, AXPPlatformScope.User].reverse();
         const scopeIndex = scopeOrder.indexOf(scope);
         if (scopeIndex === -1) {
             throw new Error(`Invalid scope: ${scope}`);
@@ -671,10 +1068,36 @@ class AXPSettingsService {
         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: 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' }); }
+    async seedMissingDefaults() {
+        const definitionService = this.injector.get(AXPSettingDefinitionProviderService);
+        const aggregator = this.injector.get(AXPSettingDefaultValuesAggregatorService);
+        const [{ defaults, seedScopeByKey }, scopeByKey] = await Promise.all([
+            aggregator.getMerged(),
+            definitionService.settingScopeByKey(),
+        ]);
+        const persistedKeysByScope = new Map(await Promise.all(this.providers.map(async (provider) => {
+            const stored = await provider.load();
+            return [provider.scope, new Set(stored.map((s) => s.key))];
+        })));
+        const toPersist = {};
+        for (const [key, value] of Object.entries(defaults)) {
+            const scope = seedScopeByKey[key] ?? scopeByKey[key];
+            if (!scope || value === undefined || persistedKeysByScope.get(scope)?.has(key)) {
+                continue;
+            }
+            toPersist[scope] ??= {};
+            toPersist[scope][key] = value;
+        }
+        for (const [scope, values] of Object.entries(toPersist)) {
+            if (Object.keys(values).length > 0) {
+                await this.scope(scope).set(values);
+            }
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPSettingsService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPSettingsService, providedIn: 'root' }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPSettingsService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPSettingsService, decorators: [{
             type: Injectable,
             args: [{
                     providedIn: 'root',
@@ -689,7 +1112,17 @@ class ScopedSettingService {
     async get(key) {
         const settings = await this.provider.load();
         const setting = settings.find((s) => s.key === key);
-        return setting ? cloneDeep(setting.value) : undefined;
+        const effective = setting?.value;
+        const defaults = await this.parent.defaultValues(this.provider.scope);
+        const defaultSample = get(defaults, key);
+        const kind = inferSettingCoercionKind(defaultSample, effective);
+        if (kind !== null) {
+            return coerceAXPSettingRawValueByKind(effective, kind);
+        }
+        if (effective === undefined) {
+            return effective;
+        }
+        return cloneDeep(effective);
     }
     async all() {
         const settings = await this.provider.load();
@@ -730,34 +1163,219 @@ class ScopedSettingService {
     }
 }
 
+const DEFAULT_APPLY_DEFAULT_MULTILANGUAGE = true;
 /**
- * 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.
+ * Synchronous access to default multi-language behavior for named entity fields and widget
+ * property bindings. Mirrors {@link AXPLayoutOrderingConfigService}: avoids async in entity
+ * modifiers and startup deadlocks.
  */
-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 = {}));
+class AXPDefaultMultiLanguageConfigService {
+    constructor() {
+        this.settingsService = inject(AXPSettingsService);
+        this._applyDefault = signal(DEFAULT_APPLY_DEFAULT_MULTILANGUAGE, ...(ngDevMode ? [{ debugName: "_applyDefault" }] : /* istanbul ignore next */ []));
+        this.syncScheduled = false;
+        this.settingsService.onLoaded.subscribe(() => this.syncFromSettings());
+        this.settingsService.onChanged.subscribe(() => this.syncFromSettings());
+    }
+    getApplyDefaultMultiLanguage() {
+        if (!this.syncScheduled) {
+            this.syncScheduled = true;
+            this.settingsService
+                .get(AXPRegionalSetting.MultiLanguageSupport)
+                .then((value) => this._applyDefault.set(value ?? DEFAULT_APPLY_DEFAULT_MULTILANGUAGE))
+                .catch(() => this._applyDefault.set(DEFAULT_APPLY_DEFAULT_MULTILANGUAGE));
+        }
+        return this._applyDefault();
+    }
+    async syncFromSettings() {
+        try {
+            const value = await this.settingsService.get(AXPRegionalSetting.MultiLanguageSupport);
+            this._applyDefault.set(value ?? DEFAULT_APPLY_DEFAULT_MULTILANGUAGE);
+        }
+        catch {
+            this._applyDefault.set(DEFAULT_APPLY_DEFAULT_MULTILANGUAGE);
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPDefaultMultiLanguageConfigService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPDefaultMultiLanguageConfigService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPDefaultMultiLanguageConfigService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [] });
+
+//#region ----   Constants ----
+/**
+ * Widget types that support the multiLanguage option (text / rich text editors).
+ */
+const MULTILANGUAGE_CAPABLE_WIDGET_TYPES = new Set([
+    'text-editor',
+    'large-text-editor',
+    'rich-text-editor',
+    'template-content-editor',
+]);
+/**
+ * Common property names / binding path segments that are usually translatable when the feature is
+ * enabled in settings. Explicit `multiLanguage` on the property still wins.
+ */
+const DEFAULT_MULTILANGUAGE_FIELD_NAMES = new Set([
+    'title',
+    'description',
+    'note',
+    'content',
+    /** e.g. `post.summaryContent` — last path segment */
+    'summaryContent',
+    'question',
+    'summary',
+    'body',
+    'caption',
+    'remarks',
+    'subtitle',
+    'label',
+    'placeholder',
+    'message',
+    'subject',
+]);
+//#endregion
+//#region ----   Helpers ----
+function interfacePathLastSegment(path) {
+    if (path == null || typeof path !== 'string' || !path.length) {
+        return null;
+    }
+    const seg = path.includes('.') ? path.split('.').pop() : path;
+    return seg && seg.length ? seg : null;
+}
+function shouldApplyDefaultMultiLanguageToEntityProperty(prop) {
+    if (prop.schema.dataType !== 'string') {
+        return false;
+    }
+    if (!DEFAULT_MULTILANGUAGE_FIELD_NAMES.has(prop.name)) {
+        return false;
+    }
+    const widgetType = prop.schema.interface?.type;
+    if (typeof widgetType !== 'string' || !MULTILANGUAGE_CAPABLE_WIDGET_TYPES.has(widgetType)) {
+        return false;
+    }
+    const opts = prop.schema.interface?.options;
+    if (opts && 'multiLanguage' in opts) {
+        return false;
+    }
+    return true;
+}
+function shouldApplyDefaultMultiLanguageToWidgetProperty(prop) {
+    if (prop.schema.dataType !== 'string') {
+        return false;
+    }
+    const key = interfacePathLastSegment(prop.schema.interface.path);
+    if (!key || !DEFAULT_MULTILANGUAGE_FIELD_NAMES.has(key)) {
+        return false;
+    }
+    const widgetType = prop.schema.interface.type;
+    if (typeof widgetType !== 'string' || !MULTILANGUAGE_CAPABLE_WIDGET_TYPES.has(widgetType)) {
+        return false;
+    }
+    const opts = prop.schema.interface.options;
+    if (opts && 'multiLanguage' in opts) {
+        return false;
+    }
+    return true;
+}
+/**
+ * Leaf widget nodes in entity `schema.interface` trees (e.g. GridLayout → RichText under `pre` /
+ * `post`) — same path/type rules as {@link shouldApplyDefaultMultiLanguageToWidgetProperty}, without
+ * `schema.dataType` (nodes do not carry entity schema).
+ */
+function shouldApplyDefaultMultiLanguageToWidgetNode(node) {
+    const widgetType = node.type;
+    if (typeof widgetType !== 'string' || !MULTILANGUAGE_CAPABLE_WIDGET_TYPES.has(widgetType)) {
+        return false;
+    }
+    const key = interfacePathLastSegment(node.path);
+    if (!key || !DEFAULT_MULTILANGUAGE_FIELD_NAMES.has(key)) {
+        return false;
+    }
+    const opts = node.options;
+    if (opts && 'multiLanguage' in opts) {
+        return false;
+    }
+    return true;
+}
+/**
+ * When {@link AXPDefaultMultiLanguageConfigService#getApplyDefaultMultiLanguage} is true, sets
+ * `options.multiLanguage` on eligible editor leaves inside an entity property's widget tree
+ * (including nested layouts). Used by entity middleware so object fields (e.g. `pre`, `post`) are
+ * covered, not only top-level string properties.
+ */
+function withDefaultMultiLanguageOnWidgetNodeTree(root, applyDefault) {
+    if (root == null || !applyDefault) {
+        return root ?? undefined;
+    }
+    return visitWidgetNodeForDefaultMultiLanguage(root);
+}
+function visitWidgetNodeForDefaultMultiLanguage(node) {
+    let next = node;
+    if (node.children?.length) {
+        const newChildren = node.children.map((child) => visitWidgetNodeForDefaultMultiLanguage(child));
+        if (newChildren.some((c, i) => c !== node.children[i])) {
+            next = { ...node, children: newChildren };
+        }
+    }
+    if (shouldApplyDefaultMultiLanguageToWidgetNode(next)) {
+        return {
+            ...next,
+            options: {
+                ...(next.options ?? {}),
+                multiLanguage: true,
+            },
+        };
+    }
+    return next;
+}
+/**
+ * When {@link AXPDefaultMultiLanguageConfigService#getApplyDefaultMultiLanguage} is true, sets
+ * `schema.interface.options.multiLanguage` for eligible string widget properties (same rules as
+ * entity middleware), unless the property already specifies `multiLanguage`.
+ */
+function withDefaultMultiLanguageOnWidgetProperty(prop, applyDefault) {
+    if (!applyDefault || !shouldApplyDefaultMultiLanguageToWidgetProperty(prop)) {
+        return prop;
+    }
+    const iface = prop.schema.interface;
+    const existingOpts = (iface.options ?? {});
+    return {
+        ...prop,
+        schema: {
+            ...prop.schema,
+            interface: {
+                ...iface,
+                options: {
+                    ...existingOpts,
+                    multiLanguage: true,
+                },
+            },
+        },
+    };
+}
+//#endregion
+
+//#region ----   Settings expression scope ----
+/**
+ * Exposes platform settings in expression strings, e.g.
+ * `{{ settings.get('Common:Setting:Entity.ShowPageBadge') }}`.
+ */
+class AXPSettingsEvaluatorScopeProvider {
+    constructor() {
+        this.settingsService = inject(AXPSettingsService);
+    }
+    async provide(context) {
+        context.addScope('settings', {
+            get: async (key) => {
+                return await this.settingsService.get(key);
+            },
+        });
+    }
+}
+//#endregion
 
 var AXPHomePageSettings;
 (function (AXPHomePageSettings) {
@@ -815,9 +1433,7 @@ class AXPHomePageService {
                 { ...home?.route, ...{ data: { key: home?.key, title: home?.title, path: fullPath } } },
             ];
         }
-        return [
-            { path: '', redirectTo: this.loginPath, pathMatch: 'full' },
-        ];
+        return [{ path: '', redirectTo: this.loginPath, pathMatch: 'full' }];
     }
     getCurrent() {
         const key = this.userHomePageKey ?? this.defaultHomePageKey;
@@ -865,30 +1481,24 @@ class AXPHomePageService {
         // Filter the original routes to drop the old home placeholders.
         // We know your dynamic routes always have path === '' or ':app'
         // or carry a `data.key` matching one of your home-page keys.
-        const otherRoutes = (this.originalConfig ?? [])
-            .filter(r => r.path !== '' &&
-            r.path !== ':app' &&
-            !(r.data && typeof r.data['key'] === 'string'));
+        const otherRoutes = (this.originalConfig ?? []).filter((r) => r.path !== '' && r.path !== ':app' && !(r.data && typeof r.data['key'] === 'string'));
         // Build the new merged tree
-        const merged = [
-            ...newHomeRoutes,
-            ...otherRoutes
-        ];
+        const merged = [...newHomeRoutes, ...otherRoutes];
         // TODO: check this for custom menu like :app/terms
         router.resetConfig(merged);
     }
     async navigateTo() {
-        // wait for the router to be initialized  
+        // wait for the router to be initialized
         setTimeout(() => {
             const router = this.injector.get(Router);
             const current = this.getCurrent();
-            router.navigate([current.path]);
+            router.navigate([current.path], { onSameUrlNavigation: 'reload' });
         }, 100);
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPHomePageService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPHomePageService, providedIn: 'root' }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPHomePageService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPHomePageService, providedIn: 'root' }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPHomePageService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPHomePageService, decorators: [{
             type: Injectable,
             args: [{
                     providedIn: 'root',
@@ -909,28 +1519,27 @@ function provideDynamicHomePage() {
     ]);
 }
 
+const I18N = '@general:settings';
 class AXPHomePageSettingProvider {
     constructor(injector) {
         this.injector = injector;
-        this.translateService = this.injector.get(AXTranslationService);
         this.homePageService = this.injector.get(AXPHomePageService);
         this.defaultHomePageKey = inject(AXP_HOME_PAGE_DEFAULT_KEY, { optional: true }) ?? 'home';
     }
     async provide(context) {
-        const trans = async (key) => await this.translateService.translateAsync(`@general:settings.${key}`);
-        const list = await this.homePageService.getRegisteredList().map((c) => ({ id: c.key, title: c.title }));
+        const list = this.homePageService.getRegisteredList().map((c) => ({ id: c.key, title: c.title }));
         if (list.length === 0) {
             return;
         }
         // Define the 'General Settings' group
         context
-            .addGroup('general', await trans('general.title'), await trans('general.description'), 'fa-light fa-palette')
+            .addGroup('general', `${I18N}.general.nav-title`, `${I18N}.general.description`, 'fa-light fa-palette', `${I18N}.general.title`, 1)
             // Add the 'Startup' section
-            .addSection('startup', await trans('general.startup.title'), await trans('general.startup.description'))
+            .addSection('startup', `${I18N}.general.startup.title`, `${I18N}.general.startup.description`)
             // Add the 'Home Page' setting
             .addSetting({
             key: AXPHomePageSettings.UserHomePath,
-            title: await trans('general.startup.home-page.title'),
+            title: `${I18N}.general.startup.home-page.title`,
             scope: AXPPlatformScope.User,
             isInherited: true,
             defaultValue: this.defaultHomePageKey || list[0].id,
@@ -943,24 +1552,24 @@ class AXPHomePageSettingProvider {
                     dataSource: list,
                 },
             },
-            description: await trans('general.startup.home-page.description'),
+            description: `${I18N}.general.startup.home-page.description`,
         })
             // End the 'Startup' section
             .endSection()
             // End the 'General Settings' group
             .endGroup();
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPHomePageSettingProvider, deps: [{ token: i0.Injector }], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPHomePageSettingProvider }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPHomePageSettingProvider, deps: [{ token: i0.Injector }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPHomePageSettingProvider }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPHomePageSettingProvider, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPHomePageSettingProvider, decorators: [{
             type: Injectable
         }], ctorParameters: () => [{ type: i0.Injector }] });
 
 class AXPHomePageModule {
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPHomePageModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
-    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "20.3.12", ngImport: i0, type: AXPHomePageModule }); }
-    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPHomePageModule, providers: [
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPHomePageModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "21.2.9", ngImport: i0, type: AXPHomePageModule }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPHomePageModule, providers: [
             {
                 provide: AXP_SETTING_DEFINITION_PROVIDER,
                 useClass: AXPHomePageSettingProvider,
@@ -968,7 +1577,7 @@ class AXPHomePageModule {
             },
         ] }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPHomePageModule, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPHomePageModule, decorators: [{
             type: NgModule,
             args: [{
                     imports: [],
@@ -991,10 +1600,10 @@ class AXPCustomOperatorServiceImpl extends AXPCustomOperatorService {
     getCustomOperators() {
         return {};
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPCustomOperatorServiceImpl, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPCustomOperatorServiceImpl }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPCustomOperatorServiceImpl, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPCustomOperatorServiceImpl }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPCustomOperatorServiceImpl, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPCustomOperatorServiceImpl, decorators: [{
             type: Injectable
         }] });
 
@@ -1039,10 +1648,10 @@ class AXPFilterOperatorMiddlewareServiceImpl extends AXPFilterOperatorMiddleware
             return acc;
         }, {});
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPFilterOperatorMiddlewareServiceImpl, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPFilterOperatorMiddlewareServiceImpl }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPFilterOperatorMiddlewareServiceImpl, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPFilterOperatorMiddlewareServiceImpl }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPFilterOperatorMiddlewareServiceImpl, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPFilterOperatorMiddlewareServiceImpl, decorators: [{
             type: Injectable
         }] });
 
@@ -1063,10 +1672,10 @@ class AXPErrorHandlerRegistryService {
     get handlers() {
         return this.errorHandlers;
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPErrorHandlerRegistryService, deps: [{ token: i0.Injector }], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPErrorHandlerRegistryService, providedIn: 'root' }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPErrorHandlerRegistryService, deps: [{ token: i0.Injector }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPErrorHandlerRegistryService, providedIn: 'root' }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPErrorHandlerRegistryService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPErrorHandlerRegistryService, decorators: [{
             type: Injectable,
             args: [{
                     providedIn: 'root'
@@ -1097,10 +1706,10 @@ class AXPGlobalErrorHandler extends ErrorHandler {
         }
         handleErrorRecursively(0, error);
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPGlobalErrorHandler, deps: [{ token: i0.Injector }, { token: AXPErrorHandlerRegistryService }], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPGlobalErrorHandler, providedIn: 'root' }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPGlobalErrorHandler, deps: [{ token: i0.Injector }, { token: AXPErrorHandlerRegistryService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPGlobalErrorHandler, providedIn: 'root' }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPGlobalErrorHandler, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPGlobalErrorHandler, decorators: [{
             type: Injectable,
             args: [{ providedIn: 'root' }]
         }], ctorParameters: () => [{ type: i0.Injector }, { type: AXPErrorHandlerRegistryService }] });
@@ -1171,10 +1780,10 @@ class AXPTokenDefinitionService {
     clearDefinitionsCache() {
         this.definitionsByName.clear();
     }
-    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' }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPTokenDefinitionService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPTokenDefinitionService, providedIn: 'root' }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPTokenDefinitionService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPTokenDefinitionService, decorators: [{
             type: Injectable,
             args: [{
                     providedIn: 'root',
@@ -1212,32 +1821,24 @@ class AXPStickyDirective {
         this.stickyOffset = 100;
         this.isStickyChange = new EventEmitter();
         this._isSticky = false;
+        this.onWindowResize = () => {
+            this.applyStickyStateFromScrollPosition();
+        };
         this.onParentScroll = () => {
-            this.zone.runOutsideAngular(() => {
-                const scrollTop = this.parentElement === window ? window.scrollY : this.parentElement.scrollTop;
-                const shouldStick = scrollTop + this.stickyOffset >= this.topOffset;
-                if (shouldStick !== this.isSticky) {
-                    this.zone.run(() => {
-                        this.isSticky = shouldStick;
-                        this.toggleStickyClasses(shouldStick);
-                        this.cdr.markForCheck();
-                    });
-                }
-            });
+            this.applyStickyStateFromScrollPosition();
         };
     }
     ngAfterViewInit() {
         this.initSticky();
         // Add mutation observer for dynamic content
         this.mutationObserver = new MutationObserver(() => {
-            this.updateTopOffset();
+            this.applyStickyStateFromScrollPosition();
         });
         this.mutationObserver.observe(this.element.nativeElement, {
             childList: true,
             subtree: true,
         });
-        // Add resize event listener
-        window.addEventListener('resize', this.updateTopOffset.bind(this));
+        window.addEventListener('resize', this.onWindowResize);
     }
     initSticky() {
         if (this.stickyParent instanceof HTMLElement) {
@@ -1247,13 +1848,42 @@ class AXPStickyDirective {
             this.parentElement = document.querySelector(this.stickyParent) || window;
         }
         this.targetElement = document.querySelector(this.stickyTarget) || this.element.nativeElement;
-        this.updateTopOffset();
         this.parentElement.addEventListener('scroll', this.onParentScroll);
+        this.applyStickyStateFromScrollPosition();
+    }
+    getScrollTop() {
+        return this.parentElement === window ? window.scrollY : this.parentElement.scrollTop;
+    }
+    /**
+     * Toggle stuck styling only while this element is visually pinned (matches `position: sticky; top: 0`).
+     * Scroll-offset thresholds would stay true for every section already passed, so multiple stacked stickies
+     * would all keep `--stuck`; geometry fixes that.
+     */
+    computeShouldStick() {
+        if (this.getScrollTop() <= 0) {
+            return false;
+        }
+        const tRect = this.targetElement.getBoundingClientRect();
+        const epsilon = 3;
+        let limitY;
+        if (this.parentElement === window) {
+            limitY = this.stickyOffset;
+        }
+        else {
+            limitY = this.parentElement.getBoundingClientRect().top;
+        }
+        return tRect.top <= limitY + epsilon && tRect.top >= limitY - epsilon;
     }
-    updateTopOffset() {
+    applyStickyStateFromScrollPosition() {
         this.zone.runOutsideAngular(() => {
-            const rect = this.targetElement.getBoundingClientRect();
-            this.topOffset = rect.top + (window.scrollY || 0);
+            const shouldStick = this.computeShouldStick();
+            if (shouldStick !== this.isSticky) {
+                this.zone.run(() => {
+                    this.isSticky = shouldStick;
+                    this.toggleStickyClasses(shouldStick);
+                    this.cdr.markForCheck();
+                });
+            }
         });
     }
     toggleStickyClasses(isSticky) {
@@ -1269,15 +1899,15 @@ class AXPStickyDirective {
     }
     ngOnDestroy() {
         this.parentElement.removeEventListener('scroll', this.onParentScroll);
-        window.removeEventListener('resize', this.updateTopOffset.bind(this));
+        window.removeEventListener('resize', this.onWindowResize);
         if (this.mutationObserver) {
             this.mutationObserver.disconnect();
         }
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPStickyDirective, deps: [{ token: i0.ElementRef }, { token: i0.Renderer2 }, { token: i0.NgZone }, { token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Directive }); }
-    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "20.3.12", type: AXPStickyDirective, isStandalone: true, selector: "[axpSticky]", inputs: { stickyClass: ["axpSticky", "stickyClass"], stickyOffset: "stickyOffset", stickyParent: "stickyParent", stickyTarget: "stickyTarget" }, outputs: { isStickyChange: "isStickyChange" }, exportAs: ["axpSticky"], ngImport: i0 }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPStickyDirective, deps: [{ token: i0.ElementRef }, { token: i0.Renderer2 }, { token: i0.NgZone }, { token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "21.2.9", type: AXPStickyDirective, isStandalone: true, selector: "[axpSticky]", inputs: { stickyClass: ["axpSticky", "stickyClass"], stickyOffset: "stickyOffset", stickyParent: "stickyParent", stickyTarget: "stickyTarget" }, outputs: { isStickyChange: "isStickyChange" }, exportAs: ["axpSticky"], ngImport: i0 }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPStickyDirective, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPStickyDirective, decorators: [{
             type: Directive,
             args: [{
                     selector: '[axpSticky]',
@@ -1620,10 +2250,10 @@ class AXPMenuMiddlewareRegistry {
     clear() {
         this.manualMiddlewares.clear();
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPMenuMiddlewareRegistry, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPMenuMiddlewareRegistry, providedIn: 'root' }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPMenuMiddlewareRegistry, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPMenuMiddlewareRegistry, providedIn: 'root' }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPMenuMiddlewareRegistry, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPMenuMiddlewareRegistry, decorators: [{
             type: Injectable,
             args: [{ providedIn: 'root' }]
         }] });
@@ -1642,6 +2272,7 @@ class AXPMenuProviderService {
         this.pendingRemovals = [];
         this.pendingUpdates = [];
         this.pendingAdditions = [];
+        this.pendingMoves = [];
         /**
          * Observable for menu reload events
          * Emits when menu cache is cleared and consumers should reload
@@ -1673,10 +2304,11 @@ class AXPMenuProviderService {
                     // If provider is a direct instance, use it directly
                     await provider.provide(context);
                 }
+                // Apply pending operations after each provider so subsequent providers
+                // can find items added by earlier providers (e.g. Tokens under Data Definitions)
+                this.applyPendingOperations(items);
             }
         }
-        // Apply pending operations
-        this.applyPendingOperations(items);
         // Sort items by priority
         items.sort((a, b) => (a.priority ?? 0) - (b.priority ?? 0));
         // Apply middlewares using registry (sorted by priority)
@@ -1706,10 +2338,10 @@ class AXPMenuProviderService {
                     // If provider is a direct instance, use it directly
                     await provider.provide(context);
                 }
+                // Apply pending operations after each provider
+                this.applyPendingOperations(items);
             }
         }
-        // Apply pending operations
-        this.applyPendingOperations(items);
         // Sort items by priority
         items.sort((a, b) => (a.priority ?? 0) - (b.priority ?? 0));
         // ADD level property to items (but NO middleware)
@@ -1726,6 +2358,7 @@ class AXPMenuProviderService {
         this.pendingRemovals = [];
         this.pendingUpdates = [];
         this.pendingAdditions = [];
+        this.pendingMoves = [];
         // Notify subscribers that menu should be reloaded
         this.menuReloadSubject.next();
     }
@@ -1787,7 +2420,14 @@ class AXPMenuProviderService {
                     },
                     addItems: (newItems) => {
                         this.pendingAdditions.push({ target, newItems });
-                    }
+                    },
+                    moveTo: (destination, position = 'inside') => {
+                        this.pendingMoves.push({
+                            source: target,
+                            destination,
+                            position: position ?? 'inside',
+                        });
+                    },
                 };
             }
         };
@@ -1894,11 +2534,15 @@ class AXPMenuProviderService {
                 }
             }
         }
+        for (const move of this.pendingMoves) {
+            this.applyPendingMove(items, move.source, move.destination, move.position);
+        }
         // Clear pending operations after applying them
         this.pendingInserts = [];
         this.pendingRemovals = [];
         this.pendingUpdates = [];
         this.pendingAdditions = [];
+        this.pendingMoves = [];
     }
     findItemWithParent(items, target, parentItems = items) {
         for (const item of items) {
@@ -1931,6 +2575,66 @@ class AXPMenuProviderService {
         }
         return null;
     }
+    applyPendingMove(items, sourceName, destName, position) {
+        if (sourceName === destName) {
+            console.warn(`moveTo: source and destination are the same ("${sourceName}"), ignored.`);
+            return;
+        }
+        const sourceInfo = this.findItemWithParent(items, sourceName);
+        const { foundItem: sourceItem, parentItems: sourceParent } = sourceInfo;
+        if (!sourceItem) {
+            console.warn(`moveTo: source "${sourceName}" not found.`);
+            return;
+        }
+        const destInfo = this.findItemWithParent(items, destName);
+        const { foundItem: destItem, parentItems: destParent } = destInfo;
+        if (!destItem) {
+            console.warn(`moveTo: destination "${destName}" not found.`);
+            return;
+        }
+        if (this.itemIsInSubtreeOf(sourceItem, destItem)) {
+            console.warn(`moveTo: cannot move "${sourceName}" because "${destName}" is inside the source subtree.`);
+            return;
+        }
+        const sourceIndex = sourceParent.indexOf(sourceItem);
+        if (sourceIndex === -1) {
+            console.warn(`moveTo: source "${sourceName}" not in parent list (inconsistent).`);
+            return;
+        }
+        sourceParent.splice(sourceIndex, 1);
+        if (position === 'inside') {
+            if (!destItem.children) {
+                destItem.children = [];
+            }
+            destItem.children.push(sourceItem);
+            return;
+        }
+        const destIndexInParent = destParent.indexOf(destItem);
+        if (destIndexInParent === -1) {
+            console.warn(`moveTo: destination "${destName}" not in parent list, reverting source removal.`);
+            sourceParent.splice(sourceIndex, 0, sourceItem);
+            return;
+        }
+        const insertIndex = position === 'before' ? destIndexInParent : destIndexInParent + 1;
+        destParent.splice(insertIndex, 0, sourceItem);
+    }
+    itemIsInSubtreeOf(root, candidate) {
+        if (root === candidate) {
+            return true;
+        }
+        if (!root.children?.length) {
+            return false;
+        }
+        for (const child of root.children) {
+            if (child === candidate) {
+                return true;
+            }
+            if (this.itemIsInSubtreeOf(child, candidate)) {
+                return true;
+            }
+        }
+        return false;
+    }
     /**
      * Merge new item properties into existing item, handling children merge
      */
@@ -1978,10 +2682,10 @@ class AXPMenuProviderService {
             }
         }
     }
-    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' }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPMenuProviderService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPMenuProviderService, providedIn: 'root' }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPMenuProviderService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPMenuProviderService, decorators: [{
             type: Injectable,
             args: [{ providedIn: 'root' }]
         }] });
@@ -2001,6 +2705,90 @@ function setMenuItemMeta(items, parentIndex = '', depth = 0) {
     });
 }
 
+//#region ---- Imports ----
+//#endregion
+//#region ---- Helpers ----
+function flattenMenuItems(items, depth) {
+    const rows = [];
+    let index = 0;
+    for (const it of items) {
+        const fallback = `menu-${depth}-${index}`;
+        index += 1;
+        const id = it.name ?? it.path ?? fallback;
+        rows.push({ id, title: it.text });
+        if (it.children?.length) {
+            rows.push(...flattenMenuItems(it.children, depth + 1));
+        }
+    }
+    return rows;
+}
+//#endregion
+//#region ---- Menu items data source ----
+/**
+ * Registered menu items (raw tree flattened) for select widgets via dataSource name {@link MENU_ITEMS_DATASOURCE_NAME}.
+ */
+const MENU_ITEMS_DATASOURCE_NAME = 'platform-menu-items';
+/**
+ * Data source definition for menu items from {@link AXPMenuProviderService#rawItems}.
+ */
+class AXPMenuItemsDataSourceDefinition {
+    constructor() {
+        //#region ---- Services & Dependencies ----
+        this.menuProviderService = inject(AXPMenuProviderService);
+        //#endregion
+    }
+    //#endregion
+    //#region ---- Public API ----
+    async items() {
+        return [
+            {
+                name: MENU_ITEMS_DATASOURCE_NAME,
+                title: 'Menu items',
+                source: () => new AXDataSource({
+                    key: 'id',
+                    load: async () => {
+                        const raw = await this.menuProviderService.rawItems();
+                        const list = flattenMenuItems(raw, 0);
+                        return { items: list, total: list.length };
+                    },
+                    byKey: async (key) => {
+                        const raw = await this.menuProviderService.rawItems();
+                        const list = flattenMenuItems(raw, 0);
+                        return list.find((item) => item.id === key);
+                    },
+                    pageSize: 1000,
+                }),
+                columns: [
+                    {
+                        name: 'id',
+                        title: 'ID',
+                        datatype: 'string',
+                        type: AXPWidgetsCatalog.text,
+                    },
+                    {
+                        name: 'title',
+                        title: 'Title',
+                        datatype: 'string',
+                        type: AXPWidgetsCatalog.text,
+                    },
+                ],
+                filters: [
+                    {
+                        field: 'title',
+                        title: 'Title',
+                        operator: { type: 'equal' },
+                        widget: { type: AXPWidgetsCatalog.text },
+                        filterType: { advance: true, inline: true },
+                    },
+                ],
+                textField: { name: 'title', title: 'Title' },
+                valueField: { name: 'id', title: 'ID' },
+            },
+        ];
+    }
+}
+//#endregion
+
 //#region ----   Menu Middleware Provider Helper   ----
 /**
  * Helper function to provide menu middlewares with proper DI setup
@@ -2295,10 +3083,10 @@ class AXPMenuVisibilityService {
         // 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' }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPMenuVisibilityService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPMenuVisibilityService, providedIn: 'root' }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPMenuVisibilityService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPMenuVisibilityService, decorators: [{
             type: Injectable,
             args: [{ providedIn: 'root' }]
         }] });
@@ -2332,21 +3120,23 @@ class AXPMenuSearchProvider {
             title: item.text, // Use `text` for the `title`
             icon: item.icon, // Include the `icon` if present
             data: omit(item, ['parent', 'children']), // Include all data except `parent` and `children`
-            command: item.path ? {
-                name: 'navigate',
-                options: {
-                    type: 'router',
+            command: item.path
+                ? {
+                    name: 'navigate',
                     options: {
-                        path: item.path,
+                        type: 'router',
+                        options: {
+                            path: item.path,
+                        },
                     },
                 }
-            } : item.command,
+                : item.command,
             parent: item.parent
                 ? {
                     title: item.parent.text,
                 }
                 : undefined,
-        })), [(o) => this.translateService.translateSync(o.title)]);
+        })), [(o) => this.translateService.translateSync(String(o.title ?? ''))]);
     }
     /**
      * Recursively searches AXPMenuItem and its children for a matching text.
@@ -2375,18 +3165,19 @@ class AXPMenuSearchProvider {
 }
 
 class AXPFooterTextSlotComponent {
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPFooterTextSlotComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
-    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "20.3.12", type: AXPFooterTextSlotComponent, isStandalone: true, selector: "ng-component", inputs: { text: "text" }, ngImport: i0, template: `
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPFooterTextSlotComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "21.2.9", type: AXPFooterTextSlotComponent, isStandalone: true, selector: "ng-component", inputs: { text: "text" }, ngImport: i0, template: `
       <small class="ax-text-sm" [innerHTML]="text"></small>
-    `, isInline: true }); }
+    `, isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPFooterTextSlotComponent, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPFooterTextSlotComponent, decorators: [{
             type: Component,
             args: [{
                     template: `
       <small class="ax-text-sm" [innerHTML]="text"></small>
     `,
-                    standalone: true
+                    standalone: true,
+                    changeDetection: ChangeDetectionStrategy.OnPush,
                 }]
         }], propDecorators: { text: [{
                 type: Input
@@ -2397,8 +3188,8 @@ class AXPNavBarSlotComponent {
         // if (action)
         //     this.store.dispatch(action)
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPNavBarSlotComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
-    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "20.3.12", type: AXPNavBarSlotComponent, isStandalone: true, selector: "ng-component", inputs: { items: "items" }, ngImport: i0, template: `
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPNavBarSlotComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "21.2.9", type: AXPNavBarSlotComponent, isStandalone: true, selector: "ng-component", inputs: { items: "items" }, ngImport: i0, template: `
     <div class="ax-flex ax-items-center ax-justify-between ax-gap-5">
       @for (link of items; track link) {
         <a (click)="handleCommand(link.command)" >{{ link.text }}</a>
@@ -2406,7 +3197,7 @@ class AXPNavBarSlotComponent {
     </div>
     `, isInline: true, encapsulation: i0.ViewEncapsulation.None }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPNavBarSlotComponent, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPNavBarSlotComponent, decorators: [{
             type: Component,
             args: [{
                     template: `
@@ -2540,17 +3331,21 @@ class AXPSearchDefinitionProviderService {
         }
         return definition;
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPSearchDefinitionProviderService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPSearchDefinitionProviderService, providedIn: 'root' }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPSearchDefinitionProviderService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPSearchDefinitionProviderService, providedIn: 'root' }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPSearchDefinitionProviderService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPSearchDefinitionProviderService, decorators: [{
             type: Injectable,
             args: [{ providedIn: 'root' }]
         }] });
 
 class AXPSearchCommandProvider {
+    constructor() {
+        this.translationService = inject(AXTranslationService);
+    }
     async search(text) {
-        return this.commands.filter((command) => command.title.toLowerCase().includes(text.toLowerCase()));
+        const locale = this.translationService.getActiveLang() ?? 'en-US';
+        return this.commands.filter((command) => searchInMultiLanguageString(command.title, text, locale));
     }
 }
 
@@ -2561,6 +3356,7 @@ class AXPSearchService {
         this.providers = inject(AXP_SEARCH_PROVIDER, { optional: true });
         this.definitionService = inject(AXPSearchDefinitionProviderService);
         this.formatService = inject(AXFormatService);
+        this.translationService = inject(AXTranslationService);
     }
     async search(text) {
         //TODO better handle this
@@ -2579,8 +3375,12 @@ class AXPSearchService {
         if (allProviders.length === 0) {
             throw new Error('No search providers available');
         }
+        const providersWithSearch = allProviders.filter((provider) => provider != null && typeof provider.search === 'function');
+        if (providersWithSearch.length === 0) {
+            throw new Error('No search providers with a valid search method available');
+        }
         const mergeData = [];
-        const promises = allProviders.map((provider) => provider.search(text));
+        const promises = providersWithSearch.map((provider) => provider.search(text));
         const results = await Promise.all(promises);
         for (const resultArray of results) {
             for (const result of resultArray) {
@@ -2599,10 +3399,7 @@ class AXPSearchService {
                             (definition.format.description
                                 ? this.formatService.format(definition.format.description, 'string', result.data)
                                 : undefined),
-                        icon: result.icon ??
-                            (result.icon
-                                ? this.formatService.format(definition.format.icon, 'string', result.data)
-                                : definition.icon),
+                        icon: result.icon ?? definition.icon,
                         data: result.data,
                         command: result.command,
                         actions: definition.actions,
@@ -2615,11 +3412,17 @@ class AXPSearchService {
                 }
             }
         }
+        const locale = this.translationService.getActiveLang() ?? 'en-US';
+        const normalizedQuery = text.trim();
+        const visibleData = normalizedQuery.length === 0
+            ? mergeData
+            : mergeData.filter((item) => searchInMultiLanguageString(item.title, normalizedQuery, locale) ||
+                searchInMultiLanguageString(item.description, normalizedQuery, locale));
         // Group data
         const groupedData = [];
         const groupMap = {};
         // Create groups
-        for (const item of mergeData) {
+        for (const item of visibleData) {
             const groupName = item.definitionName; // Change this to the property you want to group by
             if (!groupMap[groupName]) {
                 groupMap[groupName] = {
@@ -2636,18 +3439,64 @@ class AXPSearchService {
         groupedData.sort((a, b) => a.order - b.order);
         return groupedData;
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPSearchService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPSearchService, providedIn: 'root' }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPSearchService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPSearchService, providedIn: 'root' }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPSearchService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPSearchService, decorators: [{
             type: Injectable,
             args: [{ providedIn: 'root' }]
         }] });
 
+/**
+ * Shared utility for creating Entity:Create command options used in search command providers.
+ * Use with command: { name: 'Entity:Create', options: createEntityCommandOptions(...) }
+ */
+function createEntityCommandOptions(entityKey, entityInfo) {
+    return {
+        __context__: {
+            entity: entityKey,
+            entityInfo: {
+                name: entityInfo.name,
+                module: entityInfo.module,
+                title: entityInfo.title,
+                parentKey: undefined,
+                source: entityKey,
+            },
+            data: {},
+            options: {},
+        },
+    };
+}
+/**
+ * Creates a search command for "Create {Entity}" with consistent i18n pattern.
+ * Use titleKey/descriptionKey from module (e.g. @module:entity.permissions.create.title).
+ * Standard: "Create {Entity}" for title, "Create new {entities}" for description.
+ */
+function createEntitySearchCommand(config) {
+    return {
+        id: config.id,
+        group: 'command',
+        title: config.titleKey,
+        description: config.descriptionKey ?? config.titleKey,
+        icon: config.icon,
+        command: {
+            name: 'Entity:Create',
+            options: createEntityCommandOptions(config.entityKey, config.entityInfo),
+        },
+    };
+}
+
 var AXPCommonSettings;
 (function (AXPCommonSettings) {
     AXPCommonSettings["EnableOperationToasts"] = "Common:Setting:Notifications.EnableOperationToasts";
     AXPCommonSettings["EntityFilterApplyMode"] = "Common:Setting:Entity.FilterApplyMode";
+    AXPCommonSettings["ShowCategoryColumnsByDefault"] = "Common:Setting:Entity.ShowCategoryColumnsByDefault";
+    AXPCommonSettings["ApplyLayoutOrdering"] = "Common:Setting:Entity.ApplyLayoutOrdering";
+    AXPCommonSettings["RedirectToDetailsAfterCreate"] = "Common:Setting:Entity.RedirectToDetailsAfterCreate";
+    AXPCommonSettings["ShowPageBadge"] = "Common:Setting:Entity.ShowPageBadge";
+    AXPCommonSettings["DebugMode"] = "PlatformDevTools:Setting:Developer.DebugMode";
+    AXPCommonSettings["ShowRowIndexColumn"] = "Common:Setting:Entity.ShowRowIndexColumn";
+    AXPCommonSettings["EntityListPersistenceMode"] = "Common:Setting:Entity.ListPersistenceMode";
 })(AXPCommonSettings || (AXPCommonSettings = {}));
 
 //TODO Loading, Redirect, Drawer, Show toast
@@ -2672,10 +3521,10 @@ class AXPWorkflowNavigateAction extends AXPWorkflowAction {
                 this.router.navigate([payload.commands], payload.extras);
         }
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPWorkflowNavigateAction, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPWorkflowNavigateAction }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPWorkflowNavigateAction, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPWorkflowNavigateAction }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPWorkflowNavigateAction, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPWorkflowNavigateAction, decorators: [{
             type: Injectable
         }] });
 class AXPDialogConfirmAction extends AXPWorkflowAction {
@@ -2691,10 +3540,10 @@ class AXPDialogConfirmAction extends AXPWorkflowAction {
         const dialogResult = await this.dialogService.confirm(await this.translationService.translateAsync(this.title), await this.translationService.translateAsync(this.message), (await this.translationService.translateAsync(this.type)), 'horizontal', false, 'cancel');
         context.setOutput('result', dialogResult.result);
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPDialogConfirmAction, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPDialogConfirmAction }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPDialogConfirmAction, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPDialogConfirmAction }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPDialogConfirmAction, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPDialogConfirmAction, decorators: [{
             type: Injectable
         }] });
 class AXPToastAction extends AXPWorkflowAction {
@@ -2717,20 +3566,20 @@ class AXPToastAction extends AXPWorkflowAction {
             });
         }
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPToastAction, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPToastAction }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPToastAction, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPToastAction }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPToastAction, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPToastAction, decorators: [{
             type: Injectable
         }] });
 class AXPReloadAction extends AXPWorkflowAction {
     async execute(context) {
         this.dispatch(AXPReloadEvent({ entity: context.getVariable('entity'), meta: context.getVariable('meta') }));
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPReloadAction, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPReloadAction }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPReloadAction, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPReloadAction }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPReloadAction, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPReloadAction, decorators: [{
             type: Injectable
         }] });
 
@@ -2742,6 +3591,10 @@ class AXPWorkflowRouterNavigateAction extends AXPWorkflowAction {
     async execute(context) {
         const command = context.getVariable();
         const path = command.options.path;
+        if (!path) {
+            console.error('Path is required for navigate workflow');
+            return;
+        }
         if (path?.toLowerCase()?.startsWith('http') || command.options?.extras?.target === 'blank') {
             window.open(path, '_blank');
         }
@@ -2770,10 +3623,10 @@ class AXPWorkflowRouterNavigateAction extends AXPWorkflowAction {
             return params;
         }, {});
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPWorkflowRouterNavigateAction, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPWorkflowRouterNavigateAction }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPWorkflowRouterNavigateAction, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPWorkflowRouterNavigateAction }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPWorkflowRouterNavigateAction, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPWorkflowRouterNavigateAction, decorators: [{
             type: Injectable
         }] });
 const AXPNavigateWorkflow = {
@@ -2798,13 +3651,61 @@ class AXMWorkflowErrorHandler {
             next(error);
         }
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXMWorkflowErrorHandler, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXMWorkflowErrorHandler }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXMWorkflowErrorHandler, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXMWorkflowErrorHandler }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXMWorkflowErrorHandler, decorators: [{
+            type: Injectable
+        }] });
+
+class AXPFileStorageService {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPFileStorageService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPFileStorageService }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXMWorkflowErrorHandler, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPFileStorageService, decorators: [{
             type: Injectable
         }] });
 
+var AXPFileStorageStatus;
+(function (AXPFileStorageStatus) {
+    AXPFileStorageStatus["Temporary"] = "temporary";
+    AXPFileStorageStatus["Committed"] = "committed";
+    AXPFileStorageStatus["PendingDeletion"] = "pendingDeletion";
+    AXPFileStorageStatus["Archived"] = "archived";
+    AXPFileStorageStatus["Error"] = "error";
+})(AXPFileStorageStatus || (AXPFileStorageStatus = {}));
+
+class AXPFileStorageEvaluatorScopeProvider {
+    constructor() {
+        this.fileStorageService = inject(AXPFileStorageService);
+    }
+    async provide(context) {
+        console.log('fileStorageEvaluatorScopeProvider', context);
+        //
+        context.addScope('fileStorage', {
+            getFiles: async (entityType, entityId) => {
+                console.log('getFiles', entityType, entityId);
+                const filesFromService = await this.fileStorageService.find({
+                    category: '',
+                    refId: entityId,
+                    refType: entityType,
+                });
+                const mappedFiles = filesFromService?.map((file) => ({
+                    id: file.id ?? '',
+                    name: file.name,
+                    size: file.size,
+                    status: 'remote',
+                    source: {
+                        kind: 'fileId',
+                        value: file.fileId,
+                    },
+                }));
+                return mappedFiles;
+            },
+        });
+    }
+}
+
 class AXPCommonModule {
     static forRoot(configs) {
         return {
@@ -2846,12 +3747,12 @@ class AXPCommonModule {
             f();
         });
     }
-    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,
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPCommonModule, deps: [{ token: 'AXPCommonModuleFactory' }], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "21.2.9", ngImport: i0, type: AXPCommonModule, imports: [i1.AXPWorkflowModule, AXPopupModule,
             AXDateTimeModule,
             AXToastModule,
             AXPModuleManifestModule], exports: [RouterModule] }); }
-    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPCommonModule, providers: [
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPCommonModule, providers: [
             AXPAppStartUpProvider,
             {
                 provide: ErrorHandler,
@@ -2880,11 +3781,21 @@ class AXPCommonModule {
                 useClass: AXPTokenEvaluatorScopeProvider,
                 multi: true,
             },
+            {
+                provide: AXP_EXPRESSION_EVALUATOR_SCOPE_PROVIDER,
+                useClass: AXPSettingsEvaluatorScopeProvider,
+                multi: true,
+            },
+            {
+                provide: AXP_EXPRESSION_EVALUATOR_SCOPE_PROVIDER,
+                useClass: AXPFileStorageEvaluatorScopeProvider,
+                multi: true,
+            },
             {
                 provide: AXP_SETTING_DEFINITION_PROVIDER,
                 useFactory: async () => {
                     const injector = inject(Injector);
-                    const provider = (await import('./acorex-platform-common-common-settings.provider-zhqNP3xb.mjs')).AXPCommonSettingProvider;
+                    const provider = (await import('./acorex-platform-common-common-settings.provider-Bi1RYif5.mjs')).AXPCommonSettingProvider;
                     return new provider(injector);
                 },
                 multi: true,
@@ -2905,7 +3816,7 @@ class AXPCommonModule {
             AXToastModule,
             AXPModuleManifestModule, RouterModule] }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPCommonModule, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPCommonModule, decorators: [{
             type: NgModule,
             args: [{
                     imports: [
@@ -2955,11 +3866,21 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImpo
                             useClass: AXPTokenEvaluatorScopeProvider,
                             multi: true,
                         },
+                        {
+                            provide: AXP_EXPRESSION_EVALUATOR_SCOPE_PROVIDER,
+                            useClass: AXPSettingsEvaluatorScopeProvider,
+                            multi: true,
+                        },
+                        {
+                            provide: AXP_EXPRESSION_EVALUATOR_SCOPE_PROVIDER,
+                            useClass: AXPFileStorageEvaluatorScopeProvider,
+                            multi: true,
+                        },
                         {
                             provide: AXP_SETTING_DEFINITION_PROVIDER,
                             useFactory: async () => {
                                 const injector = inject(Injector);
-                                const provider = (await import('./acorex-platform-common-common-settings.provider-zhqNP3xb.mjs')).AXPCommonSettingProvider;
+                                const provider = (await import('./acorex-platform-common-common-settings.provider-Bi1RYif5.mjs')).AXPCommonSettingProvider;
                                 return new provider(injector);
                             },
                             multi: true,
@@ -2991,22 +3912,165 @@ function configPlatform(config = AXPPlatformDefaultConfigs) {
 
 const AXP_ROOT_CONFIG_TOKEN = new InjectionToken('AXP_ROOT_CONFIG_TOKEN');
 
-class AXPFileStorageService {
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPFileStorageService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPFileStorageService }); }
+//#endregion
+//#region ---- Injection Token ----
+/**
+ * Multi-provider injection token for file action providers.
+ * Modules can provide multiple implementations using this token.
+ */
+const AXP_FILE_ACTION_PROVIDER = new InjectionToken('AXP_FILE_ACTION_PROVIDER');
+//#endregion
+
+//#region ---- Service ----
+/**
+ * Service for managing file uploader actions.
+ * Aggregates actions from multiple providers and filters them based on plugin configuration.
+ * Wraps the hook system for backward compatibility.
+ */
+class AXPFileActionsService {
+    constructor() {
+        //#region ---- Dependencies ----
+        this.actionProviders = inject(AXP_FILE_ACTION_PROVIDER, { optional: true }) || [];
+        this.hookService = inject(AXPHookService);
+        this.injector = inject(Injector);
+    }
+    //#endregion
+    //#region ---- Public API ----
+    /**
+     * Get all actions from providers, filtered based on plugin configuration.
+     * Wraps the hook system for backward compatibility.
+     * @param payload Initial payload with capabilities and plugin configuration.
+     * @returns Filtered list of actions.
+     */
+    async getActions(payload) {
+        // First, run hook system for backward compatibility
+        // Note: Hook system may still use old format with 'host', but we pass capabilities
+        // Hook providers that need host will need to be migrated to use capabilities
+        let hookPayload;
+        try {
+            hookPayload = await this.hookService.runAsync('file-uploader.actions', {
+                ...payload,
+                // For backward compatibility, hooks might expect 'host' but we're using capabilities
+                // Old hook providers will need to be migrated
+            });
+        }
+        catch (err) {
+            // If hook fails, continue with new system
+            console.warn('[AXPFileActionsService] Hook system failed, continuing with providers only', err);
+        }
+        // Merge hook actions into payload (if any)
+        const mergedPayload = {
+            ...payload,
+            actions: hookPayload?.actions ?? payload.actions ?? [],
+        };
+        // Resolve all providers (handle both direct and Promise<provider>)
+        const providers = await this.resolveProviders();
+        // Filter providers by key
+        const matchingProviders = providers
+            .filter((p) => p.key === 'file-uploader.actions')
+            .sort((a, b) => (a.priority ?? 0) - (b.priority ?? 0));
+        // Execute providers sequentially (waterfall pattern)
+        let currentPayload = { ...mergedPayload, actions: [...mergedPayload.actions] };
+        for (const provider of matchingProviders) {
+            try {
+                currentPayload = await Promise.resolve(runInInjectionContext(this.injector, () => provider.execute(currentPayload)));
+            }
+            catch (err) {
+                console.error(`[AXPFileActionsService] Provider '${provider.key}' failed`, err);
+            }
+        }
+        // Filter actions based on plugin configuration
+        return this.filterActions(currentPayload.actions, payload.plugins, payload.excludePlugins);
+    }
+    //#endregion
+    //#region ---- Private Methods ----
+    /**
+     * Resolve all providers (handle both direct providers and Promise<provider>).
+     */
+    async resolveProviders() {
+        return Promise.all(this.actionProviders.map((p) => (p instanceof Promise ? p : Promise.resolve(p))));
+    }
+    /**
+     * Filter actions based on enabled plugins and exclude list.
+     */
+    filterActions(actions, enabledPlugins, excludePlugins) {
+        const enabledPluginNames = enabledPlugins?.map((p) => p.name) ?? [];
+        const excludedPluginNames = excludePlugins ?? [];
+        return actions.filter((action) => {
+            // Exclude if in exclude list
+            if (excludedPluginNames.includes(action.plugin)) {
+                return false;
+            }
+            // Include if global
+            if (action.global === true) {
+                return true;
+            }
+            // Include if plugin is explicitly enabled
+            if (enabledPluginNames.length > 0 && enabledPluginNames.includes(action.plugin)) {
+                return true;
+            }
+            // If no plugins are enabled, only show global actions
+            if (enabledPluginNames.length === 0) {
+                return !!action.global;
+            }
+            return false;
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPFileActionsService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPFileActionsService, providedIn: 'root' }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPFileStorageService, decorators: [{
-            type: Injectable
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPFileActionsService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
         }] });
 
-var AXPFileStorageStatus;
-(function (AXPFileStorageStatus) {
-    AXPFileStorageStatus["Temporary"] = "temporary";
-    AXPFileStorageStatus["Committed"] = "committed";
-    AXPFileStorageStatus["PendingDeletion"] = "pendingDeletion";
-    AXPFileStorageStatus["Archived"] = "archived";
-    AXPFileStorageStatus["Error"] = "error";
-})(AXPFileStorageStatus || (AXPFileStorageStatus = {}));
+//#endregion
+
+const UploadFromComputerActionProvider = {
+    key: 'file-uploader.actions',
+    priority: 1, // Higher priority than upload-from-drive to show first
+    execute: (payload) => {
+        const fileService = inject(AXFileService);
+        // Capture widget options for use in the action
+        const widgetOptions = payload.options;
+        payload.actions = [
+            ...payload.actions,
+            {
+                plugin: 'upload-from-computer',
+                global: true,
+                textKey: '@document-management:actions.upload-from-device',
+                icon: 'fa-light fa-file-arrow-up',
+                run: async (capabilities) => {
+                    // Open file picker with widget options
+                    const files = await fileService.choose({
+                        multiple: widgetOptions?.multiple ?? true,
+                        accept: widgetOptions?.accept,
+                    });
+                    // If no files are selected, return
+                    if (files.length === 0) {
+                        return;
+                    }
+                    // Create file list items from selected files
+                    const fileItems = files.map((file) => ({
+                        id: AXPDataGenerator.uuid(),
+                        name: file.name,
+                        size: file.size,
+                        status: 'attached',
+                        source: {
+                            kind: 'blob',
+                            value: file,
+                        },
+                    }));
+                    // Add files using capabilities
+                    capabilities.addFiles(fileItems);
+                },
+            },
+        ];
+        return payload;
+    },
+};
 
 const AXP_FILE_TYPE_INFO_PROVIDER = new InjectionToken('AXP_FILE_TYPE_INFO_PROVIDER');
 class AXPFileTypeProviderService {
@@ -3025,19 +4089,19 @@ class AXPFileTypeProviderService {
     async get(name) {
         return (await this.items()).find((c) => c.name == name);
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPFileTypeProviderService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPFileTypeProviderService, providedIn: 'root' }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPFileTypeProviderService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPFileTypeProviderService, providedIn: 'root' }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPFileTypeProviderService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPFileTypeProviderService, decorators: [{
             type: Injectable,
             args: [{ providedIn: 'root' }]
         }] });
 
 class AXPLockService {
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPLockService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPLockService }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPLockService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPLockService }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPLockService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPLockService, decorators: [{
             type: Injectable
         }] });
 
@@ -3090,7 +4154,7 @@ const AXP_STATUS_PROVIDERS = new InjectionToken('AXP_STATUS_PROVIDERS');
  * }
  *
  * // Later, get the status:
- * const status = statusService.getStatus('task-management.status');
+ * const status = await statusService.getStatus('task-management.status');
  * if (status) {
  *   console.log('Statuses:', status.statuses);
  *   console.log('Transitions:', status.transitions);
@@ -3098,8 +4162,6 @@ const AXP_STATUS_PROVIDERS = new InjectionToken('AXP_STATUS_PROVIDERS');
  * ```
  */
 class AXPStatusDefinitionProviderService {
-    //#endregion
-    //#region ----   Initialization   ----
     constructor() {
         //#region ----   Dependencies   ----
         this.providers = inject(AXP_STATUS_PROVIDERS, { optional: true }) ?? [];
@@ -3109,8 +4171,9 @@ class AXPStatusDefinitionProviderService {
         this.statusMap = new Map();
         this.initializationPromise = null;
         this.isInitialized = false;
-        this.initialize();
     }
+    //#endregion
+    //#region ----   Initialization   ----
     /**
      * Initialize providers (resolve promises if needed)
      * Called lazily on first access
@@ -3148,22 +4211,22 @@ class AXPStatusDefinitionProviderService {
     //#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.
+     * Ensures initialization is complete before accessing the status map.
      *
      * @param key - Status key (e.g., 'task-management.status')
-     * @returns Status provider with all statuses and transitions, or undefined if not found
+     * @returns Promise that resolves to status provider with all statuses and transitions, or undefined if not found
      *
      * @example
      * ```typescript
-     * const status = statusService.getStatus('task-management.status');
+     * const status = await statusService.getStatus('task-management.status');
      * if (status) {
      *   console.log('Statuses:', status.statuses);
      *   console.log('Transitions:', status.transitions);
      * }
      * ```
      */
-    getStatus(key) {
+    async getStatus(key) {
+        await this.initialize();
         return this.statusMap.get(key);
     }
     /**
@@ -3208,7 +4271,7 @@ class AXPStatusDefinitionProviderService {
         }
         else {
             // Use default Entity:UpdateStatus command
-            const entity = context['entityName'] ?? context['__meta__']?.config?.name;
+            const entity = context['entity'] ?? context['entityName'] ?? context['__meta__']?.config?.name;
             if (!entity) {
                 throw new Error('Entity name is required in context when using default status update command');
             }
@@ -3221,7 +4284,7 @@ class AXPStatusDefinitionProviderService {
             commandOptions = {
                 entity,
                 status: transition.to,
-                statusField: context['statusField'] ?? 'statusId',
+                statusField: context['statusField'] ?? context['fieldName'] ?? 'statusId',
                 ...(id ? { id } : {}),
                 ...(ids ? { ids } : {}),
             };
@@ -3229,7 +4292,8 @@ class AXPStatusDefinitionProviderService {
         // 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');
+            const text = this.commandMessageTextForError(result?.message?.text);
+            throw new Error(text || 'Failed to execute status transition command');
         }
     }
     /**
@@ -3239,13 +4303,30 @@ class AXPStatusDefinitionProviderService {
     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' }); }
+    /**
+     * Best-effort plain string for {@link Error} messages (no i18n lookup).
+     */
+    commandMessageTextForError(value) {
+        if (value == null) {
+            return '';
+        }
+        if (typeof value === 'string') {
+            return value;
+        }
+        if (typeof value === 'object' && !Array.isArray(value)) {
+            const values = Object.values(value);
+            const first = values.find((v) => typeof v === 'string' && v.length > 0);
+            return first ?? '';
+        }
+        return String(value);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPStatusDefinitionProviderService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPStatusDefinitionProviderService, providedIn: 'root' }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPStatusDefinitionProviderService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPStatusDefinitionProviderService, decorators: [{
             type: Injectable,
             args: [{ providedIn: 'root' }]
-        }], ctorParameters: () => [] });
+        }] });
 
 /**
  * Standard system status types
@@ -3263,6 +4344,7 @@ var AXPSystemStatusType;
     AXPSystemStatusType["Cancelled"] = "cancelled";
     AXPSystemStatusType["Draft"] = "draft";
     AXPSystemStatusType["PendingReview"] = "pending-review";
+    AXPSystemStatusType["WaitingSignOff"] = "waiting-sign-off";
     AXPSystemStatusType["Approved"] = "approved";
     AXPSystemStatusType["Published"] = "published";
     AXPSystemStatusType["Archived"] = "archived";
@@ -3383,6 +4465,16 @@ const AXPSystemStatuses = Object.freeze({
         isInitial: false,
         isFinal: false,
     },
+    WaitingSignOff: {
+        name: AXPSystemStatusType.WaitingSignOff,
+        title: i18n('waiting-sign-off.title'),
+        icon: 'fa-light fa-clock',
+        color: 'warning',
+        description: i18n('waiting-sign-off.description'),
+        order: 3,
+        isInitial: false,
+        isFinal: false,
+    },
     Approved: {
         name: AXPSystemStatusType.Approved,
         title: i18n('approved.title'),
@@ -3589,10 +4681,10 @@ class AXPClipBoardService {
         navigator.clipboard.writeText(value);
         this.toast.success(`${title} copied!`);
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPClipBoardService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPClipBoardService, providedIn: 'root' }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPClipBoardService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPClipBoardService, providedIn: 'root' }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPClipBoardService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPClipBoardService, decorators: [{
             type: Injectable,
             args: [{
                     providedIn: 'root',
@@ -3706,10 +4798,10 @@ class AXPDebugService {
             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' }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPDebugService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPDebugService, providedIn: 'root' }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPDebugService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPDebugService, decorators: [{
             type: Injectable,
             args: [{
                     providedIn: 'root',
@@ -3719,15 +4811,15 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImpo
 class AXMOrgChartPrintPage extends AXBasePageComponent {
     constructor() {
         super(...arguments);
-        this.ratio = signal(false, ...(ngDevMode ? [{ debugName: "ratio" }] : []));
-        this.baseWidth = signal(undefined, ...(ngDevMode ? [{ debugName: "baseWidth" }] : []));
-        this.baseHeight = signal(undefined, ...(ngDevMode ? [{ debugName: "baseHeight" }] : []));
-        this.bgcolor = model(...(ngDevMode ? [undefined, { debugName: "bgcolor" }] : []));
-        this.width = model(...(ngDevMode ? [undefined, { debugName: "width" }] : []));
-        this.height = model(...(ngDevMode ? [undefined, { debugName: "height" }] : []));
-        this.quality = model(...(ngDevMode ? [undefined, { debugName: "quality" }] : []));
-        this.qualityComputed = linkedSignal(() => (this.data.quality ?? 1) * 100, ...(ngDevMode ? [{ debugName: "qualityComputed" }] : []));
-        this.scale = model(...(ngDevMode ? [undefined, { debugName: "scale" }] : []));
+        this.ratio = signal(false, ...(ngDevMode ? [{ debugName: "ratio" }] : /* istanbul ignore next */ []));
+        this.baseWidth = signal(undefined, ...(ngDevMode ? [{ debugName: "baseWidth" }] : /* istanbul ignore next */ []));
+        this.baseHeight = signal(undefined, ...(ngDevMode ? [{ debugName: "baseHeight" }] : /* istanbul ignore next */ []));
+        this.bgcolor = model(...(ngDevMode ? [undefined, { debugName: "bgcolor" }] : /* istanbul ignore next */ []));
+        this.width = model(...(ngDevMode ? [undefined, { debugName: "width" }] : /* istanbul ignore next */ []));
+        this.height = model(...(ngDevMode ? [undefined, { debugName: "height" }] : /* istanbul ignore next */ []));
+        this.quality = model(...(ngDevMode ? [undefined, { debugName: "quality" }] : /* istanbul ignore next */ []));
+        this.qualityComputed = linkedSignal(() => (this.data.quality ?? 1) * 100, ...(ngDevMode ? [{ debugName: "qualityComputed" }] : /* istanbul ignore next */ []));
+        this.scale = model(...(ngDevMode ? [undefined, { debugName: "scale" }] : /* istanbul ignore next */ []));
         this.#init = afterNextRender(() => {
             this.bgcolor.set(this.data.bgcolor);
             this.width.set(this.data.width);
@@ -3764,8 +4856,8 @@ class AXMOrgChartPrintPage extends AXBasePageComponent {
             isCanceled,
         });
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXMOrgChartPrintPage, deps: null, target: i0.ɵɵFactoryTarget.Component }); }
-    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.1.0", version: "20.3.12", type: AXMOrgChartPrintPage, isStandalone: true, selector: "ng-component", inputs: { bgcolor: { classPropertyName: "bgcolor", publicName: "bgcolor", isSignal: true, isRequired: false, transformFunction: null }, width: { classPropertyName: "width", publicName: "width", isSignal: true, isRequired: false, transformFunction: null }, height: { classPropertyName: "height", publicName: "height", isSignal: true, isRequired: false, transformFunction: null }, quality: { classPropertyName: "quality", publicName: "quality", isSignal: true, isRequired: false, transformFunction: null }, scale: { classPropertyName: "scale", publicName: "scale", isSignal: true, isRequired: false, transformFunction: null } }, outputs: { bgcolor: "bgcolorChange", width: "widthChange", height: "heightChange", quality: "qualityChange", scale: "scaleChange" }, usesInheritance: true, ngImport: i0, template: ` <div class="ax-grid ax-grid-cols-[auto_18rem] ax-gap-4 ax-justify-center ax-p-4 ax-items-center">
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXMOrgChartPrintPage, deps: null, target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.1.0", version: "21.2.9", type: AXMOrgChartPrintPage, isStandalone: true, selector: "ng-component", inputs: { bgcolor: { classPropertyName: "bgcolor", publicName: "bgcolor", isSignal: true, isRequired: false, transformFunction: null }, width: { classPropertyName: "width", publicName: "width", isSignal: true, isRequired: false, transformFunction: null }, height: { classPropertyName: "height", publicName: "height", isSignal: true, isRequired: false, transformFunction: null }, quality: { classPropertyName: "quality", publicName: "quality", isSignal: true, isRequired: false, transformFunction: null }, scale: { classPropertyName: "scale", publicName: "scale", isSignal: true, isRequired: false, transformFunction: null } }, outputs: { bgcolor: "bgcolorChange", width: "widthChange", height: "heightChange", quality: "qualityChange", scale: "scaleChange" }, usesInheritance: true, ngImport: i0, template: ` <div class="ax-grid ax-grid-cols-[auto_18rem] ax-gap-4 ax-justify-center ax-p-4 ax-items-center">
       <ax-label>Resolution (px)</ax-label>
       <div class="ax-flex ax-gap-2 ax-items-center">
         <ax-number-box
@@ -3816,7 +4908,7 @@ class AXMOrgChartPrintPage extends AXBasePageComponent {
       </ax-suffix>
     </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: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXMOrgChartPrintPage, decorators: [{
             type: Component,
             args: [{
                     template: ` <div class="ax-grid ax-grid-cols-[auto_18rem] ax-gap-4 ax-justify-center ax-p-4 ax-items-center">
@@ -3930,10 +5022,10 @@ class AXPExportService {
         document.body.removeChild(link);
         URL.revokeObjectURL(link.href);
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPExportService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPExportService, providedIn: 'root' }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPExportService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPExportService, providedIn: 'root' }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPExportService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPExportService, decorators: [{
             type: Injectable,
             args: [{
                     providedIn: 'root',
@@ -3963,6 +5055,8 @@ function AXPCleanNestedFilters(filters) {
         .filter(Boolean);
 }
 
+const AXP_LOCALE_MANAGEMENT_PORT = new InjectionToken('AXP_LOCALE_MANAGEMENT_PORT');
+
 //#region ----   Versioning Types   ----
 var AXVChangeType;
 (function (AXVChangeType) {
@@ -3980,5 +5074,5 @@ class AXPVersioningService {
  * Generated bundle index. Do not edit.
  */
 
-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 };
+export { ALL_DEFAULT_OPERATORS, AXMWorkflowErrorHandler, AXPAppVersionService, AXPCleanNestedFilters, AXPClipBoardService, AXPCommonModule, AXPCommonSettings, AXPCustomOperatorService, AXPCustomOperatorServiceImpl, AXPDataProvider, AXPDebugService, AXPDefaultMultiLanguageConfigService, AXPDialogConfirmAction, AXPEntityCommandScope, AXPEntityQueryType, AXPEntityType, AXPErrorHandlerRegistryService, AXPExportService, AXPFileActionsService, AXPFileStorageEvaluatorScopeProvider, AXPFileStorageService, AXPFileStorageStatus, AXPFileTypeProviderService, AXPFilterOperatorMiddlewareService, AXPFilterOperatorMiddlewareServiceImpl, AXPFooterTextSlotComponent, AXPGlobalErrorHandler, AXPHomePageModule, AXPHomePageService, AXPLockService, AXPMenuItemsDataSourceDefinition, AXPMenuMiddlewareRegistry, AXPMenuProviderService, AXPMenuSearchDefinitionProvider, AXPMenuSearchProvider, AXPMenuService, AXPMenuVisibilityService, AXPNavBarSlotComponent, AXPNavigateWorkflow, AXPOutputContractTranscriptSegmentService, AXPPlatformDefaultConfigs, AXPRedirectEvent, AXPRefreshEvent, AXPRegionalSetting, AXPRelationshipCardinality, AXPRelationshipKind, AXPReloadAction, AXPReloadEvent, AXPSearchCommandProvider, AXPSearchDefinitionActionBuilder, AXPSearchDefinitionBuilder, AXPSearchDefinitionProviderContext, AXPSearchDefinitionProviderService, AXPSearchService, AXPSettingDefaultValuesAggregatorService, AXPSettingDefinitionGroupBuilder, AXPSettingDefinitionProviderContext, AXPSettingDefinitionProviderService, AXPSettingDefinitionSectionBuilder, AXPSettingsEvaluatorScopeProvider, AXPSettingsService, AXPStatusDefinitionProviderService, AXPStatusProvider, AXPStickyDirective, AXPSystemStatusType, AXPSystemStatuses, AXPToastAction, AXPTokenDefinitionService, AXPTokenEvaluatorScopeProvider, AXPVersioningService, AXPWorkflowNavigateAction, AXPWorkflowRouterNavigateAction, AXP_AGENT_OUTPUT_CONTRACT_DEFAULT_STRUCTURED_RETRIES, AXP_APP_VERSION_PROVIDER, AXP_FILE_ACTION_PROVIDER, AXP_FILE_TYPE_INFO_PROVIDER, AXP_HOME_PAGES, AXP_HOME_PAGE_DEFAULT_KEY, AXP_LOCALE_MANAGEMENT_PORT, AXP_MENU_MIDDLEWARE, AXP_MENU_PROVIDER, AXP_OUTPUT_CONTRACT_TRANSCRIPT_SEGMENT_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, DEFAULT_DATE_FILTER_PRESETS, DEFAULT_MULTILANGUAGE_FIELD_NAMES, ENDS_WITH_OPER, ENVIRONMENT, EQ_OPER, GTE_OPER, GT_OPER, IN_OPER, IS_EMPTY_OPER, IS_NOT_EMPTY_OPER, LTE_OPER, LT_OPER, MENU_ITEMS_DATASOURCE_NAME, MULTILANGUAGE_CAPABLE_WIDGET_TYPES, NOT_CONTAINS_OPER, NOT_EQ_OPER, NUMBER_OPERATORS, STARTS_WITH_OPER, STRING_OPERATORS, UploadFromComputerActionProvider, applyDateFilterPreset, coerceAXPSettingRawValue, coerceAXPSettingRawValueByKind, configPlatform, createAllQueryView, createEntityCommandOptions, createEntitySearchCommand, createMenuContext, createMenuMiddleware, createQueryView, findManualPresetIdByOperation, getEntityInfo, getStatusInfo, getSystemStatus, inferSettingCoercionKind, isCardFieldBadgeDisplay, peelSettingValueKey, provideDynamicHomePage, provideMenuMiddleware, resolveCardFieldBadgeColor, resolveDateFilterPresets, resolveDefaultMasterListLayout, resolveEnabledMasterListLayouts, resolveStatusLook, shouldApplyDefaultMultiLanguageToEntityProperty, shouldApplyDefaultMultiLanguageToWidgetNode, shouldApplyDefaultMultiLanguageToWidgetProperty, systemStatusToDefinition, withDefaultMultiLanguageOnWidgetNodeTree, withDefaultMultiLanguageOnWidgetProperty };
 //# sourceMappingURL=acorex-platform-common.mjs.map