@acorex/platform 19.1.7 → 19.1.8

package/fesm2022/acorex-platform-common.mjs

@@ -1,15 +1,12 @@
 import * as i0 from '@angular/core';
 import { Injectable, provideAppInitializer, inject, RendererFactory2, InjectionToken, Injector, ErrorHandler, Directive, Input, EventEmitter, Output, runInInjectionContext, NgModule, Optional, Inject, Component, ViewEncapsulation } from '@angular/core';
-import { kebabCase, sortBy, merge, cloneDeep, get, omit } from 'lodash-es';
+import { kebabCase, sortBy, omit, merge, cloneDeep, get } from 'lodash-es';
 import { AXPopupModule } from '@acorex/components/popup';
 import { AXToastService, AXToastModule } from '@acorex/components/toast';
 import { AXDateTimeModule } from '@acorex/core/date-time';
-import * as i5 from '@acorex/platform/workflow';
-import { createWorkFlowEvent, AXPWorkflowAction, AXPWorkflowError, AXPWorkflowModule } from '@acorex/platform/workflow';
-import * as i2$1 from '@angular/router';
+import * as i4 from '@acorex/platform/workflow';
+import { AXPWorkflowService, createWorkFlowEvent, AXPWorkflowAction, AXPWorkflowError, AXPWorkflowModule } from '@acorex/platform/workflow';
 import { Router, RouterModule } from '@angular/router';
-import * as i1$1 from '@ngrx/effects';
-import { createEffect, ofType, EffectsModule } from '@ngrx/effects';
 import { applySortArray, applyFilterArray } from '@acorex/platform/core';
 import Dexie from 'dexie';
 import * as i3 from '@acorex/components/decorators';
@@ -19,9 +16,9 @@ import { AXImageModule } from '@acorex/components/image';
 import * as i1 from '@angular/common';
 import { CommonModule } from '@angular/common';
 import { signalStore, withState, withMethods, patchState, withHooks } from '@ngrx/signals';
-import { createAction, props, Store } from '@ngrx/store';
-import { Subject, switchMap, of } from 'rxjs';
 import { AXTranslationService } from '@acorex/core/translation';
+import { Store, createAction } from '@ngrx/store';
+import { Subject } from 'rxjs';
 import { AXDialogService } from '@acorex/components/dialog';
 
 class AXPAppStartUpService {
@@ -1277,68 +1274,491 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImpor
             args: [{ providedIn: 'root' }]
         }] });
 
-const AXPNavigateAction = createAction('[Navigate] Action', props());
-const AXPSignOutAction = createAction('[SignOut] Action');
-const AXPSignInAction = createAction('[SignIn] Action');
+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)) => {
+    return {
+        setMenuItems(items) {
+            patchState(store, { items: items });
+        },
+        selectMenuItemByRoute(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
+                        const matchResult = pathsMatch(item.path, path, ["list", "view", "edit", "create"]);
+                        if (matchResult.isMatch) {
+                            return { item, isPartialMatch: matchResult.isPartial };
+                        }
+                    }
+                }
+                return { item: null, isPartialMatch: false };
+            };
+            const pathsMatch = (itemPath, currentPath, trailingSegmentsToIgnore = []) => {
+                const itemSegments = itemPath.split('/').filter(segment => segment.length > 0);
+                const pathSegments = currentPath.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;
+                for (let i = 0; i < effectiveMenuLength; i++) {
+                    if (itemSegments[i] !== pathSegments[i]) {
+                        isPrefix = false;
+                        break;
+                    }
+                }
+                // Partial match: menuPath base is a strict prefix of browserPath
+                const isPartialMatch = isPrefix && effectiveMenuLength < pathLength;
+                // Exact match: all segments match completely
+                const isExactMatch = isPrefix && effectiveMenuLength === pathLength;
+                return {
+                    isMatch: isExactMatch || isPartialMatch,
+                    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', { command: { type: 'router', options: { path: item.path } } });
+            }
+            if (item.command) {
+                workflow.execute('navigate', { command: item.command });
+            }
+            patchState(store, { selectedMenuItem: { item, isFullMatch: true } });
+        },
+        isItemOpen(item) {
+            const selectedItem = store.selectedMenuItem();
+            if (!selectedItem) {
+                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)) => ({
+    onInit() {
+        (async () => {
+            const items = await menuProviderService.items();
+            patchState(store, { items: items });
+        })();
+    },
+    onDestroy() {
+    },
+})));
 
-var AXPSettingScope;
-(function (AXPSettingScope) {
-    AXPSettingScope["Environment"] = "C";
-    AXPSettingScope["Global"] = "G";
-    AXPSettingScope["Tenant"] = "T";
-    AXPSettingScope["User"] = "U";
-})(AXPSettingScope || (AXPSettingScope = {}));
-;
+class AXPMenuSearchDefinitionProvider {
+    async provide(context) {
+        context.addDefinition('menu', 'Menu', 'fa-thin fa-bars', [
+            {
+                name: 'open',
+                command: {
+                    name: 'view',
+                    options: {},
+                },
+                type: 'view',
+                priority: 'primary',
+            },
+        ]);
+    }
+}
 
-class AXPSettingDefinitionProviderContext {
+class AXPMenuSearchProvider {
     constructor() {
-        this.rootGroups = [];
-        this.groupMap = new Map();
+        this.menuService = inject(AXPMenuProviderService);
+        this.translateService = inject(AXTranslationService);
     }
-    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);
+    async search(text) {
+        const menuItems = await this.searchMenuItems(await this.menuService.items(), text);
+        return sortBy(menuItems.map((item) => ({
+            name: '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: {
+                command: {
+                    name: 'navigate',
+                    options: {
+                        command: item.command ?? {
+                            type: 'router',
+                            options: {
+                                path: item.path
+                            }
+                        }
+                    }
+                },
+            },
+            parent: item.parent
+                ? {
+                    title: item.parent.text,
+                    data: item.parent,
+                }
+                : undefined,
+        })), [(o) => this.translateService.translateSync(o.title)]);
     }
-    group(name) {
-        const foundGroup = this.groupMap.get(name);
-        if (!foundGroup) {
-            throw new Error(`Group with name "${name}" not found.`);
+    /**
+     * 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 new AXPSettingDefinitionGroupBuilder(this, foundGroup);
-    }
-    getGroups() {
-        return this.rootGroups;
+        return result;
     }
-    // Expose groupMap for controlled access
-    hasGroup(name) {
-        return this.groupMap.has(name);
+}
+
+class AXPFooterTextSlotComponent {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPFooterTextSlotComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.0.3", type: AXPFooterTextSlotComponent, isStandalone: true, selector: "ng-component", inputs: { text: "text" }, ngImport: i0, template: `
+      <small class="ax-text-sm" [innerHTML]="text"></small>
+    `, isInline: true }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPFooterTextSlotComponent, decorators: [{
+            type: Component,
+            args: [{
+                    template: `
+      <small class="ax-text-sm" [innerHTML]="text"></small>
+    `,
+                    standalone: true
+                }]
+        }], propDecorators: { text: [{
+                type: Input
+            }] } });
+
+class AXPNavBarSlotComponent {
+    constructor() {
+        this.store = inject(Store);
     }
-    getGroup(name) {
-        return this.groupMap.get(name);
+    handleCommand(action) {
+        if (action)
+            this.store.dispatch(action);
     }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPNavBarSlotComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.0.3", 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">
+        <a *ngFor="let link of items" (click)="handleCommand(link.command)" >{{ link.text }}</a>
+    </div>
+    `, isInline: true, dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }], encapsulation: i0.ViewEncapsulation.None }); }
 }
-class AXPSettingDefinitionGroupBuilder {
-    constructor(context, group) {
-        this.context = context;
-        this.group = group;
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPNavBarSlotComponent, decorators: [{
+            type: Component,
+            args: [{
+                    template: `
+    <div class="ax-flex ax-items-center ax-justify-between ax-gap-5">
+        <a *ngFor="let link of items" (click)="handleCommand(link.command)" >{{ link.text }}</a>
+    </div>
+    `,
+                    imports: [CommonModule],
+                    encapsulation: ViewEncapsulation.None
+                }]
+        }], propDecorators: { items: [{
+                type: Input
+            }] } });
+
+class AXPSearchDefinitionProviderContext {
+    constructor() {
+        this.definitions = [];
+        this.definitionMap = new Map();
     }
-    addSection(name, title, description) {
-        const newSection = {
+    addDefinition(name, title, icon, actions) {
+        const definitionSearch = {
             name,
             title,
-            description: description,
-            settings: [],
+            icon,
+            actions: actions ?? [],
         };
-        this.group.sections.push(newSection);
+        this.definitions.push(definitionSearch);
+        this.definitionMap.set(name, definitionSearch); // Index by name
+        return new AXPSearchDefinitionBuilder(this, definitionSearch);
+    }
+    definition(name) {
+        const foundDefinition = this.definitionMap.get(name);
+        if (!foundDefinition) {
+            throw new Error(`definition with name "${name}" not found.`);
+        }
+        return new AXPSearchDefinitionBuilder(this, foundDefinition);
+    }
+    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: 'view',
+            command: '',
+            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);
+    }
+    // addGroup(name: string, title: string, description?: string, icon?: string): AXPTextSearchEntityBuilder {
+    //   const newGroup: AXPTextSearchEntity = {
+    //     name,
+    //     title,
+    //     description: description,
+    //     icon,
+    //     groups: [],
+    //     sections: [],
+    //   };
+    //   this.entity.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 AXPTextSearchEntityBuilder(this.context, newGroup);
+    // }
+    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();
+        if (Array.isArray(this.providers)) {
+            for (const provider of this.providers) {
+                await provider.provide(context);
+            }
+        }
+        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;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPSearchDefinitionProviderService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPSearchDefinitionProviderService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPSearchDefinitionProviderService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+
+class AXPCommandSearchProvider {
+    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);
+    }
+    async search(text) {
+        //TODO better handle this
+        if (this.definitionService.getList().length == 0) {
+            await this.definitionService.getListAsync();
+        }
+        if (!this.providers || (this.providers?.length || 0) === 0) {
+            throw new Error('No search providers available'); // No providers available
+        }
+        const mergeData = [];
+        const promises = this.providers.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.name);
+                    mergeData.push({
+                        definitionName: definition.name,
+                        definitionTitle: definition.title,
+                        name: result.name,
+                        title: result.title,
+                        icon: result.icon ?? definition.icon,
+                        data: result.data,
+                        actions: definition.actions,
+                        description: result.description,
+                        parent: result.parent,
+                    });
+                }
+                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
+                    children: [],
+                };
+                groupedData.push(groupMap[groupName]);
+            }
+            groupMap[groupName].children.push(omit(item, ['definitionName', 'definitionTitle']));
+        }
+        return groupedData;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPSearchService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPSearchService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPSearchService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+
+var AXPSettingScope;
+(function (AXPSettingScope) {
+    AXPSettingScope["Environment"] = "C";
+    AXPSettingScope["Global"] = "G";
+    AXPSettingScope["Tenant"] = "T";
+    AXPSettingScope["User"] = "U";
+})(AXPSettingScope || (AXPSettingScope = {}));
+;
+
+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) {
+            throw new Error(`Group with name "${name}" not found.`);
+        }
+        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) {
@@ -1388,768 +1808,335 @@ class AXPSettingDefinitionSectionBuilder {
                 name: setting.key,
                 path: setting.key,
                 defaultValue: setting.defaultValue,
-                options: merge(setting.widget.options ?? {}, {
-                    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();
-        if (Array.isArray(this.providers)) {
-            for (const provider of this.providers) {
-                await provider.provide(context);
-            }
-        }
-        this.cache = context.getGroups();
-    }
-    async getListAsync(scope) {
-        await this.load();
-        return this.getList(scope);
-    }
-    getList(scope) {
-        if (!this.cache) {
-            return [];
-        }
-        const scopeOrder = ['C', 'G', '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 filterByScope(this.cache, scope);
-    }
-    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: "19.0.3", ngImport: i0, type: AXPSettingDefinitionProviderService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPSettingDefinitionProviderService, providedIn: 'root' }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPSettingDefinitionProviderService, decorators: [{
-            type: Injectable,
-            args: [{ providedIn: 'root' }]
-        }] });
-class AXPSettingDefaultValueProvider {
-    constructor() {
-        this.definitionProvider = inject(AXPSettingDefinitionProviderService);
-    }
-    get scope() {
-        return AXPSettingScope.Global;
-    }
-    async load() {
-        return Object.entries(await this.definitionProvider.defaultValues()).map(c => ({ key: c[0], value: c[1] }));
-    }
-    set(key, value) {
-        throw new Error('Method not implemented.');
-    }
-}
-
-const AXP_SETTING_VALUE_PROVIDER = new InjectionToken('AXP_SETTING_VALUE_PROVIDER', {
-    providedIn: 'root',
-    factory: () => {
-        return [
-            //new AXPSettingDefaultValueProvider(),
-            new AXPSettingValueProviderDefault(AXPSettingScope.Tenant),
-            new AXPSettingValueProviderDefault(AXPSettingScope.User)
-        ];
-    }
-});
-class AXPSettingValueProviderDefault {
-    get scope() {
-        return this._scope;
-    }
-    constructor(_scope) {
-        this._scope = _scope;
-        this.cache = new Map();
-        this.localStorageKey = `AXP_SETTINGS_SCOPE(${this.scope})`;
-    }
-    async load() {
-        // 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() {
-        const settingsObject = {};
-        this.cache.forEach((value, key) => {
-            settingsObject[key] = value;
-        });
-        localStorage.setItem(this.localStorageKey, JSON.stringify(settingsObject));
-    }
-}
-
-class AXPSettingValueProviderService {
-    constructor() {
-        this.providers = inject(AXP_SETTING_VALUE_PROVIDER);
-        this.definitionService = inject(AXPSettingDefinitionProviderService);
-        this.scopedSettingsCache = new Map();
-        this.onChanged = new Subject();
-        // Initialize scoped caches for dynamic scopes
-        const staticScopes = [AXPSettingScope.Environment, AXPSettingScope.Global, AXPSettingScope.Tenant, AXPSettingScope.User];
-        staticScopes.forEach((scope) => {
-            if (!this.scopedSettingsCache.has(scope)) {
-                this.scopedSettingsCache.set(scope, new Map());
-            }
-        });
-    }
-    async load() {
-        try {
-            const settingsList = [];
-            for (const provider of this.providers) {
-                const scopeCache = this.scopedSettingsCache.get(provider.scope);
-                const providerSettings = await provider.load();
-                providerSettings.forEach((setting) => {
-                    scopeCache.set(setting.key, setting.value);
-                });
-                settingsList.push(...providerSettings);
-            }
-            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 = [AXPSettingScope.User, AXPSettingScope.Tenant, AXPSettingScope.Global, AXPSettingScope.Environment];
-        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.definitionService.defaultValues();
-        return get(defaults, key); // Fallback if no value is found
-    }
-    async defaultValues(scope) {
-        let scopeOrder = [AXPSettingScope.Environment, AXPSettingScope.Global, AXPSettingScope.Tenant, AXPSettingScope.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 global default values from the definition service
-        const globalDefaults = await this.definitionService.defaultValues();
-        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.onChanged, this.scopedSettingsCache.get(scope));
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPSettingValueProviderService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPSettingValueProviderService, providedIn: 'root' }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPSettingValueProviderService, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: 'root',
-                }]
-        }], ctorParameters: () => [] });
-class ScopedSettingService {
-    constructor(parent, provider, onChanged, scopeCache) {
-        this.parent = parent;
-        this.provider = provider;
-        this.onChanged = onChanged;
-        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.onChanged.next({
-                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.onChanged.next({
-                scope: this.provider.scope,
-                keys: Object.keys(keyOrValues),
-                values: keyOrValues,
-                entries,
-            });
-        }
-    }
-}
-
-class AXPCommonEffects {
-    constructor(actions$, router, settingService) {
-        this.actions$ = actions$;
-        this.router = router;
-        this.settingService = settingService;
-        this.command$ = createEffect(() => this.actions$.pipe(ofType(AXPNavigateAction), switchMap((action) => {
-            if (Array.isArray(action.payload.commands))
-                this.router.navigate(action.payload.commands, action.payload.extras);
-            else {
-                if (action.payload.commands.toLowerCase().startsWith('http'))
-                    window.open(action.payload.commands, '_blank');
-                else
-                    this.router.navigate([action.payload.commands], action.payload.extras);
-            }
-            return of();
-        })), { dispatch: false });
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPCommonEffects, deps: [{ token: i1$1.Actions }, { token: i2$1.Router }, { token: AXPSettingValueProviderService }], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPCommonEffects }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPCommonEffects, decorators: [{
-            type: Injectable
-        }], ctorParameters: () => [{ type: i1$1.Actions }, { type: i2$1.Router }, { type: AXPSettingValueProviderService }] });
-
-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), globalStore = inject(Store)) => {
-    return {
-        setMenuItems(items) {
-            patchState(store, { items: items });
-        },
-        selectMenuItemByRoute(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
-                        const matchResult = pathsMatch(item.path, path, ["list", "view", "edit", "create"]);
-                        if (matchResult.isMatch) {
-                            return { item, isPartialMatch: matchResult.isPartial };
-                        }
-                    }
-                }
-                return { item: null, isPartialMatch: false };
-            };
-            const pathsMatch = (itemPath, currentPath, trailingSegmentsToIgnore = []) => {
-                const itemSegments = itemPath.split('/').filter(segment => segment.length > 0);
-                const pathSegments = currentPath.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;
-                for (let i = 0; i < effectiveMenuLength; i++) {
-                    if (itemSegments[i] !== pathSegments[i]) {
-                        isPrefix = false;
-                        break;
-                    }
-                }
-                // Partial match: menuPath base is a strict prefix of browserPath
-                const isPartialMatch = isPrefix && effectiveMenuLength < pathLength;
-                // Exact match: all segments match completely
-                const isExactMatch = isPrefix && effectiveMenuLength === pathLength;
-                return {
-                    isMatch: isExactMatch || isPartialMatch,
-                    isPartial: isPartialMatch && !isExactMatch,
-                };
-            };
-            const items = store.items();
-            const { item, isPartialMatch } = findItem(items);
-            patchState(store, { selectedMenuItem: { item, isFullMatch: !isPartialMatch } });
-        },
-        executeCommand(item) {
-            if (item.command) {
-                globalStore.dispatch(item.command);
-            }
-            else if (item.path) {
-                globalStore.dispatch(AXPNavigateAction({ payload: { commands: item.path } }));
-            }
-            patchState(store, { selectedMenuItem: { item, isFullMatch: true } });
-        },
-        isItemOpen(item) {
-            const selectedItem = store.selectedMenuItem();
-            if (!selectedItem) {
-                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)) => ({
-    onInit() {
-        (async () => {
-            const items = await menuProviderService.items();
-            patchState(store, { items: items });
-        })();
-    },
-    onDestroy() {
-    },
-})));
-
-class AXPMenuSearchDefinitionProvider {
-    async provide(context) {
-        context.addDefinition('menu', 'Menu', 'fa-thin fa-bars', [
-            {
-                name: 'open',
-                command: {
-                    name: 'view',
-                    options: {},
-                },
-                type: 'view',
-                priority: 'primary',
-            },
-        ]);
-    }
-}
-
-class AXPMenuSearchProvider {
-    constructor() {
-        this.menuService = inject(AXPMenuProviderService);
-        this.trService = inject(AXTranslationService);
-    }
-    async search(text) {
-        const menuItems = await this.searchMenuItems(await this.menuService.items(), text);
-        return sortBy(menuItems.map((item) => ({
-            name: '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: item,
-            parent: item.parent
-                ? {
-                    title: item.parent.text,
-                    data: item.parent,
-                }
-                : undefined,
-        })), [(o) => this.trService.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.trService.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;
+                options: merge(setting.widget.options ?? {}, {
+                    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;
     }
 }
 
-class AXPFooterTextSlotComponent {
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPFooterTextSlotComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
-    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.0.3", type: AXPFooterTextSlotComponent, isStandalone: true, selector: "ng-component", inputs: { text: "text" }, ngImport: i0, template: `
-      <small class="ax-text-sm" [innerHTML]="text"></small>
-    `, isInline: true }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPFooterTextSlotComponent, decorators: [{
-            type: Component,
-            args: [{
-                    template: `
-      <small class="ax-text-sm" [innerHTML]="text"></small>
-    `,
-                    standalone: true
-                }]
-        }], propDecorators: { text: [{
-                type: Input
-            }] } });
-
-class AXPNavBarSlotComponent {
+// Injection token for setting providers
+const AXP_SETTING_DEFINITION_PROVIDER = new InjectionToken('AXP_SETTING_DEFINITION_PROVIDER');
+class AXPSettingDefinitionProviderService {
     constructor() {
-        this.store = inject(Store);
+        this.providers = inject(AXP_SETTING_DEFINITION_PROVIDER, { optional: true });
+        this.cache = null;
     }
-    handleCommand(action) {
-        if (action)
-            this.store.dispatch(action);
+    async load() {
+        if (this.cache) {
+            return;
+        }
+        const context = new AXPSettingDefinitionProviderContext();
+        if (Array.isArray(this.providers)) {
+            for (const provider of this.providers) {
+                await provider.provide(context);
+            }
+        }
+        this.cache = context.getGroups();
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPNavBarSlotComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
-    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.0.3", 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">
-        <a *ngFor="let link of items" (click)="handleCommand(link.command)" >{{ link.text }}</a>
-    </div>
-    `, isInline: true, dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }], encapsulation: i0.ViewEncapsulation.None }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPNavBarSlotComponent, decorators: [{
-            type: Component,
-            args: [{
-                    template: `
-    <div class="ax-flex ax-items-center ax-justify-between ax-gap-5">
-        <a *ngFor="let link of items" (click)="handleCommand(link.command)" >{{ link.text }}</a>
-    </div>
-    `,
-                    imports: [CommonModule],
-                    encapsulation: ViewEncapsulation.None
-                }]
-        }], propDecorators: { items: [{
-                type: Input
-            }] } });
-
-class AXPSearchDefinitionProviderContext {
-    constructor() {
-        this.definitions = [];
-        this.definitionMap = new Map();
+    async getListAsync(scope) {
+        await this.load();
+        return this.getList(scope);
     }
-    addDefinition(name, title, icon, actions) {
-        const definitionSearch = {
-            name,
-            title,
-            icon,
-            actions: actions ?? [],
+    getList(scope) {
+        if (!this.cache) {
+            return [];
+        }
+        const scopeOrder = ['C', 'G', '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
         };
-        this.definitions.push(definitionSearch);
-        this.definitionMap.set(name, definitionSearch); // Index by name
-        return new AXPSearchDefinitionBuilder(this, definitionSearch);
+        return filterByScope(this.cache, scope);
     }
-    definition(name) {
-        const foundDefinition = this.definitionMap.get(name);
-        if (!foundDefinition) {
-            throw new Error(`definition with name "${name}" not found.`);
+    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();
         }
-        return new AXPSearchDefinitionBuilder(this, foundDefinition);
+        collectDefaults(this.cache);
+        return defaults;
     }
-    getDefinitions() {
-        return this.definitions;
+    findGroup(scope, groupName) {
+        return this.searchRecursive(this.getList(scope), groupName, []); // Initialize with an empty breadcrumb
     }
-    // Expose groupMap for controlled access
-    hasEntity(name) {
-        return this.definitionMap.has(name);
+    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: []
+        };
     }
-    getDefinition(name) {
-        return this.definitionMap.get(name);
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPSettingDefinitionProviderService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPSettingDefinitionProviderService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPSettingDefinitionProviderService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+class AXPSettingDefaultValueProvider {
+    constructor() {
+        this.definitionProvider = inject(AXPSettingDefinitionProviderService);
+    }
+    get scope() {
+        return AXPSettingScope.Global;
+    }
+    async load() {
+        return Object.entries(await this.definitionProvider.defaultValues()).map(c => ({ key: c[0], value: c[1] }));
+    }
+    set(key, value) {
+        throw new Error('Method not implemented.');
     }
 }
-class AXPSearchDefinitionBuilder {
-    constructor(context, definition) {
-        this.context = context;
-        this.definition = definition;
+
+const AXP_SETTING_VALUE_PROVIDER = new InjectionToken('AXP_SETTING_VALUE_PROVIDER', {
+    providedIn: 'root',
+    factory: () => {
+        return [
+            //new AXPSettingDefaultValueProvider(),
+            new AXPSettingValueProviderDefault(AXPSettingScope.Tenant),
+            new AXPSettingValueProviderDefault(AXPSettingScope.User)
+        ];
     }
-    addAction(name) {
-        const newAction = {
-            name,
-            type: 'view',
-            command: '',
-            priority: 'primary',
-        };
-        this.definition.actions.push(newAction);
-        return new AXPSearchDefinitionActionBuilder(this);
+});
+class AXPSettingValueProviderDefault {
+    get scope() {
+        return this._scope;
     }
-    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);
+    constructor(_scope) {
+        this._scope = _scope;
+        this.cache = new Map();
+        this.localStorageKey = `AXP_SETTINGS_SCOPE(${this.scope})`;
     }
-    // addGroup(name: string, title: string, description?: string, icon?: string): AXPTextSearchEntityBuilder {
-    //   const newGroup: AXPTextSearchEntity = {
-    //     name,
-    //     title,
-    //     description: description,
-    //     icon,
-    //     groups: [],
-    //     sections: [],
-    //   };
-    //   this.entity.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 AXPTextSearchEntityBuilder(this.context, newGroup);
-    // }
-    endEntity() {
-        return this.context;
+    async load() {
+        // 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([]);
     }
-}
-class AXPSearchDefinitionActionBuilder {
-    constructor(entityBuilder) {
-        this.entityBuilder = entityBuilder;
+    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();
     }
-    endAction() {
-        return this.entityBuilder;
+    async saveToLocalStorage() {
+        const settingsObject = {};
+        this.cache.forEach((value, key) => {
+            settingsObject[key] = value;
+        });
+        localStorage.setItem(this.localStorageKey, JSON.stringify(settingsObject));
     }
 }
 
-// Injection token for setting providers
-const AXP_SEARCH_DEFINITION_PROVIDER = new InjectionToken('AXP_SEARCH_DEFINITION_PROVIDER');
-class AXPSearchDefinitionProviderService {
+class AXPSettingValueProviderService {
     constructor() {
-        this.providers = inject(AXP_SEARCH_DEFINITION_PROVIDER, { optional: true });
-        this.cache = null;
+        this.providers = inject(AXP_SETTING_VALUE_PROVIDER);
+        this.definitionService = inject(AXPSettingDefinitionProviderService);
+        this.scopedSettingsCache = new Map();
+        this.onChanged = new Subject();
+        // Initialize scoped caches for dynamic scopes
+        const staticScopes = [AXPSettingScope.Environment, AXPSettingScope.Global, AXPSettingScope.Tenant, AXPSettingScope.User];
+        staticScopes.forEach((scope) => {
+            if (!this.scopedSettingsCache.has(scope)) {
+                this.scopedSettingsCache.set(scope, new Map());
+            }
+        });
     }
     async load() {
-        if (this.cache) {
-            return;
-        }
-        const context = new AXPSearchDefinitionProviderContext();
-        if (Array.isArray(this.providers)) {
+        try {
+            const settingsList = [];
             for (const provider of this.providers) {
-                await provider.provide(context);
+                const scopeCache = this.scopedSettingsCache.get(provider.scope);
+                const providerSettings = await provider.load();
+                providerSettings.forEach((setting) => {
+                    scopeCache.set(setting.key, setting.value);
+                });
+                settingsList.push(...providerSettings);
             }
+            return settingsList;
+        }
+        catch (error) {
+            console.error('Error loading settings', error);
+            throw error;
         }
-        this.cache = context.getDefinitions();
     }
-    async getListAsync() {
-        await this.load();
-        return this.getList();
+    async get(key) {
+        if (this.scopedSettingsCache.size === 0) {
+            await this.load();
+        }
+        const scopeOrder = [AXPSettingScope.User, AXPSettingScope.Tenant, AXPSettingScope.Global, AXPSettingScope.Environment];
+        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.definitionService.defaultValues();
+        return get(defaults, key); // Fallback if no value is found
     }
-    getList() {
-        if (!this.cache) {
-            return [];
+    async defaultValues(scope) {
+        let scopeOrder = [AXPSettingScope.Environment, AXPSettingScope.Global, AXPSettingScope.Tenant, AXPSettingScope.User].reverse();
+        const scopeIndex = scopeOrder.indexOf(scope);
+        if (scopeIndex === -1) {
+            throw new Error(`Invalid scope: ${scope}`);
         }
-        else {
-            return this.cache;
+        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 global default values from the definition service
+        const globalDefaults = await this.definitionService.defaultValues();
+        return { ...globalDefaults, ...accumulatedDefaults };
     }
-    findDefinition(definitionName) {
-        const definition = this.getList().find((definition) => definition.name === definitionName);
-        if (!definition) {
-            throw new Error(`Definition with name ${definitionName} not found`);
+    scope(scope) {
+        const provider = this.providers.find((p) => p.scope === scope);
+        if (!provider) {
+            throw new Error(`No provider found for scope: ${scope}`);
         }
-        return definition;
+        return new ScopedSettingService(this, provider, this.onChanged, this.scopedSettingsCache.get(scope));
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPSearchDefinitionProviderService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPSearchDefinitionProviderService, providedIn: 'root' }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPSettingValueProviderService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPSettingValueProviderService, providedIn: 'root' }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPSearchDefinitionProviderService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPSettingValueProviderService, decorators: [{
             type: Injectable,
-            args: [{ providedIn: 'root' }]
-        }] });
-
-// 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);
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [] });
+class ScopedSettingService {
+    constructor(parent, provider, onChanged, scopeCache) {
+        this.parent = parent;
+        this.provider = provider;
+        this.onChanged = onChanged;
+        this.scopeCache = scopeCache;
     }
-    async search(text) {
-        //TODO better handle this
-        if (this.definitionService.getList().length == 0) {
-            await this.definitionService.getListAsync();
-        }
-        if (!this.providers || (this.providers?.length || 0) === 0) {
-            throw new Error('No search providers available'); // No providers available
-        }
-        const mergeData = [];
-        const promises = this.providers.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.name);
-                    mergeData.push({
-                        definitionName: definition.name,
-                        definitionTitle: definition.title,
-                        name: result.name,
-                        title: result.title,
-                        icon: result.icon ?? definition.icon,
-                        data: result.data,
-                        actions: definition.actions,
-                        description: result.description,
-                        parent: result.parent,
-                    });
-                }
-                catch (e) {
-                    console.error(e);
-                }
-            }
+    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.onChanged.next({
+                scope: this.provider.scope,
+                keys: [keyOrValues],
+                values: { [keyOrValues]: value },
+                entries: [{ key: keyOrValues, value }],
+            });
         }
-        // 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
-                    children: [],
-                };
-                groupedData.push(groupMap[groupName]);
-            }
-            groupMap[groupName].children.push(omit(item, ['definitionName', 'definitionTitle']));
+        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.onChanged.next({
+                scope: this.provider.scope,
+                keys: Object.keys(keyOrValues),
+                values: keyOrValues,
+                entries,
+            });
         }
-        return groupedData;
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPSearchService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPSearchService, providedIn: 'root' }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPSearchService, decorators: [{
-            type: Injectable,
-            args: [{ providedIn: 'root' }]
-        }] });
 
 class AXPSettingSearchDefinitionProvider {
     async provide(context) {
@@ -2273,6 +2260,35 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImpor
             type: Injectable
         }] });
 
+class AXPWorkflowRouterNavigateAction extends AXPWorkflowAction {
+    constructor() {
+        super(...arguments);
+        this.router = inject(Router);
+    }
+    async execute(context) {
+        const command = context.getVariable('command');
+        if (command.options.path.toLowerCase().startsWith('http') || command.options?.extras?.target == 'blank') {
+            window.open(command.options.path, '_blank');
+        }
+        else {
+            this.router.navigate([command.options.path], command.options.extras);
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPWorkflowRouterNavigateAction, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPWorkflowRouterNavigateAction }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPWorkflowRouterNavigateAction, decorators: [{
+            type: Injectable
+        }] });
+const AXPNavigateWorkflow = {
+    startStepId: 'start',
+    steps: {
+        'start': {
+            action: 'navigate-router',
+        },
+    },
+};
+
 class AXMWorkflowErrorHandler {
     constructor() {
         this.dialog = inject(AXDialogService);
@@ -2333,17 +2349,6 @@ class AXPCommonModule {
         instances.forEach((f) => {
             f();
         });
-        // appInitService.registerTask({
-        //   name: 'Modules',
-        //   statusText: 'Initializing Modules ...',
-        //   run: () =>
-        //     new Promise<void>((resolve) => {
-        //       setTimeout(() => {
-        //         resolve();
-        //       }, 250);
-        //     }),
-        // });
-        //
         appInitService.registerTask({
             name: 'Settings',
             statusText: 'Loading Settings ...',
@@ -2362,7 +2367,7 @@ class AXPCommonModule {
         });
     }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPCommonModule, deps: [{ token: 'AXPCommonModuleFactory' }, { token: AXPAppStartUpService }, { token: AXPSettingValueProviderService }, { token: AXPDataSeederService }], target: i0.ɵɵFactoryTarget.NgModule }); }
-    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "19.0.3", ngImport: i0, type: AXPCommonModule, imports: [i1$1.EffectsFeatureModule, i5.AXPWorkflowModule, AXPopupModule,
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "19.0.3", ngImport: i0, type: AXPCommonModule, imports: [i4.AXPWorkflowModule, AXPopupModule,
             AXDateTimeModule,
             AXToastModule], exports: [RouterModule] }); }
     static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPCommonModule, providers: [
@@ -2399,13 +2404,15 @@ class AXPCommonModule {
                 useClass: AXPMenuSearchDefinitionProvider,
                 multi: true,
             },
-        ], imports: [EffectsModule.forFeature([AXPCommonEffects]),
-            AXPWorkflowModule.forChild({
+        ], imports: [AXPWorkflowModule.forChild({
                 actions: {
-                    navigate: AXPDialogConfirmAction,
+                    'navigate-router': AXPWorkflowRouterNavigateAction,
                     'show-prompt-dialog': AXPDialogConfirmAction,
                     'show-toast': AXPToastAction,
                 },
+                workflows: {
+                    'navigate': AXPNavigateWorkflow
+                }
             }),
             AXPopupModule,
             AXDateTimeModule,
@@ -2415,13 +2422,15 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImpor
             type: NgModule,
             args: [{
                     imports: [
-                        EffectsModule.forFeature([AXPCommonEffects]),
                         AXPWorkflowModule.forChild({
                             actions: {
-                                navigate: AXPDialogConfirmAction,
+                                'navigate-router': AXPWorkflowRouterNavigateAction,
                                 'show-prompt-dialog': AXPDialogConfirmAction,
                                 'show-toast': AXPToastAction,
                             },
+                            workflows: {
+                                'navigate': AXPNavigateWorkflow
+                            }
                         }),
                         AXPopupModule,
                         AXDateTimeModule,
@@ -2528,9 +2537,12 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImpor
                 }]
         }] });
 
+const AXPSignOutAction = createAction('[SignOut] Action');
+const AXPSignInAction = createAction('[SignIn] Action');
+
 /**
  * Generated bundle index. Do not edit.
  */
 
-export { ALL_DEFAULT_OPERATORS, AXMEntityCrudService, AXMEntityCrudServiceImpl, AXMWorkflowErrorHandler, AXPAppStartUpProvider, AXPAppStartUpService, AXPClipBoardService, AXPCommonEffects, AXPCommonModule, AXPComponentLogoConfig, AXPComponentSlotDirective, AXPComponentSlotLoaderService, AXPComponentSlotModule, AXPComponentSlotRegistryService, AXPCustomOperatorService, AXPCustomOperatorServiceImpl, AXPDataGenerator, AXPDataProvider, AXPDataSeederService, AXPDexieEntityStorageService, AXPDialogConfirmAction, AXPEntityCommandScope, AXPEntityDataProvider, AXPEntityDataProviderImpl, AXPEntityQueryType, AXPEntityStorageService, AXPErrorHandlerRegistryService, AXPFileStorageService, AXPFileStorageStatus, AXPFilterOperatorMiddlewareService, AXPFilterOperatorMiddlewareServiceImpl, AXPFiltersProviderService, AXPFontIconLogoConfig, AXPFooterTextSlotComponent, AXPGlobalErrorHandler, AXPGridLayoutDirective, AXPImageUrlLogoConfig, AXPLogoComponent, AXPMenuProviderService, AXPMenuSearchDefinitionProvider, AXPMenuSearchProvider, AXPMenuService, AXPNavBarSlotComponent, AXPNavigateAction, AXPPdfPageSize, AXPPdfService, AXPPlatformDefaultConfigs, AXPRedirectEvent, AXPRefreshEvent, AXPRelationshipCardinality, AXPRelationshipKind, AXPSearchDefinitionActionBuilder, AXPSearchDefinitionBuilder, AXPSearchDefinitionProviderContext, AXPSearchDefinitionProviderService, AXPSearchService, AXPSettingDefaultValueProvider, AXPSettingDefinitionGroupBuilder, AXPSettingDefinitionProviderContext, AXPSettingDefinitionProviderService, AXPSettingDefinitionSectionBuilder, AXPSettingScope, AXPSettingValueProviderService, AXPSignInAction, AXPSignOutAction, AXPStickyDirective, AXPTextLogoConfig, AXPToastAction, AXPWorkflowNavigateAction, AXP_DATA_SEEDER_TOKEN, AXP_MENU_PROVIDER, AXP_PLATFORM_CONFIG_TOKEN, AXP_ROOT_CONFIG_TOKEN, AXP_SEARCH_DEFINITION_PROVIDER, AXP_SEARCH_PROVIDER, AXP_SETTING_DEFINITION_PROVIDER, AXP_SETTING_VALUE_PROVIDER, BETWEEN_OPER, BOOLEAN_OPERATORS, CONTAINS_OPER, DATE_OPERATORS, ENDS_WITH_OPER, ENVIRONMENT, EQ_OPER, GTE_OPER, GT_OPER, IS_EMPTY_OPER, IS_NOT_EMPTY_OPER, LTE_OPER, LT_OPER, NOT_CONTAINS_OPER, NOT_EQ_OPER, NUMBER_OPERATORS, STARTS_WITH_OPER, STRING_OPERATORS, configPlatform, getEntityInfo, resolveActionLook };
+export { ALL_DEFAULT_OPERATORS, AXMEntityCrudService, AXMEntityCrudServiceImpl, AXMWorkflowErrorHandler, AXPAppStartUpProvider, AXPAppStartUpService, AXPClipBoardService, AXPCommandSearchProvider, AXPCommonModule, AXPComponentLogoConfig, AXPComponentSlotDirective, AXPComponentSlotLoaderService, AXPComponentSlotModule, AXPComponentSlotRegistryService, AXPCustomOperatorService, AXPCustomOperatorServiceImpl, AXPDataGenerator, AXPDataProvider, AXPDataSeederService, AXPDexieEntityStorageService, AXPDialogConfirmAction, AXPEntityCommandScope, AXPEntityDataProvider, AXPEntityDataProviderImpl, AXPEntityQueryType, AXPEntityStorageService, AXPErrorHandlerRegistryService, AXPFileStorageService, AXPFileStorageStatus, AXPFilterOperatorMiddlewareService, AXPFilterOperatorMiddlewareServiceImpl, AXPFiltersProviderService, AXPFontIconLogoConfig, AXPFooterTextSlotComponent, AXPGlobalErrorHandler, AXPGridLayoutDirective, AXPImageUrlLogoConfig, AXPLogoComponent, AXPMenuProviderService, AXPMenuSearchDefinitionProvider, AXPMenuSearchProvider, AXPMenuService, AXPNavBarSlotComponent, AXPNavigateWorkflow, AXPPdfPageSize, AXPPdfService, AXPPlatformDefaultConfigs, AXPRedirectEvent, AXPRefreshEvent, AXPRelationshipCardinality, AXPRelationshipKind, AXPSearchDefinitionActionBuilder, AXPSearchDefinitionBuilder, AXPSearchDefinitionProviderContext, AXPSearchDefinitionProviderService, AXPSearchService, AXPSettingDefaultValueProvider, AXPSettingDefinitionGroupBuilder, AXPSettingDefinitionProviderContext, AXPSettingDefinitionProviderService, AXPSettingDefinitionSectionBuilder, AXPSettingScope, AXPSettingValueProviderService, AXPSignInAction, AXPSignOutAction, AXPStickyDirective, AXPTextLogoConfig, AXPToastAction, AXPWorkflowNavigateAction, AXPWorkflowRouterNavigateAction, AXP_DATA_SEEDER_TOKEN, AXP_MENU_PROVIDER, AXP_PLATFORM_CONFIG_TOKEN, AXP_ROOT_CONFIG_TOKEN, AXP_SEARCH_DEFINITION_PROVIDER, AXP_SEARCH_PROVIDER, AXP_SETTING_DEFINITION_PROVIDER, AXP_SETTING_VALUE_PROVIDER, BETWEEN_OPER, BOOLEAN_OPERATORS, CONTAINS_OPER, DATE_OPERATORS, ENDS_WITH_OPER, ENVIRONMENT, EQ_OPER, GTE_OPER, GT_OPER, IS_EMPTY_OPER, IS_NOT_EMPTY_OPER, LTE_OPER, LT_OPER, NOT_CONTAINS_OPER, NOT_EQ_OPER, NUMBER_OPERATORS, STARTS_WITH_OPER, STRING_OPERATORS, configPlatform, getEntityInfo, resolveActionLook };
 //# sourceMappingURL=acorex-platform-common.mjs.map