@acorex/modules 20.7.12 → 20.7.15

package/fesm2022/acorex-modules-data-management.mjs

@@ -39,9 +39,9 @@ import { AXSearchBoxModule } from '@acorex/components/search-box';
 import * as i4$2 from '@acorex/components/text-area';
 import { AXTextAreaModule } from '@acorex/components/text-area';
 import { AXFormModule } from '@acorex/components/form';
+import { AXPLayoutRendererComponent, AXPLayoutBuilderService } from '@acorex/platform/layout/builder';
 import { moveItemInArray as moveItemInArray$1, transferArrayItem, CdkDropList, CdkDrag, CdkDragHandle } from '@angular/cdk/drag-drop';
 import { AXDialogService } from '@acorex/components/dialog';
-import { AXPLayoutBuilderService, AXPLayoutRendererComponent } from '@acorex/platform/layout/builder';
 
 const config = {
     i18n: 'data-management',
@@ -91,6 +91,19 @@ const RootConfig = {
             title: '@general:terms.common.tag',
             icon: 'fa-light fa-tags',
         },
+        equipmentCategory: {
+            name: 'EquipmentCategory',
+            title: '@data-management:equipments.entities.equipment-category.title',
+            titlePlural: '@data-management:equipments.entities.equipment-category.plural',
+            icon: 'fa-light fa-folder-tree',
+        },
+        equipment: {
+            name: 'Equipment',
+            source: 'DataManagement.Equipment',
+            title: '@data-management:equipments.entities.equipment.title',
+            titlePlural: '@data-management:equipments.entities.equipment.plural',
+            icon: 'fa-light fa-plug',
+        },
     },
 };
 
@@ -1384,6 +1397,7 @@ const AXMDataManagementFeatureKeys = {
     Queries: 'DataManagement:Feature:Queries',
     DataSources: 'DataManagement:Feature:DataSources',
     MetaDataDefinitions: 'DataManagement:Feature:MetaDataDefinitions',
+    Equipments: 'DataManagement:Feature:Equipments',
 };
 
 //#region ----   Imports   ----
@@ -1416,6 +1430,13 @@ class AXPDataManagementFeatureDefinitionProvider {
             defaultValue: true,
             type: 'boolean',
         });
+        // Equipments feature
+        context.addFeature(AXMDataManagementFeatureKeys.Equipments, {
+            title: '@data-management:features.equipments.title',
+            description: '@data-management:features.equipments.description',
+            defaultValue: true,
+            type: 'boolean',
+        });
     }
 }
 //#endregion
@@ -1431,6 +1452,9 @@ const AXMPermissionsKeys = {
         MetaDataDefinition: {
             Management: 'DataManagement:Permission:MetaDataDefinition.Management',
         },
+        Equipment: {
+            Management: 'DataManagement:Permission:Equipment.Management',
+        },
         Tag: {
             Management: 'DataManagement:Permission:Tag.Management',
         },
@@ -1455,6 +1479,8 @@ class AXMPermissionDefinitionProvider {
         const transMetaData = async (key) => await this.translateService.translateAsync(`@data-management:metadata-definitions.permissions.metadata-definitions.${key}`);
         // Tag permissions
         const transTag = async (key) => await this.translateService.translateAsync(`@data-management:tags.permissions.tags.${key}`);
+        // Equipment permissions
+        const transEquipment = async (key) => await this.translateService.translateAsync(`@data-management:equipments.permissions.equipments.${key}`);
         context
             .addGroup(RootConfig.module.name, moduleTitle, moduleDescription)
             //
@@ -1467,6 +1493,9 @@ class AXMPermissionDefinitionProvider {
             .addPermission(keys.MetaDataDefinition.Management, await transMetaData('actions.manage.title'), await transMetaData('actions.manage.description'))
             .endPermission()
             //
+            .addPermission(keys.Equipment.Management, await transEquipment('actions.manage.title'), await transEquipment('actions.manage.description'))
+            .endPermission()
+            //
             .addPermission(keys.Tag.Management, await transTag('actions.manage.title'), await transTag('actions.manage.description'))
             .endPermission()
             //
@@ -1484,6 +1513,8 @@ const AXPDataManagementMenuKeys = {
     Queries: 'DataManagement:Menu:Queries',
     DataSources: 'DataManagement:Menu:DataSources',
     MetaDataDefinitions: 'DataManagement:Menu:MetaDataDefinitions',
+    Equipments: 'DataManagement:Menu:Equipments',
+    EquipmentCategories: 'DataManagement:Menu:EquipmentCategories',
     Tags: 'DataManagement:Menu:Tags',
 };
 
@@ -1536,12 +1567,35 @@ class AXMMenuProvider {
                             permissions: [AXMPermissionsKeys.DataManagement.MetaDataDefinition.Management],
                         },
                     },
+                    // Equipments & Equipment Categories (commented out)
+                    // {
+                    //   name: AXPDataManagementMenuKeys.Equipments,
+                    //   text: '@data-management:equipments.menus.equipments.title',
+                    //   path: this.entityService.createPath(RootConfig.module.name, RootConfig.entities.equipment.name),
+                    //   icon: RootConfig.entities.equipment.icon,
+                    //   priority: 9006,
+                    //   policy: {
+                    //     features: [AXMDataManagementFeatureKeys.Equipments],
+                    //     permissions: [AXMPermissionsKeys.DataManagement.Equipment.Management],
+                    //   },
+                    // },
+                    // {
+                    //   name: AXPDataManagementMenuKeys.EquipmentCategories,
+                    //   text: '@data-management:equipments.menus.equipment-categories.title',
+                    //   path: this.entityService.createPath(RootConfig.module.name, RootConfig.entities.equipmentCategory.name),
+                    //   icon: RootConfig.entities.equipmentCategory.icon,
+                    //   priority: 9007,
+                    //   policy: {
+                    //     features: [AXMDataManagementFeatureKeys.Equipments],
+                    //     permissions: [AXMPermissionsKeys.DataManagement.Equipment.Management],
+                    //   },
+                    // },
                     {
                         name: AXPDataManagementMenuKeys.Tags,
                         text: '@general:terms.common.tags',
                         icon: RootConfig.entities.tag.icon,
                         path: this.entityService.createPath(RootConfig.module.name, RootConfig.entities.tag.name),
-                        priority: 9006,
+                        priority: 9008,
                         policy: {
                             permissions: [AXMPermissionsKeys.DataManagement.Tag.Management],
                         },
@@ -1574,6 +1628,8 @@ class AXMEntityProvider {
                     return (await Promise.resolve().then(function () { return metaDataDefinition_entity; })).metaDataDefinitionFactory(this.injector);
                 case RootConfig.entities.tag.name:
                     return (await Promise.resolve().then(function () { return tag_entity; })).factory(this.injector);
+                case RootConfig.entities.equipment.name:
+                    return (await Promise.resolve().then(function () { return equipment_entity; })).equipmentFactory(this.injector);
             }
         }
         return null;
@@ -1936,6 +1992,64 @@ class AXMChoiceOptionsDataSourceDefinition {
                 });
             },
         };
+        //#endregion
+        //#region ----   Availability Options   ----
+        this.availabilityOptions = {
+            name: 'availability-options',
+            title: '@data-management:datasources.availability-options.title',
+            columns: [
+                {
+                    name: 'value',
+                    title: '@data-management:datasources.availability-options.columns.value.title',
+                    type: AXPWidgetsCatalog.text,
+                    datatype: 'string',
+                },
+                {
+                    name: 'title',
+                    title: '@data-management:datasources.availability-options.columns.title.title',
+                    type: AXPWidgetsCatalog.text,
+                    datatype: 'string',
+                },
+            ],
+            filters: [],
+            textField: { name: 'title', title: '@data-management:datasources.availability-options.columns.title.title' },
+            valueField: { name: 'value', title: '@data-management:datasources.availability-options.columns.value.title' },
+            samples: [
+                { value: '24-7', title: '@data-management:datasources.availability-options.samples.24-7' },
+                { value: 'business-hours', title: '@data-management:datasources.availability-options.samples.business-hours' },
+                { value: 'weekdays', title: '@data-management:datasources.availability-options.samples.weekdays' },
+                { value: 'weekends', title: '@data-management:datasources.availability-options.samples.weekends' },
+                { value: 'limited-hours', title: '@data-management:datasources.availability-options.samples.limited-hours' },
+            ],
+            source: () => {
+                return new AXDataSource({
+                    pageSize: 10,
+                    key: 'value',
+                    load: async () => {
+                        return {
+                            items: [
+                                { value: '24-7', title: '@data-management:datasources.availability-options.samples.24-7' },
+                                { value: 'business-hours', title: '@data-management:datasources.availability-options.samples.business-hours' },
+                                { value: 'weekdays', title: '@data-management:datasources.availability-options.samples.weekdays' },
+                                { value: 'weekends', title: '@data-management:datasources.availability-options.samples.weekends' },
+                                { value: 'limited-hours', title: '@data-management:datasources.availability-options.samples.limited-hours' },
+                            ],
+                            total: 5,
+                        };
+                    },
+                    byKey: async (key) => {
+                        const items = [
+                            { value: '24-7', title: '@data-management:datasources.availability-options.samples.24-7' },
+                            { value: 'business-hours', title: '@data-management:datasources.availability-options.samples.business-hours' },
+                            { value: 'weekdays', title: '@data-management:datasources.availability-options.samples.weekdays' },
+                            { value: 'weekends', title: '@data-management:datasources.availability-options.samples.weekends' },
+                            { value: 'limited-hours', title: '@data-management:datasources.availability-options.samples.limited-hours' },
+                        ];
+                        return items.find(item => item.value === key);
+                    },
+                });
+            },
+        };
     }
     //#endregion
     async items() {
@@ -1946,6 +2060,7 @@ class AXMChoiceOptionsDataSourceDefinition {
             this.frequencyOptions,
             this.satisfactionOptions,
             this.priorityOptions,
+            this.availabilityOptions,
         ];
     }
 }
@@ -4299,6 +4414,179 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.16", ngImpo
 //#region ----   Tag Entity Types   ----
 //#endregion
 
+//#region ----   Imports   ----
+//#endregion
+async function equipmentFactory(injector) {
+    const entityDef = {
+        module: RootConfig.module.name,
+        name: RootConfig.entities.equipment.name,
+        title: RootConfig.entities.equipment.title,
+        icon: RootConfig.entities.equipment.icon,
+        formats: {
+            individual: RootConfig.entities.equipment.title,
+            plural: RootConfig.entities.equipment.titlePlural,
+            displayName: RootConfig.entities.equipment.title,
+            searchResult: {
+                title: '{{ title }} ({{ code }})',
+                description: RootConfig.module.title,
+            },
+        },
+        plugins: [
+            { name: 'history' },
+            { name: 'lock' },
+            { name: 'compare' },
+            { name: 'clone' },
+            {
+                name: 'category',
+                options: {
+                    appearance: { icon: true, color: true },
+                    metaData: { enabled: true },
+                },
+            },
+            {
+                name: 'meta-data-form',
+                options: {
+                    path: 'categoryIds',
+                    title: '@data-management:equipments.entities.equipment.components.meta-data-form.title',
+                },
+            },
+            { name: 'tags' },
+            { name: 'notes' },
+        ],
+        relatedEntities: [],
+        groups: [
+            {
+                id: 'basic-info',
+                title: '@general:terms.interface.basic-info',
+            },
+        ],
+        properties: [
+            {
+                name: 'code',
+                title: '@general:terms.common.code',
+                groupId: 'basic-info',
+                options: {
+                    sort: { enabled: true },
+                    filter: {
+                        advance: { enabled: true },
+                        inline: { enabled: true },
+                    },
+                },
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsCatalog.text,
+                        options: {
+                            placeholder: 'e.g., EQ-001',
+                        },
+                    },
+                },
+                validations: [
+                    {
+                        rule: 'required',
+                    },
+                ],
+            },
+            {
+                name: 'title',
+                title: '@general:terms.common.title',
+                groupId: 'basic-info',
+                options: {
+                    sort: { enabled: true },
+                    filter: {
+                        advance: { enabled: true },
+                        inline: { enabled: true },
+                    },
+                },
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsCatalog.text,
+                    },
+                },
+                validations: [
+                    {
+                        rule: 'required',
+                    },
+                ],
+            },
+            {
+                name: 'description',
+                title: '@general:terms.common.description',
+                groupId: 'basic-info',
+                options: {
+                    sort: { enabled: false },
+                    filter: {
+                        advance: { enabled: true },
+                        inline: { enabled: false },
+                    },
+                },
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsCatalog.largeText,
+                        options: {
+                            rows: 3,
+                        },
+                    },
+                },
+            },
+        ],
+        columns: [
+            { name: 'code' },
+            { name: 'title' },
+            { name: 'categoryIds', options: { dataPath: 'categories' } },
+        ],
+        interfaces: {
+            master: {
+                create: {
+                    sections: [{ id: 'basic-info' }, { id: 'classification' }],
+                    properties: [
+                        { name: 'code', layout: { positions: { lg: { colSpan: 6, order: 1 } } } },
+                        { name: 'title', layout: { positions: { lg: { colSpan: 6, order: 2 } } } },
+                        { name: 'description', layout: { positions: { lg: { colSpan: 12, order: 3 } } } },
+                        { name: 'categoryIds', layout: { positions: { lg: { colSpan: 12, order: 12 } } } },
+                    ],
+                },
+                update: {
+                    sections: [{ id: 'basic-info' }, { id: 'classification' }],
+                    properties: [
+                        { name: 'code', layout: { positions: { lg: { colSpan: 6, order: 1 } } } },
+                        { name: 'title', layout: { positions: { lg: { colSpan: 6, order: 2 } } } },
+                        { name: 'description', layout: { positions: { lg: { colSpan: 12, order: 3 } } } },
+                        { name: 'categoryIds', layout: { positions: { lg: { colSpan: 12, order: 12 } } } },
+                    ],
+                },
+                single: {
+                    title: '{{title}}',
+                    sections: [{ id: 'basic-info' }, { id: 'classification' }],
+                    properties: [
+                        { name: 'code', layout: { positions: { lg: { colSpan: 6, order: 1 } } } },
+                        { name: 'title', layout: { positions: { lg: { colSpan: 6, order: 2 } } } },
+                        { name: 'description', layout: { positions: { lg: { colSpan: 12, order: 3 } } } },
+                        { name: 'categoryIds', layout: { label: { visible: true }, positions: { lg: { colSpan: 12, order: 12 } } } },
+                    ],
+                    actions: [...entityMasterRecordActions()],
+                },
+                list: {
+                    actions: [...entityMasterCrudActions()],
+                    views: [
+                        createAllQueryView({
+                            sorts: [{ name: 'title', dir: 'asc' }],
+                        }),
+                    ],
+                },
+            },
+        },
+    };
+    return entityDef;
+}
+
+var equipment_entity = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    equipmentFactory: equipmentFactory
+});
+
 class AXMQueryEntityModule {
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: AXMQueryEntityModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
     static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "20.3.16", ngImport: i0, type: AXMQueryEntityModule }); }
@@ -7774,12 +8062,12 @@ var queryBuilderWidgetDesigner_component = /*#__PURE__*/Object.freeze({
 //#region ----   Re-exports from Entity Types   ----
 //#endregion
 
-const AXPMetaDataSelectorWidget = {
-    name: 'meta-data-selector-editor',
-    title: '@data-management:metadata-definitions.components.meta-data-selector.title',
+const AXPMetaDataFormWidget = {
+    name: 'meta-data-form-editor',
+    title: '@data-management:metadata-definitions.components.meta-data-form.title',
     categories: AXP_WIDGETS_EDITOR_CATEGORY,
     groups: [AXPWidgetGroupEnum.UtilityWidget],
-    description: '@data-management:metadata-definitions.components.meta-data-selector.description',
+    description: '@data-management:metadata-definitions.components.meta-data-form.description',
     icon: 'fa-light fa-list-check',
     defaultFilterWidgetName: 'string-filter',
     type: 'editor',
@@ -7789,36 +8077,513 @@ const AXPMetaDataSelectorWidget = {
     properties: [
         AXP_NAME_PROPERTY,
         AXP_DATA_PATH_PROPERTY,
+        AXP_READONLY_PROPERTY,
+        AXP_DISABLED_PROPERTY,
     ],
     components: {
         view: {
-            component: () => Promise.resolve().then(function () { return metaDataSelectorView_component; }).then((c) => c.AXPMetaDataSelectorWidgetViewComponent),
+            component: () => Promise.resolve().then(function () { return metaDataFormEdit_component; }).then((c) => c.AXPMetaDataFormWidgetEditComponent),
         },
         edit: {
-            component: () => Promise.resolve().then(function () { return metaDataSelectorEdit_component; }).then((c) => c.AXPMetaDataSelectorWidgetEditComponent),
+            component: () => Promise.resolve().then(function () { return metaDataFormEdit_component; }).then((c) => c.AXPMetaDataFormWidgetEditComponent),
         },
         print: {
-            component: () => Promise.resolve().then(function () { return metaDataSelectorEdit_component; }).then((c) => c.AXPMetaDataSelectorWidgetEditComponent),
+            component: () => Promise.resolve().then(function () { return metaDataFormEdit_component; }).then((c) => c.AXPMetaDataFormWidgetEditComponent),
         },
     },
 };
 
-//#region ----   Meta-Data Selector Field Types   ----
-//#endregion
-//#region ----   Utility Functions   ----
-/**
- * Convert raw value to designer state
- */
-function convertValueToState(value) {
-    // Handle null/undefined
-    if (!value) {
-        return {
-            groups: [createDefaultGroup()],
-            mode: 'designer',
-        };
+class AXPMetaDataFormWidgetEditComponent extends AXPValueWidgetComponent {
+    constructor() {
+        super(...arguments);
+        //#region ----   Inputs   ----
+        /**
+         * Groups structure from meta-data-selector or evaluated expression
+         */
+        this.groups = computed(() => {
+            const options = this.options();
+            const groupsOption = options['groups'];
+            // Handle evaluated expression result (array of groups) or direct groups array
+            if (Array.isArray(groupsOption) && groupsOption.length > 0) {
+                return groupsOption;
+            }
+            return [];
+        }, ...(ngDevMode ? [{ debugName: "groups" }] : []));
+        this.#effect = effect(() => {
+            this.initializeFormDefinition();
+        }, ...(ngDevMode ? [{ debugName: "#effect" }] : []));
+        /**
+         * Check if there are any valid metadata definitions available
+         */
+        this.hasDefinitions = computed(() => {
+            const groups = this.groups();
+            if (groups.length === 0) {
+                return false;
+            }
+            return groups.some((group) => {
+                const fields = group.fields || [];
+                return fields.length > 0 && fields.some((field) => field != null);
+            });
+        }, ...(ngDevMode ? [{ debugName: "hasDefinitions" }] : []));
+        //#endregion
+        //#region ----   Outputs   ----
+        /**
+         * Emitted when form context changes
+         */
+        this.contextChange = output();
+        /**
+         * Emitted when form validity changes
+         */
+        this.validityChange = output();
+        //#endregion
+        //#region ----   Properties   ----
+        this.layoutRenderer = viewChild(AXPLayoutRendererComponent, ...(ngDevMode ? [{ debugName: "layoutRenderer" }] : []));
+        /**
+         * Form definition signal that only updates when structure actually changes
+         */
+        this.formDefinition = signal({ groups: [] }, ...(ngDevMode ? [{ debugName: "formDefinition" }] : []));
     }
-    // Handle old structure (flat array) - no longer supported but graceful fallback
-    if (Array.isArray(value)) {
+    #effect;
+    //#endregion
+    //#region ----   Event Handlers   ----
+    /**
+     * Handle context change from dynamic form
+     */
+    onContextChange(context) {
+        this.contextChange.emit(context);
+        this.setValue(context);
+    }
+    /**
+     * Handle validity change from dynamic form
+     */
+    onValidityChange(isValid) {
+        this.validityChange.emit(isValid);
+    }
+    //#endregion
+    //#region ----   Private Methods   ----
+    /**
+     * Initialize form definition based on current inputs
+     */
+    initializeFormDefinition() {
+        const groups = this.groups();
+        if (groups.length > 0) {
+            const newFormDefinition = this.convertGroupsToFormDefinition(groups);
+            this.formDefinition.set(newFormDefinition);
+        }
+    }
+    /**
+     * Convert groups structure from meta-data-selector to form definition
+     * Each metadata group becomes a separate form group with visual separation (card look)
+     */
+    convertGroupsToFormDefinition(groups) {
+        const formGroups = [];
+        groups.forEach((group) => {
+            const fields = group.fields || [];
+            const validFields = fields.filter((field) => field != null);
+            if (validFields.length > 0) {
+                const parameters = validFields.map((field) => this.convertMetadataToFieldDefinition(field));
+                formGroups.push({
+                    name: this.sanitizeGroupName(group.name || 'default'),
+                    title: group.title || group.name,
+                    description: group.description,
+                    look: groups.length > 1 ? 'group' : 'container',
+                    parameters,
+                });
+            }
+        });
+        return { groups: formGroups };
+    }
+    /**
+     * Convert single metadata definition to field definition
+     */
+    convertMetadataToFieldDefinition(metadata) {
+        // Handle null/undefined metadata
+        if (!metadata) {
+            console.warn('Undefined metadata definition encountered');
+            return {
+                path: 'undefined',
+                title: 'Undefined Field',
+                description: 'This field has undefined metadata',
+                widget: {
+                    type: 'text-editor',
+                    path: 'undefined',
+                    options: {
+                        defaultValue: '',
+                        validations: [],
+                    },
+                },
+            };
+        }
+        const interfaceConfig = this.parseInterfaceConfig(metadata.interface);
+        // Handle defaultValue: support both direct property and configuration.defaultValue
+        // (meta-data-selector uses configuration.defaultValue, other sources may use defaultValue directly)
+        const defaultValue = metadata.defaultValue ?? metadata.configuration?.defaultValue;
+        // Handle description: support both direct property and from configuration
+        const description = metadata.description ?? metadata.configuration?.description;
+        const widget = {
+            type: interfaceConfig.type || 'text-editor',
+            path: metadata.name || 'unnamed',
+            options: {
+                ...interfaceConfig.options,
+                defaultValue: defaultValue,
+                validations: this.parseValidations(metadata.interface),
+            },
+        };
+        if (interfaceConfig.triggers?.length) {
+            widget.triggers = interfaceConfig.triggers;
+        }
+        return {
+            path: metadata.name || 'unnamed',
+            title: metadata.title || 'Untitled Field',
+            description: description,
+            widget,
+        };
+    }
+    /**
+     * Parse interface configuration from metadata
+     */
+    parseInterfaceConfig(interfaceValue) {
+        if (typeof interfaceValue === 'string') {
+            try {
+                return JSON.parse(interfaceValue || '{}');
+            }
+            catch (error) {
+                console.warn('Failed to parse interface config:', interfaceValue, error);
+                return {};
+            }
+        }
+        return interfaceValue || {};
+    }
+    /**
+     * Parse validations from interface configuration
+     */
+    parseValidations(interfaceValue) {
+        const config = this.parseInterfaceConfig(interfaceValue);
+        return config.options?.validations || [];
+    }
+    /**
+     * Sanitize group name for use as identifier
+     */
+    sanitizeGroupName(name) {
+        return name.toLowerCase().replace(/[^a-z0-9]/g, '-');
+    }
+    //#endregion
+    //#region ----   Public Methods   ----
+    /**
+     * Get the layout renderer component instance
+     */
+    getLayoutRenderer() {
+        return this.layoutRenderer();
+    }
+    /**
+     * Validate the form
+     */
+    async validate() {
+        const renderer = this.layoutRenderer();
+        if (renderer) {
+            const validation = await renderer.validate();
+            return validation.result;
+        }
+        return false;
+    }
+    /**
+     * Get current form context
+     */
+    getContext() {
+        const renderer = this.layoutRenderer();
+        return renderer ? renderer.getContext() : {};
+    }
+    /**
+     * Update form context programmatically
+     */
+    updateContext(context) {
+        console.log('updateContext', context);
+        const renderer = this.layoutRenderer();
+        if (renderer) {
+            renderer.updateContext(context);
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: AXPMetaDataFormWidgetEditComponent, deps: null, target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "20.3.16", type: AXPMetaDataFormWidgetEditComponent, isStandalone: true, selector: "axp-meta-data-form-widget-edit", outputs: { contextChange: "contextChange", validityChange: "validityChange" }, viewQueries: [{ propertyName: "layoutRenderer", first: true, predicate: AXPLayoutRendererComponent, descendants: true, isSignal: true }], usesInheritance: true, ngImport: i0, template: `
+    @if (hasDefinitions()) {
+      <axp-layout-renderer
+        [layout]="formDefinition()"
+        [context]="getValue()"
+        [look]="'container'"
+        (contextChange)="onContextChange($event)"
+        (validityChange)="onValidityChange($event)"
+      >
+      </axp-layout-renderer>
+    } @else {
+      <axp-state-message
+        icon="fa-light fa-clipboard-list"
+        [title]="'@data-management:metadata-definitions.components.meta-data-selector.empty-states.no-metadata-definitions.title'"
+        [description]="'@data-management:metadata-definitions.components.meta-data-selector.empty-states.no-metadata-definitions.description'"
+      >
+      </axp-state-message>
+    }
+  `, isInline: true, dependencies: [{ kind: "component", type: AXPLayoutRendererComponent, selector: "axp-layout-renderer", inputs: ["layout", "context", "look", "mode"], outputs: ["contextChange", "contextInitiated", "validityChange"] }, { kind: "ngmodule", type: AXFormModule }, { kind: "ngmodule", type: AXLabelModule }, { kind: "ngmodule", type: AXPWidgetCoreModule }, { kind: "component", type: AXPStateMessageComponent, selector: "axp-state-message", inputs: ["mode", "icon", "title", "description", "variant"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: AXPMetaDataFormWidgetEditComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'axp-meta-data-form-widget-edit', template: `
+    @if (hasDefinitions()) {
+      <axp-layout-renderer
+        [layout]="formDefinition()"
+        [context]="getValue()"
+        [look]="'container'"
+        (contextChange)="onContextChange($event)"
+        (validityChange)="onValidityChange($event)"
+      >
+      </axp-layout-renderer>
+    } @else {
+      <axp-state-message
+        icon="fa-light fa-clipboard-list"
+        [title]="'@data-management:metadata-definitions.components.meta-data-selector.empty-states.no-metadata-definitions.title'"
+        [description]="'@data-management:metadata-definitions.components.meta-data-selector.empty-states.no-metadata-definitions.description'"
+      >
+      </axp-state-message>
+    }
+  `, changeDetection: ChangeDetectionStrategy.OnPush, imports: [AXPLayoutRendererComponent, AXFormModule, AXLabelModule, AXPWidgetCoreModule, AXPStateMessageComponent] }]
+        }], propDecorators: { contextChange: [{ type: i0.Output, args: ["contextChange"] }], validityChange: [{ type: i0.Output, args: ["validityChange"] }], layoutRenderer: [{ type: i0.ViewChild, args: [i0.forwardRef(() => AXPLayoutRendererComponent), { isSignal: true }] }] } });
+
+var metaDataFormEdit_component = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    AXPMetaDataFormWidgetEditComponent: AXPMetaDataFormWidgetEditComponent
+});
+
+class ShowMetaDataFormPopupCommand {
+    constructor() {
+        this.layoutBuilder = inject(AXPLayoutBuilderService);
+        this.translationService = inject(AXTranslationService);
+        this.entityService = inject(AXPEntityService);
+        this.entityRegistry = inject(AXPEntityDefinitionRegistryService);
+    }
+    async execute(input) {
+        try {
+            // Extract evaluated options from __context__ (private/controlled data)
+            // The __context__.options contains evaluated expressions from entity actions
+            const contextOptions = input.__context__?.options;
+            // Merge root-level input with evaluated options from __context__
+            // Root-level takes precedence if both exist
+            const evaluatedInput = {
+                ...contextOptions,
+                ...input,
+                // Ensure we use evaluated options from __context__ if available
+                ...(contextOptions ? contextOptions : {}),
+            };
+            const { entity, id, field = META_DATA_FORM_FIELD, title, path } = evaluatedInput;
+            if (!entity || !id) {
+                return {
+                    success: false,
+                    message: {
+                        text: await this.translationService.translateAsync('@general:messages.entity.invalid-data'),
+                    },
+                };
+            }
+            // Ensure id is a string
+            if (typeof id !== 'string' && id != null) {
+                const stringId = String(id);
+                if (stringId) {
+                    evaluatedInput.id = stringId;
+                }
+            }
+            if (!evaluatedInput.id || typeof evaluatedInput.id !== 'string') {
+                return {
+                    success: false,
+                    message: {
+                        text: await this.translationService.translateAsync('@general:messages.entity.invalid-data'),
+                    },
+                };
+            }
+            const finalId = evaluatedInput.id;
+            // Get current entity record to get the metadata expression value
+            const [moduleName, entityName] = entity.split('.');
+            const currentRecord = await this.findRecord(entity, finalId);
+            if (!currentRecord) {
+                return {
+                    success: false,
+                    message: {
+                        text: await this.translationService.translateAsync('@general:messages.entity.not-found'),
+                    },
+                };
+            }
+            // Note: pathValue might be null/undefined, but the metadata expression evaluator will handle it
+            // The expression will return an empty array if pathValue is not available
+            // Resolve entity to get metadata expression and determine if it's category or entity lookup
+            const entityDef = await this.entityRegistry.resolve(moduleName, entityName);
+            const metaDataFormExt = entityDef.extensions?.metaDataForm?.[field];
+            if (!metaDataFormExt) {
+                return {
+                    success: false,
+                    message: {
+                        text: await this.translationService.translateAsync('@data-management:metadata-definitions.messages.meta-data-form-not-configured'),
+                    },
+                };
+            }
+            // Get path property to determine metadata source type
+            const props = entityDef.properties || [];
+            const pathProperty = props.find((p) => p.name === path);
+            const targetEntity = pathProperty?.schema?.interface?.options?.['entity'];
+            if (!targetEntity) {
+                return {
+                    success: false,
+                    message: {
+                        text: await this.translationService.translateAsync('@data-management:metadata-definitions.messages.invalid-path-field'),
+                    },
+                };
+            }
+            // Build metadata expression based on target entity type
+            let metadataExpression;
+            if (targetEntity.endsWith('Category')) {
+                // Category lookup - use fromCategory
+                metadataExpression = `{{ metadata.fromCategory("${entity}", context.eval('${path}')) }}`;
+            }
+            else {
+                // Relationship lookup - use fromEntity
+                metadataExpression = `{{ metadata.fromEntity("${targetEntity}", context.eval('${path}')) }}`;
+            }
+            // Get current meta data form value
+            const currentMetaDataValue = currentRecord[field] || {};
+            // Build dialog title
+            const dialogTitle = title || metaDataFormExt.title || await this.translationService.translateAsync('@data-management:metadata-definitions.components.meta-data-form.title');
+            // Open dialog with meta-data-form-editor widget
+            const result = await this.layoutBuilder
+                .create()
+                .dialog((dialog) => {
+                dialog
+                    .setTitle(dialogTitle)
+                    .setSize('lg')
+                    .setCloseButton(true)
+                    .setContext({
+                    ...currentRecord,
+                    [field]: currentMetaDataValue,
+                })
+                    .content((layout) => {
+                    layout.flex((flex) => {
+                        flex.setDirection('column').setGap('16px');
+                        // Add meta-data-form-editor widget with metadata expression
+                        flex.formField('', (fieldBuilder) => {
+                            fieldBuilder
+                                .path(field)
+                                .setShowLabel(false)
+                                .customWidget('meta-data-form-editor', {
+                                groups: metadataExpression,
+                            });
+                        });
+                    });
+                })
+                    .setActions((actions) => {
+                    actions
+                        .cancel('@general:actions.cancel.title')
+                        .submit('@general:actions.save.title');
+                })
+                    .onAction(async (dialogRef) => {
+                    const context = dialogRef.context();
+                    const action = dialogRef.action();
+                    if (!context || action === 'cancel') {
+                        return { success: false };
+                    }
+                    const updateData = {
+                        [field]: context[field],
+                    };
+                    const updated = await this.updateRecord(entity, finalId, updateData);
+                    return {
+                        success: true,
+                        data: updated,
+                        message: {
+                            text: await this.translationService.translateAsync('@general:messages.entity.updated'),
+                        },
+                    };
+                });
+            })
+                .show();
+            return result;
+        }
+        catch (error) {
+            return {
+                success: false,
+                message: {
+                    text: error instanceof Error ? error.message : 'Failed to show meta data form popup',
+                },
+            };
+        }
+    }
+    //#region ---- Overridable Methods ----
+    /**
+     * Loads a record by entity and id. Override to use custom data sources or key handling.
+     */
+    findRecord(entity, id) {
+        const dataAccessor = this.entityService.withEntity(entity).data();
+        return dataAccessor.byKey(id);
+    }
+    /**
+     * Persists meta-data form changes. Override to use custom persistence or validation.
+     */
+    updateRecord(entity, id, data) {
+        const dataAccessor = this.entityService.withEntity(entity).data();
+        return dataAccessor.update(id, data);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: ShowMetaDataFormPopupCommand, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: ShowMetaDataFormPopupCommand, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: ShowMetaDataFormPopupCommand, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+
+var showMetaDataFormPopup_command = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    ShowMetaDataFormPopupCommand: ShowMetaDataFormPopupCommand
+});
+
+const AXPMetaDataSelectorWidget = {
+    name: 'meta-data-selector-editor',
+    title: '@data-management:metadata-definitions.components.meta-data-selector.title',
+    categories: AXP_WIDGETS_EDITOR_CATEGORY,
+    groups: [AXPWidgetGroupEnum.UtilityWidget],
+    description: '@data-management:metadata-definitions.components.meta-data-selector.description',
+    icon: 'fa-light fa-list-check',
+    defaultFilterWidgetName: 'string-filter',
+    type: 'editor',
+    options: {
+        needLabel: false,
+    },
+    properties: [
+        AXP_NAME_PROPERTY,
+        AXP_DATA_PATH_PROPERTY,
+    ],
+    components: {
+        view: {
+            component: () => Promise.resolve().then(function () { return metaDataSelectorView_component; }).then((c) => c.AXPMetaDataSelectorWidgetViewComponent),
+        },
+        edit: {
+            component: () => Promise.resolve().then(function () { return metaDataSelectorEdit_component; }).then((c) => c.AXPMetaDataSelectorWidgetEditComponent),
+        },
+        print: {
+            component: () => Promise.resolve().then(function () { return metaDataSelectorEdit_component; }).then((c) => c.AXPMetaDataSelectorWidgetEditComponent),
+        },
+    },
+};
+
+//#region ----   Meta-Data Selector Field Types   ----
+//#endregion
+//#region ----   Utility Functions   ----
+/**
+ * Convert raw value to designer state
+ */
+function convertValueToState(value) {
+    // Handle null/undefined
+    if (!value) {
+        return {
+            groups: [createDefaultGroup()],
+            mode: 'designer',
+        };
+    }
+    // Handle old structure (flat array) - no longer supported but graceful fallback
+    if (Array.isArray(value)) {
         return {
             groups: [
                 {
@@ -8686,35 +9451,22 @@ var metaDataSelectorEdit_component = /*#__PURE__*/Object.freeze({
     AXPMetaDataSelectorWidgetEditComponent: AXPMetaDataSelectorWidgetEditComponent
 });
 
-class AXPMetaDataSelectorWidgetViewComponent extends AXPValueWidgetComponent {
-    /**
-     * Returns a comma-separated list of selected meta titles.
-     * Extracting this logic into a getter keeps the template simple and
-     * avoids using arrow functions, which are not allowed in Angular
-     * interpolation expressions.
-     */
-    get display() {
-        const val = this.getValue();
-        return Array.isArray(val) ? val.map((v) => v.title || v.text).join(', ') : '';
+function normalizeSelectorDisplayConfig(display, defaultTitle) {
+    if (!display)
+        return { section: { enabled: true } };
+    if (typeof display === 'object')
+        return display;
+    switch (display) {
+        case 'section':
+            return { section: { enabled: true, title: defaultTitle }, popup: { enabled: false } };
+        case 'popup':
+            return { section: { enabled: false }, popup: { enabled: true, title: defaultTitle } };
+        case 'both':
+            return { section: { enabled: true, title: defaultTitle }, popup: { enabled: true, title: defaultTitle } };
+        default:
+            return { section: { enabled: true } };
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: AXPMetaDataSelectorWidgetViewComponent, deps: null, target: i0.ɵɵFactoryTarget.Component }); }
-    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "20.3.16", type: AXPMetaDataSelectorWidgetViewComponent, isStandalone: true, selector: "axp-meta-data-selector-widget-view", usesInheritance: true, ngImport: i0, template: `<span>{{ display }}</span>`, isInline: true, dependencies: [{ kind: "ngmodule", type: AXDecoratorModule }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: AXPMetaDataSelectorWidgetViewComponent, decorators: [{
-            type: Component,
-            args: [{
-                    selector: 'axp-meta-data-selector-widget-view',
-                    template: `<span>{{ display }}</span>`,
-                    changeDetection: ChangeDetectionStrategy.OnPush,
-                    imports: [AXDecoratorModule],
-                }]
-        }] });
-
-var metaDataSelectorView_component = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    AXPMetaDataSelectorWidgetViewComponent: AXPMetaDataSelectorWidgetViewComponent
-});
-
 /**
  * meta-data-selector plugin
  *
@@ -8772,6 +9524,12 @@ const metaDataSelectorPlugin = {
                     : (categoryMetaDataTitle && categoryMetaDataTitle.trim().length > 0)
                         ? categoryMetaDataTitle
                         : '@data-management:metadata-definitions.actions.configure-meta-data.title';
+        const displayConfig = normalizeSelectorDisplayConfig(opts.display, displayTitle);
+        const sectionConfig = displayConfig.section ?? {};
+        const popupConfig = displayConfig.popup ?? {};
+        const showSection = sectionConfig.enabled !== false;
+        const showPopup = popupConfig.enabled === true;
+        const popupTitle = popupConfig.title ?? displayTitle;
         //#region ----   Step 1: Create Meta-Data Selector Property   ----
         // Ensure group and section for the selector configuration itself
         const selectorSectionId = `meta-data-config`;
@@ -8795,62 +9553,74 @@ const metaDataSelectorPlugin = {
                 },
             });
         }
-        // Add selector to single/create/modify views (for configuration)
-        const selectorColSpan = 12;
-        ctx.interfaces.master.single.update((single) => {
-            const next = single ?? { title: ctx.entity.title, sections: [], properties: [] };
-            next.sections = next.sections ?? [];
-            if (!next.sections.some((s) => s.id === selectorSectionId)) {
-                next.sections.push({ id: selectorSectionId, title: displayTitle, order: 200 });
-            }
-            next.properties = next.properties ?? [];
-            if (!next.properties.some((p) => p.name === field)) {
-                next.properties.push({
-                    name: field,
-                    layout: {
-                        label: { visible: false },
-                        positions: { lg: { colSpan: selectorColSpan, order: 9 } },
-                    },
-                });
-            }
-            return next;
-        });
-        ctx.interfaces.master.create.update((create) => {
-            const next = create ?? { sections: [], properties: [] };
-            next.sections = next.sections ?? [];
-            if (!next.sections.some((s) => s.id === selectorSectionId)) {
-                next.sections.push({ id: selectorSectionId, title: displayTitle });
-            }
-            next.properties = next.properties ?? [];
-            if (!next.properties.some((p) => p.name === field)) {
-                next.properties.push({
-                    name: field,
-                    layout: {
-                        label: { visible: false },
-                        positions: { lg: { colSpan: selectorColSpan, order: 7 } },
-                    },
-                });
-            }
-            return next;
-        });
-        ctx.interfaces.master.modify.update((modify) => {
-            const next = modify ?? { sections: [], properties: [] };
-            next.sections = next.sections ?? [];
-            if (!next.sections.some((s) => s.id === selectorSectionId)) {
-                next.sections.push({ id: selectorSectionId, title: displayTitle });
-            }
-            next.properties = next.properties ?? [];
-            if (!next.properties.some((p) => p.name === field)) {
-                next.properties.push({
-                    name: field,
-                    layout: {
-                        label: { visible: false },
-                        positions: { lg: { colSpan: selectorColSpan, order: 7 } },
-                    },
-                });
-            }
-            return next;
-        });
+        // Add selector to single/create/modify views only when section display is enabled
+        const selectorColSpan = 12;
+        if (showSection) {
+            ctx.interfaces.master.single.update((single) => {
+                const next = single ?? { title: ctx.entity.title, sections: [], properties: [] };
+                next.sections = next.sections ?? [];
+                if (!next.sections.some((s) => s.id === selectorSectionId)) {
+                    next.sections.push({
+                        id: selectorSectionId,
+                        title: sectionConfig.title ?? displayTitle,
+                        order: sectionConfig.order ?? 200,
+                    });
+                }
+                next.properties = next.properties ?? [];
+                if (!next.properties.some((p) => p.name === field)) {
+                    next.properties.push({
+                        name: field,
+                        layout: {
+                            label: { visible: false },
+                            positions: { lg: { colSpan: selectorColSpan, order: 9 } },
+                        },
+                    });
+                }
+                return next;
+            });
+            ctx.interfaces.master.create.update((create) => {
+                const next = create ?? { sections: [], properties: [] };
+                next.sections = next.sections ?? [];
+                if (!next.sections.some((s) => s.id === selectorSectionId)) {
+                    next.sections.push({
+                        id: selectorSectionId,
+                        title: sectionConfig.title ?? displayTitle,
+                    });
+                }
+                next.properties = next.properties ?? [];
+                if (!next.properties.some((p) => p.name === field)) {
+                    next.properties.push({
+                        name: field,
+                        layout: {
+                            label: { visible: false },
+                            positions: { lg: { colSpan: selectorColSpan, order: 7 } },
+                        },
+                    });
+                }
+                return next;
+            });
+            ctx.interfaces.master.modify.update((modify) => {
+                const next = modify ?? { sections: [], properties: [] };
+                next.sections = next.sections ?? [];
+                if (!next.sections.some((s) => s.id === selectorSectionId)) {
+                    next.sections.push({
+                        id: selectorSectionId,
+                        title: sectionConfig.title ?? displayTitle,
+                    });
+                }
+                next.properties = next.properties ?? [];
+                if (!next.properties.some((p) => p.name === field)) {
+                    next.properties.push({
+                        name: field,
+                        layout: {
+                            label: { visible: false },
+                            positions: { lg: { colSpan: selectorColSpan, order: 7 } },
+                        },
+                    });
+                }
+                return next;
+            });
+        }
         //#endregion
         //#region ----   Step 2: Dynamic Group Generation Middleware   ----
         // Add metadata middleware to dynamically generate groups at runtime
@@ -8989,355 +9759,120 @@ const metaDataSelectorPlugin = {
         // Note: This is conceptual - actual implementation depends on platform capabilities
         // (ctx as any).middleware?.add?.(metadataMiddleware);
         //#endregion
-        //#region ----   Step 3: List Actions   ----
-        // Ensure list action to open meta data selector popup exists
-        // ensureListActions(ctx);
-        // ctx.interfaces.update((i) => {
-        //     const actions = (i as any).master.list.actions as any[];
-        //     const cmdName = 'show-meta-data-selector-popup';
-        //     const actionName = `meta-data-${field}`;
-        //     if (!actionExists(actions, cmdName, actionName)) {
-        //         actions.push({
-        //             name: actionName,
-        //             title: '@data-management:metadata-definitions.actions.configure-meta-data.title',
-        //             command: {
-        //                 name: cmdName,
-        //                 options: {
-        //                     id: '{{ context.eval("id") }}',
-        //                     metaData: `{{ context.eval("${field}") }}`,
-        //                     key: field,
-        //                 },
-        //             },
-        //             priority: 'secondary',
-        //             type: 'configure',
-        //             scope: AXPEntityCommandScope.Individual,
-        //         });
-        //     }
-        //     return i as any;
-        // });
-        //#endregion
-        //#region ----   Step 4: Extension Metadata   ----
-        // Stamp normalized config for middleware
-        ctx.entity.extensions ??= {};
-        ctx.entity.extensions.metaDataSelector ??= {};
-        ctx.entity.extensions.metaDataSelector[field] = {
-            title: displayTitle,
-        };
-        //#endregion
-    },
-};
-
-const AXPMetaDataFormWidget = {
-    name: 'meta-data-form-editor',
-    title: '@data-management:metadata-definitions.components.meta-data-form.title',
-    categories: AXP_WIDGETS_EDITOR_CATEGORY,
-    groups: [AXPWidgetGroupEnum.UtilityWidget],
-    description: '@data-management:metadata-definitions.components.meta-data-form.description',
-    icon: 'fa-light fa-list-check',
-    defaultFilterWidgetName: 'string-filter',
-    type: 'editor',
-    options: {
-        needLabel: false,
-    },
-    properties: [
-        AXP_NAME_PROPERTY,
-        AXP_DATA_PATH_PROPERTY,
-        AXP_READONLY_PROPERTY,
-        AXP_DISABLED_PROPERTY,
-    ],
-    components: {
-        view: {
-            component: () => Promise.resolve().then(function () { return metaDataFormEdit_component; }).then((c) => c.AXPMetaDataFormWidgetEditComponent),
-        },
-        edit: {
-            component: () => Promise.resolve().then(function () { return metaDataFormEdit_component; }).then((c) => c.AXPMetaDataFormWidgetEditComponent),
-        },
-        print: {
-            component: () => Promise.resolve().then(function () { return metaDataFormEdit_component; }).then((c) => c.AXPMetaDataFormWidgetEditComponent),
-        },
-    },
-};
-
-class AXPMetaDataFormWidgetEditComponent extends AXPValueWidgetComponent {
-    constructor() {
-        super(...arguments);
-        //#region ----   Inputs   ----
-        /**
-         * Groups structure from meta-data-selector or evaluated expression
-         */
-        this.groups = computed(() => {
-            const options = this.options();
-            const groupsOption = options['groups'];
-            // Handle evaluated expression result (array of groups) or direct groups array
-            if (Array.isArray(groupsOption) && groupsOption.length > 0) {
-                return groupsOption;
-            }
-            return [];
-        }, ...(ngDevMode ? [{ debugName: "groups" }] : []));
-        this.#effect = effect(() => {
-            this.initializeFormDefinition();
-        }, ...(ngDevMode ? [{ debugName: "#effect" }] : []));
-        /**
-         * Check if there are any valid metadata definitions available
-         */
-        this.hasDefinitions = computed(() => {
-            const groups = this.groups();
-            if (groups.length === 0) {
-                return false;
-            }
-            return groups.some((group) => {
-                const fields = group.fields || [];
-                return fields.length > 0 && fields.some((field) => field != null);
-            });
-        }, ...(ngDevMode ? [{ debugName: "hasDefinitions" }] : []));
-        //#endregion
-        //#region ----   Outputs   ----
-        /**
-         * Emitted when form context changes
-         */
-        this.contextChange = output();
-        /**
-         * Emitted when form validity changes
-         */
-        this.validityChange = output();
-        //#endregion
-        //#region ----   Properties   ----
-        this.layoutRenderer = viewChild(AXPLayoutRendererComponent, ...(ngDevMode ? [{ debugName: "layoutRenderer" }] : []));
-        /**
-         * Form definition signal that only updates when structure actually changes
-         */
-        this.formDefinition = signal({ groups: [] }, ...(ngDevMode ? [{ debugName: "formDefinition" }] : []));
-    }
-    #effect;
-    //#endregion
-    //#region ----   Event Handlers   ----
-    /**
-     * Handle context change from dynamic form
-     */
-    onContextChange(context) {
-        this.contextChange.emit(context);
-        this.setValue(context);
-    }
-    /**
-     * Handle validity change from dynamic form
-     */
-    onValidityChange(isValid) {
-        this.validityChange.emit(isValid);
-    }
-    //#endregion
-    //#region ----   Private Methods   ----
-    /**
-     * Initialize form definition based on current inputs
-     */
-    initializeFormDefinition() {
-        const groups = this.groups();
-        if (groups.length > 0) {
-            const newFormDefinition = this.convertGroupsToFormDefinition(groups);
-            this.formDefinition.set(newFormDefinition);
-        }
-    }
-    /**
-     * Convert groups structure from meta-data-selector to form definition
-     * Each metadata group becomes a separate form group with visual separation (card look)
-     */
-    convertGroupsToFormDefinition(groups) {
-        const formGroups = [];
-        groups.forEach((group) => {
-            const fields = group.fields || [];
-            const validFields = fields.filter((field) => field != null);
-            if (validFields.length > 0) {
-                const parameters = validFields.map((field) => this.convertMetadataToFieldDefinition(field));
-                formGroups.push({
-                    name: this.sanitizeGroupName(group.name || 'default'),
-                    title: group.title || group.name,
-                    description: group.description,
-                    look: groups.length > 1 ? 'group' : 'container',
-                    parameters,
-                });
-            }
-        });
-        return { groups: formGroups };
-    }
-    /**
-     * Convert single metadata definition to field definition
-     */
-    convertMetadataToFieldDefinition(metadata) {
-        // Handle null/undefined metadata
-        if (!metadata) {
-            console.warn('Undefined metadata definition encountered');
-            return {
-                path: 'undefined',
-                title: 'Undefined Field',
-                description: 'This field has undefined metadata',
-                widget: {
-                    type: 'text-editor',
-                    path: 'undefined',
-                    options: {
-                        defaultValue: '',
-                        validations: [],
-                    },
-                },
-            };
-        }
-        const interfaceConfig = this.parseInterfaceConfig(metadata.interface);
-        // Handle defaultValue: support both direct property and configuration.defaultValue
-        // (meta-data-selector uses configuration.defaultValue, other sources may use defaultValue directly)
-        const defaultValue = metadata.defaultValue ?? metadata.configuration?.defaultValue;
-        // Handle description: support both direct property and from configuration
-        const description = metadata.description ?? metadata.configuration?.description;
-        const widget = {
-            type: interfaceConfig.type || 'text-editor',
-            path: metadata.name || 'unnamed',
-            options: {
-                ...interfaceConfig.options,
-                defaultValue: defaultValue,
-                validations: this.parseValidations(metadata.interface),
-            },
-        };
-        if (interfaceConfig.triggers?.length) {
-            widget.triggers = interfaceConfig.triggers;
+        //#region ----   Step 3: Popup actions (when display is popup or both)   ----
+        if (showPopup) {
+            const actionName = `show-meta-data-selector-popup-${field}`;
+            const commandName = 'show-meta-data-selector-popup';
+            ctx.interfaces.master.single.update((single) => {
+                const next = single ?? { title: ctx.entity.title, sections: [], properties: [], actions: [] };
+                next.actions = next.actions ?? [];
+                if (!actionExists(next.actions, commandName, actionName)) {
+                    next.actions.push({
+                        name: actionName,
+                        title: popupTitle,
+                        command: {
+                            name: commandName,
+                            options: {
+                                entity: `${ctx.entity.module}.${ctx.entity.name}`,
+                                id: '{{ context.eval("id") }}',
+                                field,
+                                title: popupTitle,
+                            },
+                        },
+                        priority: 'secondary',
+                        type: 'configure',
+                        icon: 'fa-light fa-list-check',
+                        scope: AXPEntityCommandScope.Individual,
+                    });
+                }
+                return next;
+            });
+            ctx.interfaces.master.list.update((list) => {
+                const next = list ?? { actions: [], views: [] };
+                next.actions = next.actions ?? [];
+                if (!actionExists(next.actions, commandName, actionName)) {
+                    next.actions.push({
+                        name: actionName,
+                        title: popupTitle,
+                        command: {
+                            name: commandName,
+                            options: {
+                                entity: `${ctx.entity.module}.${ctx.entity.name}`,
+                                id: '{{ context.eval("id") }}',
+                                field,
+                                title: popupTitle,
+                            },
+                        },
+                        priority: 'secondary',
+                        type: 'configure',
+                        icon: 'fa-light fa-list-check',
+                        scope: AXPEntityCommandScope.Individual,
+                    });
+                }
+                return next;
+            });
         }
-        return {
-            path: metadata.name || 'unnamed',
-            title: metadata.title || 'Untitled Field',
-            description: description,
-            widget,
+        //#endregion
+        //#region ----   Step 4: Extension Metadata   ----
+        // Stamp normalized config for middleware
+        ctx.entity.extensions ??= {};
+        ctx.entity.extensions.metaDataSelector ??= {};
+        ctx.entity.extensions.metaDataSelector[field] = {
+            title: displayTitle,
+            display: displayConfig,
         };
-    }
-    /**
-     * Parse interface configuration from metadata
-     */
-    parseInterfaceConfig(interfaceValue) {
-        if (typeof interfaceValue === 'string') {
-            try {
-                return JSON.parse(interfaceValue || '{}');
-            }
-            catch (error) {
-                console.warn('Failed to parse interface config:', interfaceValue, error);
-                return {};
-            }
-        }
-        return interfaceValue || {};
-    }
-    /**
-     * Parse validations from interface configuration
-     */
-    parseValidations(interfaceValue) {
-        const config = this.parseInterfaceConfig(interfaceValue);
-        return config.options?.validations || [];
-    }
-    /**
-     * Sanitize group name for use as identifier
-     */
-    sanitizeGroupName(name) {
-        return name.toLowerCase().replace(/[^a-z0-9]/g, '-');
-    }
-    //#endregion
-    //#region ----   Public Methods   ----
-    /**
-     * Get the layout renderer component instance
-     */
-    getLayoutRenderer() {
-        return this.layoutRenderer();
-    }
-    /**
-     * Validate the form
-     */
-    async validate() {
-        const renderer = this.layoutRenderer();
-        if (renderer) {
-            const validation = await renderer.validate();
-            return validation.result;
-        }
-        return false;
-    }
-    /**
-     * Get current form context
-     */
-    getContext() {
-        const renderer = this.layoutRenderer();
-        return renderer ? renderer.getContext() : {};
-    }
+        //#endregion
+    },
+};
+
+class AXPMetaDataSelectorWidgetViewComponent extends AXPValueWidgetComponent {
     /**
-     * Update form context programmatically
+     * Returns a comma-separated list of selected meta titles.
+     * Extracting this logic into a getter keeps the template simple and
+     * avoids using arrow functions, which are not allowed in Angular
+     * interpolation expressions.
      */
-    updateContext(context) {
-        console.log('updateContext', context);
-        const renderer = this.layoutRenderer();
-        if (renderer) {
-            renderer.updateContext(context);
-        }
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: AXPMetaDataFormWidgetEditComponent, deps: null, target: i0.ɵɵFactoryTarget.Component }); }
-    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "20.3.16", type: AXPMetaDataFormWidgetEditComponent, isStandalone: true, selector: "axp-meta-data-form-widget-edit", outputs: { contextChange: "contextChange", validityChange: "validityChange" }, viewQueries: [{ propertyName: "layoutRenderer", first: true, predicate: AXPLayoutRendererComponent, descendants: true, isSignal: true }], usesInheritance: true, ngImport: i0, template: `
-    @if (hasDefinitions()) {
-      <axp-layout-renderer
-        [layout]="formDefinition()"
-        [context]="getValue()"
-        [look]="'container'"
-        (contextChange)="onContextChange($event)"
-        (validityChange)="onValidityChange($event)"
-      >
-      </axp-layout-renderer>
-    } @else {
-      <axp-state-message
-        icon="fa-light fa-clipboard-list"
-        [title]="'@data-management:metadata-definitions.components.meta-data-selector.empty-states.no-metadata-definitions.title'"
-        [description]="'@data-management:metadata-definitions.components.meta-data-selector.empty-states.no-metadata-definitions.description'"
-      >
-      </axp-state-message>
+    get display() {
+        const val = this.getValue();
+        return Array.isArray(val) ? val.map((v) => v.title || v.text).join(', ') : '';
     }
-  `, isInline: true, dependencies: [{ kind: "component", type: AXPLayoutRendererComponent, selector: "axp-layout-renderer", inputs: ["layout", "context", "look", "mode"], outputs: ["contextChange", "contextInitiated", "validityChange"] }, { kind: "ngmodule", type: AXFormModule }, { kind: "ngmodule", type: AXLabelModule }, { kind: "ngmodule", type: AXPWidgetCoreModule }, { kind: "component", type: AXPStateMessageComponent, selector: "axp-state-message", inputs: ["mode", "icon", "title", "description", "variant"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: AXPMetaDataSelectorWidgetViewComponent, deps: null, target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "20.3.16", type: AXPMetaDataSelectorWidgetViewComponent, isStandalone: true, selector: "axp-meta-data-selector-widget-view", usesInheritance: true, ngImport: i0, template: `<span>{{ display }}</span>`, isInline: true, dependencies: [{ kind: "ngmodule", type: AXDecoratorModule }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: AXPMetaDataFormWidgetEditComponent, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: AXPMetaDataSelectorWidgetViewComponent, decorators: [{
             type: Component,
-            args: [{ selector: 'axp-meta-data-form-widget-edit', template: `
-    @if (hasDefinitions()) {
-      <axp-layout-renderer
-        [layout]="formDefinition()"
-        [context]="getValue()"
-        [look]="'container'"
-        (contextChange)="onContextChange($event)"
-        (validityChange)="onValidityChange($event)"
-      >
-      </axp-layout-renderer>
-    } @else {
-      <axp-state-message
-        icon="fa-light fa-clipboard-list"
-        [title]="'@data-management:metadata-definitions.components.meta-data-selector.empty-states.no-metadata-definitions.title'"
-        [description]="'@data-management:metadata-definitions.components.meta-data-selector.empty-states.no-metadata-definitions.description'"
-      >
-      </axp-state-message>
-    }
-  `, changeDetection: ChangeDetectionStrategy.OnPush, imports: [AXPLayoutRendererComponent, AXFormModule, AXLabelModule, AXPWidgetCoreModule, AXPStateMessageComponent] }]
-        }], propDecorators: { contextChange: [{ type: i0.Output, args: ["contextChange"] }], validityChange: [{ type: i0.Output, args: ["validityChange"] }], layoutRenderer: [{ type: i0.ViewChild, args: [i0.forwardRef(() => AXPLayoutRendererComponent), { isSignal: true }] }] } });
+            args: [{
+                    selector: 'axp-meta-data-selector-widget-view',
+                    template: `<span>{{ display }}</span>`,
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    imports: [AXDecoratorModule],
+                }]
+        }] });
 
-var metaDataFormEdit_component = /*#__PURE__*/Object.freeze({
+var metaDataSelectorView_component = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    AXPMetaDataFormWidgetEditComponent: AXPMetaDataFormWidgetEditComponent
+    AXPMetaDataSelectorWidgetViewComponent: AXPMetaDataSelectorWidgetViewComponent
 });
 
-class ShowMetaDataFormPopupCommand {
+/**
+ * Opens the meta-data-selector (configuration UI for groups/fields) in a popup.
+ * Used when meta-data-selector plugin has display: 'popup' or 'both'.
+ */
+class ShowMetaDataSelectorPopupCommand {
     constructor() {
         this.layoutBuilder = inject(AXPLayoutBuilderService);
         this.translationService = inject(AXTranslationService);
         this.entityService = inject(AXPEntityService);
-        this.entityRegistry = inject(AXPEntityDefinitionRegistryService);
     }
     async execute(input) {
         try {
-            // Extract evaluated options from __context__ (private/controlled data)
-            // The __context__.options contains evaluated expressions from entity actions
             const contextOptions = input.__context__?.options;
-            // Merge root-level input with evaluated options from __context__
-            // Root-level takes precedence if both exist
             const evaluatedInput = {
                 ...contextOptions,
                 ...input,
-                // Ensure we use evaluated options from __context__ if available
                 ...(contextOptions ? contextOptions : {}),
             };
-            const { entity, id, field = META_DATA_FORM_FIELD, title, path } = evaluatedInput;
+            const { entity, id, field = META_DATA_SELECTOR_FIELD, title, } = evaluatedInput;
             if (!entity || !id) {
                 return {
                     success: false,
@@ -9346,14 +9881,8 @@ class ShowMetaDataFormPopupCommand {
                     },
                 };
             }
-            // Ensure id is a string
-            if (typeof id !== 'string' && id != null) {
-                const stringId = String(id);
-                if (stringId) {
-                    evaluatedInput.id = stringId;
-                }
-            }
-            if (!evaluatedInput.id || typeof evaluatedInput.id !== 'string') {
+            const finalId = typeof id === 'string' ? id : String(id);
+            if (!finalId) {
                 return {
                     success: false,
                     message: {
@@ -9361,11 +9890,7 @@ class ShowMetaDataFormPopupCommand {
                     },
                 };
             }
-            const finalId = evaluatedInput.id;
-            // Get current entity record to get the metadata expression value
-            const [moduleName, entityName] = entity.split('.');
-            const dataAccessor = this.entityService.withEntity(entity).data();
-            const currentRecord = await dataAccessor.byKey(finalId);
+            const currentRecord = await this.findRecord(entity, finalId);
             if (!currentRecord) {
                 return {
                     success: false,
@@ -9374,46 +9899,9 @@ class ShowMetaDataFormPopupCommand {
                     },
                 };
             }
-            // Note: pathValue might be null/undefined, but the metadata expression evaluator will handle it
-            // The expression will return an empty array if pathValue is not available
-            // Resolve entity to get metadata expression and determine if it's category or entity lookup
-            const entityDef = await this.entityRegistry.resolve(moduleName, entityName);
-            const metaDataFormExt = entityDef.extensions?.metaDataForm?.[field];
-            if (!metaDataFormExt) {
-                return {
-                    success: false,
-                    message: {
-                        text: await this.translationService.translateAsync('@data-management:metadata-definitions.messages.meta-data-form-not-configured'),
-                    },
-                };
-            }
-            // Get path property to determine metadata source type
-            const props = entityDef.properties || [];
-            const pathProperty = props.find((p) => p.name === path);
-            const targetEntity = pathProperty?.schema?.interface?.options?.['entity'];
-            if (!targetEntity) {
-                return {
-                    success: false,
-                    message: {
-                        text: await this.translationService.translateAsync('@data-management:metadata-definitions.messages.invalid-path-field'),
-                    },
-                };
-            }
-            // Build metadata expression based on target entity type
-            let metadataExpression;
-            if (targetEntity.endsWith('Category')) {
-                // Category lookup - use fromCategory
-                metadataExpression = `{{ metadata.fromCategory("${entity}", context.eval('${path}')) }}`;
-            }
-            else {
-                // Relationship lookup - use fromEntity
-                metadataExpression = `{{ metadata.fromEntity("${targetEntity}", context.eval('${path}')) }}`;
-            }
-            // Get current meta data form value
-            const currentMetaDataValue = currentRecord[field] || {};
-            // Build dialog title
-            const dialogTitle = title || metaDataFormExt.title || await this.translationService.translateAsync('@data-management:metadata-definitions.components.meta-data-form.title');
-            // Open dialog with meta-data-form-editor widget
+            const currentSelectorValue = currentRecord[field] ?? { groups: [] };
+            const dialogTitle = title ??
+                (await this.translationService.translateAsync('@data-management:metadata-definitions.actions.configure-meta-data.title'));
             const result = await this.layoutBuilder
                 .create()
                 .dialog((dialog) => {
@@ -9423,19 +9911,16 @@ class ShowMetaDataFormPopupCommand {
                     .setCloseButton(true)
                     .setContext({
                     ...currentRecord,
-                    [field]: currentMetaDataValue,
+                    [field]: currentSelectorValue,
                 })
                     .content((layout) => {
                     layout.flex((flex) => {
                         flex.setDirection('column').setGap('16px');
-                        // Add meta-data-form-editor widget with metadata expression
                         flex.formField('', (fieldBuilder) => {
                             fieldBuilder
                                 .path(field)
                                 .setShowLabel(false)
-                                .customWidget('meta-data-form-editor', {
-                                groups: metadataExpression,
-                            });
+                                .customWidget('meta-data-selector-editor', {});
                         });
                     });
                 })
@@ -9450,10 +9935,8 @@ class ShowMetaDataFormPopupCommand {
                     if (!context || action === 'cancel') {
                         return { success: false };
                     }
-                    const updateData = {
-                        [field]: context[field],
-                    };
-                    const updated = await dataAccessor.update(finalId, updateData);
+                    const updateData = { [field]: context[field] };
+                    const updated = await this.updateRecord(entity, finalId, updateData);
                     return {
                         success: true,
                         data: updated,
@@ -9470,24 +9953,41 @@ class ShowMetaDataFormPopupCommand {
             return {
                 success: false,
                 message: {
-                    text: error instanceof Error ? error.message : 'Failed to show meta data form popup',
+                    text: error instanceof Error
+                        ? error.message
+                        : 'Failed to show meta data selector popup',
                 },
             };
         }
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: ShowMetaDataFormPopupCommand, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: ShowMetaDataFormPopupCommand, providedIn: 'root' }); }
+    //#region ---- Overridable Methods ----
+    /**
+     * Loads a record by entity and id. Override to use custom data sources or key handling.
+     */
+    findRecord(entity, id) {
+        const dataAccessor = this.entityService.withEntity(entity).data();
+        return dataAccessor.byKey(id);
+    }
+    /**
+     * Persists meta-data changes. Override to use custom persistence or validation.
+     */
+    updateRecord(entity, id, data) {
+        const dataAccessor = this.entityService.withEntity(entity).data();
+        return dataAccessor.update(id, data);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: ShowMetaDataSelectorPopupCommand, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: ShowMetaDataSelectorPopupCommand, providedIn: 'root' }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: ShowMetaDataFormPopupCommand, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: ShowMetaDataSelectorPopupCommand, decorators: [{
             type: Injectable,
             args: [{
                     providedIn: 'root',
                 }]
         }] });
 
-var showMetaDataFormPopup_command = /*#__PURE__*/Object.freeze({
+var showMetaDataSelectorPopup_command = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    ShowMetaDataFormPopupCommand: ShowMetaDataFormPopupCommand
+    ShowMetaDataSelectorPopupCommand: ShowMetaDataSelectorPopupCommand
 });
 
 /**
@@ -10047,6 +10547,10 @@ class AXMDataManagementModule {
                     key: 'show-meta-data-form-popup',
                     command: () => Promise.resolve().then(function () { return showMetaDataFormPopup_command; }).then((c) => c.ShowMetaDataFormPopupCommand),
                 },
+                {
+                    key: 'show-meta-data-selector-popup',
+                    command: () => Promise.resolve().then(function () { return showMetaDataSelectorPopup_command; }).then((c) => c.ShowMetaDataSelectorPopupCommand),
+                },
             ]),
             // Module Manifest Provider
             {
@@ -10145,6 +10649,10 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.16", ngImpo
                                 key: 'show-meta-data-form-popup',
                                 command: () => Promise.resolve().then(function () { return showMetaDataFormPopup_command; }).then((c) => c.ShowMetaDataFormPopupCommand),
                             },
+                            {
+                                key: 'show-meta-data-selector-popup',
+                                command: () => Promise.resolve().then(function () { return showMetaDataSelectorPopup_command; }).then((c) => c.ShowMetaDataSelectorPopupCommand),
+                            },
                         ]),
                         // Module Manifest Provider
                         {
@@ -10191,5 +10699,5 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.16", ngImpo
  * Generated bundle index. Do not edit.
  */
 
-export { AXMColumnFilterSelectorWidget, AXMColumnFilterSelectorWidgetColumnComponent, AXMColumnFilterSelectorWidgetEditComponent, AXMColumnFilterSelectorWidgetFilterComponent, AXMColumnFilterSelectorWidgetPrintComponent, AXMColumnFilterSelectorWidgetViewComponent, AXMDataManagementFeatureKeys, AXMDataManagementModule, AXMDataSourceEntityModule, AXMDataSourceOutputType, AXMDataSourceService, AXMDataSourceServiceImpl, AXMDataSourceType, AXMDefaultAggregateFunctionProvider, AXMDefaultDatabaseTypeProvider, AXMEntityProvider, AXMMenuProvider, AXMMetaDataDefinitionEntityModule, AXMMetaDataDefinitionService, AXMMetaDataFeatureModule, AXMMetadataEvaluatorScopeProvider, AXMPMetaDataDefinitionServiceImpl, AXMPermissionsKeys, AXMQueryEntityModule, AXMQueryService, AXMQueryServiceImpl, AXMTagEntityModule, AXMTagEntityService, AXMTagsFeatureModule, AXM_COLUMN_DEF_WIDGET, AXM_FILTER_DEF_WIDGET, AXPAggregateBuilderComponent, AXPAggregateFunctionService, AXPAggregateFunctionsRegistry, AXPColumnsBuilderComponent, AXPDataManagementMenuKeys, AXPDatabaseTypeService, AXPGroupByBuilderComponent, AXPQueryBuilderComponent, AXPQueryBuilderWidget, AXPQueryBuilderWidgetColumnComponent, AXPQueryBuilderWidgetDesignerComponent, AXPQueryBuilderWidgetEditComponent, AXPQueryBuilderWidgetViewComponent, AXPRawQueryBuilderComponent, AXPSortBuilderComponent, AXPSystemTagProvider, AXPWhereBuilderComponent, AXP_AGGREGATE_FUNCTION_PROVIDER, AXP_DATABASE_TYPE_PROVIDER, AXP_DEFAULT_AGGREGATE_FUNCTION_PROVIDER, AXP_DEFAULT_DATABASE_TYPE_PROVIDER, META_DATA_FORM_FIELD, META_DATA_SELECTOR_FIELD, RootConfig, dataSourceEntityFactory, factory, metaDataDefinitionFactory, queryFactory, tagsPlugin };
+export { AXMColumnFilterSelectorWidget, AXMColumnFilterSelectorWidgetColumnComponent, AXMColumnFilterSelectorWidgetEditComponent, AXMColumnFilterSelectorWidgetFilterComponent, AXMColumnFilterSelectorWidgetPrintComponent, AXMColumnFilterSelectorWidgetViewComponent, AXMDataManagementFeatureKeys, AXMDataManagementModule, AXMDataSourceEntityModule, AXMDataSourceOutputType, AXMDataSourceService, AXMDataSourceServiceImpl, AXMDataSourceType, AXMDefaultAggregateFunctionProvider, AXMDefaultDatabaseTypeProvider, AXMEntityProvider, AXMMenuProvider, AXMMetaDataDefinitionEntityModule, AXMMetaDataDefinitionService, AXMMetaDataFeatureModule, AXMMetadataEvaluatorScopeProvider, AXMPMetaDataDefinitionServiceImpl, AXMPermissionsKeys, AXMQueryEntityModule, AXMQueryService, AXMQueryServiceImpl, AXMTagEntityModule, AXMTagEntityService, AXMTagsFeatureModule, AXM_COLUMN_DEF_WIDGET, AXM_FILTER_DEF_WIDGET, AXPAggregateBuilderComponent, AXPAggregateFunctionService, AXPAggregateFunctionsRegistry, AXPColumnsBuilderComponent, AXPDataManagementMenuKeys, AXPDatabaseTypeService, AXPGroupByBuilderComponent, AXPMetaDataFormWidget, AXPMetaDataFormWidgetEditComponent, AXPMetaDataSelectorWidget, AXPMetaDataSelectorWidgetEditComponent, AXPMetaDataSelectorWidgetViewComponent, AXPQueryBuilderComponent, AXPQueryBuilderWidget, AXPQueryBuilderWidgetColumnComponent, AXPQueryBuilderWidgetDesignerComponent, AXPQueryBuilderWidgetEditComponent, AXPQueryBuilderWidgetViewComponent, AXPRawQueryBuilderComponent, AXPSortBuilderComponent, AXPSystemTagProvider, AXPWhereBuilderComponent, AXP_AGGREGATE_FUNCTION_PROVIDER, AXP_DATABASE_TYPE_PROVIDER, AXP_DEFAULT_AGGREGATE_FUNCTION_PROVIDER, AXP_DEFAULT_DATABASE_TYPE_PROVIDER, META_DATA_FORM_FIELD, META_DATA_SELECTOR_FIELD, RootConfig, ShowMetaDataFormPopupCommand, ShowMetaDataSelectorPopupCommand, convertStateToValue, convertValueToState, createDefaultGroup, dataSourceEntityFactory, equipmentFactory, factory, metaDataDefinitionFactory, metaDataSelectorPlugin, queryFactory, tagsPlugin };
 //# sourceMappingURL=acorex-modules-data-management.mjs.map