@acorex/platform 20.2.4-next.0 → 20.2.4-next.1

package/fesm2022/acorex-platform-layout-entity.mjs

@@ -1,5 +1,5 @@
 import * as i0 from '@angular/core';
-import { InjectionToken, inject, Injectable, computed, signal, Injector, EnvironmentInjector, runInInjectionContext, viewChild, viewChildren, untracked, ChangeDetectionStrategy, Component, effect, HostBinding, ViewChild, NgModule } from '@angular/core';
+import { InjectionToken, inject, Injectable, computed, signal, Injector, runInInjectionContext, EnvironmentInjector, viewChild, viewChildren, linkedSignal, effect, untracked, ChangeDetectionStrategy, Component, HostBinding, ViewChild, NgModule } from '@angular/core';
 import { castArray, get, cloneDeep, set, merge, isNil, isEmpty, sortBy } from 'lodash-es';
 import * as i1$2 from '@acorex/cdk/common';
 import { AXDataSource, AXCommonModule } from '@acorex/cdk/common';
@@ -10,10 +10,11 @@ import { AXPExpressionEvaluatorService, AXPPlatformScope, AXPDistributedEventLis
 import * as i2$2 from '@acorex/platform/workflow';
 import { AXPWorkflowService, ofType, createWorkFlowEvent, AXPWorkflowAction, AXPWorkflowModule } from '@acorex/platform/workflow';
 import * as i2 from '@acorex/platform/layout/builder';
-import { AXPPageStatus, AXPWidgetRegistryService, AXPWidgetsCatalog, AXPValueWidgetComponent, AXPWidgetRendererDirective, AXPLayoutBuilderModule, AXPWidgetGroupEnum, AXPLayoutWidgetComponent, AXPColumnWidgetComponent, AXP_WIDGETS_EDITOR_CATEGORY } from '@acorex/platform/layout/builder';
+import { AXPPageStatus, AXPWidgetRegistryService, AXPWidgetsCatalog, AXPValueWidgetComponent, AXPWidgetContainerComponent, AXPWidgetRendererDirective, AXPLayoutBuilderModule, AXPWidgetGroupEnum, AXPLayoutWidgetComponent, AXPColumnWidgetComponent, AXP_WIDGETS_EDITOR_CATEGORY } from '@acorex/platform/layout/builder';
 import { AXPLayoutThemeService } from '@acorex/platform/themes/shared';
-import { AXPSessionService, AXPAuthGuard } from '@acorex/platform/auth';
 import { Subject, takeUntil } from 'rxjs';
+import { AXPSessionService, AXPAuthGuard } from '@acorex/platform/auth';
+import { AXPCommandService } from '@acorex/platform/runtime';
 import * as i8 from '@acorex/core/translation';
 import { AXTranslationService, AXTranslationModule } from '@acorex/core/translation';
 import { AXDialogService } from '@acorex/components/dialog';
@@ -51,7 +52,7 @@ import { AXDropdownButtonModule } from '@acorex/components/dropdown-button';
 import { AXBasePageComponent } from '@acorex/components/page';
 import * as i2$1 from '@acorex/components/text-box';
 import { AXTextBoxModule, AXTextBoxComponent } from '@acorex/components/text-box';
-import { AXPWidgetPropertyViewerComponent } from '@acorex/platform/layout/designer';
+import { AXPWidgetPropertyViewerComponent } from '@acorex/platform/layout/components';
 import { transform, isEqual } from 'lodash';
 
 const AXP_DATA_SEEDER_TOKEN = new InjectionToken('AXP_DATA_SEEDER_TOKEN');
@@ -224,7 +225,8 @@ class AXPEntityDetailListViewModel {
                 return !usedOverrideActions.has(actionKey);
             })
                 .map((action) => new AXPEntityCommandTriggerViewModel(this.detailEntity(), action));
-            return [...additionalActions, ...mergedActions].filter((a) => !a.hidden);
+            // Do not filter by hidden here; hidden/disabled may be expressions that must be evaluated dynamically
+            return [...additionalActions, ...mergedActions];
         }, ...(ngDevMode ? [{ debugName: "allActions" }] : []));
         this.selectedScopeActionsCount = computed(() => {
             return this.allActions().filter((a) => a.scope == AXPEntityCommandScope.Selected).length;
@@ -370,6 +372,43 @@ class AXPEntityDetailListViewModel {
             options,
         });
     }
+    //#region ----   Evaluated Actions (Primary/Secondary)   ----
+    /**
+     * Evaluate hidden/disabled expressions for primary actions and return the visible list.
+     */
+    async getPrimaryActions() {
+        const scope = {};
+        const actions = await Promise.all(this.allActions()
+            .filter((a) => a.priority == 'primary' &&
+            ((a.scope == AXPEntityCommandScope.Selected && this.hasSelectedItems()) ||
+                (a.scope == AXPEntityCommandScope.TypeLevel && !this.hasSelectedItems())))
+            .map(async (a) => {
+            const isHidden = await this.evaluateExpressions(a.hidden);
+            if (isHidden)
+                return null;
+            const disabled = await this.evaluateExpressions(a.disabled);
+            return { ...a, disabled };
+        }));
+        return actions.filter(Boolean);
+    }
+    /**
+     * Evaluate hidden/disabled expressions for secondary actions and return the visible list.
+     */
+    async getSecondaryActions() {
+        const scope = {};
+        const actions = await Promise.all(this.allActions()
+            .filter((a) => a.priority == 'secondary' &&
+            ((a.scope == AXPEntityCommandScope.Selected && this.hasSelectedItems()) ||
+                (a.scope == AXPEntityCommandScope.TypeLevel && !this.hasSelectedItems())))
+            .map(async (a) => {
+            const isHidden = await this.evaluateExpressions(a.hidden);
+            if (isHidden)
+                return null;
+            const disabled = await this.evaluateExpressions(a.disabled);
+            return { ...a, disabled };
+        }));
+        return actions.filter(Boolean);
+    }
 }
 
 function createModifierContext(entity) {
@@ -526,6 +565,15 @@ function createModifierContext(entity) {
                     entity.interfaces.master = updater(entity.interfaces.master);
                     return ctx;
                 },
+                list: {
+                    get: () => entity.interfaces?.master?.list,
+                    update: (updater) => {
+                        entity.interfaces ??= {};
+                        entity.interfaces.master ??= {};
+                        entity.interfaces.master.list = updater(entity.interfaces.master.list);
+                        return ctx;
+                    },
+                },
                 create: {
                     get: () => entity.interfaces?.master?.create,
                     update: (updater) => {
@@ -611,6 +659,7 @@ class AXPEntityMiddleware {
         this.patternModifiers = [];
         this.providedModifiers = inject(AXP_ENTITY_MODIFIER, { optional: true }) || [];
         this.providedActionPlugins = inject(AXP_ENTITY_ACTION_PLUGIN, { optional: true }) || [];
+        this.injector = inject(Injector);
         for (const { entityName, modifier } of this.providedModifiers) {
             this.register(entityName, modifier);
         }
@@ -631,7 +680,7 @@ class AXPEntityMiddleware {
     }
     //#endregion
     //#region ----   Processing   ----
-    process(entity) {
+    async process(entity) {
         // First, expand action plugins if entity.plugins exists
         const context = createModifierContext(entity);
         const plugins = entity.plugins;
@@ -641,7 +690,7 @@ class AXPEntityMiddleware {
                 const contrib = sorted.find((x) => x.name === p.name);
                 if (contrib) {
                     try {
-                        contrib.apply(context, p.options);
+                        await runInInjectionContext(this.injector, () => contrib.apply(context, p.options));
                     }
                     catch (err) {
                         console.error('[AXPEntityMiddleware] action plugin failed:', p.name, err);
@@ -683,11 +732,15 @@ class AXPEntityDefinitionRegistryService {
         this.providers = inject(AXP_ENTITY_DEFINITION_LOADER);
         this.resolver = inject(AXPEntityResolver);
         this.middleware = inject(AXPEntityMiddleware);
+        this.onChanged = new Subject();
         // Stores AXPEntityConfig objects, keyed by a combination of module and entity name.
         this.entities = new Map();
         // Entity resolver service for dynamically loading entity configurations.
         this.entityResolver = inject(AXPEntityResolver); // Assuming AXPEntityLoader is the correct type
     }
+    get onChanged$() {
+        return this.onChanged.asObservable();
+    }
     async preload() {
         const providers = Array.isArray(this.providers)
             ? this.providers
@@ -708,14 +761,14 @@ class AXPEntityDefinitionRegistryService {
                     .catch(err => {
                     console.error(`[AXPEntityDefinitionRegistryService] Failed to load entity ${item.module}.${item.entity}:`, err);
                     return null;
-                }), 3000, `${item.module}.${item.entity}`));
+                }), 10000, `${item.module}.${item.entity}`));
             });
         });
         const results = await Promise.allSettled(promises);
         const loadedEntities = [];
-        results.forEach((result, idx) => {
+        results.forEach(async (result, idx) => {
             if (result.status === 'fulfilled' && result.value != null) {
-                this.register(this.middleware.process(result.value));
+                this.register(await this.middleware.process(result.value));
                 loadedEntities.push(result.value);
             }
             else if (result.status === 'rejected') {
@@ -724,6 +777,43 @@ class AXPEntityDefinitionRegistryService {
         });
         //console.log('[AXPEntityDefinitionRegistryService] Loaded entities:', loadedEntities);
     }
+    async refresh(arg1, arg2) {
+        // No parameters: refresh all currently registered entities
+        if (typeof arg1 === 'undefined' && typeof arg2 === 'undefined') {
+            const keys = Array.from(this.entities.keys());
+            for (const key of keys) {
+                const [m, e] = key.split('.');
+                if (m && e) {
+                    await this.refreshOne(m, e);
+                }
+            }
+            return;
+        }
+        // One parameter: treat as fully-qualified name
+        if (typeof arg1 === 'string' && typeof arg2 === 'undefined') {
+            const [moduleName, entityName] = arg1.split('.');
+            if (!moduleName || !entityName) {
+                throw new Error(`Invalid entity full name: ${arg1}`);
+            }
+            await this.refreshOne(moduleName, entityName);
+            return;
+        }
+        // Two parameters: module + entity
+        if (typeof arg1 === 'string' && typeof arg2 === 'string') {
+            await this.refreshOne(arg1, arg2);
+            return;
+        }
+    }
+    /** Executes the actual refresh for a single entity */
+    async refreshOne(moduleName, entityName) {
+        const config = await this.entityResolver.get(moduleName, entityName);
+        if (!config) {
+            throw new Error(`Invalid entity name: ${moduleName}.${entityName}`);
+        }
+        const processedConfig = await this.middleware.process(config);
+        this.register(processedConfig);
+    }
+    //#endregion
     /**
      * Registers a new entity configuration. Entities are identified uniquely by a combination
      * of their module and name.
@@ -733,6 +823,7 @@ class AXPEntityDefinitionRegistryService {
     register(config) {
         const key = this.createEntityKey(config.module, config.name);
         this.entities.set(key, config);
+        this.onChanged.next({ name: key });
     }
     /**
      * Returns an array of all registered entity configurations.
@@ -759,7 +850,7 @@ class AXPEntityDefinitionRegistryService {
             try {
                 config = await this.entityResolver.get(moduleName, entityName);
                 if (config) {
-                    const processedConfig = this.middleware.process(config);
+                    const processedConfig = await this.middleware.process(config);
                     this.register(processedConfig);
                     return processedConfig;
                 }
@@ -978,7 +1069,7 @@ class AXPEntityMasterListViewModel {
             this.applyViewColumns();
             this.applyViewFilters();
             // this.applyFilterAndSort();
-            this.applySettings();
+            await this.applySettings();
         }
     }
     constructor(injector, config) {
@@ -992,9 +1083,12 @@ class AXPEntityMasterListViewModel {
         this.settings = this.injector.get(AXPSettingService);
         this.widgetResolver = this.injector.get(AXPWidgetRegistryService);
         this.expressionEvaluator = this.injector.get(AXPExpressionEvaluatorService);
+        this.commandService = this.injector.get(AXPCommandService);
         this.filterOperatorMiddleware = this.injector.get(AXPFilterOperatorMiddlewareService);
         this.settingEntityKey = `${this.config.module}:${this.config.name}`;
         this.destroyed = new Subject();
+        this.lastAppliedSortKey = null;
+        this.lastAppliedFilterKey = null;
         this.events$ = new Subject();
         //****************** Views ******************//
         this.views = computed(() => {
@@ -1122,19 +1216,37 @@ class AXPEntityMasterListViewModel {
         this.saveSettings('view');
         const listViewSetting = await this.settings.get(this.settingEntityKey);
         if (listViewSetting) {
-            const columns = listViewSetting.list.views[this.view().name].columns;
-            const pageSize = listViewSetting.list.views[this.view().name].pageSize;
-            const columnVisibilityMap = new Map(columns.map((col) => [col.name, col.visible]));
-            const columnWidthsMap = new Map(columns.map((col) => [col.name, col.width]));
-            // if (pageSize) {
-            //   this.dataSource.setPageSize(pageSize);
-            // }
-            this.columns.update((prev) => prev
-                .map((c) => {
-                return { ...c, width: columnWidthsMap.get(c.name), visible: columnVisibilityMap.get(c.name) ?? c.visible };
-            }) // Update visibility
-                .sort((a, b) => columns.findIndex((col) => col.name === a.name) -
-                columns.findIndex((col) => col.name === b.name)));
+            const columns = listViewSetting.list?.views?.[this.view().name]?.columns;
+            const pageSize = listViewSetting.list?.views?.[this.view().name]?.pageSize;
+            const sorts = listViewSetting.list?.views?.[this.view().name]?.sorts;
+            const filters = listViewSetting.list?.views?.[this.view().name]?.filters;
+            let columnVisibilityMap;
+            let columnWidthsMap;
+            if (columns) {
+                columnVisibilityMap = new Map(columns.map((col) => [col.name, col.visible]));
+                columnWidthsMap = new Map(columns.map((col) => [col.name, col.width]));
+            }
+            // Do not set pageSize here to avoid triggering an extra load
+            if (columns && columnVisibilityMap && columnWidthsMap) {
+                this.columns.update((prev) => prev
+                    .map((c) => {
+                    return {
+                        ...c,
+                        width: columnWidthsMap.get(c.name),
+                        visible: columnVisibilityMap.get(c.name) ?? c.visible,
+                    };
+                }) // Update visibility
+                    .sort((a, b) => columns.findIndex((col) => col.name === a.name) -
+                    columns.findIndex((col) => col.name === b.name)));
+            }
+            if (Array.isArray(sorts)) {
+                // sorts are AXPSortQuery[]; ensure we map by name
+                const sortsMap = new Map(sorts.map((s) => [s.name, s.dir]));
+                this.sortedFields.update((prev) => prev.map((sf) => ({ ...sf, dir: sortsMap.get(sf.name) || sf.dir })));
+            }
+            if (Array.isArray(filters)) {
+                this.filterQueries.set(filters);
+            }
         }
     }
     async saveSettings(changesType, data) {
@@ -1188,6 +1300,36 @@ class AXPEntityMasterListViewModel {
                     },
                 }));
                 break;
+            case 'filters':
+                updateSettings((prev) => ({
+                    ...prev,
+                    list: {
+                        ...prev?.list,
+                        views: {
+                            ...prev?.list?.views,
+                            [this.view().name]: {
+                                ...prev?.list?.views?.[this.view().name],
+                                filters: data,
+                            },
+                        },
+                    },
+                }));
+                break;
+            case 'sorts':
+                updateSettings((prev) => ({
+                    ...prev,
+                    list: {
+                        ...prev?.list,
+                        views: {
+                            ...prev?.list?.views,
+                            [this.view().name]: {
+                                ...prev?.list?.views?.[this.view().name],
+                                sorts: data,
+                            },
+                        },
+                    },
+                }));
+                break;
             default:
                 break;
         }
@@ -1280,21 +1422,30 @@ class AXPEntityMasterListViewModel {
             operator: f.operator,
             value: f.value,
         }));
-        this.filterQueries.update((prev) => ({ ...prev, filters: viewFilters }));
+        this.filterQueries.set(viewFilters);
     }
     resetFilters() {
         this.applyViewFilters();
     }
     async applyFilterAndSort() {
-        this.dataSource.clearFilter();
-        this.dataSource.sort(...this.sortedFields()
+        const sorts = this.sortedFields()
             .filter((sf) => sf.dir)
-            .map((s) => ({ dir: s.dir, field: s.name })));
+            .map((s) => ({ name: s.name, dir: s.dir }));
+        const filters = this.filterQueries();
+        const sortKey = JSON.stringify(sorts);
+        const filterKey = JSON.stringify(filters);
+        if (sortKey === this.lastAppliedSortKey && filterKey === this.lastAppliedFilterKey) {
+            return; // No effective change; avoid redundant refresh
+        }
+        this.lastAppliedSortKey = sortKey;
+        this.lastAppliedFilterKey = filterKey;
+        this.dataSource.clearFilter();
+        this.dataSource.sort(...sorts.map((s) => ({ dir: s.dir, field: s.name })));
         this.dataSource.filter(this.filterOperatorMiddleware.transformFilter({
             field: null,
             logic: 'and',
             operator: null,
-            filters: this.filterQueries(),
+            filters: filters,
         }));
         this.dataSource.refresh();
     }
@@ -1342,19 +1493,24 @@ class AXPEntityMasterListViewModel {
         });
         const command = commandName.split('&')[0];
         const options = await this.evaluateExpressions(action?.options, data);
-        await this.workflow.execute(command, {
-            entity: getEntityInfo(this.entityDef).source,
-            entityInfo: {
-                name: this.entityDef.name,
-                module: this.entityDef.module,
-                title: this.entityDef.title,
-                parentKey: this.entityDef.parentKey,
-                source: this.entityDef.source,
-            },
-            data: action?.scope == AXPEntityCommandScope.Selected ? this.selectedItems() : data,
-            options: options,
-            metadata: action?.metadata,
-        });
+        if (this.workflow.exists(command)) {
+            await this.workflow.execute(command, {
+                entity: getEntityInfo(this.entityDef).source,
+                entityInfo: {
+                    name: this.entityDef.name,
+                    module: this.entityDef.module,
+                    title: this.entityDef.title,
+                    parentKey: this.entityDef.parentKey,
+                    source: this.entityDef.source,
+                },
+                data: action?.scope == AXPEntityCommandScope.Selected ? this.selectedItems() : data,
+                options: options,
+                metadata: action?.metadata,
+            });
+        }
+        else {
+            this.commandService.execute(command, options);
+        }
     }
     async execute(command) {
         switch (command?.name) {
@@ -1893,10 +2049,14 @@ class AXPEntityMasterSingleViewModel {
         this.session = this.injector.get(AXPSessionService);
         this.formatService = this.injector.get(AXFormatService);
         this.workflow = this.injector.get(AXPWorkflowService);
+        this.commandService = this.injector.get(AXPCommandService);
         this.destroyed = new Subject();
         this.translateService = this.injector.get(AXTranslationService);
         this.entityService = this.injector.get(AXPEntityService);
         this.expressionEvaluator = this.injector.get(AXPExpressionEvaluatorService);
+        this.entityDefinitionRegistryService = this.injector.get(AXPEntityDefinitionRegistryService);
+        this._updateTrigger = signal(1, ...(ngDevMode ? [{ debugName: "_updateTrigger" }] : []));
+        this.updateTrigger = this._updateTrigger.asReadonly();
         this.context = signal(cloneDeep(this.entityData), ...(ngDevMode ? [{ debugName: "context" }] : []));
         this.actions = computed(() => {
             return (this.entityDef.interfaces?.master?.single?.actions?.map((tr) => new AXPEntityCommandTriggerViewModel(this.entityDef, tr)) ?? []);
@@ -1980,6 +2140,13 @@ class AXPEntityMasterSingleViewModel {
                 this.context.set(event.payload.values);
             }
         });
+        this.entityDefinitionRegistryService.onChanged$
+            .pipe(takeUntil(this.destroyed))
+            .subscribe((event) => {
+            if (event.name == getEntityInfo(this.entityDef).source) {
+                this._updateTrigger.set(this._updateTrigger() + 1);
+            }
+        });
     }
     navigateToUp() {
         this.workflow.execute('navigate', {
@@ -1989,7 +2156,7 @@ class AXPEntityMasterSingleViewModel {
         });
     }
     async executeCommand(commandName, data = null) {
-        //TODO: syntact for workflow
+        //TODO: syntax for workflow
         const command = commandName.split('&')[0];
         switch (command) {
             case 'modify-entity-section': {
@@ -2005,11 +2172,17 @@ class AXPEntityMasterSingleViewModel {
             default: {
                 const action = this.actions().find((c) => c.name == commandName);
                 const options = await this.evaluateExpressions(action?.options, this.context());
-                this.workflow.execute(command, {
-                    entity: getEntityInfo(this.entityDef).source,
-                    data: this.context(),
-                    options,
-                });
+                //
+                if (this.workflow.exists(command)) {
+                    this.workflow.execute(command, {
+                        entity: getEntityInfo(this.entityDef).source,
+                        data: this.context(),
+                        options,
+                    });
+                }
+                else {
+                    this.commandService.execute(command, data);
+                }
             }
         }
     }
@@ -2362,231 +2535,662 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.6", ngImpor
                 }]
         }] });
 
-async function entityRelatedEntityPageDetails(relatedEntity, entityResolver) {
-    const moduleName = relatedEntity.entity.split('.')[0];
-    const entityName = relatedEntity.entity.split('.')[1];
-    const entityDef = await entityResolver.get(moduleName, entityName);
-    if (!entityDef) {
-        throw new Error(`Entity ${relatedEntity.entity} not found`);
-    }
-    const groups = entityDef?.groups ?? [];
-    const singleInterface = entityDef?.interfaces?.master?.single;
-    const getGroupById = (id) => {
-        return groups.find((s) => s.id === id);
-    };
-    const getPropertyByGroupId = (groupId) => {
-        return entityDef?.properties.filter((p) => p.groupId === groupId) ?? [];
-    };
-    const getPropertyLayout = (name) => {
-        return singleInterface?.properties?.find((p) => p.name === name)?.layout;
-    };
-    return {
-        id: entityDef?.name ?? '',
-        title: relatedEntity.title ?? entityDef?.title ?? '',
-        icon: relatedEntity.icon,
-        settings: {
+class AXPLayoutAdapterBuilder {
+    constructor() {
+        this.adapter = {};
+    }
+    setEntity(entity, rootContext) {
+        this.entity = entity;
+        this.rootContext = rootContext;
+        return this;
+    }
+    setDependencies(dependencies) {
+        this.dependencies = dependencies;
+        return this;
+    }
+    setMainPage(mainPage) {
+        this.adapter.pages = [mainPage];
+        return this;
+    }
+    setRelatedPages(relatedPages) {
+        this.adapter.pages = [...(this.adapter.pages || []), ...relatedPages];
+        return this;
+    }
+    build() {
+        return {
+            title: this.entity?.formats.plural || this.entity?.title,
+            actions: [],
+            breadcrumbs: this.createBreadcrumbs(),
+            execute: this.createExecuteFunction(),
+            load: this.createLoadFunction(),
+            pages: this.adapter.pages || [],
+        };
+    }
+    createBreadcrumbs() {
+        const session = this.dependencies.session;
+        const moduleName = this.entity?.module;
+        const entityName = this.entity?.name;
+        return [
+            {
+                title: this.entity?.formats.plural ?? '',
+                command: {
+                    name: 'navigate',
+                    options: {
+                        path: `/${session.application?.name}/m/${moduleName}/e/${entityName}/list`,
+                    },
+                },
+            },
+            {
+                title: this.entity?.interfaces?.master?.single?.title ?? '',
+                command: {
+                    name: 'navigate',
+                    options: {
+                        path: `/${session.application?.name}/m/${moduleName}/e/${entityName}/${this.rootContext.id}/new-view`,
+                    },
+                },
+            },
+        ];
+    }
+    createExecuteFunction() {
+        return (command, context) => {
+            console.log('layout execute', command, context);
+            return Promise.resolve({ success: true });
+        };
+    }
+    createLoadFunction() {
+        return async () => {
+            return {
+                success: true,
+                result: this.rootContext,
+            };
+        };
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.6", ngImport: i0, type: AXPLayoutAdapterBuilder, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.6", ngImport: i0, type: AXPLayoutAdapterBuilder, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.6", ngImport: i0, type: AXPLayoutAdapterBuilder, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+
+class AXPBaseRelatedEntityConverter {
+    async getEntityDefinition(relatedEntity, entityResolver) {
+        const [moduleName, entityName] = relatedEntity.entity.split('.');
+        const entityDef = await entityResolver.resolve(moduleName, entityName);
+        if (!entityDef) {
+            throw new Error(`Entity ${relatedEntity.entity} not found`);
+        }
+        return { entityDef, moduleName, entityName };
+    }
+    createExpressionEvaluator(context, expressionEvaluator) {
+        return async (actionData) => {
+            const scope = {
+                context: {
+                    eval: (path) => get(context, path),
+                },
+            };
+            return await expressionEvaluator.evaluate(actionData, scope);
+        };
+    }
+    async createFilters(relatedEntity, evaluateExpressions) {
+        return (relatedEntity.conditions?.map(async (c) => {
+            const value = await evaluateExpressions(c.value);
+            return {
+                field: c.name,
+                operator: c.operator,
+                value: value,
+            };
+        }) ?? []);
+    }
+    createEntityHelpers(entityDef) {
+        const groups = entityDef?.groups ?? [];
+        const singleInterface = entityDef?.interfaces?.master?.single;
+        return {
+            getGroupById: (id) => groups.find((s) => s.id === id),
+            getPropertyByGroupId: (groupId) => entityDef?.properties.filter((p) => p.groupId === groupId) ?? [],
+            getPropertyLayout: (name) => singleInterface?.properties?.find((p) => p.name === name)?.layout,
+            singleInterface,
+            groups,
+        };
+    }
+    createGridLayoutStructure(singleInterface, helpers) {
+        return {
+            type: 'grid-layout',
+            options: {
+                grid: {
+                    default: {
+                        gridTemplateColumns: 'repeat(12, 1fr)',
+                        gridTemplateRows: 'repeat(1, 1fr)',
+                        gap: '20px',
+                    },
+                },
+            },
+            children: singleInterface?.sections.map((s) => ({
+                type: 'grid-item-layout',
+                name: s.id,
+                options: {
+                    colSpan: s.layout?.positions?.lg?.colSpan ?? 12,
+                    colStart: s.layout?.positions?.lg?.colStart,
+                    colEnd: s.layout?.positions?.lg?.colEnd,
+                },
+                children: [
+                    {
+                        type: 'fieldset-layout',
+                        options: {
+                            title: helpers.getGroupById(s.id)?.title ?? '',
+                            collapsible: true,
+                        },
+                        children: [this.createPropertyGrid(s.id, helpers)],
+                    },
+                ],
+            })),
+        };
+    }
+    createPropertyGrid(sectionId, helpers) {
+        return {
+            type: 'grid-layout',
+            mode: 'edit',
+            options: {
+                grid: {
+                    default: {
+                        gridTemplateColumns: 'repeat(12, 1fr)',
+                        gridTemplateRows: 'repeat(1, 1fr)',
+                        gap: '20px',
+                    },
+                },
+            },
+            children: helpers
+                .getPropertyByGroupId(sectionId)
+                .filter((property) => !property.schema.hidden)
+                .map((p) => {
+                const layout = helpers.getPropertyLayout(p.name);
+                return {
+                    type: 'grid-item-layout',
+                    name: p.name,
+                    options: {
+                        colSpan: layout?.positions?.lg?.colSpan ?? 12,
+                        colStart: layout?.positions?.lg?.colStart,
+                        colEnd: layout?.positions?.lg?.colEnd,
+                    },
+                    children: [
+                        {
+                            type: 'form-field',
+                            options: {
+                                label: p.title,
+                            },
+                            children: [
+                                {
+                                    type: p.schema.interface?.type ?? '',
+                                    path: p.name,
+                                    name: p.name,
+                                    defaultValue: p.schema.defaultValue,
+                                    children: p.schema.interface?.children,
+                                    options: p.schema.interface?.options,
+                                    triggers: p.schema.interface?.triggers,
+                                    valueTransforms: p.schema.interface?.valueTransforms,
+                                },
+                            ],
+                        },
+                    ],
+                };
+            }),
+        };
+    }
+}
+
+class AXPPageDetailsConverter extends AXPBaseRelatedEntityConverter {
+    async convert(relatedEntity, context) {
+        const { entityDef } = await this.getEntityDefinition(relatedEntity, context.entityResolver);
+        const helpers = this.createEntityHelpers(entityDef);
+        return {
+            id: entityDef?.name ?? '',
+            title: relatedEntity.title ?? entityDef?.title ?? '',
+            label: relatedEntity.title ?? entityDef?.formats.displayName ?? '',
+            icon: relatedEntity.icon || entityDef.icon,
+            settings: this.createPageSettings(),
+            load: this.createLoadFunction(entityDef, relatedEntity),
+            execute: this.createExecuteFunction(entityDef),
+            content: [this.createGridLayoutStructure(helpers.singleInterface, helpers)],
+        };
+    }
+    createPageSettings() {
+        return {
             commands: {
                 reject: {
                     title: 't("discard")',
                     color: 'default',
                     visible: '{{context.isDirty()}}',
-                    command: {
-                        name: 'discard',
-                    },
+                    command: { name: 'discard' },
                 },
                 accept: {
                     title: 't("confirm")',
                     color: 'secondary',
                     visible: '{{context.isDirty()}}',
-                    command: {
-                        name: 'update-entity',
-                    },
+                    command: { name: 'update-entity' },
                 },
             },
-        },
-        load: async (context) => {
+        };
+    }
+    createLoadFunction(entityDef, relatedEntity) {
+        return async (context) => {
             const fn = entityDef?.queries.byKey?.execute;
             const conditionNames = relatedEntity.conditions?.map((c) => c.name) ?? [];
             const id = getSmart(context, conditionNames[0]);
             const result = await fn(id);
-            return {
-                success: true,
-                result: result,
-            };
-        },
-        execute: async (e, context) => {
-            if (e.name == 'update-entity') {
+            return { success: true, result };
+        };
+    }
+    createExecuteFunction(entityDef) {
+        return async (e, context) => {
+            if (e.name === 'update-entity') {
                 const fn = entityDef?.commands?.update?.execute;
                 const result = await fn(context);
-                return {
-                    success: true,
-                    result: result,
-                };
+                return { success: true, result };
             }
             else {
                 return {
                     success: false,
-                    error: {
-                        code: 'invalid_command',
-                        message: 'Invalid command',
-                    },
+                    error: { code: 'invalid_command', message: 'Invalid command' },
                 };
             }
-        },
-        content: [
-            {
-                type: 'grid-layout',
-                mode: 'edit',
-                options: {
-                    grid: {
-                        default: {
-                            gridTemplateColumns: 'repeat(12, 1fr)',
-                            gridTemplateRows: 'repeat(1, 1fr)',
-                            gap: '20px',
-                        },
+        };
+    }
+}
+
+class AXPPageListConverter extends AXPBaseRelatedEntityConverter {
+    async convert(relatedEntity, context) {
+        const { entityDef } = await this.getEntityDefinition(relatedEntity, context.entityResolver);
+        const evaluateExpressions = async (actionData) => {
+            const scope = {
+                context: {
+                    eval: (path) => {
+                        return get(context.context, path);
                     },
                 },
-                children: singleInterface?.sections.map((s) => {
-                    console.log('s', s);
+            };
+            return await context.expressionEvaluator.evaluate(actionData, scope);
+        };
+        const filters = relatedEntity.conditions?.map(async (c) => {
+            const value = await evaluateExpressions(c.value);
+            return {
+                field: c.name,
+                operator: c.operator,
+                value: value,
+                hidden: true,
+            };
+        }) ?? [];
+        return {
+            id: entityDef?.name ?? '',
+            title: `${context.rootTitle}`,
+            label: relatedEntity.title,
+            icon: relatedEntity.icon || entityDef.icon,
+            actions: this.mergeActions(entityDef, relatedEntity)
+                ?.filter((a) => a.priority === 'primary')
+                ?.map((a) => {
+                return {
+                    ...a,
+                    zone: 'header',
+                    // visible:
+                    //   a.scope === AXPEntityCommandScope.Selected
+                    //     ? "{{widget.find('table').outputs().selectedItem().length > 0}}"
+                    //     : true,
+                    visible: '{{context.eval("table")}}',
+                    priority: 'primary',
+                    name: a.name,
+                    title: a.title,
+                    scope: a.scope,
+                    icon: a.icon,
+                    color: a.color,
+                    disabled: a.disabled,
+                    command: {
+                        name: a.name,
+                        options: a.options,
+                        metadata: a.metadata,
+                    },
+                };
+            }),
+            execute: async (command, executeContext) => {
+                try {
+                    const commandName = command.name.split('&')[0];
+                    const mergedActions = this.mergeActions(entityDef, relatedEntity);
+                    const action = mergedActions.find((a) => {
+                        return a.name === commandName || a.name.split('&')[0] === commandName;
+                    });
+                    if (!action) {
+                        console.warn(`Action ${commandName} not found in entity definition`);
+                        return {
+                            success: false,
+                            error: {
+                                code: 'ACTION_NOT_FOUND',
+                                message: `Action ${commandName} not found`,
+                                details: command,
+                            },
+                        };
+                    }
+                    let evaluatedOptions = command.options;
+                    if (action.options) {
+                        evaluatedOptions = await evaluateExpressions(action.options);
+                    }
+                    await context.workflowService.execute(commandName, {
+                        entity: getEntityInfo(entityDef).source,
+                        entityInfo: {
+                            name: entityDef.name,
+                            module: entityDef.module,
+                            title: entityDef.title,
+                            parentKey: entityDef.parentKey,
+                            source: entityDef.source,
+                        },
+                        data: action.scope == AXPEntityCommandScope.Selected
+                            ? executeContext
+                            : evaluatedOptions?.['process']?.data || null,
+                        options: evaluatedOptions,
+                        metadata: action.metadata,
+                    });
+                    return { success: true };
+                }
+                catch (error) {
+                    console.error('Error executing command:', error);
                     return {
-                        type: 'grid-item-layout',
-                        name: s.id,
-                        options: {
-                            colSpan: s.layout?.positions?.lg?.colSpan ?? 12,
-                            colStart: s.layout?.positions?.lg?.colStart,
-                            colEnd: s.layout?.positions?.lg?.colEnd,
+                        success: false,
+                        error: {
+                            code: 'EXECUTION_ERROR',
+                            message: error instanceof Error ? error.message : 'Unknown error occurred',
+                            details: error,
                         },
-                        children: [
-                            {
-                                type: 'fieldset-layout',
-                                options: {
-                                    title: getGroupById(s.id)?.title ?? '',
-                                    collapsible: true,
-                                },
-                                children: [
-                                    {
-                                        type: 'grid-layout',
-                                        options: {
-                                            grid: {
-                                                default: {
-                                                    gridTemplateColumns: 'repeat(12, 1fr)',
-                                                    gridTemplateRows: 'repeat(1, 1fr)',
-                                                    gap: '20px',
-                                                },
-                                            },
-                                        },
-                                        children: getPropertyByGroupId(s.id)
-                                            .filter((property) => !property.schema.hidden)
-                                            .map((p) => {
-                                            const layout = getPropertyLayout(p.name);
-                                            return {
-                                                type: 'grid-item-layout',
-                                                name: p.name,
-                                                options: {
-                                                    colSpan: layout?.positions?.lg?.colSpan ?? 12,
-                                                    colStart: layout?.positions?.lg?.colStart,
-                                                    colEnd: layout?.positions?.lg?.colEnd,
-                                                },
-                                                children: [
-                                                    {
-                                                        type: 'form-field',
-                                                        options: {
-                                                            label: p.title,
-                                                        },
-                                                        children: [
-                                                            {
-                                                                type: p.schema.interface?.type ?? '',
-                                                                path: p.name,
-                                                                name: p.name,
-                                                                defaultValue: p.schema.defaultValue,
-                                                                children: p.schema.interface?.children,
-                                                                options: p.schema.interface?.options,
-                                                                triggers: p.schema.interface?.triggers,
-                                                                valueTransforms: p.schema.interface?.valueTransforms,
-                                                            },
-                                                        ],
-                                                    },
-                                                ],
-                                            };
-                                        }),
-                                    },
-                                ],
-                            },
-                        ],
                     };
-                }),
+                }
             },
-        ],
-    };
+            content: [
+                {
+                    type: AXPWidgetsCatalog.entityList,
+                    name: 'page-list',
+                    defaultValue: {
+                        toolbar: {
+                            filters: await Promise.all(filters),
+                        },
+                    },
+                    options: {
+                        entity: relatedEntity.entity,
+                        showEntityActions: false,
+                    },
+                },
+            ],
+        };
+    }
+    mergeActions(entityDef, relatedEntity) {
+        const originalList = entityDef?.interfaces?.master?.list?.actions ?? [];
+        const relatedEntityActionList = relatedEntity.actions ?? [];
+        // Create a map to track which actions from relatedEntityActionList have been used
+        const usedOverrideActions = new Set();
+        // Start with original actions, applying overrides where they exist
+        const mergedActions = originalList.map((originalAction) => {
+            const originalCommandName = typeof originalAction.command === 'string' ? originalAction.command : originalAction.command.name;
+            const overrideAction = relatedEntityActionList.find((action) => {
+                const actionCommandName = typeof action.command === 'string' ? action.command : action.command.name;
+                return actionCommandName === originalCommandName && action.name === originalAction.name;
+            });
+            if (overrideAction) {
+                // Mark this override action as used
+                const overrideKey = `${typeof overrideAction.command === 'string' ? overrideAction.command : overrideAction.command.name}_${overrideAction.name}`;
+                usedOverrideActions.add(overrideKey);
+                return new AXPEntityCommandTriggerViewModel(entityDef, overrideAction);
+            }
+            return new AXPEntityCommandTriggerViewModel(entityDef, originalAction);
+        });
+        // Add any remaining actions from relatedEntityActionList that weren't used as overrides
+        const additionalActions = relatedEntityActionList
+            .filter((action) => {
+            const actionKey = `${typeof action.command === 'string' ? action.command : action.command.name}_${action.name}`;
+            return !usedOverrideActions.has(actionKey);
+        })
+            .map((action) => new AXPEntityCommandTriggerViewModel(entityDef, action));
+        return [...additionalActions, ...mergedActions].filter((a) => !a.hidden);
+    }
 }
 
-async function entityRelatedEntityPageList(relatedEntity, entityResolver) {
-    const moduleName = relatedEntity.entity.split('.')[0];
-    const entityName = relatedEntity.entity.split('.')[1];
-    const entityDef = await entityResolver.get(moduleName, entityName);
-    if (!entityDef) {
-        throw new Error(`Entity ${relatedEntity.entity} not found`);
+class AXPTabDetailsConverter extends AXPBaseRelatedEntityConverter {
+    async convert(relatedEntity, context) {
+        const { entityDef } = await this.getEntityDefinition(relatedEntity, context.entityResolver);
+        const helpers = this.createEntityHelpers(entityDef);
+        return {
+            id: entityDef?.name ?? '',
+            title: relatedEntity.title ?? entityDef?.title ?? '',
+            icon: relatedEntity.icon || entityDef.icon,
+            content: [this.createGridLayoutStructure(helpers.singleInterface, helpers)],
+        };
     }
-    return {
-        id: entityDef?.name ?? '',
-        title: relatedEntity.title || '',
-        icon: relatedEntity.icon,
-        content: [
-            {
-                type: AXPWidgetsCatalog.entityList,
-                name: 'page-list',
-                options: {
-                    entity: relatedEntity.entity,
+}
+
+class AXPTabListConverter extends AXPBaseRelatedEntityConverter {
+    async convert(relatedEntity, context) {
+        const { entityDef } = await this.getEntityDefinition(relatedEntity, context.entityResolver);
+        const evaluateExpressions = async (actionData) => {
+            const scope = {
+                context: {
+                    eval: (path) => {
+                        return get(context.context, path);
+                    },
                 },
-            },
-        ],
-    };
+            };
+            return await context.expressionEvaluator.evaluate(actionData, scope);
+        };
+        // console.log({ relatedEntity });
+        const filters = relatedEntity.conditions?.map(async (c) => {
+            const value = await evaluateExpressions(c.value);
+            return {
+                field: c.name,
+                operator: c.operator,
+                value: value,
+                hidden: true,
+            };
+        }) ?? [];
+        return {
+            id: entityDef?.name ?? '',
+            title: relatedEntity.title ?? entityDef?.title ?? '',
+            icon: relatedEntity.icon || entityDef.icon,
+            content: [
+                {
+                    type: AXPWidgetsCatalog.entityList,
+                    name: 'tab-list',
+                    defaultValue: {
+                        toolbar: {
+                            filters: await Promise.all(filters),
+                        },
+                    },
+                    options: {
+                        entity: relatedEntity.entity,
+                        showEntityActions: true,
+                        showToolbar: true,
+                    },
+                },
+            ],
+        };
+    }
 }
 
-async function entityRelatedEntityTabDetails(relatedEntity, entityResolver) {
-    const moduleName = relatedEntity.entity.split('.')[0];
-    const entityName = relatedEntity.entity.split('.')[1];
-    const entityDef = await entityResolver.get(moduleName, entityName);
-    if (!entityDef) {
-        throw new Error(`Entity ${relatedEntity.entity} not found`);
-    }
-    const groups = entityDef?.groups ?? [];
-    const singleInterface = entityDef?.interfaces?.master?.single;
-    const getGroupById = (id) => {
-        return groups.find((s) => s.id === id);
-    };
-    const getPropertyByGroupId = (groupId) => {
-        return entityDef?.properties.filter((p) => p.groupId === groupId) ?? [];
-    };
-    const getPropertyLayout = (name) => {
-        return singleInterface?.properties?.find((p) => p.name === name)?.layout;
-    };
-    return {
-        id: entityDef?.name ?? '',
-        title: relatedEntity.title ?? entityDef?.title ?? '',
-        icon: relatedEntity.icon,
-        content: [
-            {
-                type: 'grid-layout',
-                mode: 'edit',
-                options: {
-                    grid: {
-                        default: {
-                            gridTemplateColumns: 'repeat(12, 1fr)',
-                            gridTemplateRows: 'repeat(1, 1fr)',
-                            gap: '20px',
+class AXPRelatedEntityConverterFactory {
+    createConverter(type) {
+        switch (type) {
+            case 'page-detail':
+                return new AXPPageDetailsConverter();
+            case 'page-list':
+                return new AXPPageListConverter();
+            case 'tab-detail':
+                return new AXPTabDetailsConverter();
+            case 'tab-list':
+                return new AXPTabListConverter();
+            default:
+                throw new Error(`Unsupported converter type: ${type}`);
+        }
+    }
+    createPageDetailsConverter() {
+        return this.createConverter('page-detail');
+    }
+    createPageListConverter() {
+        return this.createConverter('page-list');
+    }
+    createTabDetailsConverter() {
+        return this.createConverter('tab-detail');
+    }
+    createTabListConverter() {
+        return this.createConverter('tab-list');
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.6", ngImport: i0, type: AXPRelatedEntityConverterFactory, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.6", ngImport: i0, type: AXPRelatedEntityConverterFactory, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.6", ngImport: i0, type: AXPRelatedEntityConverterFactory, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+
+class AXPMainEntityContentBuilder {
+    constructor(relatedEntityConverterFactory) {
+        this.relatedEntityConverterFactory = relatedEntityConverterFactory;
+        this.workflowService = inject(AXPWorkflowService);
+        this.commandService = inject(AXPCommandService);
+    }
+    async build(entity, rootContext, dependencies) {
+        const groups = entity?.groups ?? [];
+        const singleInterface = entity?.interfaces?.master?.single;
+        const getGroupById = (id) => {
+            return groups.find((s) => s.id === id);
+        };
+        const filterValidSections = (sections) => {
+            return (sections?.filter((section) => {
+                return groups.some((group) => group.id === section.id);
+            }) ?? []);
+        };
+        const getPropertyByGroupId = (groupId) => {
+            return entity?.properties.filter((p) => p.groupId === groupId) ?? [];
+        };
+        const getPropertyLayout = (name) => {
+            return singleInterface?.properties?.find((p) => p.name === name)?.layout;
+        };
+        // Get related entities for tabs
+        const tabDetailEntities = entity?.relatedEntities?.filter((re) => !re.hidden && re.layoutType === 'tab-detail');
+        const tabListEntities = entity?.relatedEntities?.filter((re) => !re.hidden && (!re.layoutType || re.layoutType === 'tab-list'));
+        // Build related tabs if dependencies are provided
+        const tabDetailTabs = await this.buildTabDetails(tabDetailEntities ?? [], dependencies);
+        const tabListTabs = await this.buildTabLists(tabListEntities ?? [], rootContext, dependencies);
+        // Build actions from single interface
+        const actions = this.buildActions(entity, singleInterface);
+        // Create expression evaluator for actions
+        const evaluateExpressions = dependencies?.expressionEvaluator
+            ? this.createExpressionEvaluator(rootContext, dependencies.expressionEvaluator)
+            : null;
+        return {
+            id: entity?.name ?? '',
+            title: singleInterface?.title ?? entity?.formats.individual ?? '',
+            label: entity?.formats.displayName ?? singleInterface?.title ?? '',
+            icon: entity?.icon,
+            actions: await this.buildEvaluatedActions(actions, evaluateExpressions),
+            settings: {
+                commands: {
+                    reject: {
+                        title: 't("discard")',
+                        color: 'default',
+                        visible: '{{context.isDirty()}}',
+                        command: {
+                            name: 'discard',
+                        },
+                    },
+                    accept: {
+                        title: 't("confirm")',
+                        color: 'secondary',
+                        visible: '{{context.isDirty()}}',
+                        command: {
+                            name: 'update-entity',
+                        },
+                    },
+                },
+            },
+            load: async () => {
+                return {
+                    success: true,
+                    result: rootContext,
+                };
+            },
+            execute: async (e, context) => {
+                if (e.name == 'update-entity') {
+                    const fn = entity?.commands?.update?.execute;
+                    const result = await fn(context);
+                    return {
+                        success: true,
+                        result: result,
+                    };
+                }
+                else {
+                    // Find action in single interface actions
+                    const action = actions.find((a) => a.name === e.name);
+                    if (action && dependencies?.workflowService) {
+                        // Evaluate action options with current context
+                        let evaluatedOptions = action.options;
+                        if (evaluateExpressions && action.options) {
+                            try {
+                                evaluatedOptions = await evaluateExpressions(action.options);
+                            }
+                            catch {
+                                // Keep original options if evaluation fails
+                            }
+                        }
+                        const commandName = e.name.split('&')[0];
+                        if (this.workflowService.exists(commandName)) {
+                            await this.workflowService.execute(commandName, {
+                                entity: getEntityInfo(entity).source,
+                                data: context,
+                                entityInfo: {
+                                    name: entity.name,
+                                    module: entity.module,
+                                    title: entity.title,
+                                    parentKey: entity.parentKey,
+                                    source: entity.source,
+                                },
+                                options: evaluatedOptions,
+                                metadata: action.metadata,
+                            });
+                            return {
+                                success: true,
+                            };
+                        }
+                        if (this.commandService.exists(commandName)) {
+                            // check options for evaluation
+                            await this.commandService.execute(commandName, e.options);
+                        }
+                    }
+                    return {
+                        success: false,
+                        error: {
+                            code: 'invalid_command',
+                            message: 'Invalid command',
+                        },
+                    };
+                }
+            },
+            tabs: [...tabDetailTabs, ...tabListTabs],
+            content: [
+                {
+                    type: 'grid-layout',
+                    mode: 'edit',
+                    options: {
+                        grid: {
+                            default: {
+                                gridTemplateColumns: 'repeat(12, 1fr)',
+                                gridTemplateRows: 'repeat(1, 1fr)',
+                                gap: '20px',
+                            },
                         },
                     },
-                },
-                children: singleInterface?.sections.map((s) => {
-                    console.log('s', s);
-                    return {
+                    children: filterValidSections(singleInterface?.sections ?? []).map((s) => ({
                         type: 'grid-item-layout',
                         name: s.id,
                         options: {
                             colSpan: s.layout?.positions?.lg?.colSpan ?? 12,
-                            colStart: s.layout?.positions?.lg?.colStart,
-                            colEnd: s.layout?.positions?.lg?.colEnd,
+                            colStart: s.layout?.positions?.lg?.colStart ?? 1,
+                            colEnd: s.layout?.positions?.lg?.colEnd ?? 13,
                         },
                         children: [
                             {
@@ -2594,6 +3198,7 @@ async function entityRelatedEntityTabDetails(relatedEntity, entityResolver) {
                                 options: {
                                     title: getGroupById(s.id)?.title ?? '',
                                     collapsible: true,
+                                    isOpen: !s.collapsed,
                                 },
                                 children: [
                                     {
@@ -2615,7 +3220,7 @@ async function entityRelatedEntityTabDetails(relatedEntity, entityResolver) {
                                                 type: 'grid-item-layout',
                                                 name: p.name,
                                                 options: {
-                                                    colSpan: layout?.positions?.lg?.colSpan ?? 12,
+                                                    colSpan: layout?.positions?.lg?.colSpan,
                                                     colStart: layout?.positions?.lg?.colStart,
                                                     colEnd: layout?.positions?.lg?.colEnd,
                                                 },
@@ -2632,9 +3237,15 @@ async function entityRelatedEntityTabDetails(relatedEntity, entityResolver) {
                                                                 name: p.name,
                                                                 defaultValue: p.schema.defaultValue,
                                                                 children: p.schema.interface?.children,
-                                                                options: p.schema.interface?.options,
                                                                 triggers: p.schema.interface?.triggers,
                                                                 valueTransforms: p.schema.interface?.valueTransforms,
+                                                                options: merge(p.schema.interface?.options, {
+                                                                    validations: p.validations?.map((c) => ({
+                                                                        rule: c.rule,
+                                                                        message: c.message,
+                                                                        options: c.options,
+                                                                    })),
+                                                                }),
                                                             },
                                                         ],
                                                     },
@@ -2645,236 +3256,192 @@ async function entityRelatedEntityTabDetails(relatedEntity, entityResolver) {
                                 ],
                             },
                         ],
-                    };
-                }),
-            },
-        ],
-    };
+                    })),
+                },
+            ],
+        };
+    }
+    buildActions(entity, singleInterface) {
+        const actions = singleInterface?.actions ?? [];
+        return actions.map((action) => new AXPEntityCommandTriggerViewModel(entity, action));
+    }
+    createExpressionEvaluator(context, expressionEvaluator) {
+        return async (actionData) => {
+            const scope = {
+                context: {
+                    eval: (path) => {
+                        return get(context, path);
+                    },
+                },
+            };
+            return await expressionEvaluator.evaluate(actionData, scope);
+        };
+    }
+    async buildEvaluatedActions(actions, evaluateExpressions) {
+        const evaluatedActions = [];
+        for (const action of actions) {
+            // Evaluate disabled condition
+            let disabled = action.disabled;
+            if (disabled && typeof disabled === 'string' && evaluateExpressions) {
+                try {
+                    const result = await evaluateExpressions({ disabled: disabled });
+                    disabled = result.disabled;
+                }
+                catch {
+                    disabled = false;
+                }
+            }
+            // Evaluate hidden condition
+            let hidden = action.hidden;
+            if (hidden && typeof hidden === 'string' && evaluateExpressions) {
+                try {
+                    const result = await evaluateExpressions({ hidden: hidden });
+                    hidden = result.hidden;
+                }
+                catch {
+                    hidden = false;
+                }
+            }
+            // Skip if hidden
+            if (hidden)
+                continue;
+            // Evaluate options
+            let options = action.options;
+            if (options && evaluateExpressions) {
+                try {
+                    options = await evaluateExpressions(options);
+                }
+                catch {
+                    // Keep original options if evaluation fails
+                }
+            }
+            evaluatedActions.push({
+                name: action.name,
+                title: action.title,
+                icon: action.icon,
+                color: action.color,
+                disabled: disabled || false,
+                zone: 'header',
+                priority: action.priority,
+                command: {
+                    name: action.name,
+                    options: options,
+                    metadata: action.metadata,
+                },
+            });
+        }
+        return evaluatedActions;
+    }
+    async buildTabDetails(tabDetailEntities, dependencies) {
+        if (!dependencies?.entityResolver || !tabDetailEntities?.length) {
+            return [];
+        }
+        const tabs = [];
+        for (const relatedEntity of tabDetailEntities) {
+            const converter = this.relatedEntityConverterFactory.createTabDetailsConverter();
+            tabs.push(await converter.convert(relatedEntity, {
+                entityResolver: dependencies.entityResolver,
+            }));
+        }
+        return tabs;
+    }
+    async buildTabLists(tabListEntities, rootContext, dependencies) {
+        if (!dependencies?.entityResolver || !tabListEntities?.length) {
+            return [];
+        }
+        const tabs = [];
+        for (const relatedEntity of tabListEntities) {
+            const converter = this.relatedEntityConverterFactory.createTabListConverter();
+            tabs.push(await converter.convert(relatedEntity, {
+                entityResolver: dependencies.entityResolver,
+                expressionEvaluator: dependencies.expressionEvaluator,
+                context: rootContext,
+            }));
+        }
+        return tabs;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.6", ngImport: i0, type: AXPMainEntityContentBuilder, deps: [{ token: AXPRelatedEntityConverterFactory }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.6", ngImport: i0, type: AXPMainEntityContentBuilder, providedIn: 'root' }); }
 }
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.6", ngImport: i0, type: AXPMainEntityContentBuilder, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [{ type: AXPRelatedEntityConverterFactory }] });
 
-async function entityRelatedEntityTabList(relatedEntity, entityResolver) {
-    const moduleName = relatedEntity.entity.split('.')[0];
-    const entityName = relatedEntity.entity.split('.')[1];
-    const entityDef = await entityResolver.get(moduleName, entityName);
-    if (!entityDef) {
-        throw new Error(`Entity ${relatedEntity.entity} not found`);
+class AXPLayoutAdapterFactory {
+    constructor(relatedEntityConverterFactory, mainEntityContentBuilder, layoutAdapterBuilder) {
+        this.relatedEntityConverterFactory = relatedEntityConverterFactory;
+        this.mainEntityContentBuilder = mainEntityContentBuilder;
+        this.layoutAdapterBuilder = layoutAdapterBuilder;
+    }
+    async createDetailsViewAdapter(entityResolver, moduleName, entityName, id, dependencies) {
+        const entity = await entityResolver.resolve(moduleName, entityName);
+        if (!entity) {
+            throw new Error(`Entity ${moduleName}.${entityName} not found`);
+        }
+        const rootContext = await this.loadRootContext(entity, id);
+        return this.layoutAdapterBuilder
+            .setEntity(entity, rootContext)
+            .setDependencies(dependencies)
+            .setMainPage(await this.buildMainPage(entity, rootContext, dependencies))
+            .setRelatedPages(await this.buildRelatedPages(entity, rootContext, dependencies))
+            .build();
+    }
+    async loadRootContext(entity, id) {
+        const fn = entity?.queries.byKey?.execute;
+        return await fn(id);
+    }
+    async buildMainPage(entity, rootContext, dependencies) {
+        return this.mainEntityContentBuilder.build(entity, rootContext, dependencies);
+    }
+    async buildRelatedPages(entity, rootContext, dependencies) {
+        const pages = [];
+        // Page Details
+        const pageDetailEntities = entity?.relatedEntities?.filter((re) => !re.hidden && re.layoutType === 'page-detail');
+        for (const relatedEntity of pageDetailEntities || []) {
+            const converter = this.relatedEntityConverterFactory.createPageDetailsConverter();
+            pages.push(await converter.convert(relatedEntity, { entityResolver: dependencies.entityResolver }));
+        }
+        // Page Lists
+        const pageListEntities = entity?.relatedEntities?.filter((re) => !re.hidden && re.layoutType === 'page-list');
+        for (const relatedEntity of pageListEntities || []) {
+            const converter = this.relatedEntityConverterFactory.createPageListConverter();
+            pages.push(await converter.convert(relatedEntity, {
+                ...dependencies,
+                context: rootContext,
+                rootTitle: await this.getRootTitle(entity, rootContext, dependencies),
+            }));
+        }
+        return pages;
     }
-    return {
-        id: entityDef?.name ?? '',
-        title: relatedEntity.title || '',
-        icon: relatedEntity.icon,
-        content: [
-            {
-                type: AXPWidgetsCatalog.entityList,
-                name: 'tab-list',
-                options: {
-                    entity: relatedEntity.entity,
-                },
-            },
-        ],
-    };
+    async getRootTitle(entity, rootContext, dependencies) {
+        // Logic for getting root title
+        return await dependencies.expressionEvaluator.evaluate(entity.interfaces?.master?.single?.title, rootContext);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.6", ngImport: i0, type: AXPLayoutAdapterFactory, deps: [{ token: AXPRelatedEntityConverterFactory }, { token: AXPMainEntityContentBuilder }, { token: AXPLayoutAdapterBuilder }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.6", ngImport: i0, type: AXPLayoutAdapterFactory, providedIn: 'root' }); }
 }
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.6", ngImport: i0, type: AXPLayoutAdapterFactory, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [{ type: AXPRelatedEntityConverterFactory }, { type: AXPMainEntityContentBuilder }, { type: AXPLayoutAdapterBuilder }] });
 
-const AXPLayoutDetailsViewRouteResolver = async (route, state, entityResolver = inject(AXPEntityResolver), session = inject(AXPSessionService)) => {
+const AXPLayoutDetailsViewRouteResolver = async (route, state, entityResolver = inject(AXPEntityDefinitionRegistryService), expressionEvaluator = inject(AXPExpressionEvaluatorService), session = inject(AXPSessionService), formatService = inject(AXFormatService), workflowService = inject(AXPWorkflowService), layoutAdapterFactory = inject(AXPLayoutAdapterFactory)) => {
     const moduleName = route.parent?.paramMap.get('module');
     const entityName = route.paramMap.get('entity');
-    const entity = await entityResolver.get(moduleName, entityName);
     const id = route.paramMap.get('id');
-    const groups = entity?.groups ?? [];
-    const singleInterface = entity?.interfaces?.master?.single;
-    const getGroupById = (id) => {
-        return groups.find((s) => s.id === id);
-    };
-    const getPropertyByGroupId = (groupId) => {
-        return entity?.properties.filter((p) => p.groupId === groupId) ?? [];
-    };
-    const getPropertyLayout = (name) => {
-        return singleInterface?.properties?.find((p) => p.name === name)?.layout;
-    };
-    const getRelatedEntities = (type) => {
-        return entity?.relatedEntities?.filter((re) => !re.hidden && re.layoutType === type);
-    };
-    //
-    const adapter = {
-        title: entity?.title,
-        // description: entity?.description,
-        actions: [],
-        breadcrumbs: [
-            {
-                title: entity?.formats.plural ?? '',
-                command: {
-                    name: 'navigate',
-                    options: {
-                        path: `/${session.application?.name}/m/${moduleName}/e/${entityName}/list`,
-                    },
-                },
-            },
-            {
-                title: entity?.interfaces?.master?.single?.title ?? '',
-            },
-        ],
-        execute: (command, context) => {
-            console.log('layout execute', command, context);
-            return Promise.resolve({ success: true });
-        },
-        load: async () => {
-            const fn = entity?.queries.byKey?.execute;
-            const result = await fn(id);
-            return {
-                success: true,
-                result: result,
-            };
-        },
-        pages: [
-            {
-                id: entity?.name ?? '',
-                // title: singleInterface?.title ?? entity?.formats.individual ?? '',
-                title: entity?.formats.individual ?? '',
-                icon: entity?.icon,
-                settings: {
-                    commands: {
-                        reject: {
-                            title: 't("discard")',
-                            color: 'default',
-                            visible: '{{context.isDirty()}}',
-                            command: {
-                                name: 'discard',
-                            },
-                        },
-                        accept: {
-                            title: 't("confirm")',
-                            color: 'secondary',
-                            visible: '{{context.isDirty()}}',
-                            command: {
-                                name: 'update-entity',
-                            },
-                        },
-                    },
-                },
-                load: async () => {
-                    const fn = entity?.queries.byKey?.execute;
-                    const result = await fn(id);
-                    return {
-                        success: true,
-                        result: result,
-                    };
-                },
-                execute: async (e, context) => {
-                    if (e.name == 'update-entity') {
-                        const fn = entity?.commands?.update?.execute;
-                        const result = await fn(context);
-                        return {
-                            success: true,
-                            result: result,
-                        };
-                    }
-                    else {
-                        return {
-                            success: false,
-                            error: {
-                                code: 'invalid_command',
-                                message: 'Invalid command',
-                            },
-                        };
-                    }
-                },
-                tabs: [
-                    ...(await Promise.all(getRelatedEntities('tab-detail')?.map(async (e) => await entityRelatedEntityTabDetails(e, entityResolver)) ?? [])),
-                    ...(await Promise.all(getRelatedEntities('tab-list')?.map(async (e) => await entityRelatedEntityTabList(e, entityResolver)) ?? [])),
-                ],
-                content: [
-                    {
-                        type: 'grid-layout',
-                        mode: 'edit',
-                        options: {
-                            grid: {
-                                default: {
-                                    gridTemplateColumns: 'repeat(12, 1fr)',
-                                    gridTemplateRows: 'repeat(1, 1fr)',
-                                    gap: '20px',
-                                },
-                            },
-                        },
-                        children: singleInterface?.sections.map((s) => ({
-                            type: 'grid-item-layout',
-                            name: s.id,
-                            options: {
-                                colSpan: s.layout?.positions?.lg?.colSpan ?? 12,
-                                colStart: s.layout?.positions?.lg?.colStart ?? 1,
-                                colEnd: s.layout?.positions?.lg?.colEnd ?? 13,
-                            },
-                            children: [
-                                {
-                                    type: 'fieldset-layout',
-                                    options: {
-                                        title: getGroupById(s.id)?.title ?? '',
-                                        collapsible: true,
-                                    },
-                                    children: [
-                                        {
-                                            type: 'grid-layout',
-                                            options: {
-                                                grid: {
-                                                    default: {
-                                                        gridTemplateColumns: 'repeat(12, 1fr)',
-                                                        gridTemplateRows: 'repeat(1, 1fr)',
-                                                        gap: '20px',
-                                                    },
-                                                },
-                                            },
-                                            children: getPropertyByGroupId(s.id)
-                                                .filter((property) => !property.schema.hidden)
-                                                .map((p) => {
-                                                const layout = getPropertyLayout(p.name);
-                                                return {
-                                                    type: 'grid-item-layout',
-                                                    name: p.name,
-                                                    options: {
-                                                        colSpan: layout?.positions?.lg?.colSpan,
-                                                        colStart: layout?.positions?.lg?.colStart,
-                                                        colEnd: layout?.positions?.lg?.colEnd,
-                                                    },
-                                                    children: [
-                                                        {
-                                                            type: 'form-field',
-                                                            options: {
-                                                                label: p.title,
-                                                            },
-                                                            children: [
-                                                                {
-                                                                    type: p.schema.interface?.type ?? '',
-                                                                    path: p.name,
-                                                                    name: p.name,
-                                                                    defaultValue: p.schema.defaultValue,
-                                                                    children: p.schema.interface?.children,
-                                                                    options: p.schema.interface?.options,
-                                                                    triggers: p.schema.interface?.triggers,
-                                                                    valueTransforms: p.schema.interface?.valueTransforms,
-                                                                },
-                                                            ],
-                                                        },
-                                                    ],
-                                                };
-                                            }),
-                                        },
-                                    ],
-                                },
-                            ],
-                        })),
-                    },
-                ],
-            },
-            ...(await Promise.all(getRelatedEntities('page-detail')?.map(async (e) => await entityRelatedEntityPageDetails(e, entityResolver)) ??
-                [])),
-            ...(await Promise.all(getRelatedEntities('page-list')?.map(async (e) => await entityRelatedEntityPageList(e, entityResolver)) ?? [])),
-        ],
+    const dependencies = {
+        entityResolver,
+        expressionEvaluator,
+        session,
+        formatService,
+        workflowService,
     };
-    //
-    return new Promise((resolve) => {
-        setTimeout(() => {
-            resolve(adapter);
-        }, 200);
-    });
+    return await layoutAdapterFactory.createDetailsViewAdapter(entityResolver, moduleName, entityName, id, dependencies);
 };
 
 class AXPEntityCommandSearchDefinitionProvider {
@@ -2919,13 +3486,12 @@ class AXPEntitySearchDefinitionProvider {
     }
 }
 
-class AXPEntityListConverterService {
+class AXPEntityListTableService {
     constructor() {
         //#region ----   Services & Dependencies   ----
         this.entityResolver = inject(AXPEntityResolver);
         this.workflow = inject(AXPWorkflowService);
         this.expressionEvaluator = inject(AXPExpressionEvaluatorService);
-        this.widgetResolver = inject(AXPWidgetRegistryService);
         this.evaluateExpressions = async (options, data) => {
             const scope = {
                 context: {
@@ -2939,14 +3505,6 @@ class AXPEntityListConverterService {
     }
     //#endregion
     //#region ----   Public Methods   ----
-    async convertEntityToolbarOptions(entity, options) {
-        const toolbarOptions = {
-            filterDefinitions: this.createFilterDefinitions(entity),
-            columnDefinitions: this.createColumnDefinitions(entity, options),
-            sortDefinitions: this.createSortDefinitions(entity),
-        };
-        return toolbarOptions;
-    }
     /**
      * Convert Entity to List Widget Options
      */
@@ -2968,6 +3526,8 @@ class AXPEntityListConverterService {
             showFooter: false,
             // 🔗 Entity Configuration
             parentField: entity.parentKey,
+            fetchDataMode: 'manual',
+            minHeight: 250,
             // 🎪 Events
             ...this.createDefaultEvents(entity, allActions),
         };
@@ -3136,6 +3696,36 @@ class AXPEntityListConverterService {
             },
         };
     }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.6", ngImport: i0, type: AXPEntityListTableService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.6", ngImport: i0, type: AXPEntityListTableService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.6", ngImport: i0, type: AXPEntityListTableService, decorators: [{
+            type: Injectable
+        }] });
+
+class AXPEntityListToolbarService {
+    constructor() {
+        //#region ----   Services & Dependencies   ----
+        this.widgetResolver = inject(AXPWidgetRegistryService);
+    }
+    //#endregion
+    //#region ----   Public Methods   ----
+    /**
+     * Convert Entity to Toolbar Options
+     */
+    async convertEntityToolbarOptions(entity, options) {
+        const toolbarOptions = {
+            filterDefinitions: this.createFilterDefinitions(entity),
+            columnDefinitions: this.createColumnDefinitions(entity, options),
+            sortDefinitions: this.createSortDefinitions(entity),
+        };
+        return toolbarOptions;
+    }
+    //#endregion
+    //#region ----   Private Methods   ----
+    /**
+     * Create Filter Definitions for Toolbar
+     */
     createFilterDefinitions(entity) {
         const props = entity.properties.filter((c) => c.options?.filter?.advance?.enabled || c.options?.filter?.inline?.enabled);
         return props.map((e) => {
@@ -3160,6 +3750,9 @@ class AXPEntityListConverterService {
             };
         });
     }
+    /**
+     * Create Column Definitions for Toolbar
+     */
     createColumnDefinitions(entity, options) {
         const { columns = [], properties } = entity;
         const excludeColumns = options?.excludeColumns || [];
@@ -3185,6 +3778,9 @@ class AXPEntityListConverterService {
             };
         });
     }
+    /**
+     * Create Sort Definitions for Toolbar
+     */
     createSortDefinitions(entity) {
         const props = entity.properties.filter((c) => c.options?.sort?.enabled);
         return props.map((e) => {
@@ -3194,10 +3790,10 @@ class AXPEntityListConverterService {
             };
         });
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.6", ngImport: i0, type: AXPEntityListConverterService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.6", ngImport: i0, type: AXPEntityListConverterService }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.6", ngImport: i0, type: AXPEntityListToolbarService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.6", ngImport: i0, type: AXPEntityListToolbarService }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.6", ngImport: i0, type: AXPEntityListConverterService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.6", ngImport: i0, type: AXPEntityListToolbarService, decorators: [{
             type: Injectable
         }] });
 
@@ -3206,21 +3802,26 @@ class AXPEntityListWidgetViewComponent extends AXPValueWidgetComponent {
         super(...arguments);
         this.entityResolver = inject(AXPEntityResolver);
         this.workflow = inject(AXPWorkflowService);
-        this.entityListService = inject(AXPEntityListConverterService);
+        this.entityListTableService = inject(AXPEntityListTableService);
+        this.entityListToolbarService = inject(AXPEntityListToolbarService);
         this.layoutThemeService = inject(AXPLayoutThemeService);
+        this.container = viewChild(AXPWidgetContainerComponent, ...(ngDevMode ? [{ debugName: "container" }] : []));
+        this.isMounted = signal(false, ...(ngDevMode ? [{ debugName: "isMounted" }] : []));
         this.entity = signal(null, ...(ngDevMode ? [{ debugName: "entity" }] : []));
         this.listNode = signal(null, ...(ngDevMode ? [{ debugName: "listNode" }] : []));
         this.list = viewChild('list', ...(ngDevMode ? [{ debugName: "list" }] : []));
         this.allWidgets = viewChildren(AXPWidgetRendererDirective, ...(ngDevMode ? [{ debugName: "allWidgets" }] : []));
-        this.listWidget = computed(() => this.allWidgets().find((widget) => widget.node()?.type === AXPWidgetsCatalog.list), ...(ngDevMode ? [{ debugName: "listWidget" }] : []));
+        this.listWidget = linkedSignal(() => this.allWidgets().find((widget) => widget.node()?.type === AXPWidgetsCatalog.list));
         this.toolbarWidget = computed(() => this.allWidgets().find((widget) => widget.node()?.type === AXPWidgetsCatalog.listToolbar), ...(ngDevMode ? [{ debugName: "toolbarWidget" }] : []));
-        this.selectedItems = computed(() => this.contextService.getValue(`${this.fullPath()}.table`) || [], ...(ngDevMode ? [{ debugName: "selectedItems" }] : []));
+        this.selectedItems = computed(() => this.getValue()?.table || [], ...(ngDevMode ? [{ debugName: "selectedItems" }] : []));
         this.toolbarNode = signal(null, ...(ngDevMode ? [{ debugName: "toolbarNode" }] : []));
         this.destroyed = new Subject();
         //options
         this.entitySource = computed(() => this.options()['entity'], ...(ngDevMode ? [{ debugName: "entitySource" }] : []));
         this.excludeColumns = computed(() => this.options()['excludeColumns'], ...(ngDevMode ? [{ debugName: "excludeColumns" }] : []));
         this.includeColumns = computed(() => this.options()['includeColumns'], ...(ngDevMode ? [{ debugName: "includeColumns" }] : []));
+        this.showEntityActions = computed(() => this.options()['showEntityActions'] ?? true, ...(ngDevMode ? [{ debugName: "showEntityActions" }] : []));
+        this.showToolbar = computed(() => this.options()['showToolbar'] ?? true, ...(ngDevMode ? [{ debugName: "showToolbar" }] : []));
         //actions
         this.allActions = computed(() => {
             const list = this.entity()?.interfaces?.master?.list?.actions ?? [];
@@ -3263,6 +3864,20 @@ class AXPEntityListWidgetViewComponent extends AXPValueWidgetComponent {
             }));
             return actions;
         }, ...(ngDevMode ? [{ debugName: "secondaryActions" }] : []));
+        //#region ----   Query Change Handler   ----
+        this.#effect = effect(() => {
+            const queries = this.getValue()?.toolbar;
+            const listInstance = this.listWidget()?.instance;
+            const dataSource = this.listWidget()?.options()['dataSource'];
+            const isMounted = this.isMounted();
+            if (!this.hasRequiredDependencies(dataSource, queries, listInstance)) {
+                return;
+            }
+            untracked(() => {
+                this.handleQueryChanges(queries, dataSource, listInstance, isMounted);
+            });
+        }, ...(ngDevMode ? [{ debugName: "#effect" }] : []));
+        //#endregion
         this.context = {};
         this.previousQueries = null;
     }
@@ -3276,6 +3891,9 @@ class AXPEntityListWidgetViewComponent extends AXPValueWidgetComponent {
             this.execute(item.command.name, null);
         }
     }
+    // ngDoCheck(): void {
+    //   console.log(this.listWidget()?.instance.output('selectedRows'));
+    // }
     async execute(commandName, data) {
         const action = this.allActions().find((c) => {
             return (c.name == commandName &&
@@ -3300,30 +3918,71 @@ class AXPEntityListWidgetViewComponent extends AXPValueWidgetComponent {
             metadata: action?.metadata,
         });
     }
-    onContextChanged(context) {
-        const queries = context.data.list.toolbar;
+    //#region ----   Query Change Handler   ----
+    #effect;
+    /**
+     * Validates that all required dependencies are available
+     */
+    hasRequiredDependencies(dataSource, queries, listInstance) {
+        return !!(dataSource && queries && listInstance);
+    }
+    /**
+     * Handles all query-related changes (filters, sorts, columns)
+     */
+    handleQueryChanges(queries, dataSource, listInstance, isMounted) {
+        const changeTracker = this.analyzeChanges(queries);
+        this.previousQueries = queries;
+        this.applyDataSourceChanges(dataSource, queries, changeTracker);
+        this.handleListRefresh(listInstance, changeTracker, isMounted);
+        this.handleColumnChanges(changeTracker);
+    }
+    /**
+     * Analyzes what has changed between current and previous queries
+     */
+    analyzeChanges(queries) {
         const changes = getChangedPaths(queries, this.previousQueries);
-        console.log('changes', changes, queries);
-        const listInstance = untracked(() => this.listWidget()?.instance);
-        const isFilterChanged = changes.includes('filters');
-        const isSortChanged = changes.includes('sorts');
-        const isColumnsChanged = changes.includes('columns');
-        untracked(() => {
-            this.previousQueries = queries;
-            const dataSource = listInstance?.options()['dataSource'];
-            if (isFilterChanged) {
-                dataSource.filter({
-                    filters: queries.filters,
-                });
-                listInstance?.call('refresh');
-            }
-            if (isSortChanged) {
-                dataSource.sort(...queries.sorts);
-                listInstance?.call('refresh');
+        return {
+            isFilterChanged: changes.includes('filters'),
+            isSortChanged: changes.includes('sorts'),
+            isColumnsChanged: changes.includes('columns'),
+            hasAnyChange: changes.length > 0,
+        };
+    }
+    /**
+     * Applies filter and sort changes to the data source
+     */
+    applyDataSourceChanges(dataSource, queries, changeTracker) {
+        if (changeTracker.isFilterChanged) {
+            dataSource.filter({
+                filters: queries?.filters,
+            });
+        }
+        if (changeTracker.isSortChanged) {
+            dataSource.sort(...(queries.sorts || []));
+        }
+    }
+    /**
+     * Handles list refresh logic based on changes and mount status
+     */
+    handleListRefresh(listInstance, changeTracker, isMounted) {
+        const shouldRefresh = changeTracker.isFilterChanged || changeTracker.isSortChanged || !isMounted;
+        if (shouldRefresh) {
+            listInstance.call('refresh');
+            // Set mounted flag only on initial load (not when filters/sorts change)
+            if (!changeTracker.isFilterChanged && !changeTracker.isSortChanged) {
+                this.isMounted.set(true);
             }
-            // if(isColumnsChanged){
-            // }
-        });
+        }
+    }
+    /**
+     * Handles column-related changes
+     * TODO: Implement column change logic
+     */
+    handleColumnChanges(changeTracker) {
+        if (changeTracker.isColumnsChanged) {
+            // TODO: Implement column change handling
+            console.log('Column changes detected - implementation needed');
+        }
     }
     async ngOnInit() {
         super.ngOnInit();
@@ -3341,21 +4000,26 @@ class AXPEntityListWidgetViewComponent extends AXPValueWidgetComponent {
             excludeColumns: this.excludeColumns(),
             includeColumns: this.includeColumns(),
         };
-        const listOptions = await this.entityListService.convertEntityToListOptions(resolvedEntity, options);
-        const toolbarOptions = await this.entityListService.convertEntityToolbarOptions(resolvedEntity, options);
+        const listOptions = await this.entityListTableService.convertEntityToListOptions(resolvedEntity, options);
+        const toolbarOptions = await this.entityListToolbarService.convertEntityToolbarOptions(resolvedEntity, options);
         this.listNode.set({
             type: AXPWidgetsCatalog.list,
             options: listOptions,
             path: `table`,
+            name: 'table',
             mode: 'view',
-            defaultValue: this.getValue(),
+            defaultValue: this.getValue()?.table,
         });
         this.toolbarNode.set({
             type: AXPWidgetsCatalog.listToolbar,
             path: `toolbar`,
             options: toolbarOptions,
             mode: 'view',
-            defaultValue: this.getValue(),
+            defaultValue: {
+                filters: this.getValue()?.toolbar?.filters,
+                sorts: this.getValue()?.toolbar?.sorts,
+                columns: this.getValue()?.toolbar?.columns,
+            },
         });
     }
     ngAfterViewInit() {
@@ -3368,13 +4032,14 @@ class AXPEntityListWidgetViewComponent extends AXPValueWidgetComponent {
             }
         });
     }
-    destroy() {
+    ngOnDestroy() {
+        this.listWidget.set(undefined);
         this.destroyed.next();
         this.destroyed.complete();
     }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.6", ngImport: i0, type: AXPEntityListWidgetViewComponent, deps: null, target: i0.ɵɵFactoryTarget.Component }); }
-    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "20.1.6", type: AXPEntityListWidgetViewComponent, isStandalone: true, selector: "ng-component", providers: [AXPEntityListConverterService], viewQueries: [{ propertyName: "list", first: true, predicate: ["list"], descendants: true, isSignal: true }, { propertyName: "allWidgets", predicate: AXPWidgetRendererDirective, descendants: true, isSignal: true }], usesInheritance: true, ngImport: i0, template: `
-    <axp-widgets-container [context]="context" (onContextChanged)="onContextChanged($event)">
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "20.1.6", type: AXPEntityListWidgetViewComponent, isStandalone: true, selector: "ng-component", host: { properties: { "class": "\"ax-h-full\"" } }, providers: [AXPEntityListTableService, AXPEntityListToolbarService], viewQueries: [{ propertyName: "container", first: true, predicate: AXPWidgetContainerComponent, descendants: true, isSignal: true }, { propertyName: "list", first: true, predicate: ["list"], descendants: true, isSignal: true }, { propertyName: "allWidgets", predicate: AXPWidgetRendererDirective, descendants: true, isSignal: true }], usesInheritance: true, ngImport: i0, template: `
+    @if (showEntityActions()) {
       <div class="ax-flex ax-gap-2 ax-justify-end ax-mb-4">
         @for (action of primaryActions(); track $index) {
           @if (action.visible != false) {
@@ -3451,37 +4116,36 @@ class AXPEntityListWidgetViewComponent extends AXPValueWidgetComponent {
           </ax-button>
         }
       </div>
-
-      <div class="ax-flex ax-flex-col ax-gap-2">
-        @if (toolbarNode() != null) {
-          <ng-container
-            #toolbar
-            axp-widget-renderer
-            [node]="toolbarNode()!"
-            [parentNode]="this"
-            [index]="index"
-            [mode]="this.mode"
-          ></ng-container>
-        }
-        @if (listNode() != null) {
-          <ng-container
-            #list
-            axp-widget-renderer
-            [node]="listNode()!"
-            [parentNode]="this"
-            [index]="index"
-            [mode]="this.mode"
-          ></ng-container>
-        }
-      </div>
-    </axp-widgets-container>
-  `, isInline: true, dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "ngmodule", type: AXDecoratorModule }, { kind: "component", type: i3.AXDecoratorIconComponent, selector: "ax-icon", inputs: ["icon"] }, { kind: "component", type: i3.AXDecoratorGenericComponent, selector: "ax-footer, ax-header, ax-content, ax-divider, ax-form-hint, ax-prefix, ax-suffix, ax-text, ax-title, ax-subtitle, ax-placeholder, ax-overlay" }, { kind: "ngmodule", type: AXPLayoutBuilderModule }, { kind: "component", type: i2.AXPWidgetContainerComponent, selector: "axp-widgets-container", inputs: ["context", "functions"], outputs: ["onContextChanged"] }, { kind: "directive", type: i2.AXPWidgetRendererDirective, selector: "[axp-widget-renderer]", inputs: ["parentNode", "index", "mode", "node"], outputs: ["onOptionsChanged", "onValueChanged"], exportAs: ["widgetRenderer"] }, { kind: "ngmodule", type: AXButtonModule }, { kind: "component", type: i3$1.AXButtonComponent, selector: "ax-button", inputs: ["disabled", "size", "tabIndex", "color", "look", "text", "toggleable", "selected", "iconOnly", "type", "loadingText"], outputs: ["onBlur", "onFocus", "onClick", "selectedChange", "toggleableChange", "lookChange", "colorChange", "disabledChange", "loadingTextChange"] }, { kind: "component", type: i3$1.AXButtonItemComponent, selector: "ax-button-item", inputs: ["color", "disabled", "text", "selected", "divided", "data", "name"], outputs: ["onClick", "onFocus", "onBlur", "disabledChange"] }, { kind: "component", type: i3$1.AXButtonItemListComponent, selector: "ax-button-item-list", inputs: ["items"], outputs: ["onItemClick"] }, { kind: "ngmodule", type: AXDropdownModule }, { kind: "component", type: i4.AXDropdownPanelComponent, selector: "ax-dropdown-panel", inputs: ["isOpen", "fitParent", "dropdownWidth", "position", "placement", "_target", "adaptivityEnabled"], outputs: ["onOpened", "onClosed"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+    }
+    <div class="ax-flex ax-flex-col ax-gap-2 ax-h-full">
+      @if (toolbarNode() != null && showToolbar()) {
+        <ng-container
+          #toolbar
+          axp-widget-renderer
+          [node]="toolbarNode()!"
+          [parentNode]="this"
+          [index]="index"
+          [mode]="this.mode"
+        ></ng-container>
+      }
+      @if (listNode() != null) {
+        <ng-container
+          #list
+          axp-widget-renderer
+          [node]="listNode()!"
+          [parentNode]="this"
+          [index]="index"
+          [mode]="this.mode"
+        ></ng-container>
+      }
+    </div>
+  `, isInline: true, dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "ngmodule", type: AXDecoratorModule }, { kind: "component", type: i3.AXDecoratorIconComponent, selector: "ax-icon", inputs: ["icon"] }, { kind: "component", type: i3.AXDecoratorGenericComponent, selector: "ax-footer, ax-header, ax-content, ax-divider, ax-form-hint, ax-prefix, ax-suffix, ax-text, ax-title, ax-subtitle, ax-placeholder, ax-overlay" }, { kind: "ngmodule", type: AXPLayoutBuilderModule }, { kind: "directive", type: i2.AXPWidgetRendererDirective, selector: "[axp-widget-renderer]", inputs: ["parentNode", "index", "mode", "node"], outputs: ["onOptionsChanged", "onValueChanged"], exportAs: ["widgetRenderer"] }, { kind: "ngmodule", type: AXButtonModule }, { kind: "component", type: i3$1.AXButtonComponent, selector: "ax-button", inputs: ["disabled", "size", "tabIndex", "color", "look", "text", "toggleable", "selected", "iconOnly", "type", "loadingText"], outputs: ["onBlur", "onFocus", "onClick", "selectedChange", "toggleableChange", "lookChange", "colorChange", "disabledChange", "loadingTextChange"] }, { kind: "component", type: i3$1.AXButtonItemComponent, selector: "ax-button-item", inputs: ["color", "disabled", "text", "selected", "divided", "data", "name"], outputs: ["onClick", "onFocus", "onBlur", "disabledChange"] }, { kind: "component", type: i3$1.AXButtonItemListComponent, selector: "ax-button-item-list", inputs: ["items"], outputs: ["onItemClick"] }, { kind: "ngmodule", type: AXDropdownModule }, { kind: "component", type: i4.AXDropdownPanelComponent, selector: "ax-dropdown-panel", inputs: ["isOpen", "fitParent", "dropdownWidth", "position", "placement", "_target", "adaptivityEnabled"], outputs: ["onOpened", "onClosed"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.6", ngImport: i0, type: AXPEntityListWidgetViewComponent, decorators: [{
             type: Component,
             args: [{
                     template: `
-    <axp-widgets-container [context]="context" (onContextChanged)="onContextChanged($event)">
+    @if (showEntityActions()) {
       <div class="ax-flex ax-gap-2 ax-justify-end ax-mb-4">
         @for (action of primaryActions(); track $index) {
           @if (action.visible != false) {
@@ -3558,34 +4222,36 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.6", ngImpor
           </ax-button>
         }
       </div>
-
-      <div class="ax-flex ax-flex-col ax-gap-2">
-        @if (toolbarNode() != null) {
-          <ng-container
-            #toolbar
-            axp-widget-renderer
-            [node]="toolbarNode()!"
-            [parentNode]="this"
-            [index]="index"
-            [mode]="this.mode"
-          ></ng-container>
-        }
-        @if (listNode() != null) {
-          <ng-container
-            #list
-            axp-widget-renderer
-            [node]="listNode()!"
-            [parentNode]="this"
-            [index]="index"
-            [mode]="this.mode"
-          ></ng-container>
-        }
-      </div>
-    </axp-widgets-container>
+    }
+    <div class="ax-flex ax-flex-col ax-gap-2 ax-h-full">
+      @if (toolbarNode() != null && showToolbar()) {
+        <ng-container
+          #toolbar
+          axp-widget-renderer
+          [node]="toolbarNode()!"
+          [parentNode]="this"
+          [index]="index"
+          [mode]="this.mode"
+        ></ng-container>
+      }
+      @if (listNode() != null) {
+        <ng-container
+          #list
+          axp-widget-renderer
+          [node]="listNode()!"
+          [parentNode]="this"
+          [index]="index"
+          [mode]="this.mode"
+        ></ng-container>
+      }
+    </div>
   `,
                     standalone: true,
+                    host: {
+                        '[class]': '"ax-h-full"',
+                    },
                     changeDetection: ChangeDetectionStrategy.OnPush,
-                    providers: [AXPEntityListConverterService],
+                    providers: [AXPEntityListTableService, AXPEntityListToolbarService],
                     imports: [CommonModule, AXDecoratorModule, AXPLayoutBuilderModule, AXButtonModule, AXDropdownModule],
                 }]
         }] });
@@ -3731,17 +4397,14 @@ var entityReferenceWidgetDesigner_component = /*#__PURE__*/Object.freeze({
 });
 
 const AXPEntityReferenceWidget = {
-    name: "entity-reference",
-    title: "Entity Reference",
+    name: 'entity-reference',
+    title: 'Entity Reference',
     description: '',
     type: 'view',
     categories: [],
-    groups: [AXPWidgetGroupEnum.FormElement],
-    icon: "fa-solid fa-square",
-    properties: [
-        AXP_NAME_PROPERTY,
-        AXP_DATA_PATH_PROPERTY,
-    ],
+    groups: [AXPWidgetGroupEnum.EntityWidget],
+    icon: 'fa-solid fa-square',
+    properties: [AXP_NAME_PROPERTY, AXP_DATA_PATH_PROPERTY],
     components: {
         view: {
             component: () => Promise.resolve().then(function () { return entityReferenceWidgetView_component; }).then((c) => c.AXPEntityReferenceWidgetViewComponent),
@@ -3758,7 +4421,7 @@ const AXPEntityReferenceWidget = {
         designer: {
             component: () => Promise.resolve().then(function () { return entityReferenceWidgetDesigner_component; }).then((c) => c.AXPEntityReferenceWidgetDesignerComponent),
         },
-    }
+    },
 };
 
 class AXPLookupWidgetViewComponent extends AXPValueWidgetComponent {
@@ -5057,6 +5720,7 @@ const AXPTagableBoxWidget = {
     description: 'Inputs text with tags',
     categories: AXP_WIDGETS_EDITOR_CATEGORY,
     type: 'editor',
+    groups: [AXPWidgetGroupEnum.EntityWidget],
     defaultFilterWidgetName: 'string-filter',
     properties: [AXP_NAME_PROPERTY, AXP_DATA_PATH_PROPERTY],
     components: {
@@ -5453,10 +6117,10 @@ class AXPShowDetailViewAction extends AXPWorkflowAction {
         this.sessionService = inject(AXPSessionService);
     }
     async execute(context) {
-        const [module, entity] = context.getVariable('entity').split(".");
+        const [module, entity] = context.getVariable('entity').split('.');
         const { id } = context.getVariable('data');
         const newPayload = {
-            commands: `/${this.sessionService.application?.name}/m/${module}/e/${entity}/${id}/view`,
+            commands: `/${this.sessionService.application?.name}/m/${module}/e/${entity}/${id}/new-view`,
         };
         context.setVariable('payload', newPayload);
         this.navigation.execute(context);
@@ -5498,6 +6162,7 @@ class AXPShowFileUploaderPopupAction extends AXPWorkflowAction {
             multiple: multiple,
             accept: accept,
             fileEditable: fileEditable,
+            // maxFileSize: maxFileSize,
         });
         // Handle case when result is undefined or empty array
         if (!res || res.length === 0) {
@@ -5587,6 +6252,57 @@ const AXPShowListViewWorkflow = {
     },
 };
 
+/**
+ * Default widths for common text columns
+ */
+const DEFAULT_COLUMN_WIDTHS = {
+    title: '250px',
+    description: '500px',
+    note: '350px',
+    notes: '350px',
+    content: '500px'
+};
+/**
+ * Factory to create a column width middleware using provided config map.
+ * Sets width for columns defined in the map if not already defined on the column.
+ */
+const columnWidthMiddlewareFactory = (widths) => {
+    return (context) => {
+        const columns = context.columns.list();
+        if (!columns) {
+            return;
+        }
+        columns.forEach((column) => {
+            const desiredWidth = widths[column.name];
+            if (desiredWidth && !column.options?.width) {
+                const normalizedWidth = typeof desiredWidth === 'number' ? `${desiredWidth}px` : desiredWidth;
+                context.columns.find(column.name).update((col) => ({
+                    ...col,
+                    options: {
+                        ...col.options,
+                        width: normalizedWidth
+                    }
+                }));
+            }
+        });
+    };
+};
+//#endregion
+//#region ----   Provider Registration   ----
+/**
+ * Helper to create a provider for the column width middleware.
+ * By default it applies to all entities using the '*' pattern.
+ */
+const createColumnWidthMiddlewareProvider = (widths, entityName = '*') => ({
+    entityName,
+    modifier: columnWidthMiddlewareFactory(widths)
+});
+/**
+ * Default provider registered with the default map.
+ */
+const columnWidthMiddlewareProvider = createColumnWidthMiddlewareProvider(DEFAULT_COLUMN_WIDTHS);
+//#endregion
+
 function routesFacory() {
     const config = inject(AXP_ENTITY_CONFIG_TOKEN);
     let routes = [];
@@ -5675,6 +6391,11 @@ class AXPEntityModule {
                 useClass: AXPEntityCommandSearchDefinitionProvider,
                 multi: true,
             },
+            {
+                provide: AXP_ENTITY_MODIFIER,
+                useValue: columnWidthMiddlewareProvider,
+                multi: true,
+            },
         ], imports: [RouterModule,
             AXPWorkflowModule.forChild({
                 actions: {
@@ -5773,6 +6494,11 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.6", ngImpor
                             useClass: AXPEntityCommandSearchDefinitionProvider,
                             multi: true,
                         },
+                        {
+                            provide: AXP_ENTITY_MODIFIER,
+                            useValue: columnWidthMiddlewareProvider,
+                            multi: true,
+                        },
                     ],
                 }]
         }], ctorParameters: () => [{ type: i1$4.AXPAppStartUpService }, { type: i0.Injector }] });
@@ -5803,6 +6529,7 @@ function entityMasterViewAction() {
         priority: 'secondary',
         type: 'view',
         scope: AXPEntityCommandScope.Individual,
+        default: true,
     };
 }
 function entityMasterDeleteAction() {
@@ -5954,7 +6681,6 @@ const eventDispatchMiddleware = {
     target: { ops: ['create', 'update', 'delete'], order: 90 },
     execute: async (ctx, next) => {
         const dispatcher = inject(AXPEntityEventDispatcherService);
-        console.log(ctx);
         await next();
         if (ctx.op === 'create') {
             const createdData = ctx.result ? { ...ctx.data, id: ctx.result } : ctx.data;
@@ -5978,5 +6704,5 @@ const eventDispatchMiddleware = {
  * Generated bundle index. Do not edit.
  */
 
-export { AXMEntityCrudService, AXMEntityCrudServiceImpl, AXPCreateEntityWorkflow, AXPDataSeederService, AXPDeleteEntityWorkflow, AXPEntityApplyUpdatesAction, AXPEntityCommandTriggerViewModel, AXPEntityCreateEvent, AXPEntityCreatePopupAction, AXPEntityCreateSubmittedAction, AXPEntityCreateViewElementViewModel, AXPEntityCreateViewModelFactory, AXPEntityCreateViewSectionViewModel, AXPEntityDataProvider, AXPEntityDataProviderImpl, AXPEntityDefinitionRegistryService, AXPEntityDeletedEvent, AXPEntityDetailListViewModel, AXPEntityDetailViewModelFactory, AXPEntityDetailViewModelResolver, AXPEntityEventDispatcherService, AXPEntityListViewColumnViewModel, AXPEntityListViewModelFactory, AXPEntityListViewModelResolver, AXPEntityMasterCreateViewModel, AXPEntityMasterListViewModel, AXPEntityMasterListViewQueryViewModel, AXPEntityMasterSingleElementViewModel, AXPEntityMasterSingleViewGroupViewModel, AXPEntityMasterSingleViewModel, AXPEntityMasterUpdateElementViewModel, AXPEntityMasterUpdateViewModel, AXPEntityMasterUpdateViewModelFactory, AXPEntityMiddleware, AXPEntityModifyConfirmedAction, AXPEntityModifyEvent, AXPEntityModifySectionPopupAction, AXPEntityModule, AXPEntityPerformDeleteAction, AXPEntityResolver, AXPEntityService, AXPEntityStorageService, AXPMiddlewareEntityStorageService, AXPModifyEntitySectionWorkflow, AXPQuickEntityModifyPopupAction, AXPQuickModifyEntityWorkflow, AXPShowDetailViewAction, AXPShowDetailsViewWorkflow, AXPShowListViewAction, AXPShowListViewWorkflow, AXP_DATA_SEEDER_TOKEN, AXP_ENTITY_ACTION_PLUGIN, AXP_ENTITY_CONFIG_TOKEN, AXP_ENTITY_DEFINITION_LOADER, AXP_ENTITY_MODIFIER, AXP_ENTITY_STORAGE_BACKEND, AXP_ENTITY_STORAGE_MIDDLEWARE, actionExists, createModifierContext, detectEntityChanges, ensureListActions, entityDetailsCreateActions, entityDetailsCrudActions, entityDetailsEditAction, entityDetailsReferenceCondition, entityDetailsReferenceCreateActions, entityDetailsSimpleCondition, entityMasterBulkDeleteAction, entityMasterCreateAction, entityMasterCrudActions, entityMasterDeleteAction, entityMasterRecordActions, entityMasterViewAction, entityOverrideDetailsViewAction, eventDispatchMiddleware };
+export { AXMEntityCrudService, AXMEntityCrudServiceImpl, AXPCreateEntityWorkflow, AXPDataSeederService, AXPDeleteEntityWorkflow, AXPEntityApplyUpdatesAction, AXPEntityCommandTriggerViewModel, AXPEntityCreateEvent, AXPEntityCreatePopupAction, AXPEntityCreateSubmittedAction, AXPEntityCreateViewElementViewModel, AXPEntityCreateViewModelFactory, AXPEntityCreateViewSectionViewModel, AXPEntityDataProvider, AXPEntityDataProviderImpl, AXPEntityDefinitionRegistryService, AXPEntityDeletedEvent, AXPEntityDetailListViewModel, AXPEntityDetailViewModelFactory, AXPEntityDetailViewModelResolver, AXPEntityEventDispatcherService, AXPEntityListViewColumnViewModel, AXPEntityListViewModelFactory, AXPEntityListViewModelResolver, AXPEntityMasterCreateViewModel, AXPEntityMasterListViewModel, AXPEntityMasterListViewQueryViewModel, AXPEntityMasterSingleElementViewModel, AXPEntityMasterSingleViewGroupViewModel, AXPEntityMasterSingleViewModel, AXPEntityMasterUpdateElementViewModel, AXPEntityMasterUpdateViewModel, AXPEntityMasterUpdateViewModelFactory, AXPEntityMiddleware, AXPEntityModifyConfirmedAction, AXPEntityModifyEvent, AXPEntityModifySectionPopupAction, AXPEntityModule, AXPEntityPerformDeleteAction, AXPEntityResolver, AXPEntityService, AXPEntityStorageService, AXPMiddlewareEntityStorageService, AXPModifyEntitySectionWorkflow, AXPQuickEntityModifyPopupAction, AXPQuickModifyEntityWorkflow, AXPShowDetailViewAction, AXPShowDetailsViewWorkflow, AXPShowListViewAction, AXPShowListViewWorkflow, AXP_DATA_SEEDER_TOKEN, AXP_ENTITY_ACTION_PLUGIN, AXP_ENTITY_CONFIG_TOKEN, AXP_ENTITY_DEFINITION_LOADER, AXP_ENTITY_MODIFIER, AXP_ENTITY_STORAGE_BACKEND, AXP_ENTITY_STORAGE_MIDDLEWARE, DEFAULT_COLUMN_WIDTHS, actionExists, columnWidthMiddlewareFactory, columnWidthMiddlewareProvider, createColumnWidthMiddlewareProvider, createModifierContext, detectEntityChanges, ensureListActions, entityDetailsCreateActions, entityDetailsCrudActions, entityDetailsEditAction, entityDetailsReferenceCondition, entityDetailsReferenceCreateActions, entityDetailsSimpleCondition, entityMasterBulkDeleteAction, entityMasterCreateAction, entityMasterCrudActions, entityMasterDeleteAction, entityMasterRecordActions, entityMasterViewAction, entityOverrideDetailsViewAction, eventDispatchMiddleware };
 //# sourceMappingURL=acorex-platform-layout-entity.mjs.map