@acorex/platform 19.1.6 → 19.1.8

package/fesm2022/acorex-platform-common.mjs

@@ -1,35 +1,25 @@
 import * as i0 from '@angular/core';
-import { Injectable, provideAppInitializer, inject, RendererFactory2, InjectionToken, Injector, ErrorHandler, NgModule, Inject, Directive, Input, EventEmitter, Output, runInInjectionContext, Optional, Component, ViewEncapsulation, ChangeDetectorRef, ChangeDetectionStrategy, ViewChild } from '@angular/core';
-import { kebabCase, merge, cloneDeep, get, sortBy, assign, isEqual, set } from 'lodash-es';
+import { Injectable, provideAppInitializer, inject, RendererFactory2, InjectionToken, Injector, ErrorHandler, Directive, Input, EventEmitter, Output, runInInjectionContext, NgModule, Optional, Inject, Component, ViewEncapsulation } from '@angular/core';
+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 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 from '@ngrx/effects';
-import { createEffect, ofType, EffectsModule } from '@ngrx/effects';
 import { applySortArray, applyFilterArray } from '@acorex/platform/core';
 import Dexie from 'dexie';
-import { Subject, switchMap, of } from 'rxjs';
-import { createAction, props, Store } from '@ngrx/store';
-import { AXDialogService } from '@acorex/components/dialog';
-import { AXTranslationService } from '@acorex/core/translation';
-import * as i5$1 from '@acorex/components/decorators';
+import * as i3 from '@acorex/components/decorators';
 import { AXDecoratorModule } from '@acorex/components/decorators';
-import * as i2$1 from '@acorex/components/image';
+import * as i2 from '@acorex/components/image';
 import { AXImageModule } from '@acorex/components/image';
-import * as i1$1 from '@angular/common';
+import * as i1 from '@angular/common';
 import { CommonModule } from '@angular/common';
 import { signalStore, withState, withMethods, patchState, withHooks } from '@ngrx/signals';
-import * as i2$2 from '@acorex/components/skeleton';
-import { AXSkeletonModule } from '@acorex/components/skeleton';
-import * as i1$2 from '@angular/cdk/portal';
-import { ComponentPortal, PortalModule } from '@angular/cdk/portal';
-import { AXDataTableColumnComponent } from '@acorex/components/data-table';
-import { AXUnsubscriber } from '@acorex/core/utils';
-import { AXFormatService } from '@acorex/core/format';
+import { AXTranslationService } from '@acorex/core/translation';
+import { Store, createAction } from '@ngrx/store';
+import { Subject } from 'rxjs';
+import { AXDialogService } from '@acorex/components/dialog';
 
 class AXPAppStartUpService {
     constructor() {
@@ -764,1141 +754,411 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImpor
             args: [{ providedIn: 'root' }]
         }], ctorParameters: () => [{ type: i0.Injector }, { type: AXPErrorHandlerRegistryService }] });
 
-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);
+// src/app/directives/grid-layout.directive.ts
+class AXPGridLayoutDirective {
+    constructor(el, renderer) {
+        this.el = el;
+        this.renderer = renderer;
     }
-    group(name) {
-        const foundGroup = this.groupMap.get(name);
-        if (!foundGroup) {
-            throw new Error(`Group with name "${name}" not found.`);
+    ngOnChanges(changes) {
+        if (changes['options']) {
+            this.applyTailwindClasses();
         }
-        return new AXPSettingDefinitionGroupBuilder(this, foundGroup);
     }
-    getGroups() {
-        return this.rootGroups;
+    applyTailwindClasses() {
+        // Clear existing grid classes
+        this.clearClasses();
+        // Apply new grid classes based on the input options
+        this.setClasses(this.options.positions?.default, '');
+        this.setClasses(this.options.positions?.md, 'md:');
+        this.setClasses(this.options.positions?.lg, 'lg:');
+        this.setClasses(this.options.positions?.xl, 'xl:');
+        this.setClasses(this.options.positions?.xxl, '2xl:');
     }
-    // Expose groupMap for controlled access
-    hasGroup(name) {
-        return this.groupMap.has(name);
+    setClasses(positions, prefix) {
+        if (positions == null)
+            return;
+        const colStart = positions.colStart ? `${prefix}ax-col-start-${positions.colStart}` : '';
+        const colEnd = positions.colEnd ? `${prefix}ax-col-end-${positions.colEnd}` : '';
+        const colSpan = positions.colSpan ? `${prefix}ax-col-span-${positions.colSpan}` : '';
+        const rowStart = positions.rowStart ? `${prefix}ax-row-start-${positions.rowStart}` : '';
+        const rowEnd = positions.rowEnd ? `${prefix}ax-row-end-${positions.rowEnd}` : '';
+        const rowSpan = positions.rowSpan ? `${prefix}ax-row-span-${positions.rowSpan}` : '';
+        const order = positions.order ? `${prefix}ax-order-${positions.order}` : ''; // Handling order
+        [colStart, colEnd, colSpan, rowStart, rowEnd, rowSpan, order].forEach(cls => {
+            if (cls) {
+                this.renderer.addClass(this.el.nativeElement, cls);
+            }
+        });
     }
-    getGroup(name) {
-        return this.groupMap.get(name);
+    clearClasses() {
+        const currentClasses = this.el.nativeElement.className.split(' ');
+        currentClasses.forEach((className) => {
+            if (className.startsWith('ax-col-') || className.startsWith('ax-row-') || className.startsWith('ax-order-')) {
+                this.renderer.removeClass(this.el.nativeElement, className);
+            }
+        });
     }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPGridLayoutDirective, deps: [{ token: i0.ElementRef }, { token: i0.Renderer2 }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "19.0.3", type: AXPGridLayoutDirective, isStandalone: true, selector: "[gridLayout]", inputs: { options: ["gridLayout", "options"] }, usesOnChanges: true, ngImport: i0 }); }
 }
-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);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPGridLayoutDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[gridLayout]',
+                    standalone: true,
+                }]
+        }], ctorParameters: () => [{ type: i0.ElementRef }, { type: i0.Renderer2 }], propDecorators: { options: [{
+                type: Input,
+                args: ['gridLayout']
+            }] } });
+
+class AXPStickyDirective {
+    get isSticky() {
+        return this._isSticky;
     }
-    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}".`);
+    set isSticky(value) {
+        if (this._isSticky !== value) {
+            this._isSticky = value;
+            this.isStickyChange.emit(value);
         }
-        return new AXPSettingDefinitionSectionBuilder(this, foundSection);
     }
-    addGroup(name, title, description, icon) {
-        const newGroup = {
-            name,
-            title,
-            description: description,
-            icon,
-            groups: [],
-            sections: [],
+    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.onParentScroll = () => {
+            this.zone.runOutsideAngular(() => {
+                const scrollTop = this.parentElement === window
+                    ? window.scrollY
+                    : this.parentElement.scrollTop;
+                const shouldStick = scrollTop + this.stickyOffset >= this.topOffset;
+                if (shouldStick !== this.isSticky) {
+                    this.zone.run(() => {
+                        this.isSticky = shouldStick;
+                        this.toggleStickyClasses(shouldStick);
+                        this.cdr.markForCheck();
+                    });
+                }
+            });
         };
-        this.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 ?? 'G',
-            widget: {
-                type: setting.widget.type,
-                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;
+    ngAfterViewInit() {
+        this.initSticky();
+        // Add mutation observer for dynamic content
+        this.mutationObserver = new MutationObserver(() => {
+            this.updateTopOffset();
+        });
+        this.mutationObserver.observe(this.element.nativeElement, {
+            childList: true,
+            subtree: true,
+        });
+        // Add resize event listener
+        window.addEventListener('resize', this.updateTopOffset.bind(this));
     }
-    endSection() {
-        return this.groupBuilder;
+    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.updateTopOffset();
+        this.parentElement.addEventListener('scroll', this.onParentScroll);
     }
-}
-
-// 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;
+    updateTopOffset() {
+        this.zone.runOutsideAngular(() => {
+            const rect = this.targetElement.getBoundingClientRect();
+            this.topOffset = rect.top + (window.scrollY || 0);
+        });
     }
-    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);
+    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.updateTopOffset.bind(this));
+        if (this.mutationObserver) {
+            this.mutationObserver.disconnect();
         }
-        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);
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", 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: "19.0.3", 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: "19.0.3", 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
+            }] } });
+
+class AXPComponentSlotRegistryService {
+    constructor() {
+        this.registry = new Map();
     }
-    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();
+    register(slotName, config) {
+        let configs = this.registry.get(slotName) || [];
+        // Check if the component is already registered in this slot
+        const isDuplicate = configs.some(existingConfig => existingConfig.name === config.name);
+        if (!isDuplicate) {
+            configs = [...configs, config]; // Add the new configuration
+            this.registry.set(slotName, configs);
         }
-        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: []
-        };
+    get(slotName) {
+        return this.registry.get(slotName) || [];
     }
-    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' }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPComponentSlotRegistryService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPComponentSlotRegistryService, providedIn: 'root' }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPSettingDefinitionProviderService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPComponentSlotRegistryService, decorators: [{
             type: Injectable,
-            args: [{ providedIn: 'root' }]
+            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})`;
+class AXPComponentSlotLoaderService {
+    constructor(registryService, injector) {
+        this.registryService = registryService;
+        this.injector = injector;
     }
-    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);
+    loadComponent(slotName, viewContainerRef) {
+        const configs = sortBy(this.registryService.get(slotName), (c) => c.priority ?? 0);
+        if (configs) {
+            viewContainerRef.clear();
+            configs.forEach(async (config) => {
+                let component;
+                let options = {};
+                if (typeof config.loadComponent === 'function') {
+                    // If component is a function
+                    runInInjectionContext(this.injector, () => {
+                        component = config.loadComponent?.();
+                    });
+                }
+                else if (config.component) {
+                    // If component is a Type
+                    component = config.component;
+                }
+                //
+                if (typeof config.options === 'function') {
+                    // If options is a function
+                    runInInjectionContext(this.injector, () => {
+                        const fun = config.options;
+                        options = fun();
+                    });
+                }
+                else if (config.options) {
+                    // If options is a object
+                    options = config.options;
+                }
+                //
+                if (component != null) {
+                    const componentRef = viewContainerRef.createComponent(component);
+                    Object.assign(componentRef.instance, options);
+                }
             });
-            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();
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPComponentSlotLoaderService, deps: [{ token: AXPComponentSlotRegistryService }, { token: i0.Injector }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPComponentSlotLoaderService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPComponentSlotLoaderService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [{ type: AXPComponentSlotRegistryService }, { type: i0.Injector }] });
+
+class AXPComponentSlotDirective {
+    constructor(dynamicLoaderService, viewContainerRef) {
+        this.dynamicLoaderService = dynamicLoaderService;
+        this.viewContainerRef = viewContainerRef;
     }
-    async saveToLocalStorage() {
-        const settingsObject = {};
-        this.cache.forEach((value, key) => {
-            settingsObject[key] = value;
-        });
-        localStorage.setItem(this.localStorageKey, JSON.stringify(settingsObject));
+    ngOnInit() {
+        this.dynamicLoaderService.loadComponent(this.name, this.viewContainerRef);
     }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPComponentSlotDirective, deps: [{ token: AXPComponentSlotLoaderService }, { token: i0.ViewContainerRef }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "19.0.3", type: AXPComponentSlotDirective, isStandalone: false, selector: "axp-component-slot", inputs: { name: "name" }, ngImport: i0 }); }
 }
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPComponentSlotDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: 'axp-component-slot',
+                    standalone: false
+                }]
+        }], ctorParameters: () => [{ type: AXPComponentSlotLoaderService }, { type: i0.ViewContainerRef }], propDecorators: { name: [{
+                type: Input
+            }] } });
 
-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);
+class AXPComponentSlotModule {
+    static forRoot(configs) {
+        return {
+            ngModule: AXPComponentSlotModule,
+            providers: [
+                {
+                    provide: 'AXPComponentSlotModuleFactory',
+                    useFactory: (registry) => () => {
+                        if (configs) {
+                            for (const [key, value] of Object.entries(configs)) {
+                                value.forEach(v => {
+                                    registry.register(key, v);
+                                });
+                            }
+                        }
+                    },
+                    deps: [AXPComponentSlotRegistryService],
+                    multi: true
                 }
-            }
-        }
-        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 };
+    static forChild(configs) {
+        return {
+            ngModule: AXPComponentSlotModule,
+            providers: [
+                {
+                    provide: 'AXPComponentSlotModuleFactory',
+                    useFactory: (registry) => () => {
+                        if (configs) {
+                            for (const [key, value] of Object.entries(configs)) {
+                                value.forEach(v => {
+                                    registry.register(key, v);
+                                });
+                            }
+                        }
+                    },
+                    deps: [AXPComponentSlotRegistryService],
+                    multi: true
+                }
+            ]
+        };
     }
-    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));
+    /**
+     * @ignore
+     */
+    constructor(instances) {
+        instances?.forEach(f => {
+            f();
+        });
     }
-    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' }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPComponentSlotModule, deps: [{ token: 'AXPComponentSlotModuleFactory', optional: true }], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "19.0.3", ngImport: i0, type: AXPComponentSlotModule, declarations: [AXPComponentSlotDirective], exports: [AXPComponentSlotDirective] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPComponentSlotModule }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPSettingValueProviderService, decorators: [{
-            type: Injectable,
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPComponentSlotModule, decorators: [{
+            type: NgModule,
             args: [{
-                    providedIn: 'root',
+                    declarations: [AXPComponentSlotDirective],
+                    exports: [AXPComponentSlotDirective]
                 }]
-        }], 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;
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: ['AXPComponentSlotModuleFactory']
+                }] }] });
+
+class AXPTextLogoConfig {
+    constructor(text) {
+        this.text = text;
     }
-    async all() {
-        const settings = await this.provider.load();
-        return Object.fromEntries(settings.map((s) => [s.key, cloneDeep(s.value)]));
+}
+class AXPImageUrlLogoConfig {
+    constructor(url) {
+        this.url = url;
     }
-    async defaultValues() {
-        return this.parent.defaultValues(this.provider.scope);
+}
+class AXPFontIconLogoConfig {
+    constructor(iconClass) {
+        this.iconClass = iconClass;
     }
-    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 AXPComponentLogoConfig {
+    constructor(component) {
+        this.component = component;
     }
 }
 
-const AXPNavigateAction = createAction('[Navigate] Action', props());
-const AXPSignOutAction = createAction('[SignOut] Action');
-const AXPSignInAction = createAction('[SignIn] Action');
-
-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 });
+class AXPLogoComponent {
+    ngOnInit() {
+        switch (true) {
+            case this.source instanceof AXPTextLogoConfig:
+                this.logoType = 'text';
+                break;
+            case this.source instanceof AXPImageUrlLogoConfig:
+                this.logoType = 'url';
+                break;
+            case this.source instanceof AXPFontIconLogoConfig:
+                this.logoType = 'iconClass';
+                break;
+            case this.source instanceof AXPComponentLogoConfig:
+                this.logoType = 'component';
+                break;
+            default:
+                break;
+        }
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPCommonEffects, deps: [{ token: i1.Actions }, { token: i2.Router }, { token: AXPSettingValueProviderService }], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPCommonEffects }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPLogoComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "19.0.3", type: AXPLogoComponent, isStandalone: true, selector: "axp-logo", inputs: { source: "source" }, host: { classAttribute: "ax-flex ax-justify-center" }, ngImport: i0, template: "@switch (logoType) {\n@case ('text') {\n<span class=\"ax-font-bold ax-select-none\">{{ source.text }}</span>\n}\n@case ('url') {\n<ax-image [src]=\"source.url\"></ax-image>\n} @case ('iconClass') {\n<ax-icon class=\"{{ source.classIcon }}\"></ax-icon>\n} @case ('component') {\n<ng-container *ngComponentOutlet=\"source.component\"></ng-container>\n}\n}", dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1.NgComponentOutlet, selector: "[ngComponentOutlet]", inputs: ["ngComponentOutlet", "ngComponentOutletInputs", "ngComponentOutletInjector", "ngComponentOutletContent", "ngComponentOutletNgModule", "ngComponentOutletNgModuleFactory"] }, { kind: "ngmodule", type: AXImageModule }, { kind: "component", type: i2.AXImageComponent, selector: "ax-image", inputs: ["overlayMode", "src", "alt", "priority", "lazy"], outputs: ["onLoad", "onError"] }, { kind: "ngmodule", type: AXDecoratorModule }, { kind: "component", type: i3.AXDecoratorIconComponent, selector: "ax-icon", inputs: ["icon"] }] }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPCommonEffects, decorators: [{
-            type: Injectable
-        }], ctorParameters: () => [{ type: i1.Actions }, { type: i2.Router }, { type: AXPSettingValueProviderService }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPLogoComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'axp-logo', imports: [CommonModule, AXImageModule, AXDecoratorModule], host: { 'class': 'ax-flex ax-justify-center' }, template: "@switch (logoType) {\n@case ('text') {\n<span class=\"ax-font-bold ax-select-none\">{{ source.text }}</span>\n}\n@case ('url') {\n<ax-image [src]=\"source.url\"></ax-image>\n} @case ('iconClass') {\n<ax-icon class=\"{{ source.classIcon }}\"></ax-icon>\n} @case ('component') {\n<ng-container *ngComponentOutlet=\"source.component\"></ng-container>\n}\n}" }]
+        }], propDecorators: { source: [{
+                type: Input
+            }] } });
 
-//TODO Loading, Redirect, Drawer, Show toast
-const AXPRedirectEvent = createWorkFlowEvent('Redirect Event Fired');
-const AXPRefreshEvent = createWorkFlowEvent('Refresh Event Fired');
-class AXPWorkflowNavigateAction extends AXPWorkflowAction {
+const AXP_MENU_PROVIDER = new InjectionToken('AXP_MENU_PROVIDER');
+class AXPMenuProviderService {
     constructor() {
-        super(...arguments);
-        this.router = inject(Router);
+        this.providers = inject(AXP_MENU_PROVIDER, { optional: true });
+        this.cache = null;
+        this.pendingInserts = [];
+        this.pendingRemovals = [];
+        this.pendingUpdates = [];
+        this.pendingAdditions = [];
     }
-    async execute(context) {
-        const payload = context.getVariable('payload');
-        if (Array.isArray(payload.commands)) {
-            this.router.navigate(payload.commands, payload.extras);
+    async items() {
+        // Return cached items if available
+        if (this.cache) {
+            return this.cache;
         }
-        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: "19.0.3", ngImport: i0, type: AXPWorkflowNavigateAction, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPWorkflowNavigateAction }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPWorkflowNavigateAction, decorators: [{
-            type: Injectable
-        }] });
-class AXPDialogConfirmAction extends AXPWorkflowAction {
-    constructor() {
-        super(...arguments);
-        this.dialogService = inject(AXDialogService);
-        this.translationService = inject(AXTranslationService);
-    }
-    async execute(context) {
-        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)));
-        context.setOutput('result', dialogResult.result);
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPDialogConfirmAction, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPDialogConfirmAction }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPDialogConfirmAction, decorators: [{
-            type: Injectable
-        }] });
-class AXPToastAction extends AXPWorkflowAction {
-    constructor() {
-        super(...arguments);
-        this.toastService = inject(AXToastService);
-        this.translationService = inject(AXTranslationService);
-    }
-    async execute(context) {
-        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: "19.0.3", ngImport: i0, type: AXPToastAction, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPToastAction }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPToastAction, decorators: [{
-            type: Injectable
-        }] });
-
-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: "19.0.3", ngImport: i0, type: AXMWorkflowErrorHandler, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXMWorkflowErrorHandler }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", 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, appInitService, settingsService, seederService) {
-        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 ...',
-            run: async () => {
-                await settingsService.load();
-            },
-        });
-        //
-        //
-        appInitService.registerTask({
-            name: 'Seeder',
-            statusText: 'Seed Data ...',
-            run: async () => {
-                await seederService.seed();
-            },
-        });
-    }
-    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.EffectsFeatureModule, i5.AXPWorkflowModule, AXPopupModule,
-            AXDateTimeModule,
-            AXToastModule], exports: [RouterModule] }); }
-    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPCommonModule, providers: [
-            AXPAppStartUpProvider,
-            {
-                provide: ErrorHandler,
-                useClass: AXPGlobalErrorHandler,
-            },
-            {
-                provide: AXPCustomOperatorService,
-                useClass: AXPCustomOperatorServiceImpl,
-            },
-            {
-                provide: AXPFilterOperatorMiddlewareService,
-                useClass: AXPFilterOperatorMiddlewareServiceImpl,
-            },
-        ], imports: [EffectsModule.forFeature([AXPCommonEffects]),
-            AXPWorkflowModule.forChild({
-                actions: {
-                    navigate: AXPDialogConfirmAction,
-                    'show-prompt-dialog': AXPDialogConfirmAction,
-                    'show-toast': AXPToastAction,
-                },
-            }),
-            AXPopupModule,
-            AXDateTimeModule,
-            AXToastModule, RouterModule] }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPCommonModule, decorators: [{
-            type: NgModule,
-            args: [{
-                    imports: [
-                        EffectsModule.forFeature([AXPCommonEffects]),
-                        AXPWorkflowModule.forChild({
-                            actions: {
-                                navigate: AXPDialogConfirmAction,
-                                'show-prompt-dialog': AXPDialogConfirmAction,
-                                'show-toast': AXPToastAction,
-                            },
-                        }),
-                        AXPopupModule,
-                        AXDateTimeModule,
-                        AXToastModule,
-                    ],
-                    exports: [RouterModule],
-                    providers: [
-                        AXPAppStartUpProvider,
-                        {
-                            provide: ErrorHandler,
-                            useClass: AXPGlobalErrorHandler,
-                        },
-                        {
-                            provide: AXPCustomOperatorService,
-                            useClass: AXPCustomOperatorServiceImpl,
-                        },
-                        {
-                            provide: AXPFilterOperatorMiddlewareService,
-                            useClass: AXPFilterOperatorMiddlewareServiceImpl,
-                        },
-                    ],
-                }]
-        }], ctorParameters: () => [{ type: undefined, decorators: [{
-                    type: Inject,
-                    args: ['AXPCommonModuleFactory']
-                }] }, { type: AXPAppStartUpService }, { type: AXPSettingValueProviderService }, { type: AXPDataSeederService }] });
-
-class AXPTextLogoConfig {
-    constructor(text) {
-        this.text = text;
-    }
-}
-class AXPImageUrlLogoConfig {
-    constructor(url) {
-        this.url = url;
-    }
-}
-class AXPFontIconLogoConfig {
-    constructor(iconClass) {
-        this.iconClass = iconClass;
-    }
-}
-class AXPComponentLogoConfig {
-    constructor(component) {
-        this.component = component;
-    }
-}
-
-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',
-    logo: {
-        dark: new AXPTextLogoConfig('ACoreX'),
-        light: new AXPTextLogoConfig('ACoreX'),
-        colored: new AXPTextLogoConfig('ACoreX'),
-    },
-    network: {
-        timeOut: 5000,
-    }
-};
-function configPlatform(config = AXPPlatformDefaultConfigs) {
-    return merge(AXPPlatformDefaultConfigs, config);
-}
-
-const AXP_ROOT_CONFIG_TOKEN = new InjectionToken('AXP_ROOT_CONFIG_TOKEN');
-
-class AXPFiltersProviderService {
-    async getAll() {
-        return Promise.resolve('');
-    }
-    async execute() {
-        return Promise.resolve('');
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPFiltersProviderService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPFiltersProviderService, providedIn: 'root' }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPFiltersProviderService, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: 'root',
-                }]
-        }] });
-
-// src/app/directives/grid-layout.directive.ts
-class AXPGridLayoutDirective {
-    constructor(el, renderer) {
-        this.el = el;
-        this.renderer = renderer;
-    }
-    ngOnChanges(changes) {
-        if (changes['options']) {
-            this.applyTailwindClasses();
-        }
-    }
-    applyTailwindClasses() {
-        // Clear existing grid classes
-        this.clearClasses();
-        // Apply new grid classes based on the input options
-        this.setClasses(this.options.positions?.default, '');
-        this.setClasses(this.options.positions?.md, 'md:');
-        this.setClasses(this.options.positions?.lg, 'lg:');
-        this.setClasses(this.options.positions?.xl, 'xl:');
-        this.setClasses(this.options.positions?.xxl, '2xl:');
-    }
-    setClasses(positions, prefix) {
-        if (positions == null)
-            return;
-        const colStart = positions.colStart ? `${prefix}ax-col-start-${positions.colStart}` : '';
-        const colEnd = positions.colEnd ? `${prefix}ax-col-end-${positions.colEnd}` : '';
-        const colSpan = positions.colSpan ? `${prefix}ax-col-span-${positions.colSpan}` : '';
-        const rowStart = positions.rowStart ? `${prefix}ax-row-start-${positions.rowStart}` : '';
-        const rowEnd = positions.rowEnd ? `${prefix}ax-row-end-${positions.rowEnd}` : '';
-        const rowSpan = positions.rowSpan ? `${prefix}ax-row-span-${positions.rowSpan}` : '';
-        const order = positions.order ? `${prefix}ax-order-${positions.order}` : ''; // Handling order
-        [colStart, colEnd, colSpan, rowStart, rowEnd, rowSpan, order].forEach(cls => {
-            if (cls) {
-                this.renderer.addClass(this.el.nativeElement, cls);
-            }
-        });
-    }
-    clearClasses() {
-        const currentClasses = this.el.nativeElement.className.split(' ');
-        currentClasses.forEach((className) => {
-            if (className.startsWith('ax-col-') || className.startsWith('ax-row-') || className.startsWith('ax-order-')) {
-                this.renderer.removeClass(this.el.nativeElement, className);
-            }
-        });
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPGridLayoutDirective, deps: [{ token: i0.ElementRef }, { token: i0.Renderer2 }], target: i0.ɵɵFactoryTarget.Directive }); }
-    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "19.0.3", type: AXPGridLayoutDirective, isStandalone: true, selector: "[gridLayout]", inputs: { options: ["gridLayout", "options"] }, usesOnChanges: true, ngImport: i0 }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPGridLayoutDirective, decorators: [{
-            type: Directive,
-            args: [{
-                    selector: '[gridLayout]',
-                    standalone: true,
-                }]
-        }], ctorParameters: () => [{ type: i0.ElementRef }, { type: i0.Renderer2 }], propDecorators: { options: [{
-                type: Input,
-                args: ['gridLayout']
-            }] } });
-
-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.onParentScroll = () => {
-            this.zone.runOutsideAngular(() => {
-                const scrollTop = this.parentElement === window
-                    ? window.scrollY
-                    : this.parentElement.scrollTop;
-                const shouldStick = scrollTop + this.stickyOffset >= this.topOffset;
-                if (shouldStick !== this.isSticky) {
-                    this.zone.run(() => {
-                        this.isSticky = shouldStick;
-                        this.toggleStickyClasses(shouldStick);
-                        this.cdr.markForCheck();
-                    });
-                }
-            });
-        };
-    }
-    ngAfterViewInit() {
-        this.initSticky();
-        // Add mutation observer for dynamic content
-        this.mutationObserver = new MutationObserver(() => {
-            this.updateTopOffset();
-        });
-        this.mutationObserver.observe(this.element.nativeElement, {
-            childList: true,
-            subtree: true,
-        });
-        // Add resize event listener
-        window.addEventListener('resize', this.updateTopOffset.bind(this));
-    }
-    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.updateTopOffset();
-        this.parentElement.addEventListener('scroll', this.onParentScroll);
-    }
-    updateTopOffset() {
-        this.zone.runOutsideAngular(() => {
-            const rect = this.targetElement.getBoundingClientRect();
-            this.topOffset = rect.top + (window.scrollY || 0);
-        });
-    }
-    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.updateTopOffset.bind(this));
-        if (this.mutationObserver) {
-            this.mutationObserver.disconnect();
-        }
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", 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: "19.0.3", 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: "19.0.3", 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
-            }] } });
-
-class AXPComponentSlotRegistryService {
-    constructor() {
-        this.registry = new Map();
-    }
-    register(slotName, config) {
-        let configs = this.registry.get(slotName) || [];
-        // Check if the component is already registered in this slot
-        const isDuplicate = configs.some(existingConfig => existingConfig.name === config.name);
-        if (!isDuplicate) {
-            configs = [...configs, config]; // Add the new configuration
-            this.registry.set(slotName, configs);
-        }
-    }
-    get(slotName) {
-        return this.registry.get(slotName) || [];
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPComponentSlotRegistryService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPComponentSlotRegistryService, providedIn: 'root' }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPComponentSlotRegistryService, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: 'root'
-                }]
-        }] });
-
-class AXPComponentSlotLoaderService {
-    constructor(registryService, injector) {
-        this.registryService = registryService;
-        this.injector = injector;
-    }
-    loadComponent(slotName, viewContainerRef) {
-        const configs = sortBy(this.registryService.get(slotName), (c) => c.priority ?? 0);
-        if (configs) {
-            viewContainerRef.clear();
-            configs.forEach(async (config) => {
-                let component;
-                let options = {};
-                if (typeof config.loadComponent === 'function') {
-                    // If component is a function
-                    runInInjectionContext(this.injector, () => {
-                        component = config.loadComponent?.();
-                    });
-                }
-                else if (config.component) {
-                    // If component is a Type
-                    component = config.component;
-                }
-                //
-                if (typeof config.options === 'function') {
-                    // If options is a function
-                    runInInjectionContext(this.injector, () => {
-                        const fun = config.options;
-                        options = fun();
-                    });
-                }
-                else if (config.options) {
-                    // If options is a object
-                    options = config.options;
-                }
-                //
-                if (component != null) {
-                    const componentRef = viewContainerRef.createComponent(component);
-                    Object.assign(componentRef.instance, options);
-                }
-            });
-        }
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPComponentSlotLoaderService, deps: [{ token: AXPComponentSlotRegistryService }, { token: i0.Injector }], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPComponentSlotLoaderService, providedIn: 'root' }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPComponentSlotLoaderService, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: 'root',
-                }]
-        }], ctorParameters: () => [{ type: AXPComponentSlotRegistryService }, { type: i0.Injector }] });
-
-class AXPComponentSlotDirective {
-    constructor(dynamicLoaderService, viewContainerRef) {
-        this.dynamicLoaderService = dynamicLoaderService;
-        this.viewContainerRef = viewContainerRef;
-    }
-    ngOnInit() {
-        this.dynamicLoaderService.loadComponent(this.name, this.viewContainerRef);
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPComponentSlotDirective, deps: [{ token: AXPComponentSlotLoaderService }, { token: i0.ViewContainerRef }], target: i0.ɵɵFactoryTarget.Directive }); }
-    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "19.0.3", type: AXPComponentSlotDirective, isStandalone: false, selector: "axp-component-slot", inputs: { name: "name" }, ngImport: i0 }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPComponentSlotDirective, decorators: [{
-            type: Directive,
-            args: [{
-                    selector: 'axp-component-slot',
-                    standalone: false
-                }]
-        }], ctorParameters: () => [{ type: AXPComponentSlotLoaderService }, { type: i0.ViewContainerRef }], propDecorators: { name: [{
-                type: Input
-            }] } });
-
-class AXPComponentSlotModule {
-    static forRoot(configs) {
-        return {
-            ngModule: AXPComponentSlotModule,
-            providers: [
-                {
-                    provide: 'AXPComponentSlotModuleFactory',
-                    useFactory: (registry) => () => {
-                        if (configs) {
-                            for (const [key, value] of Object.entries(configs)) {
-                                value.forEach(v => {
-                                    registry.register(key, v);
-                                });
-                            }
-                        }
-                    },
-                    deps: [AXPComponentSlotRegistryService],
-                    multi: true
-                }
-            ]
-        };
-    }
-    static forChild(configs) {
-        return {
-            ngModule: AXPComponentSlotModule,
-            providers: [
-                {
-                    provide: 'AXPComponentSlotModuleFactory',
-                    useFactory: (registry) => () => {
-                        if (configs) {
-                            for (const [key, value] of Object.entries(configs)) {
-                                value.forEach(v => {
-                                    registry.register(key, v);
-                                });
-                            }
-                        }
-                    },
-                    deps: [AXPComponentSlotRegistryService],
-                    multi: true
-                }
-            ]
-        };
-    }
-    /**
-     * @ignore
-     */
-    constructor(instances) {
-        instances?.forEach(f => {
-            f();
-        });
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPComponentSlotModule, deps: [{ token: 'AXPComponentSlotModuleFactory', optional: true }], target: i0.ɵɵFactoryTarget.NgModule }); }
-    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "19.0.3", ngImport: i0, type: AXPComponentSlotModule, declarations: [AXPComponentSlotDirective], exports: [AXPComponentSlotDirective] }); }
-    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPComponentSlotModule }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPComponentSlotModule, decorators: [{
-            type: NgModule,
-            args: [{
-                    declarations: [AXPComponentSlotDirective],
-                    exports: [AXPComponentSlotDirective]
-                }]
-        }], ctorParameters: () => [{ type: undefined, decorators: [{
-                    type: Optional
-                }, {
-                    type: Inject,
-                    args: ['AXPComponentSlotModuleFactory']
-                }] }] });
-
-class AXPLogoComponent {
-    ngOnInit() {
-        switch (true) {
-            case this.source instanceof AXPTextLogoConfig:
-                this.logoType = 'text';
-                break;
-            case this.source instanceof AXPImageUrlLogoConfig:
-                this.logoType = 'url';
-                break;
-            case this.source instanceof AXPFontIconLogoConfig:
-                this.logoType = 'iconClass';
-                break;
-            case this.source instanceof AXPComponentLogoConfig:
-                this.logoType = 'component';
-                break;
-            default:
-                break;
-        }
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPLogoComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
-    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "19.0.3", type: AXPLogoComponent, isStandalone: true, selector: "axp-logo", inputs: { source: "source" }, host: { classAttribute: "ax-flex ax-justify-center" }, ngImport: i0, template: "@switch (logoType) {\n@case ('text') {\n<span class=\"ax-font-bold ax-select-none\">{{ source.text }}</span>\n}\n@case ('url') {\n<ax-image [src]=\"source.url\"></ax-image>\n} @case ('iconClass') {\n<ax-icon class=\"{{ source.classIcon }}\"></ax-icon>\n} @case ('component') {\n<ng-container *ngComponentOutlet=\"source.component\"></ng-container>\n}\n}", dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1$1.NgComponentOutlet, selector: "[ngComponentOutlet]", inputs: ["ngComponentOutlet", "ngComponentOutletInputs", "ngComponentOutletInjector", "ngComponentOutletContent", "ngComponentOutletNgModule", "ngComponentOutletNgModuleFactory"] }, { kind: "ngmodule", type: AXImageModule }, { kind: "component", type: i2$1.AXImageComponent, selector: "ax-image", inputs: ["overlayMode", "src", "alt", "priority", "lazy"], outputs: ["onLoad", "onError"] }, { kind: "ngmodule", type: AXDecoratorModule }, { kind: "component", type: i5$1.AXDecoratorIconComponent, selector: "ax-icon", inputs: ["icon"] }] }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPLogoComponent, decorators: [{
-            type: Component,
-            args: [{ selector: 'axp-logo', imports: [CommonModule, AXImageModule, AXDecoratorModule], host: { 'class': 'ax-flex ax-justify-center' }, template: "@switch (logoType) {\n@case ('text') {\n<span class=\"ax-font-bold ax-select-none\">{{ source.text }}</span>\n}\n@case ('url') {\n<ax-image [src]=\"source.url\"></ax-image>\n} @case ('iconClass') {\n<ax-icon class=\"{{ source.classIcon }}\"></ax-icon>\n} @case ('component') {\n<ng-container *ngComponentOutlet=\"source.component\"></ng-container>\n}\n}" }]
-        }], propDecorators: { source: [{
-                type: Input
-            }] } });
-
-const AXP_MENU_PROVIDER = new InjectionToken('AXP_MENU_PROVIDER');
-class AXPMenuProviderService {
-    constructor() {
-        this.providers = inject(AXP_MENU_PROVIDER, { optional: true });
-        this.cache = null;
-        this.pendingInserts = [];
-        this.pendingRemovals = [];
-        this.pendingUpdates = [];
-        this.pendingAdditions = [];
-    }
-    async items() {
-        // Return cached items if available
-        if (this.cache) {
-            return this.cache;
-        }
-        const items = [];
-        const context = this.createMenuProviderContext(items);
-        if (Array.isArray(this.providers)) {
-            for (const provider of this.providers) {
-                await provider.provide(context);
+        const items = [];
+        const context = this.createMenuProviderContext(items);
+        if (Array.isArray(this.providers)) {
+            for (const provider of this.providers) {
+                await provider.provide(context);
             }
         }
         // Apply pending operations
@@ -2026,7 +1286,7 @@ withState((router = inject(Router)) => {
     };
 }), 
 // Methods for State Management
-withMethods((store, router = inject(Router), globalStore = inject(Store)) => {
+withMethods((store, router = inject(Router), workflow = inject(AXPWorkflowService)) => {
     return {
         setMenuItems(items) {
             patchState(store, { items: items });
@@ -2084,1227 +1344,1164 @@ withMethods((store, router = inject(Router), globalStore = inject(Store)) => {
             patchState(store, { selectedMenuItem: { item, isFullMatch: !isPartialMatch } });
         },
         executeCommand(item) {
+            if (item.path) {
+                workflow.execute('navigate', { command: { type: 'router', options: { path: item.path } } });
+            }
             if (item.command) {
-                globalStore.dispatch(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() {
+    },
+})));
+
+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.translateService = 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: {
+                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)]);
+    }
+    /**
+     * 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: "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);
+    }
+    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 }); }
+}
+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();
+    }
+    addDefinition(name, title, icon, actions) {
+        const definitionSearch = {
+            name,
+            title,
+            icon,
+            actions: actions ?? [],
+        };
+        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);
             }
-            else if (item.path) {
-                globalStore.dispatch(AXPNavigateAction({ payload: { commands: item.path } }));
+        }
+        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);
+                }
             }
-            patchState(store, { selectedMenuItem: { item, isFullMatch: true } });
-        },
-        isItemOpen(item) {
-            const selectedItem = store.selectedMenuItem();
-            if (!selectedItem) {
-                return false;
+        }
+        // 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]);
             }
-            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);
+            groupMap[groupName].children.push(omit(item, ['definitionName', 'definitionTitle']));
         }
-    };
-}), withHooks((store, menuProviderService = inject(AXPMenuProviderService)) => ({
-    onInit() {
-        (async () => {
-            const items = await menuProviderService.items();
-            patchState(store, { items: items });
-        })();
-    },
-    onDestroy() {
-    },
-})));
-
-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 }); }
+        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: AXPFooterTextSlotComponent, decorators: [{
-            type: Component,
-            args: [{
-                    template: `
-      <small class="ax-text-sm" [innerHTML]="text"></small>
-    `,
-                    standalone: true
-                }]
-        }], propDecorators: { text: [{
-                type: Input
-            }] } });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPSearchService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
 
-class AXPNavBarSlotComponent {
+var AXPSettingScope;
+(function (AXPSettingScope) {
+    AXPSettingScope["Environment"] = "C";
+    AXPSettingScope["Global"] = "G";
+    AXPSettingScope["Tenant"] = "T";
+    AXPSettingScope["User"] = "U";
+})(AXPSettingScope || (AXPSettingScope = {}));
+;
+
+class AXPSettingDefinitionProviderContext {
     constructor() {
-        this.store = inject(Store);
+        this.rootGroups = [];
+        this.groupMap = new Map();
     }
-    handleCommand(action) {
-        if (action)
-            this.store.dispatch(action);
+    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) {
+        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 ?? 'G',
+            widget: {
+                type: setting.widget.type,
+                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;
     }
-    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$1.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 AXPSchemaRegistryService {
+// Injection token for setting providers
+const AXP_SETTING_DEFINITION_PROVIDER = new InjectionToken('AXP_SETTING_DEFINITION_PROVIDER');
+class AXPSettingDefinitionProviderService {
     constructor() {
-        this.types = new Map();
+        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);
     }
-    register(schema) {
-        this.types.set(schema.name, schema);
+    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;
     }
-    extend(parentName, schema) {
-        const parentSchema = this.resolve(parentName);
-        const newSchema = merge({}, parentSchema, schema);
-        newSchema.name = schema.name;
-        this.register(newSchema);
+    findGroup(scope, groupName) {
+        return this.searchRecursive(this.getList(scope), groupName, []); // Initialize with an empty breadcrumb
     }
-    resolve(name) {
-        const schema = this.types.get(name);
-        if (!schema) {
-            throw new Error(`Parent schema with name ${schema} does not exist.`);
+    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;
+            }
         }
-        return schema;
+        // 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: AXPSchemaRegistryService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPSchemaRegistryService, providedIn: 'root' }); }
+    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: AXPSchemaRegistryService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPSettingDefinitionProviderService, decorators: [{
             type: Injectable,
-            args: [{
-                    providedIn: 'root',
-                }]
+            args: [{ providedIn: 'root' }]
         }] });
-
-const AXP_WIDGET_TOKEN = new InjectionToken('AXP_WIDGET_TOKEN');
-
-class AXPWidgetColumnRendererComponent extends AXDataTableColumnComponent {
+class AXPSettingDefaultValueProvider {
     constructor() {
-        super(...arguments);
-        this.widgetRegistery = inject(AXPSchemaRegistryService);
-        this.mergedOptions = {};
-        this.injector = inject(Injector);
-        this.cdr = inject(ChangeDetectorRef);
+        this.definitionProvider = inject(AXPSettingDefinitionProviderService);
+    }
+    get scope() {
+        return AXPSettingScope.Global;
     }
-    get renderFooterTemplate() {
-        return this.footerTemplate ?? this._contentFooterTemplate;
+    async load() {
+        return Object.entries(await this.definitionProvider.defaultValues()).map(c => ({ key: c[0], value: c[1] }));
     }
-    get renderCellTemplate() {
-        return this.cellTemplate ?? this._contentCellTemplate;
+    set(key, value) {
+        throw new Error('Method not implemented.');
     }
-    get renderHeaderTemplate() {
-        return this.headerTemplate ?? this._contentHeaderTemplate;
+}
+
+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)
+        ];
     }
-    get loadingEnabled() {
-        return true;
+});
+class AXPSettingValueProviderDefault {
+    get scope() {
+        return this._scope;
     }
-    get name() {
-        return `col-${this.dataField}`;
+    constructor(_scope) {
+        this._scope = _scope;
+        this.cache = new Map();
+        this.localStorageKey = `AXP_SETTINGS_SCOPE(${this.scope})`;
     }
-    get schemaName() {
-        return this._schemaName;
+    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([]);
     }
-    set schemaName(v) {
-        this._schemaName = v;
+    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 ngOnInit() {
-        const schema = this.widgetRegistery.resolve(this.schemaName);
-        if (schema?.component?.column)
-            this.component = await schema?.component?.column.component();
-        this.mergedOptions = merge(cloneDeep(schema?.component.column?.options), this.options) || {};
-        const tokenValue = {
-            prop: {
-                name: this.dataField,
-                formats: { default: this.displayFormat },
-            },
-            schema: schema,
-        };
-        this.widgetInjector = Injector.create({
-            parent: this.injector,
-            providers: [
-                {
-                    provide: AXP_WIDGET_TOKEN,
-                    useValue: tokenValue,
-                },
-            ],
+    async saveToLocalStorage() {
+        const settingsObject = {};
+        this.cache.forEach((value, key) => {
+            settingsObject[key] = value;
         });
-        this.width = this.mergedOptions.width ?? '200px';
-        this.allowResizing = this.mergedOptions.allowResizing || false;
-        this.cdr.markForCheck();
-    }
-    getInputs(data) {
-        return assign(this.mergedOptions, { context: data });
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPWidgetColumnRendererComponent, deps: null, target: i0.ɵɵFactoryTarget.Component }); }
-    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "19.0.3", type: AXPWidgetColumnRendererComponent, isStandalone: false, selector: "axp-widget-column-renderer", inputs: { width: "width", caption: "caption", headerTemplate: "headerTemplate", allowSorting: "allowSorting", fixed: "fixed", footerTemplate: "footerTemplate", cellTemplate: "cellTemplate", options: "options", dataField: "dataField", displayFormat: "displayFormat", schemaName: ["schema", "schemaName"] }, providers: [{ provide: AXDataTableColumnComponent, useExisting: AXPWidgetColumnRendererComponent }], viewQueries: [{ propertyName: "_contentFooterTemplate", first: true, predicate: ["footer"], descendants: true }, { propertyName: "_contentCellTemplate", first: true, predicate: ["cell"], descendants: true }, { propertyName: "_contentHeaderTemplate", first: true, predicate: ["header"], descendants: true }], usesInheritance: true, ngImport: i0, template: `
-    <ng-template #header>{{ caption }}</ng-template>
-    <ng-template #cell let-row>
-      @if(component && widgetInjector && row?.data) {
-      <ng-container *ngComponentOutlet="component; injector: widgetInjector; inputs: getInputs(row.data)"></ng-container>
-      }
-    </ng-template>
-    <ng-template #footer></ng-template>
-  `, isInline: true, dependencies: [{ kind: "directive", type: i1$1.NgComponentOutlet, selector: "[ngComponentOutlet]", inputs: ["ngComponentOutlet", "ngComponentOutletInputs", "ngComponentOutletInjector", "ngComponentOutletContent", "ngComponentOutletNgModule", "ngComponentOutletNgModuleFactory"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+        localStorage.setItem(this.localStorageKey, JSON.stringify(settingsObject));
+    }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPWidgetColumnRendererComponent, decorators: [{
-            type: Component,
-            args: [{
-                    selector: 'axp-widget-column-renderer',
-                    template: `
-    <ng-template #header>{{ caption }}</ng-template>
-    <ng-template #cell let-row>
-      @if(component && widgetInjector && row?.data) {
-      <ng-container *ngComponentOutlet="component; injector: widgetInjector; inputs: getInputs(row.data)"></ng-container>
-      }
-    </ng-template>
-    <ng-template #footer></ng-template>
-  `,
-                    providers: [{ provide: AXDataTableColumnComponent, useExisting: AXPWidgetColumnRendererComponent }],
-                    changeDetection: ChangeDetectionStrategy.OnPush,
-                    inputs: ['width', 'caption', 'headerTemplate', 'allowSorting', 'fixed'],
-                    standalone: false
-                }]
-        }], propDecorators: { footerTemplate: [{
-                type: Input
-            }], _contentFooterTemplate: [{
-                type: ViewChild,
-                args: ['footer']
-            }], cellTemplate: [{
-                type: Input
-            }], _contentCellTemplate: [{
-                type: ViewChild,
-                args: ['cell']
-            }], headerTemplate: [{
-                type: Input
-            }], _contentHeaderTemplate: [{
-                type: ViewChild,
-                args: ['header']
-            }], options: [{
-                type: Input
-            }], dataField: [{
-                type: Input
-            }], displayFormat: [{
-                type: Input
-            }], schemaName: [{
-                type: Input,
-                args: ['schema']
-            }] } });
 
-class AXPWidgetFilterRendererComponent {
+class AXPSettingValueProviderService {
     constructor() {
-        this.widgetRegistery = inject(AXPSchemaRegistryService);
-        this.isLoading = true;
-        this.valueChange = new EventEmitter();
-        this.operatorChange = new EventEmitter();
-        this.injector = inject(Injector);
-        this.cdr = inject(ChangeDetectorRef);
-        this.options = {};
-    }
-    get value() {
-        return this._value;
-    }
-    set value(v) {
-        this._value = v;
-        this.updateValue();
-        this.valueChange.emit(v);
-    }
-    get operator() {
-        return this._operator;
-    }
-    set operator(op) {
-        this._operator = op;
-        this.updateOperator();
-        this.operatorChange.emit(op);
-    }
-    get schemaName() {
-        return this._schemaName;
-    }
-    set schemaName(v) {
-        this._schemaName = v;
-        setTimeout(async () => {
-            await this.render();
+        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 render() {
-        const schema = this.widgetRegistery.resolve(this.schemaName);
-        this.options =
-            merge(cloneDeep(this.prop?.component?.common?.options), cloneDeep(this.prop?.component?.filter?.options), schema?.component?.filter?.options) || {};
-        const tokenValue = {
-            prop: this.prop,
-            schema: schema,
-        };
-        const token = Injector.create({
-            parent: this.injector,
-            providers: [
-                {
-                    provide: AXP_WIDGET_TOKEN,
-                    useValue: tokenValue,
-                },
-            ],
-        });
-        if (schema?.component && schema.component.filter?.component) {
-            var com = await schema.component.filter?.component();
-            this.portal = new ComponentPortal(com, null, token);
-            this.isLoading = false;
-            this.cdr.markForCheck();
+    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;
         }
-    }
-    updateValue() {
-        if (this.instance) {
-            this.instance.value = this.value;
+        catch (error) {
+            console.error('Error loading settings', error);
+            throw error;
         }
     }
-    updateOperator() {
-        if (this.instance) {
-            this.instance.operator = this.operator;
+    async get(key) {
+        if (this.scopedSettingsCache.size === 0) {
+            await this.load();
         }
-    }
-    handleAttached(portalOutletRef) {
-        portalOutletRef = portalOutletRef;
-        this.instance = portalOutletRef.instance;
-        // console.log(this.schemaName, this.instance);
-        assign(this.instance, this.options);
-        this.updateValue();
-        this.updateOperator();
-        this.instance.valueChange.subscribe((v) => {
-            if (!isEqual(v, this.value)) {
-                this.value = v;
+        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);
+                }
             }
-        });
-        this.instance.operatorChange.subscribe((op) => {
-            if (!isEqual(op, this.operator)) {
-                this.operator = op;
+        }
+        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 };
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPWidgetFilterRendererComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
-    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "19.0.3", type: AXPWidgetFilterRendererComponent, isStandalone: false, selector: "axp-widget-filter-renderer", inputs: { value: "value", operator: "operator", prop: "prop", schemaName: ["schema", "schemaName"] }, outputs: { valueChange: "valueChange", operatorChange: "operatorChange" }, host: { styleAttribute: "display: contents;" }, ngImport: i0, template: `
-    @if(isLoading){
-    <ax-skeleton [animated]="true" class="ax-w-full ax-h-8 ax-rounded"></ax-skeleton>
-    } @else {
-    <ng-template [cdkPortalOutlet]="portal" (attached)="handleAttached($event)"></ng-template>
+    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));
     }
-  `, isInline: true, dependencies: [{ kind: "directive", type: i1$2.CdkPortalOutlet, selector: "[cdkPortalOutlet]", inputs: ["cdkPortalOutlet"], outputs: ["attached"], exportAs: ["cdkPortalOutlet"] }, { kind: "component", type: i2$2.AXSkeletonComponent, selector: "ax-skeleton", inputs: ["animated"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+    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: AXPWidgetFilterRendererComponent, decorators: [{
-            type: Component,
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPSettingValueProviderService, decorators: [{
+            type: Injectable,
             args: [{
-                    selector: 'axp-widget-filter-renderer',
-                    template: `
-    @if(isLoading){
-    <ax-skeleton [animated]="true" class="ax-w-full ax-h-8 ax-rounded"></ax-skeleton>
-    } @else {
-    <ng-template [cdkPortalOutlet]="portal" (attached)="handleAttached($event)"></ng-template>
-    }
-  `,
-                    changeDetection: ChangeDetectionStrategy.OnPush,
-                    host: { style: 'display: contents;' },
-                    standalone: false
-                }]
-        }], propDecorators: { valueChange: [{
-                type: Output
-            }], operatorChange: [{
-                type: Output
-            }], value: [{
-                type: Input
-            }], operator: [{
-                type: Input
-            }], prop: [{
-                type: Input
-            }], schemaName: [{
-                type: Input,
-                args: ['schema']
-            }] } });
-
-class AXPWidgetBase {
-    constructor() {
-        this.cdr = inject(ChangeDetectorRef);
-        this.token = inject(AXP_WIDGET_TOKEN);
-        this.formatService = inject(AXFormatService);
-        this.markForCheck = inject(ChangeDetectorRef).markForCheck;
-    }
-    get schema() {
-        return this.token.schema;
-    }
-    get prop() {
-        return this.token.prop;
-    }
-    get rawValue() {
-        return get(this.context, this.token.prop.name);
-    }
-    //   protected get multiple(): boolean {
-    //     return this.token.prop.multiple ?? false;
-    //   }
-    get formats() {
-        return merge(cloneDeep(this.schema.formats), this.token.prop.formats);
-    }
-    get context() {
-        return this._context;
-    }
-    set context(v) {
-        this._context = v;
-        this.render();
-        this.cdr.markForCheck();
-    }
-    render() { }
-    setOption(name, value) {
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPWidgetBase, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPWidgetBase }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPWidgetBase, decorators: [{
-            type: Injectable
-        }], propDecorators: { context: [{
-                type: Input
-            }] } });
-class AXPWidgetEditBase extends AXPWidgetBase {
-    constructor() {
-        super(...arguments);
-        this.valueChange = new EventEmitter();
-    }
-    get value() {
-        return this._value;
-    }
-    set value(v) {
-        this._value = v;
-        this.valueChange.emit(v);
-        this.render();
-        this.cdr.markForCheck();
-    }
-    get validations() {
-        const merged = [...(this.schema.validationRules ?? []), ...(this.token.prop.validationRules ?? [])];
-        return merged;
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPWidgetEditBase, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPWidgetEditBase }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPWidgetEditBase, decorators: [{
-            type: Injectable
-        }], propDecorators: { valueChange: [{
-                type: Output
-            }], value: [{
-                type: Input
-            }] } });
-class AXPWidgetFilterBase extends AXPWidgetBase {
-    constructor() {
-        super(...arguments);
-        this.operatorChange = new EventEmitter();
-        this.valueChange = new EventEmitter();
-    }
-    get operator() {
-        return this._operator;
-    }
-    set operator(op) {
-        this._operator = op;
-        this.operatorChange.emit(op);
-        this.render();
-        this.cdr.markForCheck();
-    }
-    get value() {
-        return this._value;
-    }
-    set value(v) {
-        this._value = v;
-        this.valueChange.emit(v);
-        this.render();
-        this.cdr.markForCheck();
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPWidgetFilterBase, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPWidgetFilterBase }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPWidgetFilterBase, decorators: [{
-            type: Injectable
-        }], propDecorators: { operatorChange: [{
-                type: Output
-            }], operator: [{
-                type: Input
-            }], valueChange: [{
-                type: Output
-            }], value: [{
-                type: Input
-            }] } });
-
-class AXPWidgetRendererComponent {
-    constructor() {
-        this.widgetRegistery = inject(AXPSchemaRegistryService);
-        this.subscriber = inject(AXUnsubscriber);
-        this.mode = 'view';
-        this.isLoading = true;
-        this.injector = inject(Injector);
-        this.cdr = inject(ChangeDetectorRef);
-        this.options = {};
-    }
-    get context() {
-        return this._context;
-    }
-    set context(v) {
-        this._context = v;
-        if (this.instance) {
-            this.instance.context = v;
-        }
-        this.updateValue();
-    }
-    get schemaName() {
-        return this._schemaName;
-    }
-    set schemaName(v) {
-        this._schemaName = v;
-        setTimeout(async () => {
-            //TODO: move to better place
-            await this.render();
-        });
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [] });
+class ScopedSettingService {
+    constructor(parent, provider, onChanged, scopeCache) {
+        this.parent = parent;
+        this.provider = provider;
+        this.onChanged = onChanged;
+        this.scopeCache = scopeCache;
     }
-    async render() {
-        const schema = this.widgetRegistery.resolve(this.schemaName);
-        this.options =
-            merge(cloneDeep(this.prop?.component?.common?.options), cloneDeep(this.prop?.component?.[this.mode]?.options), schema?.component?.[this.mode]?.options) || {};
-        const tokenValue = {
-            prop: this.prop,
-            schema: schema,
-        };
-        const token = Injector.create({
-            parent: this.injector,
-            providers: [
-                {
-                    provide: AXP_WIDGET_TOKEN,
-                    useValue: tokenValue,
-                },
-            ],
-        });
-        if (schema?.component && schema.component[this.mode]?.component) {
-            var com = await schema.component[this.mode]?.component();
-            this.portal = new ComponentPortal(com, null, token);
-            this.isLoading = false;
-            this.cdr.markForCheck();
-        }
+    async get(key) {
+        const settings = await this.provider.load();
+        const setting = settings.find((s) => s.key === key);
+        return setting ? cloneDeep(setting.value) : undefined;
     }
-    updateValue() {
-        if (this.instance && this.context && this.instance instanceof AXPWidgetEditBase) {
-            this.instance.value = get(this.context, this.prop.name);
-        }
+    async all() {
+        const settings = await this.provider.load();
+        return Object.fromEntries(settings.map((s) => [s.key, cloneDeep(s.value)]));
     }
-    updateProps() {
-        if (this.instance) {
-            assign(this.instance, this.options);
-        }
+    async defaultValues() {
+        return this.parent.defaultValues(this.provider.scope);
     }
-    attachReferenceField(v) {
-        if (this.options['reference']) {
-            const valueField = this.prop.component?.common?.options?.valueField || 'id';
-            const referenceField = this.options['referenceField'];
-            if (referenceField) {
-                if (Array.isArray(v)) {
-                    this.context[referenceField] = v.map((item) => item[valueField]);
-                }
-                else {
-                    this.context[referenceField] = v?.[valueField];
-                }
-            }
-            else {
-                this.context[`${this.prop.name}Id`] = v?.[valueField];
-            }
+    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 }],
+            });
         }
-    }
-    handleAttached(portalOutletRef) {
-        portalOutletRef = portalOutletRef;
-        this.instance = portalOutletRef.instance;
-        this.instance.context = this.context;
-        this.updateProps();
-        this.updateValue();
-        if (this.instance instanceof AXPWidgetEditBase) {
-            this.attachReferenceField(this.instance.value);
-            this.instance.valueChange.pipe(this.subscriber.takeUntilDestroy).subscribe((v) => {
-                this.attachReferenceField(v);
-                set(this.context, this.prop.name, v);
+        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,
             });
         }
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPWidgetRendererComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
-    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "19.0.3", type: AXPWidgetRendererComponent, isStandalone: false, selector: "axp-widget-renderer", inputs: { context: "context", prop: "prop", mode: "mode", schemaName: ["schema", "schemaName"] }, host: { styleAttribute: "display: contents;" }, providers: [
+}
+
+class AXPSettingSearchDefinitionProvider {
+    async provide(context) {
+        context.addDefinition('setting', 'Setting', 'fa-solid fa-gear', [
             {
-                provide: AXUnsubscriber,
+                name: 'open',
+                command: {
+                    name: 'view',
+                    options: {},
+                },
+                type: 'view',
+                priority: 'primary',
             },
-        ], ngImport: i0, template: `
-    @if(isLoading){
-    <ax-skeleton [animated]="true" class="ax-w-full  lg:ax-w-[50%] ax-h-8 ax-rounded"></ax-skeleton>
-    } @else {
-    <ng-template [cdkPortalOutlet]="portal" (attached)="handleAttached($event)"></ng-template>
+        ]);
     }
-  `, isInline: true, dependencies: [{ kind: "directive", type: i1$2.CdkPortalOutlet, selector: "[cdkPortalOutlet]", inputs: ["cdkPortalOutlet"], outputs: ["attached"], exportAs: ["cdkPortalOutlet"] }, { kind: "component", type: i2$2.AXSkeletonComponent, selector: "ax-skeleton", inputs: ["animated"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPWidgetRendererComponent, decorators: [{
-            type: Component,
-            args: [{
-                    selector: 'axp-widget-renderer',
-                    template: `
-    @if(isLoading){
-    <ax-skeleton [animated]="true" class="ax-w-full  lg:ax-w-[50%] ax-h-8 ax-rounded"></ax-skeleton>
-    } @else {
-    <ng-template [cdkPortalOutlet]="portal" (attached)="handleAttached($event)"></ng-template>
-    }
-  `,
-                    changeDetection: ChangeDetectionStrategy.OnPush,
-                    host: { style: 'display: contents;' },
-                    providers: [
-                        {
-                            provide: AXUnsubscriber,
-                        },
-                    ],
-                    standalone: false
-                }]
-        }], propDecorators: { context: [{
-                type: Input
-            }], prop: [{
-                type: Input
-            }], mode: [{
-                type: Input
-            }], schemaName: [{
-                type: Input,
-                args: ['schema']
-            }] } });
-
-class AXPSchemaModule {
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPSchemaModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
-    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "19.0.3", ngImport: i0, type: AXPSchemaModule, declarations: [AXPWidgetRendererComponent, AXPWidgetColumnRendererComponent, AXPWidgetFilterRendererComponent], imports: [PortalModule, AXSkeletonModule, CommonModule], exports: [AXPWidgetRendererComponent, AXPWidgetFilterRendererComponent, AXPWidgetColumnRendererComponent] }); }
-    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPSchemaModule, imports: [PortalModule, AXSkeletonModule, CommonModule] }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPSchemaModule, decorators: [{
-            type: NgModule,
-            args: [{
-                    imports: [PortalModule, AXSkeletonModule, CommonModule],
-                    exports: [AXPWidgetRendererComponent, AXPWidgetFilterRendererComponent, AXPWidgetColumnRendererComponent],
-                    declarations: [AXPWidgetRendererComponent, AXPWidgetColumnRendererComponent, AXPWidgetFilterRendererComponent],
-                    providers: [],
-                }]
-        }] });
-
-const AXPEntityListViewConfigEmpty = {
-    fixed: false,
-    columns: [],
-    conditions: [],
-    sorts: [],
-    name: 'empty',
-    title: 'Empty',
-};
-function convertPropertyToColumn(property) {
-    return {
-        //TODO: merge format function
-        schema: property.schema,
-        name: property.name,
-        title: property.title,
-        visible: true,
-        displayFormat: property.formats?.list ?? property.formats?.default,
-        sortOptions: {
-            enabled: property.canSort,
-            property: property.name,
-        },
-        filterOptions: {
-            enabled: property.canFilter,
-            property: property.name,
-        },
-        options: merge(cloneDeep(property.component?.common?.options), property.component?.column?.options),
-    };
-}
-function convertPropertiesToColumns(...propertis) {
-    return propertis.map((p) => convertPropertyToColumn(p));
 }
 
-class AXEntityLoaderDefault {
-    async get(moduleName, entityName) {
-        return null;
+class AXPSettingSearchProvider {
+    constructor() {
+        this.settingService = inject(AXPSettingDefinitionProviderService);
+    }
+    async search(text) {
+        const groupsSetting = this.settingService.getList(AXPSettingScope.User);
+        if (groupsSetting.length == 0) {
+            groupsSetting.push(...(await this.settingService.getListAsync(AXPSettingScope.User)));
+        }
+        // Step 2: Flatten settings from groups
+        const allSettings = [];
+        const extractSettings = (group) => {
+            for (const section of group.sections) {
+                allSettings.push(...section.settings.map((x) => ({ ...x, group })));
+            }
+            for (const subGroup of group.groups) {
+                extractSettings(subGroup); // Recursive extraction
+            }
+        };
+        for (const group of groupsSetting) {
+            extractSettings(group);
+        }
+        // Step 3: Search settings by title
+        const searchResults = allSettings.filter((setting) => setting.title.toLowerCase().includes(text.toLowerCase()));
+        return sortBy(searchResults.map((setting) => ({
+            title: setting.title,
+            description: setting.description,
+            name: 'setting',
+            data: setting,
+            parent: setting.group
+                ? {
+                    title: setting.group.title,
+                    data: setting.group,
+                }
+                : undefined,
+        })), ['title']);
     }
 }
-const AXP_ENTITY_LOADER = new InjectionToken('AXP_ENTITY_LOADER', {
-    providedIn: 'root',
-    factory: () => {
-        return new AXEntityLoaderDefault();
-    },
-});
 
-class AXPEntityRegistryService {
+//TODO Loading, Redirect, Drawer, Show toast
+const AXPRedirectEvent = createWorkFlowEvent('Redirect Event Fired');
+const AXPRefreshEvent = createWorkFlowEvent('Refresh Event Fired');
+class AXPWorkflowNavigateAction extends AXPWorkflowAction {
     constructor() {
-        // Stores AXPEntityConfig objects, keyed by a combination of module and entity name.
-        this.entities = new Map();
-        // Entity loader service for dynamically loading entity configurations.
-        this.loader = inject(AXP_ENTITY_LOADER); // Assuming AXPEntityLoader is the correct type
-    }
-    /**
-     * Registers a new entity configuration. Entities are identified uniquely by a combination
-     * of their module and name.
-     *
-     * @param config The configuration object of the entity to be registered.
-     */
-    register(config) {
-        const key = this.createEntityKey(config.module, config.name);
-        this.entities.set(key, config);
+        super(...arguments);
+        this.router = inject(Router);
     }
-    /**
-     * Resolves an entity configuration based on module and entity name. If the configuration
-     * is not already registered, attempts to load it dynamically. Throws an error if the
-     * entity cannot be found or loaded.
-     *
-     * @param moduleName The module name of the entity.
-     * @param entityName The name of the entity.
-     * @returns A promise resolving to the entity configuration.
-     * @throws Error if the entity configuration cannot be resolved.
-     */
-    async resolve(moduleName, entityName) {
-        const key = this.createEntityKey(moduleName, entityName);
-        let config = this.entities.get(key) ?? null;
-        if (!config) {
-            try {
-                config = await this.loader.get(moduleName, entityName);
-                if (config) {
-                    this.register(config);
-                }
-            }
-            catch (error) {
-                console.error(`Error loading entity '${key}':`, error);
-                throw error; // Rethrow to allow error handling by caller
-            }
-            if (!config) {
-                throw new Error(`Invalid entity name: ${key}`);
+    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);
         }
-        return config;
     }
-    /**
-     * Creates a unique key for an entity based on its module and name.
-     *
-     * @param moduleName The module name of the entity.
-     * @param entityName The name of the entity.
-     * @returns The unique key for the entity.
-     */
-    createEntityKey(moduleName, entityName) {
-        return `${moduleName}.${entityName}`;
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPWorkflowNavigateAction, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPWorkflowNavigateAction }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPWorkflowNavigateAction, decorators: [{
+            type: Injectable
+        }] });
+class AXPDialogConfirmAction extends AXPWorkflowAction {
+    constructor() {
+        super(...arguments);
+        this.dialogService = inject(AXDialogService);
+        this.translationService = inject(AXTranslationService);
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPEntityRegistryService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPEntityRegistryService, providedIn: 'root' }); }
+    async execute(context) {
+        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)));
+        context.setOutput('result', dialogResult.result);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPDialogConfirmAction, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPDialogConfirmAction }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPEntityRegistryService, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: 'root',
-                }]
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPDialogConfirmAction, decorators: [{
+            type: Injectable
         }] });
-
-const widgetSchemas = {
-    //*Sharing schema list with other modules
-    text: 'text',
-    largetext: 'largetext',
-    number: 'number',
-    currency: 'currency',
-    phone: 'phone',
-    email: 'email',
-    dateTime: 'dateTime',
-    date: 'date',
-    time: 'time',
-    toggle: 'toggle',
-    checkbox: 'checkbox',
-    password: 'password',
-    file: 'file',
-    lookup: 'lookup',
-    selectionList: 'selection-list',
-    richText: 'rich-text',
-    map: 'map',
-    avatar: 'avatar',
-    messenger: 'messenger',
-    gallery: 'gallery',
-    signaturePad: 'signature-pad',
-};
-class AXPCommonWidgetModule {
-    constructor(service) {
-        //text
-        service.register({
-            component: {
-                view: {
-                    component: () => import('./acorex-platform-common-text-widget-view.component-BH0LTD80.mjs').then((c) => c.AXPTextWidgetViewComponent),
-                },
-                filter: {
-                    component: () => import('./acorex-platform-common-string-widget-filter.component-CDssxMLR.mjs').then((c) => c.AXPStringWidgetFilterComponent),
-                },
-                edit: {
-                    component: () => import('./acorex-platform-common-text-widget-edit.component-5koh5Aws.mjs').then((c) => c.AXPTextWidgetEditComponent),
-                },
-                column: {
-                    component: () => import('./acorex-platform-common-text-widget-column.component-7yp4qqIb.mjs').then((c) => c.AXPTextWidgetColumnComponent),
-                    options: { allowResizing: true },
-                },
-            },
-            filterOptions: {
-                operators: [...STRING_OPERATORS],
-                default: EQ_OPER,
-            },
-            name: widgetSchemas.text,
-            dataType: 'string',
-        });
-        service.extend('text', {
-            name: widgetSchemas.largetext,
-            component: {
-                edit: {
-                    component: () => import('./acorex-platform-common-largetext-widget-edit.component-BYMIaLCI.mjs').then((c) => c.AXPLargeTextWidgetEditComponent),
-                },
-                column: {
-                    options: {
-                        width: '400px',
-                    },
-                },
-            },
-        });
-        //
-        service.register({
-            component: {
-                view: {
-                    component: () => import('./acorex-platform-common-number-widget-view.component-L2pxAqqz.mjs').then((c) => c.AXPNumberWidgetViewComponent),
-                },
-                filter: {
-                    component: () => import('./acorex-platform-common-number-widget-filter.component-womVAhSr.mjs').then((c) => c.AXPNumberWidgetFilterComponent),
-                },
-                edit: {
-                    component: () => import('./acorex-platform-common-number-widget-edit.component-DZf-n-yr.mjs').then((c) => c.AXPNumberWidgetEditComponent),
-                },
-                column: {
-                    component: () => import('./acorex-platform-common-number-widget-view.component-L2pxAqqz.mjs').then((c) => c.AXPNumberWidgetViewComponent),
-                    options: { allowResizing: true },
-                },
-            },
-            name: widgetSchemas.number,
-            filterOptions: {
-                operators: [...NUMBER_OPERATORS],
-                default: BETWEEN_OPER,
-            },
-            dataType: 'number',
-        });
-        service.extend('number', {
-            name: widgetSchemas.currency,
-            formats: {
-                default: 'EN-GB',
-            },
-            component: {
-                edit: {
-                    options: {
-                        clearButton: false,
-                    },
-                },
-            },
-        });
-        //phone
-        service.register({
-            component: {
-                view: {
-                    component: () => import('./acorex-platform-common-phone-widget-view.component-B1Xu_rxC.mjs').then((c) => c.AXPPhoneWidgetViewComponent),
-                },
-                column: {
-                    component: () => import('./acorex-platform-common-phone-widget-column.component-79Me_VNP.mjs').then((c) => c.AXPPhoneWidgetColumnComponent),
-                    options: { allowResizing: true },
-                },
-                edit: {
-                    component: () => import('./acorex-platform-common-phone-widget-edit.component-CIayMoT1.mjs').then((c) => c.AXPPhoneWidgetEditComponent),
-                },
-                filter: {
-                    component: () => import('./acorex-platform-common-string-widget-filter.component-CDssxMLR.mjs').then((c) => c.AXPStringWidgetFilterComponent),
-                },
-            },
-            name: widgetSchemas.phone,
-            filterOptions: {
-                operators: [...STRING_OPERATORS],
-                default: EQ_OPER,
-            },
-            dataType: 'object',
-        });
-        //email
-        service.register({
-            component: {
-                view: {
-                    component: () => import('./acorex-platform-common-email-widget-view.component-dMByK5bc.mjs').then((c) => c.AXPEmailWidgetViewComponent),
-                },
-                edit: {
-                    component: () => import('./acorex-platform-common-email-widget-edit.component-aLPGOG3r.mjs').then((c) => c.AXPEmailWidgetEditComponent),
-                },
-                filter: {
-                    component: () => import('./acorex-platform-common-string-widget-filter.component-CDssxMLR.mjs').then((c) => c.AXPStringWidgetFilterComponent),
-                },
-                column: {
-                    component: () => import('./acorex-platform-common-email-widget-column.component-BPoSZTqM.mjs').then((c) => c.AXPEmailWidgetColumnComponent),
-                    options: { allowResizing: true },
-                },
-            },
-            name: widgetSchemas.email,
-            filterOptions: {
-                operators: [...STRING_OPERATORS],
-                default: EQ_OPER,
-            },
-            dataType: 'object',
-        });
-        // dateTime
-        service.register({
-            component: {
-                view: {
-                    component: () => import('./acorex-platform-common-dateTime-widget-view.component-C7hmUXLz.mjs').then((c) => c.AXPDateTimeWidgetViewComponent),
-                },
-                edit: {
-                    component: () => import('./acorex-platform-common-dateTime-widget-edit.component-B50J-bwp.mjs').then((c) => c.AXPDateTimeWidgetEditComponent),
-                },
-                filter: {
-                    component: () => import('./acorex-platform-common-dateTime-widget-filter.component-CTV2a3c0.mjs').then((c) => c.AXPDateTimeWidgetFilterComponent),
-                },
-                column: {
-                    component: () => import('./acorex-platform-common-dateTime-widget-column.component-CKaMC189.mjs').then((c) => c.AXPDateTimeWidgetColumnComponent),
-                    options: {
-                        width: '200px',
-                        allowResizing: true,
-                    },
-                },
-            },
-            formats: {
-                default: 'date',
-            },
-            filterOptions: {
-                operators: [...DATE_OPERATORS],
-                default: BETWEEN_OPER,
-            },
-            name: widgetSchemas.dateTime,
-            dataType: 'date',
-        });
-        service.extend(widgetSchemas.dateTime, {
-            name: widgetSchemas.date,
-            formats: {
-                default: 'date',
-            },
-            component: {
-                column: {
-                    options: {
-                        width: '120px',
-                    },
-                },
-            },
-        });
-        service.extend(widgetSchemas.dateTime, {
-            name: widgetSchemas.time,
-            formats: {
-                default: 'time',
-            },
-            component: {
-                column: {
-                    options: {
-                        width: '80px',
-                    },
-                },
-            },
-        });
-        //toggle
-        service.register({
-            component: {
-                view: {
-                    component: () => import('./acorex-platform-common-toggle-widget-view.component-DguoIz_c.mjs').then((c) => c.AXPToggleWidgetViewComponent),
-                },
-                edit: {
-                    component: () => import('./acorex-platform-common-toggle-widget-edit.component-JOnGMn-9.mjs').then((c) => c.AXPToggleWidgetEditComponent),
-                },
-                filter: {
-                    component: () => import('./acorex-platform-common-boolean-widget-filter.component-aaKT0FyC.mjs').then((c) => c.AXPBooleanWidgetFilterComponent),
-                },
-                column: {
-                    component: () => import('./acorex-platform-common-toggle-widget-column.component-C5dMjerm.mjs').then((c) => c.AXPToggleWidgetColumnComponent),
-                    options: {
-                        width: '100px',
-                        allowResizing: true,
-                    },
-                },
-            },
-            filterOptions: {
-                operators: [],
-                default: EQ_OPER,
-            },
-            name: widgetSchemas.toggle,
-            dataType: 'boolean',
-        });
-        //checkbox
-        service.register({
-            component: {
-                view: {
-                    component: () => import('./acorex-platform-common-checkbox-widget-view.component-3XLnJx9A.mjs').then((c) => c.AXPCheckboxWidgetViewComponent),
-                },
-                edit: {
-                    component: () => import('./acorex-platform-common-checkbox-widget-edit.component-CNmYVpMu.mjs').then((c) => c.AXPCheckboxWidgetEditComponent),
-                },
-                filter: {
-                    component: () => import('./acorex-platform-common-boolean-widget-filter.component-aaKT0FyC.mjs').then((c) => c.AXPBooleanWidgetFilterComponent),
-                },
-                column: {
-                    component: () => import('./acorex-platform-common-checkbox-widget-column.component-DZxykkVr.mjs').then((c) => c.AXPCheckboxWidgetColumnComponent),
-                    options: {
-                        width: '100px',
-                        allowResizing: true,
-                    },
-                },
-            },
-            filterOptions: {
-                operators: [],
-                default: EQ_OPER,
-            },
-            name: widgetSchemas.checkbox,
-            dataType: 'boolean',
-        });
-        //password
-        service.register({
-            component: {
-                view: {
-                    component: () => import('./acorex-platform-common-password-widget-view.component-BuFoE2fz.mjs').then((c) => c.AXPPasswordWidgetViewComponent),
-                },
-                column: {
-                    component: () => import('./acorex-platform-common-password-widget-column.component-3ubqJk-d.mjs').then((c) => c.AXPPasswordWidgetColumnComponent),
-                    options: {
-                        allowResizing: true,
-                    },
-                },
-                edit: {
-                    component: () => import('./acorex-platform-common-password-widget-edit.component-BokyEDfK.mjs').then((c) => c.AXPPasswordWidgetEditComponent),
-                },
-            },
-            filterOptions: {
-                operators: [],
-                default: EQ_OPER,
-            },
-            name: widgetSchemas.password,
-            dataType: 'string',
-        });
-        //file
-        service.register({
-            component: {
-                view: {
-                    component: () => import('./acorex-platform-common-file-widget-view.component-T3r6musY.mjs').then((c) => c.AXPFileWidgetViewComponent),
-                },
-                column: {
-                    component: () => import('./acorex-platform-common-file-widget-column.component-Dafc2zLc.mjs').then((c) => c.AXPFileWidgetColumnComponent),
-                    options: {
-                        allowResizing: true,
-                    },
-                },
-                edit: {
-                    component: () => import('./acorex-platform-common-file-widget-edit.component-C31kfJSw.mjs').then((c) => c.AXPFileWidgetEditComponent),
-                },
-                filter: {
-                    component: () => import('./acorex-platform-common-file-widget-filter.component-BNCcBun4.mjs').then((c) => c.AXPFileWidgetFilterComponent),
-                },
-            },
-            filterOptions: {
-                operators: [],
-                default: EQ_OPER,
-            },
-            name: widgetSchemas.file,
-            dataType: 'object',
+class AXPToastAction extends AXPWorkflowAction {
+    constructor() {
+        super(...arguments);
+        this.toastService = inject(AXToastService);
+        this.translationService = inject(AXTranslationService);
+    }
+    async execute(context) {
+        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,
         });
-        // look up
-        service.register({
-            component: {
-                view: {
-                    component: () => import('./acorex-platform-common-lookup-widget-view.component-CJijszjn.mjs').then((c) => c.AXPLookupWidgetViewComponent),
-                },
-                edit: {
-                    component: () => import('./acorex-platform-common-lookup-widget-edit.component-DUPsS_ZW.mjs').then((c) => c.AXPLookupWidgetEditComponent),
-                },
-                filter: {
-                    component: () => import('./acorex-platform-common-lookup-widget-filter.component-CLyl94AJ.mjs').then((c) => c.AXPLookupWidgetFilterComponent),
-                },
-                column: {
-                    component: () => import('./acorex-platform-common-lookup-widget-column.component-BB0Mdx2u.mjs').then((c) => c.AXPLookupWidgetColumnComponent),
-                    options: {
-                        allowResizing: true,
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPToastAction, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPToastAction }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPToastAction, decorators: [{
+            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);
+    }
+    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: "19.0.3", ngImport: i0, type: AXMWorkflowErrorHandler, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXMWorkflowErrorHandler }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", 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,
                 },
-            },
-            filterOptions: {
-                operators: [],
-                default: EQ_OPER,
-            },
-            name: widgetSchemas.lookup,
-            dataType: 'object',
-        });
-        // selection list
-        service.register({
-            component: {
-                view: {
-                    component: () => import('./acorex-platform-common-selection-list-widget-view.component-B7disiIF.mjs').then((c) => c.AXPSelectionListWidgetViewComponent),
-                },
-                edit: {
-                    component: () => import('./acorex-platform-common-selection-list-widget-edit.component-B8dmJ_jJ.mjs').then((c) => c.AXPSelectionListWidgetEditComponent),
-                },
-                column: {
-                    component: () => import('./acorex-platform-common-selection-list-widget-column.component-E7yRTViz.mjs').then((c) => c.AXPSelectionListWidgetColumnComponent),
-                    options: {
-                        allowResizing: true,
+            ],
+        };
+    }
+    static forChild(configs) {
+        return {
+            ngModule: AXPCommonModule,
+            providers: [
+                ...(configs?.errorHandlers || []),
+                {
+                    provide: 'AXPCommonModuleFactory',
+                    useFactory: (registry) => () => {
+                        registry.register(...(configs?.errorHandlers || []));
                     },
+                    deps: [AXPErrorHandlerRegistryService],
+                    multi: true,
                 },
-                filter: {
-                    component: () => import('./acorex-platform-common-selection-list-widget-filter.component-i4syx0Bj.mjs').then((c) => c.AXPSelectionListWidgetFilterComponent),
-                },
-            },
-            filterOptions: {
-                operators: [],
-                default: EQ_OPER,
-            },
-            name: widgetSchemas.selectionList,
-            dataType: 'object',
+            ],
+        };
+    }
+    /**
+     * @ignore
+     */
+    constructor(instances, appInitService, settingsService, seederService) {
+        instances.forEach((f) => {
+            f();
         });
-        // rich text
-        service.register({
-            component: {
-                view: {
-                    component: () => import('./acorex-platform-common-rich-text-widget-view.component-qvUpx39D.mjs').then((c) => c.AXPRichTextWidgetViewComponent),
-                },
-                edit: {
-                    component: () => import('./acorex-platform-common-rich-text-widget-edit.component-CJZJzh1K.mjs').then((c) => c.AXPRichTextWidgetEditComponent),
-                    options: {
-                        allowResizing: true,
-                    },
-                },
-                column: {
-                    component: () => import('./acorex-platform-common-rich-text-widget-column.component-Dbn3JMOu.mjs').then((c) => c.AXPRichTextWidgetColumnComponent),
-                    options: {
-                        width: '400px',
-                    },
-                },
-                filter: {
-                    component: () => import('./acorex-platform-common-string-widget-filter.component-CDssxMLR.mjs').then((c) => c.AXPStringWidgetFilterComponent),
-                },
-            },
-            filterOptions: {
-                operators: [...STRING_OPERATORS],
-                default: EQ_OPER,
+        appInitService.registerTask({
+            name: 'Settings',
+            statusText: 'Loading Settings ...',
+            run: async () => {
+                await settingsService.load();
             },
-            name: widgetSchemas.richText,
-            dataType: 'object',
         });
-        // map
-        service.register({
-            component: {
-                view: {
-                    component: () => import('./acorex-platform-common-map-widget-view.component-CQzW1ZeD.mjs').then((c) => c.AXPMapWidgetViewComponent),
-                },
-                edit: {
-                    component: () => import('./acorex-platform-common-map-widget-edit.component-BTHORlG5.mjs').then((c) => c.AXPMapWidgetEditComponent),
-                },
-            },
-            filterOptions: {
-                operators: [],
-                default: EQ_OPER,
+        //
+        //
+        appInitService.registerTask({
+            name: 'Seeder',
+            statusText: 'Seed Data ...',
+            run: async () => {
+                await seederService.seed();
             },
-            name: widgetSchemas.map,
-            dataType: 'object',
         });
-        // avatar
-        service.register({
-            component: {
-                view: {
-                    component: () => import('./acorex-platform-common-avatar-widget-view.component-DSju_bgg.mjs').then((c) => c.AXPAvatarWidgetViewComponent),
-                },
-                edit: {
-                    component: () => import('./acorex-platform-common-avatar-widget-edit.component-syRKKn21.mjs').then((c) => c.AXPAvatarWidgetEditComponent),
-                },
-            },
-            filterOptions: {
-                operators: [],
-                default: EQ_OPER,
+    }
+    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: [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: [
+            AXPAppStartUpProvider,
+            {
+                provide: ErrorHandler,
+                useClass: AXPGlobalErrorHandler,
             },
-            name: widgetSchemas.avatar,
-            dataType: 'object',
-        });
-        // messenger
-        service.register({
-            component: {
-                view: {
-                    component: () => import('./acorex-platform-common-messenger-widget-view.component-DVylp_2t.mjs').then((c) => c.AXPMessengerWidgetViewComponent),
-                },
-                edit: {
-                    component: () => import('./acorex-platform-common-messenger-widget-edit.component-CJHvut2C.mjs').then((c) => c.AXPMessengerWidgetEditComponent),
-                },
-                column: {
-                    component: () => import('./acorex-platform-common-messenger-widget-column.component-Brm4vLGA.mjs').then((c) => c.AXPMessengerWidgetColumnComponent),
-                    options: {
-                        allowResizing: true,
-                    },
-                },
+            {
+                provide: AXPCustomOperatorService,
+                useClass: AXPCustomOperatorServiceImpl,
             },
-            filterOptions: {
-                operators: [],
-                default: EQ_OPER,
+            {
+                provide: AXPFilterOperatorMiddlewareService,
+                useClass: AXPFilterOperatorMiddlewareServiceImpl,
             },
-            name: widgetSchemas.messenger,
-            dataType: 'object',
-        });
-        //
-        // gallery
-        service.register({
-            component: {
-                view: {
-                    component: () => import('./acorex-platform-common-gallery-widget-view.component-Dxf4Oj1E.mjs').then((c) => c.AXPGalleryWidgetViewComponent),
-                },
-                edit: {
-                    component: () => import('./acorex-platform-common-gallery-widget-edit.component-zBsaBkzu.mjs').then((c) => c.AXPGalleryWidgetEditComponent),
-                },
-                filter: {
-                    component: () => import('./acorex-platform-common-gallery-widget-filter.component-BhLYuB6p.mjs').then((c) => c.AXPGalleryWidgetFilterComponent),
-                },
+            {
+                provide: AXP_SEARCH_PROVIDER,
+                useClass: AXPSettingSearchProvider,
+                multi: true,
             },
-            filterOptions: {
-                operators: [],
-                default: EQ_OPER,
+            {
+                provide: AXP_SEARCH_PROVIDER,
+                useClass: AXPMenuSearchProvider,
+                multi: true,
             },
-            name: widgetSchemas.gallery,
-            dataType: 'object',
-        });
-        // signature-pad
-        service.register({
-            component: {
-                view: {
-                    component: () => import('./acorex-platform-common-signature-pad-widget-view.component-HfArY6VQ.mjs').then((c) => c.AXPSignaturePadWidgetViewComponent),
-                },
-                edit: {
-                    component: () => import('./acorex-platform-common-signature-pad-widget-edit.component-CMoiIhgJ.mjs').then((c) => c.AXPSignaturePadWidgetEditComponent),
-                },
+            {
+                provide: AXP_SEARCH_DEFINITION_PROVIDER,
+                useClass: AXPSettingSearchDefinitionProvider,
+                multi: true,
             },
-            filterOptions: {
-                operators: [],
-                default: EQ_OPER,
+            {
+                provide: AXP_SEARCH_DEFINITION_PROVIDER,
+                useClass: AXPMenuSearchDefinitionProvider,
+                multi: true,
             },
-            name: widgetSchemas.signaturePad,
-            dataType: 'object',
-        });
-        //
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPCommonWidgetModule, deps: [{ token: AXPSchemaRegistryService }], target: i0.ɵɵFactoryTarget.NgModule }); }
-    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "19.0.3", ngImport: i0, type: AXPCommonWidgetModule, imports: [AXToastModule] }); }
-    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPCommonWidgetModule, imports: [AXToastModule] }); }
+        ], imports: [AXPWorkflowModule.forChild({
+                actions: {
+                    'navigate-router': AXPWorkflowRouterNavigateAction,
+                    'show-prompt-dialog': AXPDialogConfirmAction,
+                    'show-toast': AXPToastAction,
+                },
+                workflows: {
+                    'navigate': AXPNavigateWorkflow
+                }
+            }),
+            AXPopupModule,
+            AXDateTimeModule,
+            AXToastModule, RouterModule] }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPCommonWidgetModule, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPCommonModule, decorators: [{
             type: NgModule,
             args: [{
-                    imports: [AXToastModule],
-                    exports: [],
-                    declarations: [],
-                    providers: [],
+                    imports: [
+                        AXPWorkflowModule.forChild({
+                            actions: {
+                                'navigate-router': AXPWorkflowRouterNavigateAction,
+                                'show-prompt-dialog': AXPDialogConfirmAction,
+                                'show-toast': AXPToastAction,
+                            },
+                            workflows: {
+                                'navigate': AXPNavigateWorkflow
+                            }
+                        }),
+                        AXPopupModule,
+                        AXDateTimeModule,
+                        AXToastModule,
+                    ],
+                    exports: [RouterModule],
+                    providers: [
+                        AXPAppStartUpProvider,
+                        {
+                            provide: ErrorHandler,
+                            useClass: AXPGlobalErrorHandler,
+                        },
+                        {
+                            provide: AXPCustomOperatorService,
+                            useClass: AXPCustomOperatorServiceImpl,
+                        },
+                        {
+                            provide: AXPFilterOperatorMiddlewareService,
+                            useClass: AXPFilterOperatorMiddlewareServiceImpl,
+                        },
+                        {
+                            provide: AXP_SEARCH_PROVIDER,
+                            useClass: AXPSettingSearchProvider,
+                            multi: true,
+                        },
+                        {
+                            provide: AXP_SEARCH_PROVIDER,
+                            useClass: AXPMenuSearchProvider,
+                            multi: true,
+                        },
+                        {
+                            provide: AXP_SEARCH_DEFINITION_PROVIDER,
+                            useClass: AXPSettingSearchDefinitionProvider,
+                            multi: true,
+                        },
+                        {
+                            provide: AXP_SEARCH_DEFINITION_PROVIDER,
+                            useClass: AXPMenuSearchDefinitionProvider,
+                            multi: true,
+                        },
+                    ],
                 }]
-        }], ctorParameters: () => [{ type: AXPSchemaRegistryService }] });
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: ['AXPCommonModuleFactory']
+                }] }, { type: AXPAppStartUpService }, { type: AXPSettingValueProviderService }, { type: AXPDataSeederService }] });
+
+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',
+    logo: {
+        dark: new AXPTextLogoConfig('ACoreX'),
+        light: new AXPTextLogoConfig('ACoreX'),
+        colored: new AXPTextLogoConfig('ACoreX'),
+    },
+    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: "19.0.3", ngImport: i0, type: AXPFileStorageService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
@@ -3323,9 +2520,29 @@ var AXPFileStorageStatus;
     AXPFileStorageStatus["Error"] = "error";
 })(AXPFileStorageStatus || (AXPFileStorageStatus = {}));
 
+class AXPFiltersProviderService {
+    async getAll() {
+        return Promise.resolve('');
+    }
+    async execute() {
+        return Promise.resolve('');
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPFiltersProviderService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPFiltersProviderService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPFiltersProviderService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+
+const AXPSignOutAction = createAction('[SignOut] Action');
+const AXPSignInAction = createAction('[SignIn] Action');
+
 /**
  * Generated bundle index. Do not edit.
  */
 
-export { ALL_DEFAULT_OPERATORS, AXEntityLoaderDefault, AXMEntityCrudService, AXMEntityCrudServiceImpl, AXMWorkflowErrorHandler, AXPAppStartUpProvider, AXPAppStartUpService, AXPClipBoardService, AXPCommonEffects, AXPCommonModule, AXPCommonWidgetModule, AXPComponentLogoConfig, AXPComponentSlotDirective, AXPComponentSlotLoaderService, AXPComponentSlotModule, AXPComponentSlotRegistryService, AXPCustomOperatorService, AXPCustomOperatorServiceImpl, AXPDataGenerator, AXPDataProvider, AXPDataSeederService, AXPDexieEntityStorageService, AXPDialogConfirmAction, AXPEntityCommandScope, AXPEntityDataProvider, AXPEntityDataProviderImpl, AXPEntityListViewConfigEmpty, AXPEntityQueryType, AXPEntityRegistryService, AXPEntityStorageService, AXPErrorHandlerRegistryService, AXPFileStorageService, AXPFileStorageStatus, AXPFilterOperatorMiddlewareService, AXPFilterOperatorMiddlewareServiceImpl, AXPFiltersProviderService, AXPFontIconLogoConfig, AXPFooterTextSlotComponent, AXPGlobalErrorHandler, AXPGridLayoutDirective, AXPImageUrlLogoConfig, AXPLogoComponent, AXPMenuProviderService, AXPMenuService, AXPNavBarSlotComponent, AXPNavigateAction, AXPPdfPageSize, AXPPdfService, AXPPlatformDefaultConfigs, AXPRedirectEvent, AXPRefreshEvent, AXPRelationshipCardinality, AXPRelationshipKind, AXPSchemaModule, AXPSchemaRegistryService, AXPSettingDefaultValueProvider, AXPSettingDefinitionGroupBuilder, AXPSettingDefinitionProviderContext, AXPSettingDefinitionProviderService, AXPSettingDefinitionSectionBuilder, AXPSettingScope, AXPSettingValueProviderService, AXPSignInAction, AXPSignOutAction, AXPStickyDirective, AXPTextLogoConfig, AXPToastAction, AXPWidgetBase, AXPWidgetColumnRendererComponent, AXPWidgetEditBase, AXPWidgetFilterBase, AXPWidgetFilterRendererComponent, AXPWidgetRendererComponent, AXPWorkflowNavigateAction, AXP_DATA_SEEDER_TOKEN, AXP_ENTITY_LOADER, AXP_MENU_PROVIDER, AXP_PLATFORM_CONFIG_TOKEN, AXP_ROOT_CONFIG_TOKEN, AXP_SETTING_DEFINITION_PROVIDER, AXP_SETTING_VALUE_PROVIDER, AXP_WIDGET_TOKEN, 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, convertPropertiesToColumns, convertPropertyToColumn, getEntityInfo, resolveActionLook, widgetSchemas };
+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