@acorex/platform 21.0.0-next.43 → 21.0.0-next.45

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

@@ -357,65 +357,78 @@ class AXPEntityMiddleware {
         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);
+        for (const { entityName, modifier, order } of this.providedModifiers) {
+            this.register(entityName, modifier, order);
         }
     }
     //#endregion
     //#region ----   Registration Methods   ----
-    register(entityName, modifier) {
+    register(entityName, modifier, order) {
+        const resolvedOrder = order ?? 0;
         if (entityName instanceof RegExp) {
-            this.patternModifiers.push({ pattern: this.normalizeRegExp(entityName), modifier });
+            this.patternModifiers.push({ pattern: this.normalizeRegExp(entityName), modifier, order: resolvedOrder });
             return;
         }
         if (entityName.includes('*')) {
             const pattern = this.wildcardToRegExp(entityName);
-            this.patternModifiers.push({ pattern, modifier });
+            this.patternModifiers.push({ pattern, modifier, order: resolvedOrder });
             return;
         }
-        this.exactModifiers.set(entityName, modifier);
+        this.exactModifiers.set(entityName, { modifier, order: resolvedOrder });
     }
     //#endregion
     //#region ----   Processing   ----
     async process(entity) {
-        // First, expand action plugins if entity.plugins exists
         const context = createModifierContext(entity);
-        const plugins = entity.plugins;
-        if (plugins && plugins.length) {
-            const sorted = [...this.providedActionPlugins].sort((a, b) => (a.order ?? 0) - (b.order ?? 0));
-            for (const p of plugins) {
-                const contrib = sorted.find((x) => x.name === p.name);
-                if (contrib) {
-                    try {
-                        await runInInjectionContext(this.injector, () => contrib.apply(context, p.options));
-                    }
-                    catch (err) {
-                        console.error('[AXPEntityMiddleware] action plugin failed:', p.name, err);
-                    }
-                }
-            }
-        }
-        // Then apply entity-specific modifiers
-        // Collect all matching modifiers
-        const modifiers = [];
-        // Exact match first
+        const steps = [];
         const exact = this.exactModifiers.get(entity.name);
         if (exact) {
-            modifiers.push(exact);
+            steps.push(this.createModifierStep(exact, context));
         }
-        // Then all pattern matches
-        for (const { pattern, modifier } of this.patternModifiers) {
-            if (pattern.test(entity.name)) {
-                modifiers.push(modifier);
+        for (const entry of this.patternModifiers) {
+            if (entry.pattern.test(entity.name)) {
+                steps.push(this.createModifierStep(entry, context));
             }
         }
-        // Apply all matching modifiers in order
-        for (const modifier of modifiers) {
-            runInInjectionContext(this.injector, () => modifier(context));
+        const entityPlugins = entity.plugins ?? [];
+        for (const pluginRef of entityPlugins) {
+            const contrib = this.providedActionPlugins.find((x) => x.name === pluginRef.name);
+            if (contrib) {
+                steps.push(this.createPluginStep(contrib, pluginRef.name, context));
+            }
+        }
+        const sorted = steps.sort((a, b) => a.order - b.order);
+        for (const step of sorted) {
+            try {
+                await runInInjectionContext(this.injector, step.run);
+            }
+            catch (err) {
+                console.error('[AXPEntityMiddleware] entity processing step failed:', err);
+            }
         }
         return context.toEntity();
     }
     //#endregion
+    //#region ----   Step Factories   ----
+    createModifierStep(entry, context) {
+        return {
+            order: entry.order,
+            run: () => entry.modifier(context),
+        };
+    }
+    createPluginStep(contrib, pluginName, context) {
+        return {
+            order: contrib.order ?? 0,
+            run: async () => {
+                const pluginRef = context.plugins.find(pluginName).get();
+                if (!pluginRef) {
+                    return;
+                }
+                await contrib.apply(context, pluginRef.options);
+            },
+        };
+    }
+    //#endregion
     //#region ----   Helpers   ----
     wildcardToRegExp(pattern) {
         const escaped = pattern.replace(/[.+?^${}()|\[\]\\]/g, '\\$&');
@@ -3215,6 +3228,24 @@ class AXPEntityDataProviderImpl {
     insertOne(entity) {
         return this.storageService.insertOne(this.entityName, entity);
     }
+    count(request) {
+        return this.storageService.count(this.entityName, request);
+    }
+    queryAll(request, options) {
+        return this.storageService.queryAll(this.entityName, request, options);
+    }
+    getMany(ids) {
+        return this.storageService.getMany(this.entityName, ids);
+    }
+    exists(id) {
+        return this.storageService.exists(this.entityName, id);
+    }
+    upsertOne(entity, options) {
+        return this.storageService.upsertOne(this.entityName, entity, options);
+    }
+    aggregate(request, options) {
+        return this.storageService.aggregate(this.entityName, request, options);
+    }
 }
 class AXMEntityCrudService {
 }
@@ -3316,6 +3347,24 @@ class AXMEntityCrudServiceImpl {
     get storageService() {
         return this._storageService;
     }
+    async count(request) {
+        return this._entityDataProvider.count(request);
+    }
+    async queryAll(request, options) {
+        return this._entityDataProvider.queryAll(request, options);
+    }
+    async getMany(ids) {
+        return this._entityDataProvider.getMany(ids);
+    }
+    async exists(id) {
+        return this._entityDataProvider.exists(id);
+    }
+    async upsertOne(entity, options) {
+        return this._entityDataProvider.upsertOne(entity, options);
+    }
+    async aggregate(request, options) {
+        return this._entityDataProvider.aggregate(request, options);
+    }
     async custom(request) { }
 }
 
@@ -3943,6 +3992,11 @@ class AXPEntityDetailListViewModel {
         this.filterOperatorMiddleware = this.injector.get(AXPFilterOperatorMiddlewareService);
         this.expressionEvaluator = this.injector.get(AXPExpressionEvaluatorService);
         this.queryExecutor = this.injector.get(AXPQueryExecutor);
+        this.settingsService = this.injector.get(AXPSettingsService);
+        this.destroyed = new Subject();
+        this.showRowIndexColumnEnabled = signal(false, ...(ngDevMode ? [{ debugName: "showRowIndexColumnEnabled" }] : /* istanbul ignore next */ []));
+        /** Whether the row index column is shown (user setting). */
+        this.showIndexColumn = computed(() => this.showRowIndexColumnEnabled(), ...(ngDevMode ? [{ debugName: "showIndexColumn" }] : /* istanbul ignore next */ []));
         this.dataSource = new AXDataSource({
             byKey: async (key) => {
                 const execute = this.detailEntity()?.queries?.byKey?.execute;
@@ -4082,8 +4136,28 @@ class AXPEntityDetailListViewModel {
             };
             return await this.expressionEvaluator.evaluate(actionData, scope);
         };
+        void this.syncShowRowIndexColumnSetting();
+        this.settingsService.onLoaded.pipe(takeUntil(this.destroyed)).subscribe(() => {
+            void this.syncShowRowIndexColumnSetting();
+        });
+        this.settingsService.onChanged.pipe(takeUntil(this.destroyed)).subscribe(() => {
+            void this.syncShowRowIndexColumnSetting();
+        });
         this.initialize();
     }
+    async syncShowRowIndexColumnSetting() {
+        try {
+            const value = await this.settingsService.get(AXPCommonSettings.ShowRowIndexColumn);
+            this.showRowIndexColumnEnabled.set(value ?? false);
+        }
+        catch {
+            this.showRowIndexColumnEnabled.set(false);
+        }
+    }
+    destroy() {
+        this.destroyed.next();
+        this.destroyed.complete();
+    }
     async initialize() {
         const entityResolver = this.injector.get(AXPEntityDefinitionRegistryService);
         const [moduleName, entityName] = this.detailEntityConfig.entity.split('.');
@@ -4223,6 +4297,73 @@ const AXPEntityEventsKeys = {
     REFRESH_DATA: 'entity:refresh-data',
 };
 
+/**
+ * Resolves a stable row id from entity list row data.
+ */
+function getEntityListRowId(data, key = 'id') {
+    const value = data[key];
+    if (value != null && value !== '') {
+        return String(value);
+    }
+    return '';
+}
+/**
+ * Finds row data in a hierarchical grid tree (root rows and nested children).
+ */
+function findEntityListRowDataInTree(items, id, key) {
+    for (const item of items) {
+        if (item && typeof item === 'object' && String(item[key]) === id) {
+            return item;
+        }
+        const rec = item;
+        const metaChildren = rec?.['__meta__']?.['children'];
+        const directChildren = rec?.['children'];
+        const childArr = Array.isArray(metaChildren)
+            ? metaChildren
+            : Array.isArray(directChildren)
+                ? directChildren
+                : null;
+        if (childArr?.length) {
+            const found = findEntityListRowDataInTree(childArr, id, key);
+            if (found) {
+                return found;
+            }
+        }
+    }
+    return null;
+}
+/**
+ * Restores expanded rows after data load (parents before children).
+ */
+async function restoreEntityListExpandedRows(options) {
+    const pending = [...new Set(options.expandedRowIds.filter(Boolean))];
+    if (!pending.length) {
+        return;
+    }
+    let safety = 0;
+    const maxPasses = Math.max(pending.length * 3, 10);
+    while (pending.length > 0 && safety++ < maxPasses) {
+        const rows = options.getDisplayedRows();
+        let progressed = false;
+        for (let i = pending.length - 1; i >= 0; i--) {
+            const id = pending[i];
+            const item = findEntityListRowDataInTree(rows, id, options.rowKey);
+            if (!item) {
+                continue;
+            }
+            const meta = item['__meta__'];
+            if (meta?.['expanded'] !== true) {
+                await options.expandRow({ data: item });
+            }
+            pending.splice(i, 1);
+            progressed = true;
+        }
+        if (!progressed) {
+            break;
+        }
+    }
+}
+
 /**
  * Entity Event Dispatcher - A wrapper for entity-specific events
  * Handles pattern-based dispatching for entity operations with wildcard support
@@ -4587,6 +4728,10 @@ class AXPEntityMasterListViewModel {
         this.lastAppliedSortKey = null;
         this.lastAppliedFilterKey = null;
         this.hasQueryParamsFilters = false; // Flag to prevent overriding queryParams filters
+        /** Persisted expanded row ids for hierarchical lists (per view). */
+        this.expandedRowIds = signal([], ...(ngDevMode ? [{ debugName: "expandedRowIds" }] : /* istanbul ignore next */ []));
+        /** When true, row expand/collapse is not written to user settings (restore in progress). */
+        this.skipExpandedRowPersistence = false;
         this.events$ = new Subject();
         //****************** Views ******************//
         this.views = computed(() => {
@@ -4596,6 +4741,18 @@ class AXPEntityMasterListViewModel {
             });
         }, ...(ngDevMode ? [{ debugName: "views" }] : /* istanbul ignore next */ []));
         this.view = signal(this.views()[0], ...(ngDevMode ? [{ debugName: "view" }] : /* istanbul ignore next */ []));
+        this.showRowIndexColumnEnabled = signal(false, ...(ngDevMode ? [{ debugName: "showRowIndexColumnEnabled" }] : /* istanbul ignore next */ []));
+        /**
+         * Row index column: if the list view defines `indexCol` (true/false), that overrides the user setting;
+         * if `indexCol` is omitted, visibility follows {@link AXPCommonSettings.ShowRowIndexColumn}.
+         */
+        this.showIndexColumn = computed(() => {
+            const indexCol = this.view().indexCol;
+            if (indexCol !== undefined) {
+                return indexCol;
+            }
+            return this.showRowIndexColumnEnabled();
+        }, ...(ngDevMode ? [{ debugName: "showIndexColumn" }] : /* istanbul ignore next */ []));
         this.dataSource = new AXDataSource({
             byKey: async (key) => {
                 const execute = this.entityDef.queries?.byKey?.execute;
@@ -4766,6 +4923,23 @@ class AXPEntityMasterListViewModel {
             }
         });
         this.sortedFields.set(this.sortableFields());
+        void this.syncShowRowIndexColumnSetting();
+        this.settings.onLoaded.pipe(takeUntil(this.destroyed)).subscribe(() => {
+            void this.syncShowRowIndexColumnSetting();
+        });
+        this.settings.onChanged.pipe(takeUntil(this.destroyed)).subscribe(() => {
+            void this.syncShowRowIndexColumnSetting();
+        });
+    }
+    async syncShowRowIndexColumnSetting() {
+        try {
+            const value = await this.settings.get(AXPCommonSettings.ShowRowIndexColumn);
+            this.showRowIndexColumnEnabled.set(value ?? false);
+        }
+        catch {
+            console.log('catch');
+            this.showRowIndexColumnEnabled.set(false);
+        }
     }
     async applySettings() {
         this.saveSettings('view');
@@ -4803,7 +4977,49 @@ class AXPEntityMasterListViewModel {
             if (Array.isArray(filters) && !this.hasQueryParamsFilters) {
                 this.filterQueries.set(filters);
             }
+            const expandedRowIds = listViewSetting.list?.views?.[this.view().name]?.expandedRowIds;
+            if (Array.isArray(expandedRowIds)) {
+                this.expandedRowIds.set(expandedRowIds.map((id) => String(id)).filter(Boolean));
+            }
+            else {
+                this.expandedRowIds.set([]);
+            }
+        }
+    }
+    getExpandedRowIds() {
+        return this.expandedRowIds();
+    }
+    /**
+     * Updates persisted expanded row ids when the user expands or collapses a tree row.
+     */
+    updateExpandedRowId(rowId, expanded) {
+        if (!rowId || !this.parentKey()) {
+            return;
+        }
+        const next = new Set(this.expandedRowIds());
+        if (expanded) {
+            next.add(rowId);
+        }
+        else {
+            next.delete(rowId);
         }
+        const ids = Array.from(next);
+        this.expandedRowIds.set(ids);
+        this.saveSettings('expandedRows', ids);
+    }
+    handleRowExpandChange(rowData) {
+        if (this.skipExpandedRowPersistence || !this.parentKey()) {
+            return;
+        }
+        const key = this.dataSource.config?.key ?? 'id';
+        const rowId = getEntityListRowId(rowData, key);
+        if (!rowId) {
+            return;
+        }
+        // onItemExpanded fires before the grid toggles __meta__.expanded on expandedItem.
+        const meta = rowData['__meta__'];
+        const wasExpanded = meta?.['expanded'] === true;
+        this.updateExpandedRowId(rowId, !wasExpanded);
     }
     async saveSettings(changesType, data) {
         const updateSettings = (updateFn) => {
@@ -4900,6 +5116,21 @@ class AXPEntityMasterListViewModel {
                     },
                 }));
                 break;
+            case 'expandedRows':
+                updateSettings((prev) => ({
+                    ...prev,
+                    list: {
+                        ...prev?.list,
+                        views: {
+                            ...prev?.list?.views,
+                            [this.view().name]: {
+                                ...prev?.list?.views?.[this.view().name],
+                                expandedRowIds: data,
+                            },
+                        },
+                    },
+                }));
+                break;
             default:
                 break;
         }
@@ -6343,6 +6574,225 @@ const AXPEntityPreloadFiltersViewModelResolver = async (route, state) => {
 };
 //#endregion
 
+//#region ---- Path / numeric helpers ----
+function getPath(obj, path) {
+    if (obj == null || path.length === 0) {
+        return undefined;
+    }
+    const parts = path.split('.');
+    let cur = obj;
+    for (const p of parts) {
+        if (cur == null || typeof cur !== 'object') {
+            return undefined;
+        }
+        cur = cur[p];
+    }
+    return cur;
+}
+function toNumber(value) {
+    if (typeof value === 'number' && Number.isFinite(value)) {
+        return value;
+    }
+    if (typeof value === 'string' && value.trim().length > 0) {
+        const n = Number(value);
+        return Number.isFinite(n) ? n : null;
+    }
+    return null;
+}
+function defaultAlias(measure, index) {
+    if (measure.alias?.trim()) {
+        return measure.alias.trim();
+    }
+    if (measure.reducer === 'count') {
+        return index === 0 ? 'count' : `count_${index}`;
+    }
+    const field = measure.field ?? 'value';
+    const safeField = field.replace(/\./g, '_');
+    return `${measure.reducer}_${safeField}`;
+}
+/**
+ * Pure aggregation over already-filtered plain rows (e.g. outputs of {@link filterSortEntityRows}).
+ */
+function computeEntityAggregates(rows, request) {
+    const groupBy = request.groupBy ?? [];
+    const measures = request.measures ?? [];
+    if (measures.length === 0) {
+        return [];
+    }
+    const groups = new Map();
+    const stableGroupKey = (row) => {
+        const parts = groupBy.map((path) => getPath(row, path));
+        return JSON.stringify(parts);
+    };
+    for (const row of rows) {
+        const k = stableGroupKey(row);
+        let bucket = groups.get(k);
+        if (!bucket) {
+            bucket = {
+                keyParts: groupBy.map((path) => getPath(row, path)),
+                rows: [],
+            };
+            groups.set(k, bucket);
+        }
+        bucket.rows.push(row);
+    }
+    const result = [];
+    for (const bucket of groups.values()) {
+        const out = {};
+        groupBy.forEach((field, i) => {
+            out[field] = bucket.keyParts[i];
+        });
+        measures.forEach((measure, index) => {
+            const alias = defaultAlias(measure, index);
+            const gRows = bucket.rows;
+            if (measure.reducer === 'count') {
+                out[alias] = gRows.length;
+                return;
+            }
+            const fieldPath = measure.field;
+            if (!fieldPath) {
+                out[alias] = null;
+                return;
+            }
+            const nums = gRows.map((r) => toNumber(getPath(r, fieldPath))).filter((n) => n !== null);
+            switch (measure.reducer) {
+                case 'sum':
+                    out[alias] = nums.reduce((a, b) => a + b, 0);
+                    break;
+                case 'min':
+                    out[alias] = nums.length ? Math.min(...nums) : null;
+                    break;
+                case 'max':
+                    out[alias] = nums.length ? Math.max(...nums) : null;
+                    break;
+                case 'avg':
+                    out[alias] = nums.length ? nums.reduce((a, b) => a + b, 0) / nums.length : null;
+                    break;
+                default:
+                    out[alias] = null;
+            }
+        });
+        result.push(out);
+    }
+    return result;
+}
+//#endregion
+
+//#endregion
+//#region ---- Pure helpers ----
+/**
+ * Fields where `contains` means hierarchical category membership (expand to descendants).
+ * Excludes e.g. `roleIds`, which uses array membership only and must use normal filter logic.
+ */
+function isCategoryContainsFieldName(field) {
+    if (field === 'categoryIds') {
+        return true;
+    }
+    if (typeof field === 'string' && field.endsWith('Ids') && field !== 'roleIds') {
+        return true;
+    }
+    return false;
+}
+/**
+ * Check if the entity is a category entity (ends with 'Category').
+ */
+function isCategoryEntity(entityName) {
+    return entityName.endsWith('Category');
+}
+/**
+ * Check if the filter is a category filter (contains operator on categoryIds field).
+ * Handles both simple filters and compound filters.
+ */
+function isCategoryFilter(filter) {
+    if (filter?.operator?.type === 'contains' && isCategoryContainsFieldName(filter.field)) {
+        return true;
+    }
+    if (filter?.logic && filter?.filters && Array.isArray(filter.filters)) {
+        return filter.filters.some((nestedFilter) => nestedFilter?.operator?.type === 'contains' && isCategoryContainsFieldName(nestedFilter.field));
+    }
+    return false;
+}
+//#endregion
+//#region ---- Query execution ----
+/**
+ * Apply recursive category filtering: entities that belong to the category or any of its children.
+ */
+async function applyRecursiveCategoryFilter(result, filter, entityName, getAllChildCategoryIds) {
+    let categoryFilter = filter;
+    let otherFilters = [];
+    if (filter?.logic && filter?.filters && Array.isArray(filter.filters)) {
+        const categoryFilterIndex = filter.filters.findIndex((f) => f?.operator?.type === 'contains' && isCategoryContainsFieldName(f.field));
+        if (categoryFilterIndex !== -1) {
+            categoryFilter = filter.filters[categoryFilterIndex];
+            otherFilters = filter.filters.filter((_, index) => index !== categoryFilterIndex);
+        }
+    }
+    if (!categoryFilter) {
+        return applyFilterArray(result, [filter]);
+    }
+    const categoryId = categoryFilter.value;
+    const categoryField = categoryFilter.field;
+    const allCategoryIds = await getAllChildCategoryIds(categoryId, entityName);
+    let filteredResult = result.filter((item) => {
+        const categoryIds = item[categoryField];
+        if (!categoryIds)
+            return false;
+        const itemCategoryIds = Array.isArray(categoryIds) ? categoryIds : [categoryIds];
+        return itemCategoryIds.some((itemCategoryId) => allCategoryIds.includes(itemCategoryId));
+    });
+    if (otherFilters.length > 0) {
+        filteredResult = applyFilterArray(filteredResult, otherFilters);
+    }
+    return filteredResult;
+}
+/**
+ * Calculate childrenCount for each category entity when missing.
+ */
+async function calculateChildrenCounts(items, entityName, getDirectChildCount) {
+    return Promise.all(items.map(async (item) => {
+        if (typeof item.childrenCount === 'number') {
+            return { ...item };
+        }
+        const childrenCount = await getDirectChildCount(item.id, entityName);
+        return { ...item, childrenCount };
+    }));
+}
+/**
+ * Loads raw rows for an entity and applies the same sorting and filtering as {@link runEntityQuery},
+ * without pagination.
+ */
+async function filterSortEntityRows(entityName, request, adapters) {
+    let result = await adapters.getRawAll(entityName);
+    if (request.sort && request.sort.length) {
+        result = applySortArray(result, request.sort);
+    }
+    if (request.filter && isCategoryFilter(request.filter)) {
+        result = await applyRecursiveCategoryFilter(result, request.filter, entityName, adapters.getAllChildCategoryIds);
+    }
+    else {
+        result = applyFilterArray(result, request.filter ? [request.filter] : []);
+    }
+    if (isCategoryEntity(entityName)) {
+        result = await calculateChildrenCounts(result, entityName, adapters.getDirectChildCount);
+    }
+    return result;
+}
+/**
+ * Shared entity query logic: sort, filter (including recursive category filter), childrenCount, pagination.
+ */
+async function runEntityQuery(entityName, request, adapters) {
+    const rows = await filterSortEntityRows(entityName, request, adapters);
+    const skip = request.skip ?? 0;
+    const take = request.take ?? 0;
+    return {
+        total: rows.length,
+        items: rows.slice(skip, skip + take),
+    };
+}
+//#endregion
+
+//#endregion
+
 //#region ---- Imports ----
 //#endregion
 //#region ---- Constants ----
@@ -10581,6 +11031,7 @@ class AXPEntityListTableService {
         this.workflow = inject(AXPWorkflowService);
         this.commandService = inject(AXPCommandService);
         this.expressionEvaluator = inject(AXPExpressionEvaluatorService);
+        this.settings = inject(AXPSettingsService);
         this.evaluateExpressions = async (options, data) => {
             if (!options) {
                 return {};
@@ -10601,6 +11052,20 @@ class AXPEntityListTableService {
      * Convert Entity to List Widget Options
      */
     async convertEntityToListOptions(entity, options, allActions) {
+        const viewIndexCol = entity.interfaces?.master?.list?.views?.[0]?.indexCol;
+        let showIndex = false;
+        if (viewIndexCol !== undefined) {
+            showIndex = viewIndexCol;
+        }
+        else {
+            try {
+                const fromSetting = await this.settings.get(AXPCommonSettings.ShowRowIndexColumn);
+                showIndex = fromSetting ?? false;
+            }
+            catch {
+                showIndex = false;
+            }
+        }
         const listOptions = {
             // 📊 Data Source
             dataSource: this.createDataSource(entity),
@@ -10610,7 +11075,7 @@ class AXPEntityListTableService {
             primaryCommands: this.createRowCommands(allActions, 'primary'),
             secondaryCommands: this.createRowCommands(allActions, 'secondary'),
             // ⚙️ Table Features
-            showIndex: entity.interfaces?.master?.list?.views?.[0]?.indexCol ?? false,
+            showIndex,
             allowSelection: this.hasSelectedScopeActions(entity),
             paging: true,
             showHeader: true,
@@ -10627,7 +11092,6 @@ class AXPEntityListTableService {
             // 🎪 Events
             ...this.createDefaultEvents(entity, allActions, options?.excludeProperties),
         };
-        console.log('listOptions', listOptions);
         return listOptions;
     }
     //#endregion
@@ -11015,6 +11479,7 @@ class AXPEntityListWidgetViewComponent extends AXPValueWidgetComponent {
         this.commandService = inject(AXPCommandService);
         this.eventService = inject(AXPBroadcastEventService);
         this.expressionEvaluator = inject(AXPExpressionEvaluatorService);
+        this.route = inject(ActivatedRoute);
         this.isMounted = signal(false, ...(ngDevMode ? [{ debugName: "isMounted" }] : /* istanbul ignore next */ []));
         this.entity = signal(null, ...(ngDevMode ? [{ debugName: "entity" }] : /* istanbul ignore next */ []));
         this.listNode = signal(null, ...(ngDevMode ? [{ debugName: "listNode" }] : /* istanbul ignore next */ []));
@@ -11188,13 +11653,7 @@ class AXPEntityListWidgetViewComponent extends AXPValueWidgetComponent {
     //   console.log(this.listWidget()?.instance.output('selectedRows'));
     // }
     async execute(commandName, _data) {
-        const action = this.allActions().find((c) => {
-            return (c.name == commandName &&
-                ((this.selectedItems().length
-                    ? c.scope == AXPEntityCommandScope.Selected
-                    : c.scope == AXPEntityCommandScope.Individual) ||
-                    c.scope == AXPEntityCommandScope.TypeLevel));
-        });
+        const action = this.findToolbarAction(commandName);
         const command = commandName.split('&')[0];
         const commandData = action?.scope == AXPEntityCommandScope.Selected
             ? this.selectedItems()
@@ -11260,6 +11719,29 @@ class AXPEntityListWidgetViewComponent extends AXPValueWidgetComponent {
             });
         }
     }
+    /**
+     * Resolves toolbar commands including nested dropdown (`items`) actions.
+     */
+    findToolbarAction(commandName) {
+        const scopeMatches = (c) => (this.selectedItems().length
+            ? c.scope === AXPEntityCommandScope.Selected
+            : c.scope === AXPEntityCommandScope.Individual) || c.scope === AXPEntityCommandScope.TypeLevel;
+        const visit = (nodes) => {
+            for (const node of nodes) {
+                if (node.name === commandName && scopeMatches(node)) {
+                    return node;
+                }
+                if (node.items?.length) {
+                    const nested = visit(node.items);
+                    if (nested) {
+                        return nested;
+                    }
+                }
+            }
+            return undefined;
+        };
+        return visit(this.allActions());
+    }
     async evaluateToolbarExpressions(opts, expressionData) {
         if (!opts) {
             return {};
@@ -11272,6 +11754,92 @@ class AXPEntityListWidgetViewComponent extends AXPValueWidgetComponent {
         };
         return (await this.expressionEvaluator.evaluate(opts, scope));
     }
+    /**
+     * Parses the `filters` query param (same shape as standalone entity list routes).
+     */
+    parseFiltersFromRoute() {
+        const filtersJson = this.route.snapshot.queryParamMap.get('filters');
+        if (!filtersJson) {
+            return [];
+        }
+        try {
+            const parsed = JSON.parse(filtersJson);
+            const rows = [];
+            if (Array.isArray(parsed)) {
+                for (const item of parsed) {
+                    if (item && typeof item === 'object' && typeof item.field === 'string') {
+                        rows.push(item);
+                    }
+                }
+            }
+            else if (parsed !== null && typeof parsed === 'object') {
+                for (const [field, value] of Object.entries(parsed)) {
+                    rows.push({ field, value, operator: { type: 'equal' } });
+                }
+            }
+            return rows
+                .filter((row) => row.field && row.value !== undefined && row.value !== null && row.value !== '')
+                .map((row) => ({
+                field: row.field,
+                operator: row.operator && typeof row.operator === 'object' && 'type' in row.operator
+                    ? row.operator
+                    : { type: 'equal' },
+                value: row.value,
+                hidden: true,
+            }));
+        }
+        catch {
+            return [];
+        }
+    }
+    /**
+     * Route `filters` apply only when the active details `page` matches this list's entity
+     * (e.g. WorkOrder filters must not affect FailureRegister on the same asset layout).
+     */
+    shouldApplyRouteFilters() {
+        const pageId = this.route.snapshot.queryParamMap.get('page');
+        if (!pageId) {
+            return false;
+        }
+        const entitySource = this.entitySource();
+        if (!entitySource) {
+            return false;
+        }
+        const [, entityName] = entitySource.split('.');
+        return !!entityName && pageId === entityName;
+    }
+    /**
+     * Merges route filters into related-entity toolbar filters (route wins per field).
+     */
+    mergeToolbarFilters(baseFilters, routeFilters) {
+        const byField = new Map(baseFilters.map((filter) => [filter.field, filter]));
+        for (const filter of routeFilters) {
+            byField.set(filter.field, filter);
+        }
+        return [...byField.values()];
+    }
+    getMergedToolbarFilters() {
+        const base = (this.getValue()?.toolbar?.filters ?? []);
+        if (!this.shouldApplyRouteFilters()) {
+            return base;
+        }
+        const routeFilters = this.parseFiltersFromRoute();
+        return routeFilters.length ? this.mergeToolbarFilters(base, routeFilters) : base;
+    }
+    /**
+     * Applies merged route + parent-scope filters to the widget value and data source.
+     */
+    applyMergedRouteFiltersToList() {
+        const merged = this.getMergedToolbarFilters();
+        const current = this.getValue();
+        if (!isEqual$1(current?.toolbar?.filters, merged)) {
+            this.setValue({
+                ...current,
+                toolbar: { ...(current?.toolbar ?? {}), filters: merged },
+            });
+        }
+        this.pushToolbarFiltersToDataSource();
+    }
     /**
      * Re-evaluates related-entity list filters from the live dialog form context (e.g. after create saves the main row id).
      */
@@ -11461,23 +12029,27 @@ class AXPEntityListWidgetViewComponent extends AXPValueWidgetComponent {
                 mode: 'view',
                 defaultValue: this.getValue()?.table,
             });
+            const mergedToolbarFilters = this.getMergedToolbarFilters();
             this.toolbarNode.set({
                 type: AXPWidgetsCatalog.listToolbar,
                 path: `toolbar`,
                 options: toolbarOptions,
                 mode: 'view',
                 defaultValue: {
-                    filters: this.getValue()?.toolbar?.filters,
+                    filters: mergedToolbarFilters,
                     sorts: this.getValue()?.toolbar?.sorts,
                     columns: this.getValue()?.toolbar?.columns,
                 },
             });
             queueMicrotask(() => {
-                void this.pushToolbarFiltersToDataSource();
+                this.applyMergedRouteFiltersToList();
             });
         }, 100);
     }
     async ngAfterViewInit() {
+        this.route.queryParamMap.pipe(takeUntil(this.destroyed)).subscribe(() => {
+            this.applyMergedRouteFiltersToList();
+        });
         this.workflow.events$
             .pipe(ofType(AXPRefreshEvent))
             .pipe(takeUntil(this.destroyed))
@@ -13269,6 +13841,14 @@ class AXPLookupWidgetEditComponent extends AXPValueWidgetComponent {
             }
         });
     }
+    outputs() {
+        return [
+            {
+                name: 'selectedItems',
+                value: this.selectedItems(),
+            },
+        ];
+    }
     singleOrMultiple(values) {
         return this.multiple() ? values : values[0];
     }
@@ -17438,9 +18018,16 @@ class AXPPageListConverter extends AXPBaseRelatedEntityConverter {
                         return result;
                     };
                     const flatActions = flattenActions(mergedActions);
-                    const action = flatActions.find((a) => {
-                        return a.name === command.name || a.name === commandName || a.name.split('&')[0] === commandName;
-                    });
+                    /**
+                     * Toolbar keys are `commandKey&action.name`. Several dropdown items can share the same `commandKey`
+                     * (e.g. multiple `WorkflowManagement.WorkflowDefinition:Execute` lifecycle templates). Matching only by
+                     * prefix makes `.find` return the first sibling — wrong template (e.g. offboarding runs onboarding).
+                     */
+                    const action = command.name.includes('&')
+                        ? flatActions.find((a) => a.name === command.name)
+                        : flatActions.find((a) => {
+                            return a.name === command.name || a.name === commandName || a.name.split('&')[0] === commandName;
+                        });
                     if (!action) {
                         console.warn(`Action ${commandName} not found in entity definition`);
                         return {
@@ -19396,6 +19983,9 @@ function getDedupKey(op, entityName, init) {
     if (op === 'getOne' && init?.id !== undefined) {
         return `getOne:${entityName}:${String(init.id)}`;
     }
+    if (op === 'exists' && init?.id !== undefined) {
+        return `exists:${entityName}:${String(init.id)}`;
+    }
     if (op === 'getAll') {
         return `getAll:${entityName}`;
     }
@@ -19403,6 +19993,20 @@ function getDedupKey(op, entityName, init) {
         const r = init.request;
         return `query:${entityName}:${r.skip ?? 0}:${r.take ?? 0}:${JSON.stringify(r.filter ?? null)}:${JSON.stringify(r.sort ?? null)}:${JSON.stringify(r.params ?? null)}`;
     }
+    if (op === 'count' && init?.request) {
+        const r = init.request;
+        return `count:${entityName}:${JSON.stringify(r.filter ?? null)}:${JSON.stringify(r.sort ?? null)}`;
+    }
+    if (op === 'queryAll' && init?.request) {
+        const r = init.request;
+        return `queryAll:${entityName}:${JSON.stringify(r.filter ?? null)}:${JSON.stringify(r.sort ?? null)}:${JSON.stringify(init.queryAllOptions ?? null)}`;
+    }
+    if (op === 'getMany' && init?.ids) {
+        return `getMany:${entityName}:${init.ids.map(String).join(',')}`;
+    }
+    if (op === 'aggregate' && init?.aggregateRequest) {
+        return `aggregate:${entityName}:${JSON.stringify(init.aggregateRequest)}:${JSON.stringify(init.aggregateOptions ?? null)}`;
+    }
     return '';
 }
 class AXPMiddlewareEntityStorageService extends AXPEntityStorageService {
@@ -19462,6 +20066,13 @@ class AXPMiddlewareEntityStorageService extends AXPEntityStorageService {
                 insertOne: (name, e) => this.backend.insertOne(name, e),
                 query: (name, request) => this.backend.query(name, request),
                 updateOne: (name, id, data) => this.backend.updateOne(name, id, data),
+                deleteOne: (name, id) => this.backend.deleteOne(name, id),
+                count: (name, request) => this.backend.count(name, request),
+                queryAll: (name, request, options) => this.backend.queryAll(name, request, options),
+                getMany: (name, ids) => this.backend.getMany(name, ids),
+                exists: (name, id) => this.backend.exists(name, id),
+                upsertOne: (name, entity, options) => this.backend.upsertOne(name, entity, options),
+                aggregate: (name, request, options) => this.backend.aggregate(name, request, options),
             },
             ...init,
         };
@@ -19533,6 +20144,100 @@ class AXPMiddlewareEntityStorageService extends AXPEntityStorageService {
         const ctx = this.createCtx('query', entityName, { request });
         return this.run(ctx, () => this.backend.query(ctx.entityName, request));
     }
+    async count(entityName, request) {
+        const filterSortRequest = { ...request, skip: 0, take: 0 };
+        const key = getDedupKey('count', entityName, { request: filterSortRequest });
+        if (key) {
+            const existing = this.inFlight.get(key);
+            if (existing) {
+                return existing;
+            }
+            const promise = this.runWithDedup(key, () => {
+                const ctx = this.createCtx('count', entityName, { request: filterSortRequest });
+                return this.run(ctx, () => this.backend.count(ctx.entityName, request));
+            });
+            this.inFlight.set(key, promise);
+            return promise;
+        }
+        const ctx = this.createCtx('count', entityName, { request: filterSortRequest });
+        return this.run(ctx, () => this.backend.count(ctx.entityName, request));
+    }
+    async queryAll(entityName, request, options) {
+        const filterSortRequest = { ...request, skip: 0, take: 0 };
+        const key = getDedupKey('queryAll', entityName, { request: filterSortRequest, queryAllOptions: options });
+        if (key) {
+            const existing = this.inFlight.get(key);
+            if (existing) {
+                return existing;
+            }
+            const promise = this.runWithDedup(key, () => {
+                const ctx = this.createCtx('queryAll', entityName, { request: filterSortRequest });
+                return this.run(ctx, () => this.backend.queryAll(ctx.entityName, request, options));
+            });
+            this.inFlight.set(key, promise);
+            return promise;
+        }
+        const ctx = this.createCtx('queryAll', entityName, { request: filterSortRequest });
+        return this.run(ctx, () => this.backend.queryAll(ctx.entityName, request, options));
+    }
+    async getMany(entityName, ids) {
+        const key = getDedupKey('getMany', entityName, { ids: ids });
+        if (key) {
+            const existing = this.inFlight.get(key);
+            if (existing) {
+                return existing;
+            }
+            const promise = this.runWithDedup(key, () => {
+                const ctx = this.createCtx('getMany', entityName);
+                return this.run(ctx, () => this.backend.getMany(ctx.entityName, ids));
+            });
+            this.inFlight.set(key, promise);
+            return promise;
+        }
+        const ctx = this.createCtx('getMany', entityName);
+        return this.run(ctx, () => this.backend.getMany(ctx.entityName, ids));
+    }
+    async exists(entityName, id) {
+        const key = getDedupKey('exists', entityName, { id });
+        if (key) {
+            const existing = this.inFlight.get(key);
+            if (existing) {
+                return existing;
+            }
+            const promise = this.runWithDedup(key, () => {
+                const ctx = this.createCtx('exists', entityName, { id });
+                return this.run(ctx, () => this.backend.exists(ctx.entityName, id));
+            });
+            this.inFlight.set(key, promise);
+            return promise;
+        }
+        const ctx = this.createCtx('exists', entityName, { id });
+        return this.run(ctx, () => this.backend.exists(ctx.entityName, id));
+    }
+    async upsertOne(entityName, entity, options) {
+        const ctx = this.createCtx('upsertOne', entityName, { data: entity });
+        ctx.locals.set('upsertOptions', options);
+        return this.run(ctx, () => this.backend.upsertOne(ctx.entityName, entity, options));
+    }
+    async aggregate(entityName, request, options) {
+        const key = getDedupKey('aggregate', entityName, { aggregateRequest: request, aggregateOptions: options });
+        if (key) {
+            const existing = this.inFlight.get(key);
+            if (existing) {
+                return existing;
+            }
+            const promise = this.runWithDedup(key, () => {
+                const ctx = this.createCtx('aggregate', entityName);
+                ctx.locals.set('aggregateRequest', request);
+                ctx.locals.set('aggregateOptions', options);
+                return this.run(ctx, () => this.backend.aggregate(ctx.entityName, request, options));
+            });
+            this.inFlight.set(key, promise);
+            return promise;
+        }
+        const ctx = this.createCtx('aggregate', entityName);
+        return this.run(ctx, () => this.backend.aggregate(ctx.entityName, request, options));
+    }
     async runWithDedup(key, fn) {
         try {
             return await fn();
@@ -20493,5 +21198,5 @@ var getEntityDetails_query = /*#__PURE__*/Object.freeze({
  * Generated bundle index. Do not edit.
  */
 
-export { AXMEntityCrudService, AXMEntityCrudServiceImpl, AXPCategoryTreeService, AXPCreateEntityCommand, AXPCreateEntityWorkflow, AXPDataSeederService, AXPDeleteEntityWorkflow, AXPEntitiesListDataSourceDefinition, AXPEntityApplyUpdatesAction, AXPEntityCategoryTreeSelectorComponent, AXPEntityCategoryWidget, AXPEntityCategoryWidgetColumnComponent, AXPEntityCategoryWidgetEditComponent, AXPEntityCategoryWidgetViewComponent, AXPEntityCommandTriggerViewModel, AXPEntityCreateEvent, AXPEntityCreatePopupAction, AXPEntityCreateSubmittedAction, AXPEntityCreateViewElementViewModel, AXPEntityCreateViewModelFactory, AXPEntityCreateViewSectionViewModel, AXPEntityDataProvider, AXPEntityDataProviderImpl, AXPEntityDataSelectorService, AXPEntityDefinitionProviderWidget, AXPEntityDefinitionProviderWidgetEditComponent, AXPEntityDefinitionRegistryService, AXPEntityDeletedEvent, AXPEntityDetailListViewModel, AXPEntityDetailPopoverComponent, AXPEntityDetailPopoverService, AXPEntityDetailViewModelFactory, AXPEntityDetailViewModelResolver, AXPEntityEventDispatcherService, AXPEntityEventsKeys, AXPEntityFormBuilderService, AXPEntityListTableService, AXPEntityListToolbarService, AXPEntityListViewColumnViewModel, AXPEntityListViewModelFactory, AXPEntityListViewModelResolver, AXPEntityListWidget, AXPEntityListWidgetViewComponent, AXPEntityMasterCreateViewModel, AXPEntityMasterListViewModel, AXPEntityMasterListViewQueryViewModel, AXPEntityMasterSingleElementViewModel, AXPEntityMasterSingleViewGroupViewModel, AXPEntityMasterSingleViewModel, AXPEntityMasterUpdateElementViewModel, AXPEntityMasterUpdateViewModel, AXPEntityMasterUpdateViewModelFactory, AXPEntityMiddleware, AXPEntityModifyConfirmedAction, AXPEntityModifyEvent, AXPEntityModifySectionPopupAction, AXPEntityModule, AXPEntityPerformDeleteAction, AXPEntityPreloadFiltersContainerComponent, AXPEntityPreloadFiltersViewModel, AXPEntityPreloadFiltersViewModelResolver, AXPEntityResolver, AXPEntityService, AXPEntityStorageService, AXPEntityUpdateViewSectionViewModel, AXPGetEntityDetailsQuery, AXPLayoutOrderingConfigService, AXPLookupWidget, AXPLookupWidgetColumnComponent, AXPLookupWidgetEditComponent, AXPLookupWidgetViewComponent, AXPMiddlewareAbortError, AXPMiddlewareEntityStorageService, AXPModifyEntitySectionWorkflow, AXPMultiSourceDefinitionProviderContext, AXPMultiSourceDefinitionProviderService, AXPMultiSourceFederatedSearchService, AXPMultiSourceSelectorComponent, AXPMultiSourceSelectorService, AXPMultiSourceSelectorWidget, AXPMultiSourceSelectorWidgetColumnComponent, AXPMultiSourceSelectorWidgetEditComponent, AXPMultiSourceSelectorWidgetViewComponent, AXPMultiSourceType, AXPOpenEntityDetailsCommand, AXPQuickEntityModifyPopupAction, AXPQuickModifyEntityWorkflow, AXPRelatedColumnEnrichmentService, AXPRelatedColumnMetadataResolver, AXPSelectorStructureWidget, AXPSelectorStructureWidgetColumnComponent, AXPSelectorStructureWidgetEditComponent, AXPSelectorStructureWidgetViewComponent, AXPShowDetailViewAction, AXPShowDetailsViewWorkflow, AXPShowListViewAction, AXPShowListViewWorkflow, AXPTruncatedBreadcrumbComponent, AXPUpdateEntityCommand, AXPViewEntityDetailsCommand, AXP_CATEGORY_TREE_ROOT_TITLE_I18N_KEY, 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, AXP_MULTI_SOURCE_DEFINITION_PROVIDER, DEFAULT_COLUMN_ORDER, DEFAULT_PAIR_SPAN_RULES, DEFAULT_PROPERTY_ORDER, DEFAULT_SECTION_ORDER, EntityBuilder, EntityDataAccessor, actionExists, axpCreateEntityAiToolInputDefaults, axpCreateEntityCommandDefinition, cloneLayoutArrays, collectEntityQuickSearchFieldPaths, collectNestedCreateHiddenProperties, collectNestedFieldPathsFromEntityColumns, collectQuickSearchPathsFromSingleEntityDefinition, columnOrderingMiddleware, columnOrderingMiddlewareProvider, columnWidthMiddleware, columnWidthMiddlewareProvider, createColumnOrderingMiddlewareProvider, createLayoutOrderingMiddlewareProvider, createModifierContext, defaultMultiLanguageMiddleware, defaultMultiLanguageMiddlewareProvider, detectEntityChanges, ensureLayoutPropertyView, ensureLayoutSection, ensureListActions, entityDetailsCreateActions, entityDetailsCreateActionsDeferredParent, entityDetailsCrudActions, entityDetailsEditAction, entityDetailsNewEditAction, entityDetailsReferenceCondition, entityDetailsReferenceCreateActions, entityDetailsSimpleCondition, entityMasterBulkDeleteAction, entityMasterCreateAction, entityMasterCrudActions, entityMasterDeleteAction, entityMasterEditAction, entityMasterRecordActions, entityMasterViewAction, entityOverrideDetailsViewAction, eventDispatchMiddleware, getMasterInterfacePropertySortKey, isAXPMiddlewareAbortError, layoutOrderingMiddlewareFactory, layoutOrderingMiddlewareProvider, mergeForeignKeyFieldIntoCreateActions, provideEntity, resolveEntityPluginDetailPageOrder, searchResultDescriptionMiddleware, searchResultDescriptionMiddlewareProvider };
+export { AXMEntityCrudService, AXMEntityCrudServiceImpl, AXPCategoryTreeService, AXPCreateEntityCommand, AXPCreateEntityWorkflow, AXPDataSeederService, AXPDeleteEntityWorkflow, AXPEntitiesListDataSourceDefinition, AXPEntityApplyUpdatesAction, AXPEntityCategoryTreeSelectorComponent, AXPEntityCategoryWidget, AXPEntityCategoryWidgetColumnComponent, AXPEntityCategoryWidgetEditComponent, AXPEntityCategoryWidgetViewComponent, AXPEntityCommandTriggerViewModel, AXPEntityCreateEvent, AXPEntityCreatePopupAction, AXPEntityCreateSubmittedAction, AXPEntityCreateViewElementViewModel, AXPEntityCreateViewModelFactory, AXPEntityCreateViewSectionViewModel, AXPEntityDataProvider, AXPEntityDataProviderImpl, AXPEntityDataSelectorService, AXPEntityDefinitionProviderWidget, AXPEntityDefinitionProviderWidgetEditComponent, AXPEntityDefinitionRegistryService, AXPEntityDeletedEvent, AXPEntityDetailListViewModel, AXPEntityDetailPopoverComponent, AXPEntityDetailPopoverService, AXPEntityDetailViewModelFactory, AXPEntityDetailViewModelResolver, AXPEntityEventDispatcherService, AXPEntityEventsKeys, AXPEntityFormBuilderService, AXPEntityListTableService, AXPEntityListToolbarService, AXPEntityListViewColumnViewModel, AXPEntityListViewModelFactory, AXPEntityListViewModelResolver, AXPEntityListWidget, AXPEntityListWidgetViewComponent, AXPEntityMasterCreateViewModel, AXPEntityMasterListViewModel, AXPEntityMasterListViewQueryViewModel, AXPEntityMasterSingleElementViewModel, AXPEntityMasterSingleViewGroupViewModel, AXPEntityMasterSingleViewModel, AXPEntityMasterUpdateElementViewModel, AXPEntityMasterUpdateViewModel, AXPEntityMasterUpdateViewModelFactory, AXPEntityMiddleware, AXPEntityModifyConfirmedAction, AXPEntityModifyEvent, AXPEntityModifySectionPopupAction, AXPEntityModule, AXPEntityPerformDeleteAction, AXPEntityPreloadFiltersContainerComponent, AXPEntityPreloadFiltersViewModel, AXPEntityPreloadFiltersViewModelResolver, AXPEntityResolver, AXPEntityService, AXPEntityStorageService, AXPEntityUpdateViewSectionViewModel, AXPGetEntityDetailsQuery, AXPLayoutOrderingConfigService, AXPLookupWidget, AXPLookupWidgetColumnComponent, AXPLookupWidgetEditComponent, AXPLookupWidgetViewComponent, AXPMiddlewareAbortError, AXPMiddlewareEntityStorageService, AXPModifyEntitySectionWorkflow, AXPMultiSourceDefinitionProviderContext, AXPMultiSourceDefinitionProviderService, AXPMultiSourceFederatedSearchService, AXPMultiSourceSelectorComponent, AXPMultiSourceSelectorService, AXPMultiSourceSelectorWidget, AXPMultiSourceSelectorWidgetColumnComponent, AXPMultiSourceSelectorWidgetEditComponent, AXPMultiSourceSelectorWidgetViewComponent, AXPMultiSourceType, AXPOpenEntityDetailsCommand, AXPQuickEntityModifyPopupAction, AXPQuickModifyEntityWorkflow, AXPRelatedColumnEnrichmentService, AXPRelatedColumnMetadataResolver, AXPSelectorStructureWidget, AXPSelectorStructureWidgetColumnComponent, AXPSelectorStructureWidgetEditComponent, AXPSelectorStructureWidgetViewComponent, AXPShowDetailViewAction, AXPShowDetailsViewWorkflow, AXPShowListViewAction, AXPShowListViewWorkflow, AXPTruncatedBreadcrumbComponent, AXPUpdateEntityCommand, AXPViewEntityDetailsCommand, AXP_CATEGORY_TREE_ROOT_TITLE_I18N_KEY, 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, AXP_MULTI_SOURCE_DEFINITION_PROVIDER, DEFAULT_COLUMN_ORDER, DEFAULT_PAIR_SPAN_RULES, DEFAULT_PROPERTY_ORDER, DEFAULT_SECTION_ORDER, EntityBuilder, EntityDataAccessor, actionExists, axpCreateEntityAiToolInputDefaults, axpCreateEntityCommandDefinition, cloneLayoutArrays, collectEntityQuickSearchFieldPaths, collectNestedCreateHiddenProperties, collectNestedFieldPathsFromEntityColumns, collectQuickSearchPathsFromSingleEntityDefinition, columnOrderingMiddleware, columnOrderingMiddlewareProvider, columnWidthMiddleware, columnWidthMiddlewareProvider, computeEntityAggregates, createColumnOrderingMiddlewareProvider, createLayoutOrderingMiddlewareProvider, createModifierContext, defaultMultiLanguageMiddleware, defaultMultiLanguageMiddlewareProvider, detectEntityChanges, ensureLayoutPropertyView, ensureLayoutSection, ensureListActions, entityDetailsCreateActions, entityDetailsCreateActionsDeferredParent, entityDetailsCrudActions, entityDetailsEditAction, entityDetailsNewEditAction, entityDetailsReferenceCondition, entityDetailsReferenceCreateActions, entityDetailsSimpleCondition, entityMasterBulkDeleteAction, entityMasterCreateAction, entityMasterCrudActions, entityMasterDeleteAction, entityMasterEditAction, entityMasterRecordActions, entityMasterViewAction, entityOverrideDetailsViewAction, eventDispatchMiddleware, filterSortEntityRows, findEntityListRowDataInTree, getEntityListRowId, getMasterInterfacePropertySortKey, isAXPMiddlewareAbortError, isCategoryEntity, isCategoryFilter, layoutOrderingMiddlewareFactory, layoutOrderingMiddlewareProvider, mergeForeignKeyFieldIntoCreateActions, provideEntity, resolveEntityPluginDetailPageOrder, restoreEntityListExpandedRows, runEntityQuery, searchResultDescriptionMiddleware, searchResultDescriptionMiddlewareProvider };
 //# sourceMappingURL=acorex-platform-layout-entity.mjs.map