@acorex/platform 0.0.0-ACOREX

package/fesm2022/acorex-platform-common.mjs

@@ -0,0 +1,4601 @@
+import * as i0 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, AXPHookService, AXPDataGenerator, AXPModuleManifestRegistry } from '@acorex/platform/core';
+import { AXTranslationService } from '@acorex/core/translation';
+import { AXPWidgetsCatalog } from '@acorex/platform/layout/widget-core';
+import { AXPopupModule, AXPopupService } from '@acorex/components/popup';
+import { AXToastService, AXToastModule } from '@acorex/components/toast';
+import { AXDateTimeModule } from '@acorex/core/date-time';
+import * as 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 { 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';
+import * as i6 from '@acorex/components/color-box';
+import { AXColorBoxModule } from '@acorex/components/color-box';
+import * as i4 from '@acorex/components/decorators';
+import { AXDecoratorModule } from '@acorex/components/decorators';
+import * as i3 from '@acorex/components/label';
+import { AXLabelModule } from '@acorex/components/label';
+import * as i2 from '@acorex/components/number-box';
+import { AXNumberBoxModule } from '@acorex/components/number-box';
+import { AXBasePageComponent } from '@acorex/components/page';
+import { AXTextBoxModule } from '@acorex/components/text-box';
+import * as i1$1 from '@angular/forms';
+import { FormsModule } from '@angular/forms';
+
+const AXP_APP_VERSION_PROVIDER = new InjectionToken('AXP_APP_VERSION_PROVIDER', {
+    providedIn: 'root',
+    factory: () => {
+        return new AXPAppVersionDefaultProvider();
+    },
+});
+class AXPAppVersionDefaultProvider {
+    async provider() {
+        return {
+            version: '1.0.0',
+            build: 1,
+            date: new Date(),
+        };
+    }
+}
+class AXPAppVersionService {
+    constructor() {
+        this.provider = inject(AXP_APP_VERSION_PROVIDER);
+    }
+    async getAppVersion() {
+        return this.provider.provider();
+    }
+    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: "21.2.9", ngImport: i0, type: AXPAppVersionService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+
+var AXPRelationshipKind;
+(function (AXPRelationshipKind) {
+    AXPRelationshipKind[AXPRelationshipKind["Association"] = 0] = "Association";
+    AXPRelationshipKind[AXPRelationshipKind["Composition"] = 1] = "Composition";
+    AXPRelationshipKind[AXPRelationshipKind["Aggregation"] = 2] = "Aggregation";
+})(AXPRelationshipKind || (AXPRelationshipKind = {}));
+var AXPRelationshipCardinality;
+(function (AXPRelationshipCardinality) {
+    AXPRelationshipCardinality[AXPRelationshipCardinality["OneToOne"] = 0] = "OneToOne";
+    AXPRelationshipCardinality[AXPRelationshipCardinality["OneToMany"] = 1] = "OneToMany";
+    AXPRelationshipCardinality[AXPRelationshipCardinality["ManyToMany"] = 2] = "ManyToMany";
+})(AXPRelationshipCardinality || (AXPRelationshipCardinality = {}));
+var AXPEntityCommandScope;
+(function (AXPEntityCommandScope) {
+    AXPEntityCommandScope["TypeLevel"] = "typeLevel";
+    AXPEntityCommandScope["Selected"] = "selected";
+    AXPEntityCommandScope["Individual"] = "individual";
+    AXPEntityCommandScope["Section"] = "section";
+})(AXPEntityCommandScope || (AXPEntityCommandScope = {}));
+var AXPEntityQueryType;
+(function (AXPEntityQueryType) {
+    AXPEntityQueryType["Single"] = "single";
+    AXPEntityQueryType["List"] = "list";
+})(AXPEntityQueryType || (AXPEntityQueryType = {}));
+function getEntityInfo(entity) {
+    return {
+        source: `${entity.module}.${entity.name}`,
+        module: {
+            route: kebabCase(entity.module),
+        },
+        entity: {
+            route: kebabCase(entity.name),
+        },
+    };
+}
+function createQueryView(name, title, fixed, params = {
+    columns: [],
+    conditions: [],
+    sorts: [],
+}) {
+    params = Object.assign({ columns: [], sorts: [], conditions: [] }, params);
+    return {
+        name,
+        title,
+        fixed,
+        columns: params.columns ?? [],
+        conditions: params.conditions ?? [],
+        sorts: params.sorts ?? [],
+    };
+}
+function createAllQueryView(params = {
+    columns: [],
+    sorts: [],
+    conditions: [],
+}) {
+    params = Object.assign({ columns: [], sorts: [], conditions: [] }, params);
+    return createQueryView('all', '@general:terms.interface.selection.all-items', true, {
+        columns: params.columns ?? [],
+        conditions: params.conditions ?? [],
+        sorts: params.sorts ?? [],
+    });
+}
+// 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 };
+const GT_OPER = { name: 'greaterThan', title: '@general:terms.operators.greater-than', hasValue: true };
+const LT_OPER = { name: 'lessThan', title: '@general:terms.operators.less-than', hasValue: true };
+const GTE_OPER = {
+    name: 'greaterThanOrEqual',
+    title: '@general:terms.operators.greater-than-or-equal',
+    hasValue: true,
+};
+const LTE_OPER = { name: 'lessThanOrEqual', title: '@general:terms.operators.less-than-or-equal', hasValue: true };
+const CONTAINS_OPER = { name: 'contains', title: '@general:terms.operators.contains', hasValue: true };
+const NOT_CONTAINS_OPER = { name: 'notContains', title: '@general:terms.operators.not-contains', hasValue: true };
+const IN_OPER = { name: 'in', title: '@general:terms.operators.in', hasValue: true };
+const STARTS_WITH_OPER = { name: 'startsWith', title: '@general:terms.operators.starts-with', hasValue: true };
+const ENDS_WITH_OPER = { name: 'endsWith', title: '@general:terms.operators.ends-with', hasValue: true };
+const IS_EMPTY_OPER = { name: 'isEmpty', title: '@general:terms.operators.is-empty', hasValue: false };
+const IS_NOT_EMPTY_OPER = { name: 'isNotEmpty', title: '@general:terms.operators.is-not-empty', hasValue: false };
+const BETWEEN_OPER = { name: 'between', title: '@general:terms.operators.between', hasValue: true };
+const STRING_OPERATORS = [
+    EQ_OPER,
+    NOT_EQ_OPER,
+    CONTAINS_OPER,
+    NOT_CONTAINS_OPER,
+    STARTS_WITH_OPER,
+    ENDS_WITH_OPER,
+    IS_EMPTY_OPER,
+    IS_NOT_EMPTY_OPER,
+    IN_OPER
+];
+const NUMBER_OPERATORS = [
+    EQ_OPER,
+    NOT_EQ_OPER,
+    BETWEEN_OPER,
+    GT_OPER,
+    GTE_OPER,
+    LT_OPER,
+    LTE_OPER,
+    IS_EMPTY_OPER,
+    IS_NOT_EMPTY_OPER,
+];
+const BOOLEAN_OPERATORS = [EQ_OPER];
+const DATE_OPERATORS = [
+    EQ_OPER,
+    NOT_EQ_OPER,
+    GT_OPER,
+    GTE_OPER,
+    LT_OPER,
+    LTE_OPER,
+    IS_EMPTY_OPER,
+    IS_NOT_EMPTY_OPER,
+];
+const ALL_DEFAULT_OPERATORS = [
+    EQ_OPER,
+    NOT_EQ_OPER,
+    GT_OPER,
+    LT_OPER,
+    GTE_OPER,
+    LTE_OPER,
+    CONTAINS_OPER,
+    IN_OPER,
+    NOT_CONTAINS_OPER,
+    STARTS_WITH_OPER,
+    ENDS_WITH_OPER,
+    IS_EMPTY_OPER,
+    IS_NOT_EMPTY_OPER,
+    BETWEEN_OPER,
+];
+
+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 = {}));
+
+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)
+        ];
+    }
+});
+class AXPSettingValueProviderDefault {
+    constructor(_scope, injector) {
+        this._scope = _scope;
+        this.injector = injector;
+        this.cache = new Map();
+        this.localStorageKey = null;
+        this.sessionService = this.injector.get(AXPSessionService);
+        // 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;
+    }
+    async load() {
+        if (!this.localStorageKey) {
+            return Promise.resolve([]);
+        }
+        // Load settings from localStorage as a single key
+        const storedSettings = localStorage.getItem(this.localStorageKey);
+        if (storedSettings) {
+            const parsedSettings = JSON.parse(storedSettings);
+            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([]);
+    }
+    async set(keyOrValues, value) {
+        if (typeof keyOrValues === 'string') {
+            // Single value update
+            this.cache.set(keyOrValues, value);
+        }
+        else {
+            // Bulk update
+            for (const [key, val] of Object.entries(keyOrValues)) {
+                this.cache.set(key, val);
+            }
+        }
+        await this.saveToLocalStorage();
+    }
+    async saveToLocalStorage() {
+        if (!this.localStorageKey) {
+            return;
+        }
+        const settingsObject = {};
+        this.cache.forEach((value, key) => {
+            settingsObject[key] = value;
+        });
+        localStorage.setItem(this.localStorageKey, JSON.stringify(settingsObject));
+    }
+    async clear() {
+        if (!this.localStorageKey) {
+            return;
+        }
+        localStorage.removeItem(this.localStorageKey);
+    }
+}
+
+class AXPSettingDefinitionProviderContext {
+    constructor() {
+        this.rootGroups = [];
+        this.groupMap = new Map();
+    }
+    addGroup(name, title, description, icon) {
+        const newGroup = {
+            name,
+            title,
+            description,
+            icon,
+            groups: [],
+            sections: [],
+        };
+        this.rootGroups.push(newGroup);
+        this.groupMap.set(name, newGroup); // Index by name
+        return new AXPSettingDefinitionGroupBuilder(this, newGroup);
+    }
+    group(name) {
+        const foundGroup = this.groupMap.get(name);
+        if (!foundGroup) {
+            console.error(`Group with name "${name}" not found.`);
+            return null;
+        }
+        return new AXPSettingDefinitionGroupBuilder(this, foundGroup);
+    }
+    getGroups() {
+        return this.rootGroups;
+    }
+    // Expose groupMap for controlled access
+    hasGroup(name) {
+        return this.groupMap.has(name);
+    }
+    getGroup(name) {
+        return this.groupMap.get(name);
+    }
+}
+class AXPSettingDefinitionGroupBuilder {
+    constructor(context, group) {
+        this.context = context;
+        this.group = group;
+    }
+    addSection(name, title, description) {
+        const newSection = {
+            name,
+            title,
+            description: description,
+            settings: [],
+        };
+        this.group.sections.push(newSection);
+        return new AXPSettingDefinitionSectionBuilder(this, newSection);
+    }
+    section(name) {
+        const foundSection = this.group.sections.find((section) => section.name === name);
+        if (!foundSection) {
+            throw new Error(`Section with name "${name}" not found in group "${this.group.name}".`);
+        }
+        return new AXPSettingDefinitionSectionBuilder(this, foundSection);
+    }
+    addGroup(name, title, description, icon) {
+        const newGroup = {
+            name,
+            title,
+            description: description,
+            icon,
+            groups: [],
+            sections: [],
+        };
+        this.group.groups.push(newGroup);
+        if (this.context.hasGroup(name)) {
+            throw new Error(`Group with name "${name}" already exists.`);
+        }
+        this.context['groupMap'].set(name, newGroup);
+        return new AXPSettingDefinitionGroupBuilder(this.context, newGroup);
+    }
+    endGroup() {
+        return this.context;
+    }
+}
+class AXPSettingDefinitionSectionBuilder {
+    constructor(groupBuilder, section) {
+        this.groupBuilder = groupBuilder;
+        this.section = section;
+    }
+    addSetting(setting) {
+        const newSetting = {
+            name: setting.key,
+            title: setting.title,
+            description: setting.description,
+            isRequired: setting.isRequired ?? false,
+            isInherited: setting.isInherited ?? false,
+            isEncrypted: setting.isEncrypted ?? false,
+            defaultValue: setting.defaultValue,
+            scope: setting.scope ?? 'P',
+            layout: setting.widget.layout,
+            widget: {
+                type: setting.widget.type,
+                name: setting.key,
+                path: setting.key,
+                defaultValue: setting.defaultValue,
+                options: merge(setting.widget.options ?? {}, {
+                    label: Object.keys(setting.widget.options ?? {}).includes('label') ? setting.widget.options?.['label'] : setting.title,
+                    validationRules: setting.validationRules ?? [],
+                }),
+                valueTransforms: setting.valueTransforms,
+                triggers: setting.widget.triggers,
+            },
+        };
+        this.section.settings.push(newSetting);
+        return this;
+    }
+    endSection() {
+        return this.groupBuilder;
+    }
+}
+
+// Injection token for setting providers
+const AXP_SETTING_DEFINITION_PROVIDER = new InjectionToken('AXP_SETTING_DEFINITION_PROVIDER');
+class AXPSettingDefinitionProviderService {
+    constructor() {
+        this.providers = inject(AXP_SETTING_DEFINITION_PROVIDER, { optional: true });
+        this.cache = null;
+    }
+    async load() {
+        if (this.cache) {
+            return;
+        }
+        const context = new AXPSettingDefinitionProviderContext();
+        // Load providers from DI tokens
+        if (Array.isArray(this.providers)) {
+            for (const provider of this.providers) {
+                if (provider instanceof Promise) {
+                    // If provider is a promise, resolve it
+                    const resolvedProvider = await provider;
+                    await resolvedProvider.provide(context);
+                }
+                else {
+                    // If provider is a direct instance, use it directly
+                    await provider.provide(context);
+                }
+            }
+        }
+        this.cache = context.getGroups();
+    }
+    async reload() {
+        this.cache = null;
+        await this.load();
+    }
+    async getListAsync(scope) {
+        await this.load();
+        return this.getList(scope);
+    }
+    getList(scope) {
+        if (!this.cache) {
+            return [];
+        }
+        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) => ({
+                    ...section,
+                    settings: section.settings.filter((setting) => {
+                        const settingScopeIndex = scopeOrder.indexOf(setting.scope);
+                        // Include settings where:
+                        // 1. The scope matches the requested scope.
+                        if (setting.scope === currentScope)
+                            return true;
+                        // 2. The setting scope is higher (closer to 'U') and is inherited.
+                        if (setting.isInherited &&
+                            settingScopeIndex > currentScopeIndex // Higher scope
+                        ) {
+                            return true;
+                        }
+                        // 3. Exclude settings with a lower or irrelevant scope.
+                        return false;
+                    }),
+                })).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');
+    }
+    async defaultValues() {
+        const defaults = {};
+        const collectDefaults = (groups) => {
+            groups.forEach((group) => {
+                group.sections.forEach((section) => {
+                    section.settings.forEach((setting) => {
+                        if (setting.defaultValue !== undefined) {
+                            defaults[setting.name] = setting.defaultValue;
+                        }
+                    });
+                });
+                collectDefaults(group.groups);
+            });
+        };
+        if (!this.cache) {
+            await this.load();
+        }
+        collectDefaults(this.cache);
+        return defaults;
+    }
+    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 }];
+            // If the group name matches, return its details
+            if (group.name === groupName) {
+                return {
+                    breadcrumb: currentBreadcrumb,
+                    sections: group.sections.length > 0 ? group.sections : null,
+                    groups: group.groups.length > 0 ? group.groups : null,
+                };
+            }
+            // Recursively search in nested groups
+            const nestedResult = this.searchRecursive(group.groups, groupName, currentBreadcrumb);
+            if (nestedResult.breadcrumb.length > 0) {
+                return nestedResult;
+            }
+        }
+        // If no matching group is found
+        return {
+            breadcrumb: [],
+            groups: [],
+            sections: []
+        };
+    }
+    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: "21.2.9", ngImport: i0, type: AXPSettingDefinitionProviderService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+// Multi-provider token for higher-layer default values
+const AXP_SETTING_DEFAULT_VALUES_PROVIDERS = new InjectionToken('AXP_SETTING_DEFAULT_VALUES_PROVIDERS', {
+    providedIn: 'root',
+    factory: () => [],
+});
+// Aggregator service that merges definition defaults with higher-layer providers (by priority)
+class AXPSettingDefaultValuesAggregatorService {
+    constructor() {
+        this.definitionService = inject(AXPSettingDefinitionProviderService);
+        this.providers = inject(AXP_SETTING_DEFAULT_VALUES_PROVIDERS, { optional: true }) ?? [];
+    }
+    async getDefaults() {
+        const baseDefaults = await this.definitionService.defaultValues();
+        const ordered = [...this.providers].sort((a, b) => (a.priority ?? 0) - (b.priority ?? 0));
+        const merged = { ...baseDefaults };
+        for (const provider of ordered) {
+            try {
+                const overrideMap = await provider.provide();
+                Object.assign(merged, overrideMap);
+            }
+            catch (err) {
+                console.error('AXPSettingDefaultValuesProvider failed:', err);
+            }
+        }
+        return merged;
+    }
+    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: "21.2.9", ngImport: i0, type: AXPSettingDefaultValuesAggregatorService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+
+class AXPSettingsService {
+    constructor() {
+        this.providers = inject(AXP_SETTING_VALUE_PROVIDER);
+        this.injector = inject(Injector);
+        this.eventService = inject(AXPBroadcastEventService);
+        this.sessionService = inject(AXPSessionService);
+        this.scopedSettingsCache = new Map();
+        this.onChanged = new Subject();
+        this.onLoaded = new Subject();
+        // Initialize scoped caches for dynamic scopes
+        const staticScopes = [
+            AXPPlatformScope.Platform,
+            AXPPlatformScope.Tenant,
+            AXPPlatformScope.User,
+        ];
+        staticScopes.forEach((scope) => {
+            if (!this.scopedSettingsCache.has(scope)) {
+                this.scopedSettingsCache.set(scope, new Map());
+            }
+        });
+        // Listen for setting changes from other tabs
+        this.eventService.listen('AXPSettingChangedEvent').subscribe((event) => {
+            const data = event.data;
+            data.keys.forEach((key) => {
+                this.scopedSettingsCache.get(data.scope)?.set(key, data.values[key]);
+            });
+            this.onChanged.next(data); // Notify subscribers in the current tab
+        });
+        // reload settings when user is authenticated
+        this.sessionService.isAuthenticated$.pipe(distinctUntilChanged()).subscribe(async (isAuthenticated) => {
+            if (isAuthenticated) {
+                await this.reload();
+            }
+        });
+    }
+    async reload() {
+        await this.load();
+    }
+    async load() {
+        try {
+            const settingsList = [];
+            for (const provider of this.providers) {
+                const scopeCache = this.scopedSettingsCache.get(provider.scope) ?? new Map();
+                const providerSettings = await provider.load();
+                providerSettings.forEach((setting) => {
+                    scopeCache.set(setting.key, setting.value);
+                });
+                settingsList.push(...providerSettings);
+            }
+            this.onLoaded.next();
+            return settingsList;
+        }
+        catch (error) {
+            console.error('Error loading settings', error);
+            throw error;
+        }
+    }
+    async get(key) {
+        if (this.scopedSettingsCache.size === 0) {
+            await this.load();
+        }
+        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);
+                }
+            }
+        }
+        const defaults = await this.injector.get(AXPSettingDefaultValuesAggregatorService).getDefaults();
+        return get(defaults, key); // Fallback if no value is found
+    }
+    async defaultValues(scope) {
+        let scopeOrder = [
+            AXPPlatformScope.Platform,
+            AXPPlatformScope.Tenant,
+            AXPPlatformScope.User,
+        ].reverse();
+        const scopeIndex = scopeOrder.indexOf(scope);
+        if (scopeIndex === -1) {
+            throw new Error(`Invalid scope: ${scope}`);
+        }
+        scopeOrder = scopeOrder.slice(scopeIndex + 1);
+        // Accumulate defaults from the current scope and higher scopes
+        const accumulatedDefaults = {};
+        for (let i = scopeIndex; i < scopeOrder.length; i++) {
+            const currentScope = scopeOrder[i];
+            const scopeCache = this.scopedSettingsCache.get(currentScope);
+            if (scopeCache) {
+                scopeCache.forEach((value, key) => {
+                    if (!(key in accumulatedDefaults)) {
+                        accumulatedDefaults[key] = value;
+                    }
+                });
+            }
+        }
+        // Merge with aggregated default values (definition + higher-layer providers)
+        const globalDefaults = await this.injector.get(AXPSettingDefaultValuesAggregatorService).getDefaults();
+        return { ...globalDefaults, ...accumulatedDefaults };
+    }
+    scope(scope) {
+        const provider = this.providers.find((p) => p.scope === scope);
+        if (!provider) {
+            throw new Error(`No provider found for scope: ${scope}`);
+        }
+        return new ScopedSettingService(this, provider, this.scopedSettingsCache.get(scope));
+    }
+    invokeChangeEvent(event) {
+        this.onChanged.next(event);
+        this.eventService.publish('AXPSettingChangedEvent', event);
+    }
+    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: "21.2.9", ngImport: i0, type: AXPSettingsService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [] });
+class ScopedSettingService {
+    constructor(parent, provider, scopeCache) {
+        this.parent = parent;
+        this.provider = provider;
+        this.scopeCache = scopeCache;
+    }
+    async get(key) {
+        const settings = await this.provider.load();
+        const setting = settings.find((s) => s.key === key);
+        return setting ? cloneDeep(setting.value) : undefined;
+    }
+    async all() {
+        const settings = await this.provider.load();
+        return Object.fromEntries(settings.map((s) => [s.key, cloneDeep(s.value)]));
+    }
+    async defaultValues() {
+        return this.parent.defaultValues(this.provider.scope);
+    }
+    async set(keyOrValues, value) {
+        if (typeof keyOrValues === 'string') {
+            // Single key-value pair
+            await this.provider.set(keyOrValues, value);
+            this.scopeCache.set(keyOrValues, value); // Sync the cache
+            this.parent.invokeChangeEvent({
+                scope: this.provider.scope,
+                keys: [keyOrValues],
+                values: { [keyOrValues]: value },
+                entries: [{ key: keyOrValues, value }],
+            });
+        }
+        else {
+            // Multiple key-value pairs
+            await this.provider.set(keyOrValues);
+            Object.entries(keyOrValues).forEach(([key, val]) => this.scopeCache.set(key, val)); // Sync the cache
+            const entries = Object.entries(keyOrValues).map(([key, val]) => ({ key, value: val }));
+            this.parent.invokeChangeEvent({
+                scope: this.provider.scope,
+                keys: Object.keys(keyOrValues),
+                values: keyOrValues,
+                entries,
+            });
+        }
+    }
+    async update(key, updateFn) {
+        const currentValue = await this.get(key);
+        const newValue = updateFn(currentValue);
+        await this.set(key, newValue);
+    }
+}
+
+const DEFAULT_APPLY_DEFAULT_MULTILANGUAGE = true;
+/**
+ * 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.
+ */
+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) {
+    AXPHomePageSettings["UserHomePath"] = "Common:Setting:Startup.HomePage";
+})(AXPHomePageSettings || (AXPHomePageSettings = {}));
+
+class AXPHomePageService {
+    get flatCandidates() {
+        return this.candidates.flatMap((c) => c);
+    }
+    constructor() {
+        this.defaultHomePageKey = inject(AXP_HOME_PAGE_DEFAULT_KEY, { optional: true }) ?? 'home';
+        this.userHomePageKey = null;
+        this.candidates = inject(AXP_HOME_PAGES, { optional: true }) ?? [];
+        this.settingsService = inject(AXPSettingsService);
+        this.sessionService = inject(AXPSessionService);
+        this.injector = inject(Injector);
+        this.originalConfig = null;
+        this.loginPath = 'auth/login';
+        // remove circular dependency
+        setTimeout(async () => {
+            await this.init();
+        });
+    }
+    async init() {
+        await this.load();
+        //
+        const keys = [AXPHomePageSettings.UserHomePath];
+        this.settingsService.onChanged.subscribe(async (c) => {
+            if (keys.some((k) => c.keys.includes(k))) {
+                await this.load();
+                this.refreshRoutes();
+            }
+        });
+        //
+        merge$1(this.sessionService.status$, this.sessionService.application$, this.sessionService.tenant$).subscribe(async (data) => {
+            await this.load();
+            this.refreshRoutes();
+        });
+    }
+    async load() {
+        this.userHomePageKey = await this.settingsService.get(AXPHomePageSettings.UserHomePath);
+    }
+    getRegisteredList() {
+        return this.flatCandidates.filter((c) => c.route);
+    }
+    getRegisteredRoutes() {
+        const defaultHomePage = this.flatCandidates.find((c) => c.key === this.defaultHomePageKey);
+        const home = this.flatCandidates.find((c) => this.userHomePageKey && c.key === this.userHomePageKey) ?? defaultHomePage;
+        if (home && home.route && this.sessionService.application?.name) {
+            const fullPath = this.findPath(home.route);
+            return [
+                { path: '', redirectTo: fullPath, pathMatch: 'full' },
+                { path: ':app', redirectTo: fullPath, pathMatch: 'full' },
+                { ...home?.route, ...{ data: { key: home?.key, title: home?.title, path: fullPath } } },
+            ];
+        }
+        return [{ path: '', redirectTo: this.loginPath, pathMatch: 'full' }];
+    }
+    getCurrent() {
+        const key = this.userHomePageKey ?? this.defaultHomePageKey;
+        const homePage = this.getRegisteredRoutes().find((c) => c.data?.['key'] === key);
+        if (homePage) {
+            return {
+                path: homePage.data?.['path'],
+                title: homePage.data?.['title'],
+            };
+        }
+        return {
+            path: this.loginPath,
+            title: '',
+        };
+    }
+    findPath(target) {
+        const rawPath = this.buildFullPaths(target).join('/');
+        const appName = this.sessionService.application?.name;
+        if (appName) {
+            return rawPath.replace(':app', appName);
+        }
+        return rawPath;
+    }
+    buildFullPaths(route, parentPath = []) {
+        const segments = [...parentPath];
+        if (route.path) {
+            segments.push(route.path);
+        }
+        // Recursively search the first matched child (deepest first match)
+        if (route.children?.length) {
+            return this.buildFullPaths(route.children[0], segments);
+        }
+        return segments;
+    }
+    refreshRoutes() {
+        const router = this.injector.get(Router);
+        // 👇 On first call, remember what was there before:
+        if (!this.originalConfig) {
+            this.originalConfig = router.config;
+        }
+        this.applyMergedConfig(router);
+    }
+    applyMergedConfig(router) {
+        const newHomeRoutes = this.getRegisteredRoutes(); // your 3 home entries
+        // 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'));
+        // Build the new merged tree
+        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
+        setTimeout(() => {
+            const router = this.injector.get(Router);
+            const current = this.getCurrent();
+            router.navigate([current.path], { onSameUrlNavigation: 'reload' });
+        }, 100);
+    }
+    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: "21.2.9", ngImport: i0, type: AXPHomePageService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [] });
+
+function dynamicRoutesFactory() {
+    const service = inject(AXPHomePageService);
+    return service.getRegisteredRoutes();
+}
+function provideDynamicHomePage() {
+    return makeEnvironmentProviders([
+        {
+            provide: ROUTES,
+            useFactory: dynamicRoutesFactory,
+            multi: true
+        }
+    ]);
+}
+
+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 }));
+        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')
+            // Add the 'Startup' section
+            .addSection('startup', await trans('general.startup.title'), await trans('general.startup.description'))
+            // Add the 'Home Page' setting
+            .addSetting({
+            key: AXPHomePageSettings.UserHomePath,
+            title: await trans('general.startup.home-page.title'),
+            scope: AXPPlatformScope.User,
+            isInherited: true,
+            defaultValue: this.defaultHomePageKey || list[0].id,
+            valueTransforms: objectKeyValueTransforms('id'),
+            widget: {
+                type: AXPWidgetsCatalog.select,
+                options: {
+                    valueField: 'id',
+                    textField: 'title',
+                    dataSource: list,
+                },
+            },
+            description: await trans('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: "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: "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: "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,
+                multi: true,
+            },
+        ] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPHomePageModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [],
+                    providers: [
+                        {
+                            provide: AXP_SETTING_DEFINITION_PROVIDER,
+                            useClass: AXPHomePageSettingProvider,
+                            multi: true,
+                        },
+                    ],
+                }]
+        }] });
+
+class AXPDataProvider {
+}
+
+class AXPCustomOperatorService {
+}
+class AXPCustomOperatorServiceImpl extends AXPCustomOperatorService {
+    getCustomOperators() {
+        return {};
+    }
+    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: "21.2.9", ngImport: i0, type: AXPCustomOperatorServiceImpl, decorators: [{
+            type: Injectable
+        }] });
+
+class AXPFilterOperatorMiddlewareService {
+}
+class AXPFilterOperatorMiddlewareServiceImpl extends AXPFilterOperatorMiddlewareService {
+    constructor() {
+        super(...arguments);
+        this.customOperatorService = inject(AXPCustomOperatorService);
+        this.operators = {
+            ...this.getDefaultOperators(),
+            ...this.customOperatorService.getCustomOperators(),
+        };
+    }
+    transformFilters(filters) {
+        return filters.map((filter) => this.transformFilter(filter));
+    }
+    transformFilter(filter) {
+        const { operator, value, filters, field } = filter;
+        // Find the operator (either default or custom)
+        const filterOperator = this.operators[operator?.type ?? ''] || null;
+        // Start by transforming the filter itself
+        const transformedFilter = {
+            ...filter, // Keep the original filter structure
+            operator: filterOperator ? filterOperator : operator, // Add operator name
+        };
+        // If the filter contains nested filters, recursively transform them
+        if (filters && filters.length > 0) {
+            transformedFilter.filters = this.transformFilters(filters); // Recursively transform nested filters
+        }
+        return transformedFilter;
+    }
+    getOperator(key) {
+        return this.operators[key];
+    }
+    // Helper function to return the default operators
+    getDefaultOperators() {
+        return ALL_DEFAULT_OPERATORS.reduce((acc, operator) => {
+            acc[operator.name] = {
+                type: operator.name,
+            };
+            return acc;
+        }, {});
+    }
+    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: "21.2.9", ngImport: i0, type: AXPFilterOperatorMiddlewareServiceImpl, decorators: [{
+            type: Injectable
+        }] });
+
+class AXPErrorHandlerRegistryService {
+    constructor(injector) {
+        this.injector = injector;
+        this.errorHandlers = [];
+    }
+    register(...plugins) {
+        plugins.forEach(t => {
+            const childInjector = Injector.create({ providers: [{ provide: t, useClass: t, deps: [] }], parent: this.injector });
+            const handler = childInjector.get(t);
+            if (handler) {
+                this.errorHandlers.push(handler);
+            }
+        });
+    }
+    get handlers() {
+        return this.errorHandlers;
+    }
+    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: "21.2.9", ngImport: i0, type: AXPErrorHandlerRegistryService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i0.Injector }] });
+
+class AXPGlobalErrorHandler extends ErrorHandler {
+    constructor(injector, registry) {
+        super();
+        this.injector = injector;
+        this.registry = registry;
+    }
+    handleError(error) {
+        const handleErrorRecursively = (index, error) => {
+            const errorHandlers = this.registry.handlers;
+            if (index < errorHandlers.length) {
+                errorHandlers[index].handleError(error, (err) => {
+                    handleErrorRecursively(index + 1, err);
+                });
+            }
+            else {
+                super.handleError(error); // Fallback to default handler
+            }
+        };
+        if (error.message?.startsWith('NG0100')) {
+            //ignore it
+            return;
+        }
+        handleErrorRecursively(0, error);
+    }
+    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: "21.2.9", ngImport: i0, type: AXPGlobalErrorHandler, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [{ type: i0.Injector }, { type: AXPErrorHandlerRegistryService }] });
+
+const AXP_TOKEN_DEFINITION_PROVIDER = new InjectionToken('AXP_TOKEN_DEFINITION_PROVIDER', {
+    factory: () => [],
+});
+
+//#region ----   Imports   ----
+//#endregion
+class AXPTokenDefinitionService {
+    constructor() {
+        //#region ----   Providers & Caches   ----
+        this.definitionProviders = inject(AXP_TOKEN_DEFINITION_PROVIDER, { optional: true }) || [];
+        /** Cache for definitions by name. */
+        this.definitionsByName = new Map();
+    }
+    //#endregion
+    //#region ----   Public API   ----
+    /**
+     * Returns a token definition by its name.
+     * First checks the cache, then queries all providers if not found.
+     * @param name The token name.
+     * @returns The token definition if found, undefined otherwise.
+     */
+    async getDefinition(name) {
+        // Check cache first
+        if (this.definitionsByName.has(name)) {
+            return this.definitionsByName.get(name);
+        }
+        // Not in cache, query providers
+        // Resolve all providers (some may be promises, some may be arrays)
+        const resolvedProviders = await Promise.all(this.definitionProviders);
+        // Flatten the array - some providers may be arrays of providers (e.g., dynamic token providers)
+        const flattenedProviders = [];
+        for (const provider of resolvedProviders) {
+            if (Array.isArray(provider)) {
+                // If provider is an array, add all items
+                flattenedProviders.push(...provider);
+            }
+            else if (provider) {
+                // If provider is a single provider, add it
+                flattenedProviders.push(provider);
+            }
+        }
+        const match = flattenedProviders.find(def => def?.name === name);
+        if (match) {
+            this.definitionsByName.set(name, match);
+            return match;
+        }
+        return undefined;
+    }
+    /**
+     * Gets the resolved value of a token by its name.
+     * @param name The token name.
+     * @returns The resolved token value, or undefined if the token is not found.
+     */
+    async getValue(name) {
+        const definition = await this.getDefinition(name);
+        if (definition) {
+            return await definition.execute();
+        }
+        return undefined;
+    }
+    //#endregion
+    //#region ----   Cache Management   ----
+    /** Clears the definitions by name cache. */
+    clearDefinitionsCache() {
+        this.definitionsByName.clear();
+    }
+    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: "21.2.9", ngImport: i0, type: AXPTokenDefinitionService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+
+class AXPTokenEvaluatorScopeProvider {
+    constructor() {
+        this.tokenService = inject(AXPTokenDefinitionService);
+    }
+    async provide(context) {
+        context.addScope('tokens', {
+            get: async (name) => {
+                return await this.tokenService.getValue(name);
+            }
+        });
+    }
+}
+
+class AXPStickyDirective {
+    get isSticky() {
+        return this._isSticky;
+    }
+    set isSticky(value) {
+        if (this._isSticky !== value) {
+            this._isSticky = value;
+            this.isStickyChange.emit(value);
+        }
+    }
+    constructor(element, renderer, zone, cdr) {
+        this.element = element;
+        this.renderer = renderer;
+        this.zone = zone;
+        this.cdr = cdr;
+        this.stickyOffset = 100;
+        this.isStickyChange = new EventEmitter();
+        this._isSticky = false;
+        this.onWindowResize = () => {
+            this.applyStickyStateFromScrollPosition();
+        };
+        this.onParentScroll = () => {
+            this.applyStickyStateFromScrollPosition();
+        };
+    }
+    ngAfterViewInit() {
+        this.initSticky();
+        // Add mutation observer for dynamic content
+        this.mutationObserver = new MutationObserver(() => {
+            this.applyStickyStateFromScrollPosition();
+        });
+        this.mutationObserver.observe(this.element.nativeElement, {
+            childList: true,
+            subtree: true,
+        });
+        window.addEventListener('resize', this.onWindowResize);
+    }
+    initSticky() {
+        if (this.stickyParent instanceof HTMLElement) {
+            this.parentElement = this.stickyParent;
+        }
+        else {
+            this.parentElement = document.querySelector(this.stickyParent) || window;
+        }
+        this.targetElement = document.querySelector(this.stickyTarget) || this.element.nativeElement;
+        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;
+    }
+    applyStickyStateFromScrollPosition() {
+        this.zone.runOutsideAngular(() => {
+            const shouldStick = this.computeShouldStick();
+            if (shouldStick !== this.isSticky) {
+                this.zone.run(() => {
+                    this.isSticky = shouldStick;
+                    this.toggleStickyClasses(shouldStick);
+                    this.cdr.markForCheck();
+                });
+            }
+        });
+    }
+    toggleStickyClasses(isSticky) {
+        const classes = this.stickyClass.split(' ').filter(Boolean);
+        classes.forEach((className) => {
+            if (isSticky) {
+                this.renderer.addClass(this.targetElement, className);
+            }
+            else {
+                this.renderer.removeClass(this.targetElement, className);
+            }
+        });
+    }
+    ngOnDestroy() {
+        this.parentElement.removeEventListener('scroll', this.onParentScroll);
+        window.removeEventListener('resize', this.onWindowResize);
+        if (this.mutationObserver) {
+            this.mutationObserver.disconnect();
+        }
+    }
+    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: "21.2.9", ngImport: i0, type: AXPStickyDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[axpSticky]',
+                    exportAs: 'axpSticky',
+                    standalone: true,
+                }]
+        }], ctorParameters: () => [{ type: i0.ElementRef }, { type: i0.Renderer2 }, { type: i0.NgZone }, { type: i0.ChangeDetectorRef }], propDecorators: { stickyClass: [{
+                type: Input,
+                args: ['axpSticky']
+            }], stickyOffset: [{
+                type: Input,
+                args: ['stickyOffset']
+            }], isStickyChange: [{
+                type: Output
+            }], stickyParent: [{
+                type: Input
+            }], stickyTarget: [{
+                type: Input
+            }] } });
+
+//#region ----   Menu Context Builder   ----
+/**
+ * Creates a rich context for menu manipulation
+ * Similar to entity modifier context pattern
+ */
+function createMenuContext(items) {
+    const context = {
+        get items() {
+            return items;
+        },
+        find(nameOrPattern) {
+            if (typeof nameOrPattern === 'string') {
+                return context.findByName(nameOrPattern);
+            }
+            const found = context.findByPattern(nameOrPattern);
+            return found.length > 0 ? found[0] : createEmptyFinder();
+        },
+        findByName(name) {
+            return createMenuItemFinder(items, name);
+        },
+        findByPattern(pattern) {
+            const regex = typeof pattern === 'string' ? wildcardToRegex(pattern) : pattern;
+            const results = [];
+            const searchRecursive = (itemList) => {
+                for (const item of itemList) {
+                    if (item.name && regex.test(item.name)) {
+                        results.push(createMenuItemFinder(items, item.name));
+                    }
+                    if (item.children) {
+                        searchRecursive(item.children);
+                    }
+                }
+            };
+            searchRecursive(items);
+            return results;
+        },
+        add(...newItems) {
+            items.push(...newItems);
+            return context;
+        },
+        remove(predicate) {
+            removeRecursive(items, predicate);
+            return context;
+        },
+        sort() {
+            sortItemsRecursively(items);
+            return context;
+        },
+        toArray() {
+            return items;
+        },
+    };
+    return context;
+}
+//#endregion
+//#region ----   Menu Item Finder Implementation   ----
+/**
+ * Creates a finder for a specific menu item
+ */
+function createMenuItemFinder(rootItems, targetName) {
+    const findItemWithParent = (items, name, parent = { items: rootItems }) => {
+        for (const item of items) {
+            if (item.name === name) {
+                return { item, parent };
+            }
+            if (item.children) {
+                const result = findItemWithParent(item.children, name, { items: item.children });
+                if (result.item) {
+                    return result;
+                }
+            }
+        }
+        return { item: undefined, parent };
+    };
+    const finder = {
+        get() {
+            return findItemWithParent(rootItems, targetName).item;
+        },
+        exists() {
+            return finder.get() !== undefined;
+        },
+        update(updater) {
+            const { item } = findItemWithParent(rootItems, targetName);
+            if (item) {
+                const updates = typeof updater === 'function' ? updater(item) : updater;
+                Object.assign(item, updates);
+            }
+            return finder;
+        },
+        remove() {
+            const { item, parent } = findItemWithParent(rootItems, targetName);
+            if (item) {
+                const index = parent.items.indexOf(item);
+                if (index !== -1) {
+                    parent.items.splice(index, 1);
+                }
+            }
+            return finder;
+        },
+        hide() {
+            // Hide by removing the item from menu
+            return finder.remove();
+        },
+        show() {
+            // Show is a no-op since items are visible by default
+            // To truly implement show, we'd need to track removed items and re-add them
+            console.warn('show() is not fully implemented - items are visible by default');
+            return finder;
+        },
+        setPriority(priority) {
+            return finder.update({ priority });
+        },
+        addChildren(...children) {
+            const { item } = findItemWithParent(rootItems, targetName);
+            if (item) {
+                item.children = item.children || [];
+                item.children.push(...children);
+            }
+            return finder;
+        },
+        removeChildren(predicate) {
+            const { item } = findItemWithParent(rootItems, targetName);
+            if (item && item.children) {
+                item.children = item.children.filter((c) => !predicate(c));
+            }
+            return finder;
+        },
+        moveTo(parentName) {
+            const { item, parent: oldParent } = findItemWithParent(rootItems, targetName);
+            if (!item) {
+                return finder;
+            }
+            // Remove from old parent
+            const oldIndex = oldParent.items.indexOf(item);
+            if (oldIndex !== -1) {
+                oldParent.items.splice(oldIndex, 1);
+            }
+            // Add to new parent
+            if (!parentName || parentName === '') {
+                // Move to root (handles null, undefined, and empty string)
+                rootItems.push(item);
+            }
+            else {
+                const { item: newParentItem } = findItemWithParent(rootItems, parentName);
+                if (newParentItem) {
+                    newParentItem.children = newParentItem.children || [];
+                    newParentItem.children.push(item);
+                }
+            }
+            return finder;
+        },
+        insertBefore(...items) {
+            const { item, parent } = findItemWithParent(rootItems, targetName);
+            if (item) {
+                const index = parent.items.indexOf(item);
+                if (index !== -1) {
+                    parent.items.splice(index, 0, ...items);
+                }
+            }
+            return finder;
+        },
+        insertAfter(...items) {
+            const { item, parent } = findItemWithParent(rootItems, targetName);
+            if (item) {
+                const index = parent.items.indexOf(item);
+                if (index !== -1) {
+                    parent.items.splice(index + 1, 0, ...items);
+                }
+            }
+            return finder;
+        },
+    };
+    return finder;
+}
+/**
+ * Creates an empty finder for items not found
+ */
+function createEmptyFinder() {
+    return {
+        get: () => undefined,
+        exists: () => false,
+        update: () => createEmptyFinder(),
+        remove: () => createEmptyFinder(),
+        hide: () => createEmptyFinder(),
+        show: () => createEmptyFinder(),
+        setPriority: () => createEmptyFinder(),
+        addChildren: () => createEmptyFinder(),
+        removeChildren: () => createEmptyFinder(),
+        moveTo: () => createEmptyFinder(),
+        insertBefore: () => createEmptyFinder(),
+        insertAfter: () => createEmptyFinder(),
+    };
+}
+//#endregion
+//#region ----   Helper Functions   ----
+/**
+ * Converts wildcard pattern to regex
+ */
+function wildcardToRegex(pattern) {
+    const escaped = pattern.replace(/[.+?^${}()|\[\]\\]/g, '\\$&');
+    const regexStr = `^${escaped.replace(/\*/g, '.*')}$`;
+    return new RegExp(regexStr);
+}
+/**
+ * Recursively removes items matching predicate
+ */
+function removeRecursive(items, predicate) {
+    for (let i = items.length - 1; i >= 0; i--) {
+        const item = items[i];
+        if (predicate(item)) {
+            items.splice(i, 1);
+        }
+        else if (item.children) {
+            removeRecursive(item.children, predicate);
+        }
+    }
+}
+/**
+ * Recursively sorts items by priority
+ */
+function sortItemsRecursively(items) {
+    items.sort((a, b) => (a.priority ?? 0) - (b.priority ?? 0));
+    items.forEach((item) => {
+        if (item.children && item.children.length > 0) {
+            sortItemsRecursively(item.children);
+        }
+    });
+}
+//#endregion
+
+/**
+ * Injection token for menu middlewares (multi-provider)
+ */
+const AXP_MENU_MIDDLEWARE = new InjectionToken('AXP_MENU_MIDDLEWARE');
+//#endregion
+
+//#region ----   Menu Middleware Registry   ----
+/**
+ * Central service for managing menu middlewares with priority-based ordering
+ * Similar to token registry pattern used in identifier-management
+ */
+class AXPMenuMiddlewareRegistry {
+    constructor() {
+        //#region ----   Fields   ----
+        /**
+         * Manually registered middlewares
+         */
+        this.manualMiddlewares = new Map();
+        /**
+         * Provider-based middlewares (multi-provider injection)
+         */
+        this.providerMiddlewares = inject(AXP_MENU_MIDDLEWARE, { optional: true }) ?? [];
+    }
+    //#endregion
+    //#region ----   Registration Methods   ----
+    /**
+     * Manually register a middleware
+     * @param middleware - The middleware to register
+     */
+    register(middleware) {
+        const name = middleware.name || `middleware_${Date.now()}_${Math.random()}`;
+        const existing = this.manualMiddlewares.get(name);
+        if (!existing || (middleware.priority ?? 0) > (existing.priority ?? 0)) {
+            this.manualMiddlewares.set(name, middleware);
+        }
+    }
+    /**
+     * Unregister a middleware by name
+     * @param name - The name of the middleware to remove
+     */
+    unregister(name) {
+        this.manualMiddlewares.delete(name);
+    }
+    /**
+     * Get a specific middleware by name
+     * @param name - The middleware name
+     */
+    get(name) {
+        // Provider-provided middlewares take precedence
+        const fromProvider = this.providerMiddlewares
+            .filter((m) => m.name === name)
+            .sort((a, b) => (b.priority ?? 0) - (a.priority ?? 0))[0];
+        if (fromProvider) {
+            return fromProvider;
+        }
+        return this.manualMiddlewares.get(name);
+    }
+    /**
+     * Get all middlewares sorted by priority (highest first)
+     * Combines provider-based and manually registered middlewares
+     */
+    list() {
+        const map = new Map();
+        // Helper to add middleware, respecting priority
+        const addMiddleware = (m) => {
+            const name = m.name || `anonymous_${Date.now()}`;
+            const existing = map.get(name);
+            if (!existing || (m.priority ?? 0) > (existing.priority ?? 0)) {
+                map.set(name, m);
+            }
+        };
+        // Add provider middlewares first (higher precedence)
+        this.providerMiddlewares.forEach(addMiddleware);
+        // Add manual middlewares
+        Array.from(this.manualMiddlewares.values()).forEach(addMiddleware);
+        // Return sorted by priority (highest first)
+        return Array.from(map.values()).sort((a, b) => (b.priority ?? 0) - (a.priority ?? 0));
+    }
+    /**
+     * Check if a middleware exists
+     * @param name - The middleware name
+     */
+    exists(name) {
+        return this.get(name) !== undefined;
+    }
+    /**
+     * Clear all manually registered middlewares
+     * Provider-based middlewares are not affected
+     */
+    clear() {
+        this.manualMiddlewares.clear();
+    }
+    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: "21.2.9", ngImport: i0, type: AXPMenuMiddlewareRegistry, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+
+const AXP_MENU_PROVIDER = new InjectionToken('AXP_MENU_PROVIDER');
+//TODO: check performance of this service
+class AXPMenuProviderService {
+    constructor() {
+        //#region ----   Dependencies   ----
+        this.providers = inject(AXP_MENU_PROVIDER, { optional: true });
+        this.middlewareRegistry = inject(AXPMenuMiddlewareRegistry);
+        //#endregion
+        //#region ----   State   ----
+        this.cache = null;
+        this.pendingInserts = [];
+        this.pendingRemovals = [];
+        this.pendingUpdates = [];
+        this.pendingAdditions = [];
+        this.pendingMoves = [];
+        /**
+         * Observable for menu reload events
+         * Emits when menu cache is cleared and consumers should reload
+         */
+        this.menuReloadSubject = new Subject();
+        this.menuReload$ = this.menuReloadSubject.asObservable();
+    }
+    //#endregion
+    //#region ----   Public API   ----
+    /**
+     * Get menu items with middlewares applied (for end-user display)
+     */
+    async items() {
+        // Return cached items if available
+        if (this.cache) {
+            return this.cache;
+        }
+        const items = [];
+        const context = this.createMenuProviderContext(items);
+        // Load providers from DI tokens
+        if (Array.isArray(this.providers)) {
+            for (const provider of this.providers) {
+                if (provider instanceof Promise) {
+                    // If provider is a promise, resolve it
+                    const resolvedProvider = await provider;
+                    await resolvedProvider.provide(context);
+                }
+                else {
+                    // If provider is a direct instance, use it directly
+                    await provider.provide(context);
+                }
+                // Apply pending operations after each provider so subsequent providers
+                // can find items added by earlier providers (e.g. Tokens under Data Definitions)
+                this.applyPendingOperations(items);
+            }
+        }
+        // Sort items by priority
+        items.sort((a, b) => (a.priority ?? 0) - (b.priority ?? 0));
+        // Apply middlewares using registry (sorted by priority)
+        await this.applyMiddlewares(items);
+        // ADD level property to items
+        setMenuItemMeta(items);
+        // Cache the computed items
+        this.cache = items;
+        return items;
+    }
+    /**
+     * Get raw menu items WITHOUT middleware applied (for management/editing)
+     * Used by menu management pages to show original items before customization
+     */
+    async rawItems() {
+        const items = [];
+        const context = this.createMenuProviderContext(items);
+        // Load providers from DI tokens
+        if (Array.isArray(this.providers)) {
+            for (const provider of this.providers) {
+                if (provider instanceof Promise) {
+                    // If provider is a promise, resolve it
+                    const resolvedProvider = await provider;
+                    await resolvedProvider.provide(context);
+                }
+                else {
+                    // If provider is a direct instance, use it directly
+                    await provider.provide(context);
+                }
+                // Apply pending operations after each provider
+                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)
+        setMenuItemMeta(items);
+        return items;
+    }
+    /**
+     * Clear the cache to force reload of menu items
+     * Notifies all subscribers to reload their menu data
+     */
+    clearCache() {
+        this.cache = null;
+        this.pendingInserts = [];
+        this.pendingRemovals = [];
+        this.pendingUpdates = [];
+        this.pendingAdditions = [];
+        this.pendingMoves = [];
+        // Notify subscribers that menu should be reloaded
+        this.menuReloadSubject.next();
+    }
+    //#endregion
+    //#region ----   Private Methods   ----
+    /**
+     * Apply middlewares in priority order using the enhanced context API
+     */
+    async applyMiddlewares(items) {
+        const middlewares = this.middlewareRegistry.list();
+        for (const middleware of middlewares) {
+            try {
+                const context = createMenuContext(items);
+                await middleware.process(context);
+                // The context mutates the items array, so no need to reassign
+            }
+            catch (error) {
+                console.error(`Error in menu middleware ${middleware.name || 'anonymous'}:`, error);
+            }
+        }
+    }
+    /**
+     * Create provider context for menu providers
+     */
+    createMenuProviderContext(items) {
+        return {
+            addItems: (newItems) => {
+                for (const newItem of newItems) {
+                    if (newItem.name) {
+                        const existingItem = this.findItemByName(items, newItem.name);
+                        if (existingItem) {
+                            // Update existing item, merging properties
+                            this.mergeMenuItem(existingItem, newItem);
+                        }
+                        else {
+                            // Add new item if it doesn't exist
+                            items.push(newItem);
+                        }
+                    }
+                    else {
+                        // Add item without name (no way to check for duplicates)
+                        items.push(newItem);
+                    }
+                }
+            },
+            find: (target) => {
+                const foundItemInfo = this.findItemWithParent(items, target);
+                const exists = foundItemInfo.foundItem !== null;
+                return {
+                    exists,
+                    insert: (newItems, position) => {
+                        this.pendingInserts.push({ target, newItems, position });
+                    },
+                    remove: () => {
+                        this.pendingRemovals.push(target);
+                    },
+                    update: (updatedItem) => {
+                        this.pendingUpdates.push({ target, updatedItem });
+                    },
+                    addItems: (newItems) => {
+                        this.pendingAdditions.push({ target, newItems });
+                    },
+                    moveTo: (destination, position = 'inside') => {
+                        this.pendingMoves.push({
+                            source: target,
+                            destination,
+                            position: position ?? 'inside',
+                        });
+                    },
+                };
+            }
+        };
+    }
+    applyPendingOperations(items) {
+        for (const { target, newItems, position } of this.pendingInserts) {
+            const foundItemInfo = this.findItemWithParent(items, target);
+            const { foundItem, parentItems } = foundItemInfo;
+            if (!foundItem) {
+                console.warn(`Target "${target}" not found, appending items.`);
+                items.push(...newItems);
+            }
+            else {
+                if (position === 'inside') {
+                    if (!foundItem.children) {
+                        foundItem.children = [];
+                    }
+                    // Check for duplicates by name and merge or add
+                    for (const newItem of newItems) {
+                        if (newItem.name) {
+                            const existingChild = this.findItemByName(foundItem.children, newItem.name);
+                            if (existingChild) {
+                                this.mergeMenuItem(existingChild, newItem);
+                            }
+                            else {
+                                foundItem.children.push(newItem);
+                            }
+                        }
+                        else {
+                            foundItem.children.push(newItem);
+                        }
+                    }
+                }
+                else {
+                    // For 'before' and 'after', check for duplicates in parent items
+                    const itemsToInsert = [];
+                    for (const newItem of newItems) {
+                        if (newItem.name) {
+                            const existingItem = this.findItemByName(parentItems, newItem.name);
+                            if (existingItem) {
+                                this.mergeMenuItem(existingItem, newItem);
+                            }
+                            else {
+                                itemsToInsert.push(newItem);
+                            }
+                        }
+                        else {
+                            itemsToInsert.push(newItem);
+                        }
+                    }
+                    if (itemsToInsert.length > 0) {
+                        const index = parentItems.indexOf(foundItem);
+                        const insertPosition = position === 'before' ? index : index + 1;
+                        parentItems.splice(insertPosition, 0, ...itemsToInsert);
+                    }
+                }
+            }
+        }
+        for (const target of this.pendingRemovals) {
+            const foundItemInfo = this.findItemWithParent(items, target);
+            const { foundItem, parentItems } = foundItemInfo;
+            if (!foundItem) {
+                console.warn(`Target "${target}" not found, nothing to remove.`);
+            }
+            else {
+                const index = parentItems.indexOf(foundItem);
+                parentItems.splice(index, 1);
+            }
+        }
+        for (const { target, updatedItem } of this.pendingUpdates) {
+            const foundItemInfo = this.findItemWithParent(items, target);
+            const { foundItem } = foundItemInfo;
+            if (!foundItem) {
+                console.warn(`Target "${target}" not found, nothing to update.`);
+            }
+            else {
+                Object.assign(foundItem, updatedItem);
+            }
+        }
+        for (const { target, newItems } of this.pendingAdditions) {
+            const foundItemInfo = this.findItemWithParent(items, target);
+            const { foundItem } = foundItemInfo;
+            if (!foundItem) {
+                console.warn(`Target "${target}" not found, nothing to add items to.`);
+            }
+            else {
+                if (!foundItem.children) {
+                    foundItem.children = [];
+                }
+                // Check for duplicates by name and merge or add
+                for (const newItem of newItems) {
+                    if (newItem.name) {
+                        const existingChild = this.findItemByName(foundItem.children, newItem.name);
+                        if (existingChild) {
+                            this.mergeMenuItem(existingChild, newItem);
+                        }
+                        else {
+                            foundItem.children.push(newItem);
+                        }
+                    }
+                    else {
+                        foundItem.children.push(newItem);
+                    }
+                }
+            }
+        }
+        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) {
+            if (item.name === target) {
+                return { foundItem: item, parentItems };
+            }
+            if (item.children) {
+                const result = this.findItemWithParent(item.children, target, item.children);
+                if (result.foundItem) {
+                    return result;
+                }
+            }
+        }
+        return { foundItem: null, parentItems: items };
+    }
+    /**
+     * Find menu item by name in the items tree (recursive search)
+     */
+    findItemByName(items, name) {
+        for (const item of items) {
+            if (item.name === name) {
+                return item;
+            }
+            if (item.children) {
+                const found = this.findItemByName(item.children, name);
+                if (found) {
+                    return found;
+                }
+            }
+        }
+        return null;
+    }
+    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
+     */
+    mergeMenuItem(existingItem, newItem) {
+        // Merge top-level properties (newItem properties override existing only if defined)
+        if (newItem.text !== undefined)
+            existingItem.text = newItem.text;
+        if (newItem.description !== undefined)
+            existingItem.description = newItem.description;
+        if (newItem.icon !== undefined)
+            existingItem.icon = newItem.icon;
+        if (newItem.path !== undefined)
+            existingItem.path = newItem.path;
+        if (newItem.priority !== undefined)
+            existingItem.priority = newItem.priority;
+        if (newItem.type !== undefined)
+            existingItem.type = newItem.type;
+        if (newItem.command !== undefined)
+            existingItem.command = newItem.command;
+        if (newItem.badgeKey !== undefined)
+            existingItem.badgeKey = newItem.badgeKey;
+        if (newItem.data !== undefined)
+            existingItem.data = newItem.data;
+        if (newItem.policy !== undefined)
+            existingItem.policy = newItem.policy;
+        // Merge children if both have children
+        if (newItem.children && newItem.children.length > 0) {
+            if (!existingItem.children) {
+                existingItem.children = [];
+            }
+            // For each child in newItem, check if it exists by name and merge or add
+            for (const newChild of newItem.children) {
+                if (newChild.name) {
+                    const existingChild = this.findItemByName(existingItem.children, newChild.name);
+                    if (existingChild) {
+                        this.mergeMenuItem(existingChild, newChild);
+                    }
+                    else {
+                        existingItem.children.push(newChild);
+                    }
+                }
+                else {
+                    existingItem.children.push(newChild);
+                }
+            }
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "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: "21.2.9", ngImport: i0, type: AXPMenuProviderService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+function setMenuItemMeta(items, parentIndex = '', depth = 0) {
+    items.forEach((item, index) => {
+        const currentIndex = parentIndex ? `${parentIndex}-${index}` : `${index}`;
+        const hasChildren = !!(item.children && Array.isArray(item.children) && item.children.length > 0);
+        item.meta = {
+            index: currentIndex,
+            isRoot: depth === 0,
+            hasChildren,
+            depth
+        };
+        if (hasChildren) {
+            setMenuItemMeta(item.children, currentIndex, depth + 1);
+        }
+    });
+}
+
+//#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
+ * Similar to provideCommandMiddleware pattern
+ *
+ * @example
+ * ```typescript
+ * // In app.config.ts or module providers
+ * export const appConfig: ApplicationConfig = {
+ *   providers: [
+ *     provideMenuMiddleware([
+ *       customizationMiddleware,
+ *       securityMiddleware,
+ *       loggingMiddleware
+ *     ])
+ *   ]
+ * };
+ * ```
+ */
+function provideMenuMiddleware(middlewares) {
+    return makeEnvironmentProviders([
+        ...middlewares.map((middleware) => ({
+            provide: AXP_MENU_MIDDLEWARE,
+            useValue: middleware,
+            multi: true,
+        })),
+    ]);
+}
+/**
+ * Helper to create a class-based middleware with priority
+ *
+ * @example
+ * ```typescript
+ * const myMiddleware = createMenuMiddleware({
+ *   name: 'my-middleware',
+ *   priority: 100,
+ *   process: async (context) => {
+ *     context.find('dashboard').setPriority(1);
+ *   }
+ * });
+ * ```
+ */
+function createMenuMiddleware(config) {
+    return {
+        name: config.name,
+        priority: config.priority ?? 0,
+        process: config.process,
+    };
+}
+//#endregion
+
+const AXPMenuService = signalStore({ providedIn: 'root' }, 
+// Initial State
+withState((router = inject(Router)) => {
+    return {
+        items: [],
+        selectedMenuItem: {
+            item: null,
+            isFullMatch: false,
+        },
+    };
+}), 
+// Methods for State Management
+withMethods((store, router = inject(Router), workflow = inject(AXPWorkflowService), commandExecutor = inject(AXPCommandExecutor)) => {
+    return {
+        setMenuItems(items) {
+            patchState(store, { items: items });
+        },
+        selectMenuItemByRoute(path) {
+            const currentRawPath = path;
+            const findItem = (items) => {
+                for (const item of items) {
+                    // Recursively search children first
+                    if (item.children) {
+                        const foundChild = findItem(item.children);
+                        if (foundChild.item) {
+                            return foundChild;
+                        }
+                    }
+                    if (item.path) {
+                        // Check if the item path matches the current path (including query param subset if provided on item)
+                        const matchResult = pathsMatch(item.path, currentRawPath, ['list', 'view', 'edit', 'create']);
+                        if (matchResult.isMatch) {
+                            return { item, isPartialMatch: matchResult.isPartial };
+                        }
+                    }
+                }
+                return { item: null, isPartialMatch: false };
+            };
+            const pathsMatch = (itemPath, currentPath, trailingSegmentsToIgnore = []) => {
+                // Split base and query/hash
+                const itemNoHash = itemPath.split('#')[0];
+                const currentNoHash = currentPath.split('#')[0];
+                const [itemBase, itemQueryString = ''] = itemNoHash.split('?');
+                const [currentBase, currentQueryString = ''] = currentNoHash.split('?');
+                const itemSegments = itemBase.split('/').filter((segment) => segment.length > 0);
+                const pathSegments = currentBase.split('/').filter((segment) => segment.length > 0);
+                const menuLength = itemSegments.length;
+                const pathLength = pathSegments.length;
+                // Identify the effective base length for the menuPath
+                let effectiveMenuLength = menuLength;
+                if (menuLength > 0 && trailingSegmentsToIgnore.includes(itemSegments[menuLength - 1])) {
+                    effectiveMenuLength--; // Exclude trailing non-hierarchical segments
+                }
+                // Check if the menuPath (base segments) is a prefix of browserPath
+                let isPrefix = true;
+                if (pathLength < effectiveMenuLength) {
+                    return { isMatch: false, isPartial: false };
+                }
+                for (let i = 0; i < effectiveMenuLength; i++) {
+                    if (itemSegments[i] !== pathSegments[i]) {
+                        isPrefix = false;
+                        break;
+                    }
+                }
+                if (!isPrefix) {
+                    return { isMatch: false, isPartial: false };
+                }
+                // Partial match: menuPath base is a strict prefix of browserPath
+                const isPartialMatch = effectiveMenuLength < pathLength;
+                // Exact match: all segments match completely
+                const isExactMatch = effectiveMenuLength === pathLength;
+                // Query params subset match: if item defines any query params, require them to match
+                const itemParams = new URLSearchParams(itemQueryString);
+                const currentParams = new URLSearchParams(currentQueryString);
+                let queryMatches = true;
+                const itemParamPairs = [];
+                itemParams.forEach((value, key) => {
+                    itemParamPairs.push([key, value]);
+                });
+                if (itemParamPairs.length > 0) {
+                    for (const [k, v] of itemParamPairs) {
+                        if (currentParams.get(k) !== v) {
+                            queryMatches = false;
+                            break;
+                        }
+                    }
+                }
+                return {
+                    isMatch: (isExactMatch || isPartialMatch) && queryMatches,
+                    isPartial: isPartialMatch && !isExactMatch,
+                };
+            };
+            const items = store.items();
+            const { item, isPartialMatch } = findItem(items);
+            patchState(store, { selectedMenuItem: { item, isFullMatch: !isPartialMatch } });
+        },
+        executeCommand(item) {
+            if (item.path) {
+                workflow.execute('navigate', {
+                    type: 'router',
+                    options: { path: item.path },
+                });
+                patchState(store, { selectedMenuItem: { item, isFullMatch: true } });
+            }
+            if (item.command) {
+                const command = item.command;
+                if (workflow.exists(command?.name)) {
+                    workflow.execute(command.name, command.options);
+                }
+                else {
+                    commandExecutor.execute(command.name, command.options);
+                }
+            }
+        },
+        isItemOpen(item) {
+            const selectedItem = store.selectedMenuItem();
+            if (!selectedItem.item) {
+                return false;
+            }
+            const findParent = (currentItem, targetItem) => {
+                if (currentItem.children?.includes(targetItem)) {
+                    return true;
+                }
+                return currentItem.children?.some((child) => findParent(child, targetItem)) ?? false;
+            };
+            return item === selectedItem.item || findParent(item, selectedItem.item);
+        },
+    };
+}), withHooks((store, menuProviderService = inject(AXPMenuProviderService)) => {
+    let reloadSubscription;
+    return {
+        onInit() {
+            // Load initial menu items
+            (async () => {
+                const items = await menuProviderService.items();
+                patchState(store, { items: items });
+            })();
+            // Subscribe to menu reload events
+            reloadSubscription = menuProviderService.menuReload$.subscribe(async () => {
+                const items = await menuProviderService.items();
+                patchState(store, { items: items });
+            });
+        },
+        onDestroy() {
+            // Clean up subscription
+            if (reloadSubscription) {
+                reloadSubscription.unsubscribe();
+            }
+        },
+    };
+}));
+
+/**
+ * Service for checking menu item visibility based on permissions, features, and children.
+ * This service helps filter out empty menu items that have no visible children.
+ */
+class AXPMenuVisibilityService {
+    constructor() {
+        this.sessionService = inject(AXPSessionService);
+    }
+    /**
+     * Checks if a menu item should be visible based on permissions and features.
+     */
+    isItemVisible(item) {
+        const policy = item.policy;
+        if (!policy) {
+            return true; // No policy means visible
+        }
+        // Check features
+        if (policy.features && policy.features.length > 0) {
+            const featureKeys = Array.isArray(policy.features) ? policy.features : [policy.features];
+            if (!this.sessionService.isFeatureEnabled(...featureKeys)) {
+                return false;
+            }
+        }
+        // Check permissions
+        if (policy.permissions && policy.permissions.length > 0) {
+            const permissionKeys = Array.isArray(policy.permissions) ? policy.permissions : [policy.permissions];
+            if (!this.sessionService.authorize(...permissionKeys)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    /**
+     * Recursively checks if a menu item has any visible children.
+     * @param item The menu item to check
+     * @param getRouterLink Optional function to check if an item has a router link
+     */
+    hasVisibleChildren(item, getRouterLink) {
+        if (!item.children || item.children.length === 0) {
+            return false;
+        }
+        return item.children.some((child) => {
+            // Check if child itself is visible
+            if (!this.isItemVisible(child)) {
+                return false;
+            }
+            // If child has a routerLink, it's visible
+            if (getRouterLink && getRouterLink(child)) {
+                return true;
+            }
+            // If child has visible children, it's visible
+            if (this.hasVisibleChildren(child, getRouterLink)) {
+                return true;
+            }
+            // For items without routerLink, check if they have a command (non-empty menu items)
+            if (child.command) {
+                return true;
+            }
+            return false;
+        });
+    }
+    /**
+     * Determines if a menu item should be rendered.
+     * A menu item should be rendered if:
+     * 1. It has a routerLink, OR
+     * 2. It has visible children, OR
+     * 3. It has a command (for non-router navigation)
+     *
+     * @param item The menu item to check
+     * @param getRouterLink Optional function to check if an item has a router link
+     */
+    shouldRenderMenuItem(item, getRouterLink) {
+        // Check if item itself is visible (permissions/features)
+        if (!this.isItemVisible(item)) {
+            return false;
+        }
+        // If it has a routerLink, render it
+        if (getRouterLink && getRouterLink(item)) {
+            return true;
+        }
+        // If it has visible children, render it
+        if (this.hasVisibleChildren(item, getRouterLink)) {
+            return true;
+        }
+        // If it has a command (for non-router navigation), render it
+        if (item.command) {
+            return true;
+        }
+        // Otherwise, don't render empty menu items
+        return false;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "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: "21.2.9", ngImport: i0, type: AXPMenuVisibilityService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+
+class AXPMenuSearchDefinitionProvider {
+    async provide(context) {
+        context.addDefinition('menu', 'Menu', 'menu', 'fa-thin fa-bars', 2, {
+            format: {
+                id: '{{data.name}}',
+            },
+            actions: [
+                {
+                    name: 'navigate',
+                    type: AXPSystemActionType.View,
+                    priority: 'primary',
+                },
+            ],
+        });
+    }
+}
+
+class AXPMenuSearchProvider {
+    constructor() {
+        this.menuService = inject(AXPMenuProviderService);
+        this.translateService = inject(AXTranslationService);
+    }
+    async search(text) {
+        const menuItems = await this.searchMenuItems(await this.menuService.items(), text);
+        return sortBy(menuItems.map((item) => ({
+            group: 'menu', // Use `name` or empty string if undefined
+            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',
+                    options: {
+                        path: item.path,
+                    },
+                }
+            } : item.command,
+            parent: item.parent
+                ? {
+                    title: item.parent.text,
+                }
+                : undefined,
+        })), [(o) => this.translateService.translateSync(o.title)]);
+    }
+    /**
+     * Recursively searches AXPMenuItem and its children for a matching text.
+     *
+     * @param menuItems - The array of AXPMenuItem to search in.
+     * @param searchText - The text to search for (case-insensitive).
+     * @returns An array of AXPMenuItem that match the search text.
+     */
+    async searchMenuItems(menuItems, searchText) {
+        const result = [];
+        for (const item of menuItems) {
+            // Check if the current item's text matches the search text
+            if (item.type != 'group' &&
+                (item.children?.length ?? 0) == 0 &&
+                (await this.translateService.translateAsync(item.text)).toLowerCase().includes(searchText.toLowerCase())) {
+                result.push(item);
+            }
+            // Recursively search in children if they exist
+            if (item.children && item.children.length > 0) {
+                const childResults = await this.searchMenuItems(item.children, searchText);
+                result.push(...childResults.map((x) => ({ ...x, parent: item })));
+            }
+        }
+        return result;
+    }
+}
+
+class AXPFooterTextSlotComponent {
+    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, changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+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,
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                }]
+        }], propDecorators: { text: [{
+                type: Input
+            }] } });
+
+class AXPNavBarSlotComponent {
+    handleCommand(action) {
+        // if (action)
+        //     this.store.dispatch(action)
+    }
+    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>
+      }
+    </div>
+    `, isInline: true, encapsulation: i0.ViewEncapsulation.None }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPNavBarSlotComponent, decorators: [{
+            type: Component,
+            args: [{
+                    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>
+      }
+    </div>
+    `,
+                    imports: [],
+                    encapsulation: ViewEncapsulation.None
+                }]
+        }], propDecorators: { items: [{
+                type: Input
+            }] } });
+
+class AXPSearchDefinitionProviderContext {
+    constructor() {
+        this.definitions = [];
+        this.definitionMap = new Map();
+    }
+    addDefinition(name, title, group, icon, order, options) {
+        const definitionSearch = {
+            name,
+            title,
+            group,
+            icon,
+            order,
+            format: {
+                title: options?.format?.title ?? '{{ title }}',
+                description: options?.format?.description ?? undefined,
+                icon: options?.format?.icon ?? undefined,
+                id: options?.format?.id ?? '{{ id }}',
+            },
+            actions: options?.actions ?? [],
+        };
+        this.definitions.push(definitionSearch);
+        this.definitionMap.set(name, definitionSearch); // Index by name
+        return new AXPSearchDefinitionBuilder(this, definitionSearch);
+    }
+    getDefinitions() {
+        return this.definitions;
+    }
+    // Expose groupMap for controlled access
+    hasEntity(name) {
+        return this.definitionMap.has(name);
+    }
+    getDefinition(name) {
+        return this.definitionMap.get(name);
+    }
+}
+class AXPSearchDefinitionBuilder {
+    constructor(context, definition) {
+        this.context = context;
+        this.definition = definition;
+    }
+    addAction(name) {
+        const newAction = {
+            name,
+            type: AXPSystemActionType.View,
+            priority: 'primary',
+        };
+        this.definition.actions.push(newAction);
+        return new AXPSearchDefinitionActionBuilder(this);
+    }
+    action(name) {
+        const foundAction = this.definition.actions.find((action) => action.name === name);
+        if (!foundAction) {
+            throw new Error(`action with name "${name}" not found in entity "${this.definition.name}".`);
+        }
+        return new AXPSearchDefinitionActionBuilder(this);
+    }
+    endEntity() {
+        return this.context;
+    }
+}
+class AXPSearchDefinitionActionBuilder {
+    constructor(entityBuilder) {
+        this.entityBuilder = entityBuilder;
+    }
+    endAction() {
+        return this.entityBuilder;
+    }
+}
+
+// Injection token for setting providers
+const AXP_SEARCH_DEFINITION_PROVIDER = new InjectionToken('AXP_SEARCH_DEFINITION_PROVIDER');
+class AXPSearchDefinitionProviderService {
+    constructor() {
+        this.providers = inject(AXP_SEARCH_DEFINITION_PROVIDER, { optional: true });
+        this.cache = null;
+    }
+    async load() {
+        if (this.cache) {
+            return;
+        }
+        const context = new AXPSearchDefinitionProviderContext();
+        // Load providers from DI tokens (backward compatibility)
+        if (Array.isArray(this.providers)) {
+            for (const provider of this.providers) {
+                await provider.provide(context);
+            }
+        }
+        // Note: Search definition providers are different from search command providers
+        // Search command providers are handled separately in search.service.ts
+        this.cache = context.getDefinitions();
+    }
+    async getListAsync() {
+        await this.load();
+        return this.getList();
+    }
+    getList() {
+        if (!this.cache) {
+            return [];
+        }
+        else {
+            return this.cache;
+        }
+    }
+    findDefinition(definitionName) {
+        const definition = this.getList().find((definition) => definition.name === definitionName);
+        if (!definition) {
+            throw new Error(`Definition with name ${definitionName} not found`);
+        }
+        return definition;
+    }
+    findDefinitionByGroup(definitionGroup) {
+        const definition = this.getList().find((definition) => definition.group === definitionGroup);
+        if (!definition) {
+            throw new Error(`Definition with group ${definitionGroup} not found`);
+        }
+        return definition;
+    }
+    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: "21.2.9", ngImport: i0, type: AXPSearchDefinitionProviderService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+
+class AXPSearchCommandProvider {
+    async search(text) {
+        return this.commands.filter((command) => command.title.toLowerCase().includes(text.toLowerCase()));
+    }
+}
+
+// Injection token for setting providers
+const AXP_SEARCH_PROVIDER = new InjectionToken('AXP_SEARCH_PROVIDER');
+class AXPSearchService {
+    constructor() {
+        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
+        if (this.definitionService.getList().length == 0) {
+            await this.definitionService.getListAsync();
+        }
+        // Collect providers from DI tokens
+        const allProviders = [];
+        // Load from DI tokens
+        if (Array.isArray(this.providers)) {
+            allProviders.push(...this.providers);
+        }
+        else if (this.providers) {
+            allProviders.push(this.providers);
+        }
+        if (allProviders.length === 0) {
+            throw new Error('No search providers available');
+        }
+        const 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 = providersWithSearch.map((provider) => provider.search(text));
+        const results = await Promise.all(promises);
+        for (const resultArray of results) {
+            for (const result of resultArray) {
+                try {
+                    const definition = this.definitionService.findDefinition(result.group);
+                    mergeData.push({
+                        definitionName: definition.group,
+                        definitionTitle: definition.title,
+                        name: result.group,
+                        id: `${definition.name}:${this.formatService.format(definition.format.id, 'string', result)}`,
+                        title: result.title ??
+                            (definition.format.title
+                                ? this.formatService.format(definition.format.title, 'string', result.data)
+                                : 'Unknown'),
+                        description: result.description ??
+                            (definition.format.description
+                                ? this.formatService.format(definition.format.description, 'string', result.data)
+                                : undefined),
+                        icon: result.icon ?? definition.icon,
+                        data: result.data,
+                        command: result.command,
+                        actions: definition.actions,
+                        parent: result.parent,
+                        order: definition.order,
+                    });
+                }
+                catch (e) {
+                    console.error(e);
+                }
+            }
+        }
+        // Group data
+        const groupedData = [];
+        const groupMap = {};
+        // Create groups
+        for (const item of mergeData) {
+            const groupName = item.definitionName; // Change this to the property you want to group by
+            if (!groupMap[groupName]) {
+                groupMap[groupName] = {
+                    name: groupName,
+                    title: item.definitionTitle, // You can adjust the title logic if needed
+                    order: item.order, // Add order to the group
+                    children: [],
+                };
+                groupedData.push(groupMap[groupName]);
+            }
+            groupMap[groupName].children.push(omit(item, ['definitionName', 'definitionTitle', 'order']));
+        }
+        // Sort groups by order
+        groupedData.sort((a, b) => a.order - b.order);
+        return groupedData;
+    }
+    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: "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 || (AXPCommonSettings = {}));
+
+//TODO Loading, Redirect, Drawer, Show toast
+const AXPRedirectEvent = createWorkFlowEvent('Redirect Event Fired');
+const AXPRefreshEvent = createWorkFlowEvent('Refresh Event Fired');
+const AXPReloadEvent = createWorkFlowEvent('Reload Event Fired');
+class AXPWorkflowNavigateAction extends AXPWorkflowAction {
+    constructor() {
+        super(...arguments);
+        this.router = inject(Router);
+    }
+    async execute(context) {
+        const payload = context.getVariable('payload');
+        if (Array.isArray(payload.commands)) {
+            this.router.navigate(payload.commands, payload.extras);
+        }
+        else {
+            if (payload.commands.toLowerCase().startsWith('http') || payload.target == 'blank') {
+                window.open(payload.commands, '_blank');
+            }
+            else
+                this.router.navigate([payload.commands], payload.extras);
+        }
+    }
+    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: "21.2.9", ngImport: i0, type: AXPWorkflowNavigateAction, decorators: [{
+            type: Injectable
+        }] });
+class AXPDialogConfirmAction extends AXPWorkflowAction {
+    constructor() {
+        super(...arguments);
+        this.dialogService = inject(AXDialogService);
+        this.translationService = inject(AXTranslationService);
+        this.defaultAction = 'cancel';
+    }
+    async execute(context) {
+        console.log('AXPDialogConfirmAction', this.title, this.message, this.type);
+        context.setOutput('result', false);
+        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: "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: "21.2.9", ngImport: i0, type: AXPDialogConfirmAction, decorators: [{
+            type: Injectable
+        }] });
+class AXPToastAction extends AXPWorkflowAction {
+    constructor() {
+        super(...arguments);
+        this.toastService = inject(AXToastService);
+        this.translationService = inject(AXTranslationService);
+        this.settingsService = inject(AXPSettingsService);
+    }
+    async execute(context) {
+        const showResult = await this.settingsService.get(AXPCommonSettings.EnableOperationToasts);
+        if (showResult) {
+            this.toastService.show({
+                color: this.color,
+                title: await this.translationService.translateAsync(this.title),
+                content: await this.translationService.translateAsync(this.content),
+                closeButton: true,
+                timeOut: 3000,
+                timeOutProgress: true,
+            });
+        }
+    }
+    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: "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: "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: "21.2.9", ngImport: i0, type: AXPReloadAction, decorators: [{
+            type: Injectable
+        }] });
+
+class AXPWorkflowRouterNavigateAction extends AXPWorkflowAction {
+    constructor() {
+        super(...arguments);
+        this.router = inject(Router);
+    }
+    async execute(context) {
+        const command = context.getVariable();
+        const path = command.options.path;
+        if (path?.toLowerCase()?.startsWith('http') || command.options?.extras?.target === 'blank') {
+            window.open(path, '_blank');
+        }
+        else {
+            const [basePathAndFragment, queryString] = path.split('?');
+            const [basePath, fragment] = basePathAndFragment.split('#'); // Extract fragment if present
+            const queryParams = this.parseQueryParams(queryString);
+            this.router.navigate([basePath], {
+                ...command.options.extras,
+                queryParams, // Pass query parameters separately
+                fragment, // Pass fragment explicitly
+            });
+        }
+    }
+    /**
+     * Parses query parameters from a query string into an object.
+     */
+    parseQueryParams(queryString) {
+        if (!queryString)
+            return undefined;
+        return queryString
+            .split('&')
+            .map((pair) => pair.split('='))
+            .reduce((params, [key, value]) => {
+            params[decodeURIComponent(key)] = decodeURIComponent(value);
+            return params;
+        }, {});
+    }
+    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: "21.2.9", ngImport: i0, type: AXPWorkflowRouterNavigateAction, decorators: [{
+            type: Injectable
+        }] });
+const AXPNavigateWorkflow = {
+    startStepId: 'start',
+    steps: {
+        start: {
+            action: 'navigate-router',
+        },
+    },
+};
+
+class AXMWorkflowErrorHandler {
+    constructor() {
+        this.dialog = inject(AXDialogService);
+    }
+    handleError(error, next) {
+        if (error instanceof AXPWorkflowError) {
+            this.dialog.alert("Somthing is wrong!", error.inner ? error.inner.message : error.message, 'danger');
+            next(error);
+        }
+        else {
+            next(error);
+        }
+    }
+    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 AXPCommonModule {
+    static forRoot(configs) {
+        return {
+            ngModule: AXPCommonModule,
+            providers: [
+                ...(configs?.errorHandlers || []),
+                {
+                    provide: 'AXPCommonModuleFactory',
+                    useFactory: (registry) => () => {
+                        registry.register(...(configs?.errorHandlers || []));
+                    },
+                    deps: [AXPErrorHandlerRegistryService],
+                    multi: true,
+                },
+            ],
+        };
+    }
+    static forChild(configs) {
+        return {
+            ngModule: AXPCommonModule,
+            providers: [
+                ...(configs?.errorHandlers || []),
+                {
+                    provide: 'AXPCommonModuleFactory',
+                    useFactory: (registry) => () => {
+                        registry.register(...(configs?.errorHandlers || []));
+                    },
+                    deps: [AXPErrorHandlerRegistryService],
+                    multi: true,
+                },
+            ],
+        };
+    }
+    /**
+     * @ignore
+     */
+    constructor(instances) {
+        instances.forEach((f) => {
+            f();
+        });
+    }
+    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: "21.2.9", ngImport: i0, type: AXPCommonModule, providers: [
+            AXPAppStartUpProvider,
+            {
+                provide: ErrorHandler,
+                useClass: AXPGlobalErrorHandler,
+            },
+            {
+                provide: AXPCustomOperatorService,
+                useClass: AXPCustomOperatorServiceImpl,
+            },
+            {
+                provide: AXPFilterOperatorMiddlewareService,
+                useClass: AXPFilterOperatorMiddlewareServiceImpl,
+            },
+            {
+                provide: AXP_SEARCH_PROVIDER,
+                useClass: AXPMenuSearchProvider,
+                multi: true,
+            },
+            {
+                provide: AXP_SEARCH_DEFINITION_PROVIDER,
+                useClass: AXPMenuSearchDefinitionProvider,
+                multi: true,
+            },
+            {
+                provide: AXP_EXPRESSION_EVALUATOR_SCOPE_PROVIDER,
+                useClass: AXPTokenEvaluatorScopeProvider,
+                multi: true,
+            },
+            {
+                provide: AXP_EXPRESSION_EVALUATOR_SCOPE_PROVIDER,
+                useClass: AXPSettingsEvaluatorScopeProvider,
+                multi: true,
+            },
+            {
+                provide: AXP_SETTING_DEFINITION_PROVIDER,
+                useFactory: async () => {
+                    const injector = inject(Injector);
+                    const provider = (await import('./acorex-platform-common-common-settings.provider-G9XcXXOG.mjs')).AXPCommonSettingProvider;
+                    return new provider(injector);
+                },
+                multi: true,
+            },
+        ], imports: [AXPWorkflowModule.forChild({
+                actions: {
+                    'navigate-router': AXPWorkflowRouterNavigateAction,
+                    'show-prompt-dialog': AXPDialogConfirmAction,
+                    'show-toast': AXPToastAction,
+                    reload: AXPReloadAction,
+                },
+                workflows: {
+                    navigate: AXPNavigateWorkflow,
+                },
+            }),
+            AXPopupModule,
+            AXDateTimeModule,
+            AXToastModule,
+            AXPModuleManifestModule, RouterModule] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPCommonModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [
+                        AXPWorkflowModule.forChild({
+                            actions: {
+                                'navigate-router': AXPWorkflowRouterNavigateAction,
+                                'show-prompt-dialog': AXPDialogConfirmAction,
+                                'show-toast': AXPToastAction,
+                                reload: AXPReloadAction,
+                            },
+                            workflows: {
+                                navigate: AXPNavigateWorkflow,
+                            },
+                        }),
+                        AXPopupModule,
+                        AXDateTimeModule,
+                        AXToastModule,
+                        AXPModuleManifestModule,
+                    ],
+                    exports: [RouterModule],
+                    providers: [
+                        AXPAppStartUpProvider,
+                        {
+                            provide: ErrorHandler,
+                            useClass: AXPGlobalErrorHandler,
+                        },
+                        {
+                            provide: AXPCustomOperatorService,
+                            useClass: AXPCustomOperatorServiceImpl,
+                        },
+                        {
+                            provide: AXPFilterOperatorMiddlewareService,
+                            useClass: AXPFilterOperatorMiddlewareServiceImpl,
+                        },
+                        {
+                            provide: AXP_SEARCH_PROVIDER,
+                            useClass: AXPMenuSearchProvider,
+                            multi: true,
+                        },
+                        {
+                            provide: AXP_SEARCH_DEFINITION_PROVIDER,
+                            useClass: AXPMenuSearchDefinitionProvider,
+                            multi: true,
+                        },
+                        {
+                            provide: AXP_EXPRESSION_EVALUATOR_SCOPE_PROVIDER,
+                            useClass: AXPTokenEvaluatorScopeProvider,
+                            multi: true,
+                        },
+                        {
+                            provide: AXP_EXPRESSION_EVALUATOR_SCOPE_PROVIDER,
+                            useClass: AXPSettingsEvaluatorScopeProvider,
+                            multi: true,
+                        },
+                        {
+                            provide: AXP_SETTING_DEFINITION_PROVIDER,
+                            useFactory: async () => {
+                                const injector = inject(Injector);
+                                const provider = (await import('./acorex-platform-common-common-settings.provider-G9XcXXOG.mjs')).AXPCommonSettingProvider;
+                                return new provider(injector);
+                            },
+                            multi: true,
+                        },
+                    ],
+                }]
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: ['AXPCommonModuleFactory']
+                }] }] });
+
+const ENVIRONMENT = new InjectionToken('ENVIRONMENT');
+const AXP_PLATFORM_CONFIG_TOKEN = new InjectionToken('AXP_PLATFORM_CONFIG_TOKEN', {
+    providedIn: 'root',
+    factory: () => {
+        return AXPPlatformDefaultConfigs;
+    },
+});
+const AXPPlatformDefaultConfigs = {
+    copyright: 'ACoreX @ 2024',
+    title: 'ACoreX Platform',
+    network: {
+        timeOut: 5000,
+    },
+};
+function configPlatform(config = AXPPlatformDefaultConfigs) {
+    return merge(AXPPlatformDefaultConfigs, config);
+}
+
+const AXP_ROOT_CONFIG_TOKEN = new InjectionToken('AXP_ROOT_CONFIG_TOKEN');
+
+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: "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 = {}));
+
+//#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: "21.2.9", ngImport: i0, type: AXPFileActionsService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+
+//#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 {
+    constructor() {
+        this.providers = inject(AXP_FILE_TYPE_INFO_PROVIDER, { optional: true });
+    }
+    async items() {
+        const items = [];
+        if (Array.isArray(this.providers)) {
+            for (const provider of this.providers) {
+                items.push(...(await provider.items()));
+            }
+        }
+        return items;
+    }
+    async get(name) {
+        return (await this.items()).find((c) => c.name == name);
+    }
+    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: "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: "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: "21.2.9", ngImport: i0, type: AXPLockService, decorators: [{
+            type: Injectable
+        }] });
+
+/**
+ * Status Definition Types
+ * Defines the structure for status definitions and their transitions
+ */
+/**
+ * Abstract class for status providers
+ * Similar to AXPTaskBadgeProvider pattern
+ */
+class AXPStatusProvider {
+}
+//#endregion
+
+//#region ----   Injection Token   ----
+/**
+ * Injection token for status providers
+ * Use with multi: true to register multiple providers
+ */
+const AXP_STATUS_PROVIDERS = new InjectionToken('AXP_STATUS_PROVIDERS');
+//#endregion
+//#region ----   Provider Service   ----
+/**
+ * Service for managing status definitions from multiple providers
+ * Similar to AXPTaskBadgeService pattern - no cache, direct access
+ *
+ * @example
+ * ```typescript
+ * // In a module providers array:
+ * {
+ *   provide: AXP_STATUS_PROVIDERS,
+ *   useClass: TaskStatusProvider,
+ *   multi: true,
+ * }
+ *
+ * // Example provider implementation:
+ * export class TaskStatusProvider extends AXPStatusProvider {
+ *   readonly key = 'task-management.status';
+ *   readonly statuses = [
+ *     { name: 'todo', title: 'To Do', color: '#6b7280', icon: 'fa-light fa-circle', isInitial: true },
+ *     { name: 'in-progress', title: 'In Progress', color: '#3b82f6', icon: 'fa-light fa-play' },
+ *     { name: 'done', title: 'Done', color: '#10b981', icon: 'fa-light fa-check-circle', isFinal: true },
+ *   ];
+ *   readonly transitions = [
+ *     { from: 'todo', to: 'in-progress', title: 'Start', condition: '{{user.canEdit}}' },
+ *     { from: 'in-progress', to: 'done', title: 'Complete' },
+ *   ];
+ *   readonly defaultStatus = 'todo';
+ * }
+ *
+ * // Later, get the status:
+ * const status = await statusService.getStatus('task-management.status');
+ * if (status) {
+ *   console.log('Statuses:', status.statuses);
+ *   console.log('Transitions:', status.transitions);
+ * }
+ * ```
+ */
+class AXPStatusDefinitionProviderService {
+    constructor() {
+        //#region ----   Dependencies   ----
+        this.providers = inject(AXP_STATUS_PROVIDERS, { optional: true }) ?? [];
+        this.commandService = inject(AXPCommandService);
+        //#endregion
+        //#region ----   State   ----
+        this.statusMap = new Map();
+        this.initializationPromise = null;
+        this.isInitialized = false;
+    }
+    //#endregion
+    //#region ----   Initialization   ----
+    /**
+     * Initialize providers (resolve promises if needed)
+     * Called lazily on first access
+     */
+    async initialize() {
+        if (this.isInitialized) {
+            return;
+        }
+        if (this.initializationPromise) {
+            return this.initializationPromise;
+        }
+        this.initializationPromise = this._doInitialize();
+        await this.initializationPromise;
+    }
+    async _doInitialize() {
+        // Register all providers, resolving promises if needed
+        for (const provider of this.providers) {
+            let resolvedProvider;
+            if (provider instanceof Promise) {
+                // If provider is a promise, resolve it
+                resolvedProvider = await provider;
+            }
+            else {
+                // If provider is a direct instance, use it directly
+                resolvedProvider = provider;
+            }
+            if (this.statusMap.has(resolvedProvider.key)) {
+                console.warn(`Status with key "${resolvedProvider.key}" already exists. Overwriting with new status.`);
+            }
+            this.statusMap.set(resolvedProvider.key, resolvedProvider);
+        }
+        this.isInitialized = true;
+    }
+    //#endregion
+    //#region ----   Public API   ----
+    /**
+     * Get a status provider by key
+     * Ensures initialization is complete before accessing the status map.
+     *
+     * @param key - Status key (e.g., 'task-management.status')
+     * @returns Promise that resolves to status provider with all statuses and transitions, or undefined if not found
+     *
+     * @example
+     * ```typescript
+     * const status = await statusService.getStatus('task-management.status');
+     * if (status) {
+     *   console.log('Statuses:', status.statuses);
+     *   console.log('Transitions:', status.transitions);
+     * }
+     * ```
+     */
+    async getStatus(key) {
+        await this.initialize();
+        return this.statusMap.get(key);
+    }
+    /**
+     * Execute a status transition workflow action
+     * Uses transition.command if provided, otherwise defaults to Entity:UpdateStatus
+     * Validates the transition is allowed before executing
+     *
+     * @param definitionKey - Status definition key
+     * @param transition - The transition to execute
+     * @param context - Context data for the command (must include entity name and id/ids)
+     * @returns Promise that resolves when the command execution completes
+     *
+     * @example
+     * ```typescript
+     * await statusService.executeTransition(
+     *   'task-management.status',
+     *   { from: 'todo', to: 'in-progress' },
+     *   { entity: 'TaskManagement.Task', id: '123', ...entityData }
+     * );
+     * ```
+     */
+    async executeTransition(definitionKey, transition, context) {
+        await this.initialize();
+        const provider = this.statusMap.get(definitionKey);
+        if (!provider) {
+            throw new Error(`Status provider with key "${definitionKey}" not found.`);
+        }
+        // Validate transition is allowed
+        if (!this.isValidTransition(provider, transition.from, transition.to)) {
+            throw new Error(`Invalid transition from "${transition.from}" to "${transition.to}"`);
+        }
+        // Determine which command to use
+        let commandName;
+        let commandOptions;
+        if (transition.command) {
+            // Use transition's explicit command
+            commandName = transition.command.name;
+            commandOptions = {
+                ...(transition.command.options ?? {}),
+                ...context,
+            };
+        }
+        else {
+            // Use default Entity:UpdateStatus command
+            const entity = context['entityName'] ?? context['__meta__']?.config?.name;
+            if (!entity) {
+                throw new Error('Entity name is required in context when using default status update command');
+            }
+            const id = context['id'];
+            const ids = context['ids'];
+            if (!id && !ids) {
+                throw new Error('Either id or ids must be provided in context');
+            }
+            commandName = 'Entity:UpdateStatus';
+            commandOptions = {
+                entity,
+                status: transition.to,
+                statusField: context['statusField'] ?? 'statusId',
+                ...(id ? { id } : {}),
+                ...(ids ? { ids } : {}),
+            };
+        }
+        // Execute the command
+        const result = await this.commandService.execute(commandName, commandOptions);
+        if (!result?.success) {
+            throw new Error(result?.message?.text || 'Failed to execute status transition command');
+        }
+    }
+    /**
+     * Validate if a transition is allowed
+     * Checks if the transition exists in the provider's transitions list
+     */
+    isValidTransition(provider, from, to) {
+        return provider.transitions.some((transition) => transition.from === from && transition.to === to);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "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: "21.2.9", ngImport: i0, type: AXPStatusDefinitionProviderService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+
+/**
+ * Standard system status types
+ * These are the predefined status values used across the platform
+ */
+var AXPSystemStatusType;
+(function (AXPSystemStatusType) {
+    AXPSystemStatusType["Todo"] = "todo";
+    AXPSystemStatusType["InProgress"] = "in-progress";
+    AXPSystemStatusType["InReview"] = "in-review";
+    AXPSystemStatusType["Open"] = "open";
+    AXPSystemStatusType["Closed"] = "closed";
+    AXPSystemStatusType["Blocked"] = "blocked";
+    AXPSystemStatusType["Done"] = "done";
+    AXPSystemStatusType["Cancelled"] = "cancelled";
+    AXPSystemStatusType["Draft"] = "draft";
+    AXPSystemStatusType["PendingReview"] = "pending-review";
+    AXPSystemStatusType["Approved"] = "approved";
+    AXPSystemStatusType["Published"] = "published";
+    AXPSystemStatusType["Archived"] = "archived";
+    AXPSystemStatusType["Rejected"] = "rejected";
+    AXPSystemStatusType["Active"] = "active";
+    AXPSystemStatusType["Inactive"] = "inactive";
+    AXPSystemStatusType["Pending"] = "pending";
+    AXPSystemStatusType["Completed"] = "completed";
+    AXPSystemStatusType["Suspended"] = "suspended";
+    AXPSystemStatusType["Failed"] = "failed";
+    AXPSystemStatusType["Review"] = "review";
+    AXPSystemStatusType["Expired"] = "expired";
+})(AXPSystemStatusType || (AXPSystemStatusType = {}));
+const i18n = (key) => `@general:statuses.${key}`;
+/**
+ * Standard system status definitions
+ * Provides consistent status definitions across the platform
+ * Uses AXPStatusDefinition interface from status-definition.types.ts
+ */
+const AXPSystemStatuses = Object.freeze({
+    Open: {
+        name: AXPSystemStatusType.Open,
+        title: i18n('open.title'),
+        icon: 'fa-light fa-circle',
+        color: 'secondary',
+        description: i18n('open.description'),
+        order: 1,
+        isInitial: true,
+        isFinal: false,
+    },
+    Closed: {
+        name: AXPSystemStatusType.Closed,
+        title: i18n('closed.title'),
+        icon: 'fa-light fa-circle',
+        color: 'danger',
+        description: i18n('closed.description'),
+        order: 2,
+        isInitial: false,
+        isFinal: true,
+    },
+    Todo: {
+        name: AXPSystemStatusType.Todo,
+        title: i18n('todo.title'),
+        icon: 'fa-light fa-circle',
+        color: 'secondary',
+        description: i18n('todo.description'),
+        order: 1,
+        isInitial: true,
+        isFinal: false,
+    },
+    InProgress: {
+        name: AXPSystemStatusType.InProgress,
+        title: i18n('in-progress.title'),
+        icon: 'fa-light fa-play',
+        color: 'info',
+        description: i18n('in-progress.description'),
+        order: 2,
+        isInitial: false,
+        isFinal: false,
+    },
+    InReview: {
+        name: AXPSystemStatusType.InReview,
+        title: i18n('in-review.title'),
+        icon: 'fa-light fa-eye',
+        color: 'info',
+        description: i18n('in-review.description'),
+        order: 3,
+        isInitial: false,
+        isFinal: false,
+    },
+    Blocked: {
+        name: AXPSystemStatusType.Blocked,
+        title: i18n('blocked.title'),
+        icon: 'fa-light fa-ban',
+        color: 'danger',
+        description: i18n('blocked.description'),
+        order: 4,
+        isInitial: false,
+        isFinal: false,
+    },
+    Done: {
+        name: AXPSystemStatusType.Done,
+        title: i18n('done.title'),
+        icon: 'fa-light fa-check-circle',
+        color: 'success',
+        description: i18n('done.description'),
+        order: 5,
+        isInitial: false,
+        isFinal: true,
+    },
+    Cancelled: {
+        name: AXPSystemStatusType.Cancelled,
+        title: i18n('cancelled.title'),
+        icon: 'fa-light fa-times-circle',
+        color: 'neutral',
+        description: i18n('cancelled.description'),
+        order: 6,
+        isInitial: false,
+        isFinal: true,
+    },
+    Draft: {
+        name: AXPSystemStatusType.Draft,
+        title: i18n('draft.title'),
+        icon: 'fa-light fa-file-pen',
+        color: 'neutral',
+        description: i18n('draft.description'),
+        order: 1,
+        isInitial: true,
+        isFinal: false,
+    },
+    PendingReview: {
+        name: AXPSystemStatusType.PendingReview,
+        title: i18n('pending-review.title'),
+        icon: 'fa-light fa-clock',
+        color: 'warning',
+        description: i18n('pending-review.description'),
+        order: 2,
+        isInitial: false,
+        isFinal: false,
+    },
+    Approved: {
+        name: AXPSystemStatusType.Approved,
+        title: i18n('approved.title'),
+        icon: 'fa-light fa-check-circle',
+        color: 'success',
+        description: i18n('approved.description'),
+        order: 3,
+        isInitial: false,
+        isFinal: false,
+    },
+    Published: {
+        name: AXPSystemStatusType.Published,
+        title: i18n('published.title'),
+        icon: 'fa-light fa-globe',
+        color: 'primary',
+        description: i18n('published.description'),
+        order: 4,
+        isInitial: false,
+        isFinal: false,
+    },
+    Archived: {
+        name: AXPSystemStatusType.Archived,
+        title: i18n('archived.title'),
+        icon: 'fa-light fa-archive',
+        color: 'danger',
+        description: i18n('archived.description'),
+        order: 5,
+        isInitial: false,
+        isFinal: true,
+    },
+    Rejected: {
+        name: AXPSystemStatusType.Rejected,
+        title: i18n('rejected.title'),
+        icon: 'fa-light fa-times-circle',
+        color: 'danger',
+        description: i18n('rejected.description'),
+        order: 6,
+        isInitial: false,
+        isFinal: true,
+    },
+    Active: {
+        name: AXPSystemStatusType.Active,
+        title: i18n('active.title'),
+        icon: 'fa-light fa-check-circle',
+        color: 'success',
+        description: i18n('active.description'),
+        order: 1,
+        isInitial: false,
+        isFinal: false,
+    },
+    Inactive: {
+        name: AXPSystemStatusType.Inactive,
+        title: i18n('inactive.title'),
+        icon: 'fa-light fa-circle',
+        color: 'secondary',
+        description: i18n('inactive.description'),
+        order: 2,
+        isInitial: false,
+        isFinal: false,
+    },
+    Pending: {
+        name: AXPSystemStatusType.Pending,
+        title: i18n('pending.title'),
+        icon: 'fa-light fa-clock',
+        color: 'warning',
+        description: i18n('pending.description'),
+        order: 1,
+        isInitial: true,
+        isFinal: false,
+    },
+    Completed: {
+        name: AXPSystemStatusType.Completed,
+        title: i18n('completed.title'),
+        icon: 'fa-light fa-check-circle',
+        color: 'success',
+        description: i18n('completed.description'),
+        order: 10,
+        isInitial: false,
+        isFinal: true,
+    },
+    Suspended: {
+        name: AXPSystemStatusType.Suspended,
+        title: i18n('suspended.title'),
+        icon: 'fa-light fa-pause-circle',
+        color: 'neutral',
+        description: i18n('suspended.description'),
+        order: 5,
+        isInitial: false,
+        isFinal: false,
+    },
+    Failed: {
+        name: AXPSystemStatusType.Failed,
+        title: i18n('failed.title'),
+        icon: 'fa-light fa-xmark-circle',
+        color: 'danger',
+        description: i18n('failed.description'),
+        order: 10,
+        isInitial: false,
+        isFinal: true,
+    },
+    Review: {
+        name: AXPSystemStatusType.Review,
+        title: i18n('review.title'),
+        icon: 'fa-light fa-eye',
+        color: 'info',
+        description: i18n('review.description'),
+        order: 3,
+    },
+    Expired: {
+        name: AXPSystemStatusType.Expired,
+        title: i18n('expired.title'),
+        icon: 'fa-light fa-clock',
+        color: 'danger',
+        description: i18n('expired.description'),
+        order: 10,
+        isInitial: false,
+        isFinal: true,
+    },
+});
+/**
+ * Get system status definition by type
+ * @param type - Status type
+ * @returns System status definition or undefined
+ */
+function getSystemStatus(type) {
+    return Object.values(AXPSystemStatuses).find(status => status.name === type);
+}
+/**
+ * Resolves the visual appearance (color and icon) for status
+ * using the system statuses from the core module.
+ * @param statusType - Status type string
+ * @returns Color and icon for the status
+ */
+function resolveStatusLook(statusType) {
+    // Try to get system status first
+    const systemStatusType = statusType;
+    if (systemStatusType) {
+        const systemStatus = getSystemStatus(systemStatusType);
+        if (systemStatus) {
+            // Convert hex color to semantic color type if needed
+            // For now, return as-is and let the UI handle it
+            return {
+                color: systemStatus.color,
+                icon: systemStatus.icon || ''
+            };
+        }
+    }
+    // Fallback for unknown statuses
+    return {
+        color: 'secondary',
+        icon: ''
+    };
+}
+/**
+ * Resolves the complete status information (title, description, icon, color) for a status
+ * using the system statuses from the core module.
+ * @param statusType - Status type string
+ * @returns Complete status information as AXPStatusDefinition
+ */
+function getStatusInfo(statusType) {
+    const systemStatusType = statusType;
+    if (systemStatusType) {
+        const systemStatus = getSystemStatus(systemStatusType);
+        if (systemStatus) {
+            return systemStatus;
+        }
+    }
+    // Fallback for unknown statuses
+    return {
+        name: statusType,
+        title: statusType,
+        description: `Status: ${statusType}`,
+        icon: '',
+        color: 'secondary'
+    };
+}
+/**
+ * Get system status definition directly (no conversion needed since it's already AXPStatusDefinition)
+ * @param statusType - Status type
+ * @param overrides - Optional overrides for the status definition
+ * @returns AXPStatusDefinition
+ */
+function systemStatusToDefinition(statusType, overrides) {
+    const systemStatus = getSystemStatus(statusType);
+    if (!systemStatus) {
+        throw new Error(`System status ${statusType} not found`);
+    }
+    return {
+        ...systemStatus,
+        ...overrides,
+    };
+}
+
+class AXPClipBoardService {
+    constructor() {
+        this.toast = inject(AXToastService);
+    }
+    copy(title, value) {
+        const copyText = document.createElement('input');
+        copyText.type = 'text';
+        copyText.select();
+        copyText.setSelectionRange(0, 99999); // For mobile devices
+        copyText.remove();
+        navigator.clipboard.writeText(value);
+        this.toast.success(`${title} copied!`);
+    }
+    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: "21.2.9", ngImport: i0, type: AXPClipBoardService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+
+//#region ----   Imports   ----
+//#endregion
+//#region ----   Debug Service   ----
+/**
+ * Service for debugging user access information.
+ * Displays loaded modules, features, and permissions for the current user.
+ */
+class AXPDebugService {
+    constructor() {
+        //#region ----   Services & Dependencies   ----
+        this.sessionService = inject(AXPSessionService);
+        this.manifestRegistry = inject(AXPModuleManifestRegistry);
+    }
+    //#endregion
+    //#region ----   Public Methods   ----
+    /**
+     * Display all loaded modules, features, and permissions for the current user.
+     */
+    async displayUserAccessInfo() {
+        try {
+            // Ensure registry is initialized
+            await this.manifestRegistry.initialize();
+            // Get all registered modules
+            const allManifests = this.manifestRegistry.getAll();
+            // Get all feature definitions
+            const allFeatures = this.manifestRegistry.getAllFeatureDefinitions();
+            // Get current user permissions
+            const userPermissions = this.sessionService.permissions;
+            const user = this.sessionService.user;
+            console.group('🔐 User Access Information');
+            console.log(`User: ${user?.name || user?.title || 'Unknown'} (${user?.id || 'N/A'})`);
+            console.log('');
+            if (allManifests.length === 0) {
+                console.log('No modules loaded');
+                console.groupEnd();
+                return;
+            }
+            // Group features by module
+            const featuresByModule = new Map();
+            allFeatures.forEach((feature) => {
+                const moduleName = feature.module;
+                if (!featuresByModule.has(moduleName)) {
+                    featuresByModule.set(moduleName, []);
+                }
+                featuresByModule.get(moduleName).push(feature);
+            });
+            // Group permissions by module (if they follow ModuleName:PermissionKey pattern)
+            const permissionsByModule = new Map();
+            const ungroupedPermissions = [];
+            userPermissions.forEach((permission) => {
+                const parts = permission.split(':');
+                if (parts.length >= 2) {
+                    const moduleName = parts[0];
+                    if (!permissionsByModule.has(moduleName)) {
+                        permissionsByModule.set(moduleName, []);
+                    }
+                    permissionsByModule.get(moduleName).push(permission);
+                }
+                else {
+                    ungroupedPermissions.push(permission);
+                }
+            });
+            // Display modules in tree format
+            allManifests.forEach((manifest) => {
+                const moduleName = manifest.name;
+                const moduleFeatures = featuresByModule.get(moduleName) || [];
+                const modulePermissions = permissionsByModule.get(moduleName) || [];
+                console.group(`📦 ${moduleName}`);
+                // Display Features
+                if (moduleFeatures.length > 0) {
+                    console.log('   --- Features:');
+                    moduleFeatures.forEach((feature) => {
+                        console.log(`      • ${feature.name}`);
+                    });
+                }
+                else {
+                    console.log('   --- Features: (none)');
+                }
+                // Display Permissions
+                if (modulePermissions.length > 0) {
+                    console.log('   --- Permissions:');
+                    modulePermissions.forEach((permission) => {
+                        console.log(`      • ${permission}`);
+                    });
+                }
+                else {
+                    console.log('   --- Permissions: (none)');
+                }
+                console.groupEnd();
+            });
+            // Display ungrouped permissions if any
+            if (ungroupedPermissions.length > 0) {
+                console.group('📁 Other Permissions');
+                ungroupedPermissions.forEach((permission) => {
+                    console.log(`  • ${permission}`);
+                });
+                console.groupEnd();
+            }
+            // Summary
+            console.log('');
+            console.log(`Summary: ${allManifests.length} modules, ${allFeatures.length} features, ${userPermissions.length} permissions`);
+            console.groupEnd();
+        }
+        catch (error) {
+            console.error('[AXPDebugService] Failed to display user access info:', error);
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "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: "21.2.9", ngImport: i0, type: AXPDebugService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+
+class AXMOrgChartPrintPage extends AXBasePageComponent {
+    constructor() {
+        super(...arguments);
+        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);
+            this.baseWidth.set(this.data.width);
+            this.height.set(this.data.height);
+            this.baseHeight.set(this.data.height);
+            this.quality.set(this.data.quality);
+            this.scale.set(this.data.scale);
+        });
+    }
+    #init;
+    calculateRatio(event, type) {
+        if (!this.ratio() || !event.isUserInteraction)
+            return;
+        const value = event.value;
+        if (type === 'width') {
+            const newHeight = Math.round((value / this.baseWidth()) * this.baseHeight() * 100) / 100;
+            this.height.set(newHeight);
+            this.width.set(value);
+        }
+        else {
+            const newWidth = Math.round((value / this.baseHeight()) * this.baseWidth() * 100) / 100;
+            this.width.set(newWidth);
+            this.height.set(value);
+        }
+    }
+    async handleClose(isCanceled = false) {
+        this.close({
+            bgcolor: this.bgcolor(),
+            width: this.width(),
+            height: this.height(),
+            quality: this.qualityComputed() / 100,
+            scale: this.scale(),
+            isCanceled,
+        });
+    }
+    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
+          [changeOnScroll]="true"
+          [decimals]="4"
+          [value]="width()"
+          (onValueChanged)="calculateRatio($event, 'width')"
+          name="Width"
+        >
+        </ax-number-box>
+        <ax-button [toggleable]="true" [(selected)]="ratio"
+          ><ax-icon><i class="fa-solid fa-vector-square"></i></ax-icon
+        ></ax-button>
+        <ax-number-box
+          [changeOnScroll]="true"
+          [decimals]="4"
+          [value]="height()"
+          (onValueChanged)="calculateRatio($event, 'height')"
+          name="Height"
+        >
+        </ax-number-box>
+      </div>
+
+      <ax-label>Background color</ax-label>
+      <ax-color-box [(ngModel)]="bgcolor"></ax-color-box>
+
+      <ax-label>Quality of image (50-100%)</ax-label>
+      <ax-number-box
+        [changeOnScroll]="true"
+        [minValue]="50"
+        [maxValue]="100"
+        [(ngModel)]="qualityComputed"
+        name="Quality"
+      >
+      </ax-number-box>
+
+      <ax-label>Scale</ax-label>
+      <ax-number-box [changeOnScroll]="true" [minValue]="1" [(ngModel)]="scale" name="scale"> </ax-number-box>
+    </div>
+
+    <ax-footer>
+      <ax-prefix> </ax-prefix>
+      <ax-suffix>
+        <ax-button text="Cancel" look="solid" (onClick)="handleClose(true)"> </ax-button>
+        <ax-button text="Print" look="solid" color="primary" (onClick)="handleClose()">
+          <ax-icon class="fa-solid fa-print"> </ax-icon>
+        </ax-button>
+      </ax-suffix>
+    </ax-footer>`, isInline: true, dependencies: [{ kind: "ngmodule", type: FormsModule }, { kind: "directive", type: i1$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: "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">
+      <ax-label>Resolution (px)</ax-label>
+      <div class="ax-flex ax-gap-2 ax-items-center">
+        <ax-number-box
+          [changeOnScroll]="true"
+          [decimals]="4"
+          [value]="width()"
+          (onValueChanged)="calculateRatio($event, 'width')"
+          name="Width"
+        >
+        </ax-number-box>
+        <ax-button [toggleable]="true" [(selected)]="ratio"
+          ><ax-icon><i class="fa-solid fa-vector-square"></i></ax-icon
+        ></ax-button>
+        <ax-number-box
+          [changeOnScroll]="true"
+          [decimals]="4"
+          [value]="height()"
+          (onValueChanged)="calculateRatio($event, 'height')"
+          name="Height"
+        >
+        </ax-number-box>
+      </div>
+
+      <ax-label>Background color</ax-label>
+      <ax-color-box [(ngModel)]="bgcolor"></ax-color-box>
+
+      <ax-label>Quality of image (50-100%)</ax-label>
+      <ax-number-box
+        [changeOnScroll]="true"
+        [minValue]="50"
+        [maxValue]="100"
+        [(ngModel)]="qualityComputed"
+        name="Quality"
+      >
+      </ax-number-box>
+
+      <ax-label>Scale</ax-label>
+      <ax-number-box [changeOnScroll]="true" [minValue]="1" [(ngModel)]="scale" name="scale"> </ax-number-box>
+    </div>
+
+    <ax-footer>
+      <ax-prefix> </ax-prefix>
+      <ax-suffix>
+        <ax-button text="Cancel" look="solid" (onClick)="handleClose(true)"> </ax-button>
+        <ax-button text="Print" look="solid" color="primary" (onClick)="handleClose()">
+          <ax-icon class="fa-solid fa-print"> </ax-icon>
+        </ax-button>
+      </ax-suffix>
+    </ax-footer>`,
+                    imports: [
+                        FormsModule,
+                        AXCheckBoxModule,
+                        AXNumberBoxModule,
+                        AXTextBoxModule,
+                        AXLabelModule,
+                        AXDecoratorModule,
+                        AXButtonModule,
+                        AXColorBoxModule,
+                    ],
+                }]
+        }], propDecorators: { bgcolor: [{ type: i0.Input, args: [{ isSignal: true, alias: "bgcolor", required: false }] }, { type: i0.Output, args: ["bgcolorChange"] }], width: [{ type: i0.Input, args: [{ isSignal: true, alias: "width", required: false }] }, { type: i0.Output, args: ["widthChange"] }], height: [{ type: i0.Input, args: [{ isSignal: true, alias: "height", required: false }] }, { type: i0.Output, args: ["heightChange"] }], quality: [{ type: i0.Input, args: [{ isSignal: true, alias: "quality", required: false }] }, { type: i0.Output, args: ["qualityChange"] }], scale: [{ type: i0.Input, args: [{ isSignal: true, alias: "scale", required: false }] }, { type: i0.Output, args: ["scaleChange"] }] } });
+
+// AXPPdfService
+class AXPExportService {
+    constructor() {
+        this.popupService = inject(AXPopupService);
+    }
+    async generateBlobFromElement(element, blobOptions) {
+        const domtoimage = (await import('dom-to-image')).default;
+        const originalWidth = element.scrollWidth;
+        const originalHeight = element.scrollHeight;
+        let popup, options = {}, newOptions = {};
+        if (blobOptions) {
+            ({ popup, ...options } = blobOptions);
+        }
+        if (popup) {
+            const result = await this.popupService.open(AXMOrgChartPrintPage, {
+                header: true,
+                size: 'fit',
+                draggable: true,
+                hasBackdrop: true,
+                title: 'Export Options',
+                data: { data: options },
+            });
+            if (result.data.isCanceled) {
+                throw new Error('Process is Canceled by User!');
+            }
+            else {
+                newOptions = { ...options, ...result.data };
+            }
+        }
+        return domtoimage.toBlob(element, {
+            ...newOptions,
+            width: (newOptions.width ?? originalWidth) * (newOptions?.scale ?? 1),
+            height: (newOptions.height ?? originalHeight) * (newOptions?.scale ?? 1),
+            style: {
+                transform: `scale(${newOptions?.scale ?? 1})`,
+                transformOrigin: 'top left',
+            },
+        });
+    }
+    download(blob, filename) {
+        const link = document.createElement('a');
+        link.href = URL.createObjectURL(blob);
+        link.download = filename;
+        document.body.appendChild(link);
+        link.click();
+        document.body.removeChild(link);
+        URL.revokeObjectURL(link.href);
+    }
+    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: "21.2.9", ngImport: i0, type: AXPExportService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+
+function AXPCleanNestedFilters(filters) {
+    return filters
+        .map((filter) => {
+        if (!filter)
+            return undefined;
+        if (filter.filters?.length) {
+            const cleanedNestedFilters = AXPCleanNestedFilters(filter.filters);
+            if (!filter.field && !filter.operator && cleanedNestedFilters.length === 0) {
+                return undefined;
+            }
+            return {
+                ...filter,
+                filters: cleanedNestedFilters.filter(Boolean),
+            };
+        }
+        if ((!filter.value && filter.value != false) || filter.value === 'unknown') {
+            return undefined;
+        }
+        return filter;
+    })
+        .filter(Boolean);
+}
+
+const AXP_LOCALE_MANAGEMENT_PORT = new InjectionToken('AXP_LOCALE_MANAGEMENT_PORT');
+
+//#region ----   Versioning Types   ----
+var AXVChangeType;
+(function (AXVChangeType) {
+    AXVChangeType["Create"] = "Create";
+    AXVChangeType["Update"] = "Update";
+    AXVChangeType["Delete"] = "Delete";
+})(AXVChangeType || (AXVChangeType = {}));
+//#endregion
+//#region ----   Service Contract   ----
+class AXPVersioningService {
+}
+//#endregion
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { ALL_DEFAULT_OPERATORS, AXMWorkflowErrorHandler, AXPAppVersionService, AXPCleanNestedFilters, AXPClipBoardService, AXPCommonModule, AXPCommonSettings, AXPCustomOperatorService, AXPCustomOperatorServiceImpl, AXPDataProvider, AXPDebugService, AXPDefaultMultiLanguageConfigService, AXPDialogConfirmAction, AXPEntityCommandScope, AXPEntityQueryType, AXPEntityType, AXPErrorHandlerRegistryService, AXPExportService, AXPFileActionsService, AXPFileStorageService, AXPFileStorageStatus, AXPFileTypeProviderService, AXPFilterOperatorMiddlewareService, AXPFilterOperatorMiddlewareServiceImpl, AXPFooterTextSlotComponent, AXPGlobalErrorHandler, AXPHomePageModule, AXPHomePageService, AXPLockService, AXPMenuItemsDataSourceDefinition, 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, AXPSettingsEvaluatorScopeProvider, AXPSettingsService, AXPStatusDefinitionProviderService, AXPStatusProvider, AXPStickyDirective, AXPSystemStatusType, AXPSystemStatuses, AXPToastAction, AXPTokenDefinitionService, AXPTokenEvaluatorScopeProvider, AXPVersioningService, AXPWorkflowNavigateAction, AXPWorkflowRouterNavigateAction, 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_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_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, configPlatform, createAllQueryView, createEntityCommandOptions, createEntitySearchCommand, createMenuContext, createMenuMiddleware, createQueryView, getEntityInfo, getStatusInfo, getSystemStatus, provideDynamicHomePage, provideMenuMiddleware, resolveStatusLook, shouldApplyDefaultMultiLanguageToEntityProperty, shouldApplyDefaultMultiLanguageToWidgetNode, shouldApplyDefaultMultiLanguageToWidgetProperty, systemStatusToDefinition, withDefaultMultiLanguageOnWidgetNodeTree, withDefaultMultiLanguageOnWidgetProperty };
+//# sourceMappingURL=acorex-platform-common.mjs.map