@acorex/modules 21.0.0-next.74 → 21.0.0-next.76

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

@@ -1,8 +1,8 @@
 import * as i0 from '@angular/core';
 import { computed, effect, HostBinding, ChangeDetectionStrategy, Component, EventEmitter, signal, Output, Input, inject, ElementRef, DestroyRef, PLATFORM_ID, input, output, untracked, afterNextRender, InjectionToken, Injectable, viewChild, NgModule, model, ViewEncapsulation } from '@angular/core';
-import { AXPDataSourceDefinitionProviderService, applyFilterArray, applySortArray, AXPContextStore, AXPDataGenerator, compareMultiLanguageStrings, AXPTagProvider, AXP_TAG_PROVIDER, AXP_EXPRESSION_EVALUATOR_SCOPE_PROVIDER, AXP_MODULE_MANIFEST_PROVIDER, AXP_FEATURE_DEFINITION_PROVIDER, AXP_DATASOURCE_DEFINITION_PROVIDER, provideLazyProvider, AXPSystemActionType } from '@acorex/platform/core';
+import { AXPDataSourceDefinitionProviderService, applyFilterArray, applySortArray, AXPContextStore, AXPDataGenerator, compareMultiLanguageStrings, AXPTagProvider, AXP_TAG_PROVIDER, AXP_EXPRESSION_EVALUATOR_SCOPE_PROVIDER, AXP_MODULE_MANIFEST_PROVIDER, AXP_FEATURE_DEFINITION_PROVIDER, AXP_DATASOURCE_DEFINITION_PROVIDER, provideLazyProvider } from '@acorex/platform/core';
 import { AXPStateMessageComponent, AXPStandardSectionItemsBuilderComponent, AXPDataSelectorService, AXPWidgetPropertyViewerService, AXPItemConfiguratorComponent, AXP_PAGE_COMPONENT_PROVIDER } from '@acorex/platform/layout/components';
-import { AXPEntityDefinitionRegistryService, AXPEntityService, resolveEntityPluginDetailPageOrder, actionExists, AXP_ENTITY_ACTION_PLUGIN, ensureListActions, cloneLayoutArrays, ensureLayoutSection, ensureLayoutPropertyView, AXP_ENTITY_STORAGE_MIDDLEWARE, AXP_ENTITY_DEFINITION_LOADER, entityMasterCrudActions, entityMasterRecordActions, entityMasterDeleteAction } from '@acorex/platform/layout/entity';
+import { AXPEntityDefinitionRegistryService, AXPEntityService, resolveEntityPluginDetailPageOrder, actionExists, AXP_ENTITY_ACTION_PLUGIN, ensureListActions, cloneLayoutArrays, ensureLayoutSection, ensureLayoutPropertyView, AXP_ENTITY_STORAGE_MIDDLEWARE, AXP_ENTITY_DEFINITION_LOADER } from '@acorex/platform/layout/entity';
 import * as i4 from '@acorex/platform/layout/widget-core';
 import { AXP_WIDGETS_EDITOR_CATEGORY, AXPValueWidgetComponent, AXPWidgetCoreModule, AXPWidgetGroupEnum, AXPWidgetRegistryService, AXPWidgetsCatalog, AXPPageStatus, AXP_WIDGET_DEFINITION_PROVIDER } from '@acorex/platform/layout/widget-core';
 import { AXP_NAME_PROPERTY, AXP_DATA_PATH_PROPERTY, AXP_DISABLED_PROPERTY, AXP_LABEL_PROPERTY, AXP_READONLY_PROPERTY } from '@acorex/platform/layout/widgets';
@@ -33,7 +33,7 @@ import * as i4$1 from '@acorex/components/search-box';
 import { AXSearchBoxModule } from '@acorex/components/search-box';
 import * as i4$2 from '@acorex/components/text-area';
 import { AXTextAreaModule } from '@acorex/components/text-area';
-import { AXPEntityCommandScope, AXP_MENU_PROVIDER, createAllQueryView, createQueryView } from '@acorex/platform/common';
+import { AXPEntityCommandScope, AXP_MENU_PROVIDER } from '@acorex/platform/common';
 import { AXP_PERMISSION_DEFINITION_PROVIDER } from '@acorex/platform/auth';
 import { AXPQueryService, provideCommandSetups } from '@acorex/platform/runtime';
 import { get, cloneDeep, unset } from 'lodash-es';
@@ -42,9 +42,287 @@ import { AXPLayoutBuilderService, AXPLayoutRendererComponent } from '@acorex/pla
 import { AXToastService } from '@acorex/components/toast';
 import { AXFormModule } from '@acorex/components/form';
 import { AXDialogService } from '@acorex/components/dialog';
-import { AXP_PREVIEW_WIDGET_FIELD_COMMAND_KEY } from '@acorex/platform/contracts';
+import { AXP_PREVIEW_WIDGET_FIELD_COMMAND_KEY, createAllQueryView, createQueryView, entityMasterCrudActions, entityMasterRecordActions, AXPWidgetsCatalog as AXPWidgetsCatalog$1, AXPWidgetsList as AXPWidgetsList$1, AXPEntityCommandScope as AXPEntityCommandScope$1, AXPSystemActionType, entityMasterDeleteAction } from '@acorex/platform/contracts';
 import { toSignal } from '@angular/core/rxjs-interop';
 
+//#region ---- Datasource keys ----
+/** Data Management datasource registry names. */
+const AXMDataManagementDataSourceKeys = {
+    DataSourcesList: 'dataSources',
+    EditorWidgets: 'editor-widgets',
+    ChoiceOptions: {
+        YesNo: 'yes-no-options',
+        YesNoMaybe: 'yes-no-maybe-options',
+        YesNoNa: 'yes-no-na-options',
+        RatingScale: 'rating-scale-options',
+        Rating1To10: 'rating-1-10-options',
+        NpsScale: 'nps-scale-options',
+        AgreementScale: 'agreement-scale-options',
+        Frequency: 'frequency-options',
+        Satisfaction: 'satisfaction-options',
+        Priority: 'priority-options',
+        Gender: 'gender-options',
+        Availability: 'availability-options',
+    },
+};
+//#endregion
+
+//#region ----   Column Definition Widget   ----
+const AXM_COLUMN_DEF_WIDGET = [
+    {
+        type: 'grid-layout',
+        mode: 'view',
+        options: {
+            direction: 'horizontal',
+        },
+        children: [
+            {
+                type: 'grid-item-layout',
+                mode: 'view',
+                options: { colSpan: 3 },
+                children: [
+                    {
+                        type: 'text-editor',
+                        mode: 'edit',
+                        path: 'name',
+                        options: {
+                            placeholder: 'Column Name',
+                            required: true,
+                        },
+                    },
+                ],
+            },
+            {
+                type: 'grid-item-layout',
+                mode: 'view',
+                options: { colSpan: 3 },
+                children: [
+                    {
+                        type: 'text-editor',
+                        mode: 'edit',
+                        path: 'title',
+                        options: {
+                            placeholder: 'Display Title',
+                            required: true,
+                        },
+                    },
+                ],
+            },
+            {
+                type: 'grid-item-layout',
+                options: { colSpan: 3 },
+                mode: 'view',
+                children: [
+                    {
+                        type: 'select-editor',
+                        mode: 'edit',
+                        path: 'type',
+                        options: {
+                            placeholder: 'Widget Type',
+                            valueField: 'name',
+                            textField: 'title',
+                            dataSource: AXMDataManagementDataSourceKeys.EditorWidgets,
+                            direction: 'horizontal',
+                            multiple: false,
+                            required: true,
+                        },
+                    },
+                ],
+            },
+            {
+                type: 'grid-item-layout',
+                options: { colSpan: 1 },
+                mode: 'view',
+                children: [
+                    {
+                        type: 'checkbox-editor',
+                        mode: 'edit',
+                        path: 'isValueField',
+                        options: {
+                            tooltip: 'Value Field (only one can be selected)',
+                            label: 'Value',
+                        },
+                        triggers: [
+                            {
+                                event: "{{ events.context('columns.isValueField') }}",
+                                action: `{{ context.set('columns.isValueField', context.eval('columns.isValueField')[0]); }}`,
+                            },
+                        ],
+                    },
+                ],
+            },
+            {
+                type: 'grid-item-layout',
+                options: { colSpan: 1 },
+                mode: 'view',
+                children: [
+                    {
+                        type: 'checkbox-editor',
+                        mode: 'edit',
+                        path: 'isTextField',
+                        options: {
+                            tooltip: 'Text Field (multiple allowed)',
+                            label: 'Text',
+                        },
+                    },
+                ],
+            },
+            {
+                type: 'grid-item-layout',
+                options: { colSpan: 1 },
+                mode: 'view',
+                children: [
+                    {
+                        type: 'checkbox-editor',
+                        mode: 'edit',
+                        path: 'isRequired',
+                        options: {
+                            label: 'Required',
+                            tooltip: 'Required field',
+                        },
+                    },
+                ],
+            },
+        ],
+    },
+];
+//#endregion
+
+const AXMDataManagementFeatureKeys = {
+    Queries: 'DataManagement:Feature:Queries',
+    DataSources: 'DataManagement:Feature:DataSources',
+    MetaDataDefinitions: 'DataManagement:Feature:MetaDataDefinitions',
+};
+
+const AXPDataManagementMenuKeys = {
+    Root: 'DataManagement:Menu',
+    Queries: 'DataManagement:Menu:Queries',
+    DataSources: 'DataManagement:Menu:DataSources',
+    MetaDataDefinitions: 'DataManagement:Menu:MetaDataDefinitions',
+    Tags: 'DataManagement:Menu:Tags',
+};
+
+//#endregion
+//#region ----   Utility Functions   ----
+function convertValueToState(value) {
+    if (!value) {
+        return {
+            groups: [createDefaultGroup()],
+            mode: 'designer',
+        };
+    }
+    if (Array.isArray(value)) {
+        return {
+            groups: [
+                {
+                    id: 'group-default',
+                    name: 'default',
+                    title: 'Default Section',
+                    description: undefined,
+                    order: 0,
+                    fields: value.map((item, index) => ({
+                        id: item.id || `field-${index}`,
+                        name: item.name,
+                        title: item.title,
+                        description: item.description,
+                        interface: item.interface,
+                        configuration: item.configuration,
+                        status: item.status || 'active',
+                        order: item.order ?? index,
+                        isNewlyAdded: item.isNewlyAdded,
+                    })),
+                },
+            ],
+            mode: 'designer',
+        };
+    }
+    const v = value;
+    if (v.groups && Array.isArray(v.groups)) {
+        const groups = v.groups.map((group, groupIndex) => ({
+            id: group.id || `group-${group.name}`,
+            name: group.name,
+            title: group.title,
+            description: group.description,
+            order: group.order ?? groupIndex,
+            fields: (group.fields || []).map((field, fieldIndex) => ({
+                id: field.id || `field-${fieldIndex}`,
+                name: field.name,
+                title: field.title,
+                description: field.description,
+                interface: field.interface,
+                configuration: field.configuration,
+                status: field.status || 'active',
+                order: field.order ?? fieldIndex,
+                isNewlyAdded: field.isNewlyAdded,
+            })),
+            isNewlyAdded: group.isNewlyAdded,
+        }));
+        const finalGroups = groups.length > 0 ? groups : [createDefaultGroup()];
+        return {
+            groups: finalGroups,
+            mode: 'designer',
+        };
+    }
+    return {
+        groups: [createDefaultGroup()],
+        mode: 'designer',
+    };
+}
+function convertStateToValue(state) {
+    return {
+        groups: state.groups.map((group) => {
+            const activeFields = group.fields.filter((field) => field.status !== 'deleted');
+            return {
+                name: group.name,
+                title: group.title,
+                description: group.description,
+                order: group.order,
+                fields: activeFields.map((field) => ({
+                    id: field.id,
+                    name: field.name,
+                    title: field.title,
+                    description: field.description,
+                    interface: field.interface,
+                    configuration: field.configuration,
+                    order: field.order,
+                })),
+            };
+        }),
+    };
+}
+function createDefaultGroup() {
+    return {
+        id: 'group-default',
+        name: 'default',
+        title: 'Default Section',
+        description: undefined,
+        order: 0,
+        fields: [],
+        isNewlyAdded: true,
+    };
+}
+//#endregion
+
+const AXMPermissionsKeys = {
+    DataManagement: {
+        Query: {
+            Management: 'DataManagement:Permission:Query.Management',
+        },
+        DataSource: {
+            Management: 'DataManagement:Permission:DataSource.Management',
+        },
+        MetaDataDefinition: {
+            Management: 'DataManagement:Permission:MetaDataDefinition.Management',
+        },
+        Equipment: {
+            Management: 'DataManagement:Permission:Equipment.Management',
+        },
+        Tag: {
+            Management: 'DataManagement:Permission:Tag.Management',
+        },
+    },
+};
+
 const config = {
     i18n: 'data-management',
 };
@@ -109,6 +387,9 @@ const RootConfig = {
     },
 };
 
+//#region ---- Contracts barrel ----
+//#endregion
+
 //#region ----   Imports   ----
 //#endregion
 //#region ----   Manifest Definition   ----
@@ -5269,12 +5550,6 @@ class AXMDataSourceEvaluatorScopeProvider {
     }
 }
 
-const AXMDataManagementFeatureKeys = {
-    Queries: 'DataManagement:Feature:Queries',
-    DataSources: 'DataManagement:Feature:DataSources',
-    MetaDataDefinitions: 'DataManagement:Feature:MetaDataDefinitions',
-};
-
 //#region ----   Imports   ----
 //#endregion
 //#region ----   Feature Definition Provider   ----
@@ -5309,26 +5584,6 @@ class AXPDataManagementFeatureDefinitionProvider {
 }
 //#endregion
 
-const AXMPermissionsKeys = {
-    DataManagement: {
-        Query: {
-            Management: 'DataManagement:Permission:Query.Management',
-        },
-        DataSource: {
-            Management: 'DataManagement:Permission:DataSource.Management',
-        },
-        MetaDataDefinition: {
-            Management: 'DataManagement:Permission:MetaDataDefinition.Management',
-        },
-        Equipment: {
-            Management: 'DataManagement:Permission:Equipment.Management',
-        },
-        Tag: {
-            Management: 'DataManagement:Permission:Tag.Management',
-        },
-    },
-};
-
 class AXMPermissionDefinitionProvider {
     constructor(injector) {
         this.injector = injector;
@@ -5376,14 +5631,6 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImpor
             type: Injectable
         }], ctorParameters: () => [{ type: i0.Injector }] });
 
-const AXPDataManagementMenuKeys = {
-    Root: 'DataManagement:Menu',
-    Queries: 'DataManagement:Menu:Queries',
-    DataSources: 'DataManagement:Menu:DataSources',
-    MetaDataDefinitions: 'DataManagement:Menu:MetaDataDefinitions',
-    Tags: 'DataManagement:Menu:Tags',
-};
-
 class AXMMenuProvider {
     constructor() {
         this.entityService = inject(AXPEntityService);
@@ -5452,13 +5699,13 @@ class AXMEntityProvider {
         if (moduleName == RootConfig.module.name) {
             switch (entityName) {
                 case RootConfig.entities.query.name:
-                    return (await Promise.resolve().then(function () { return query_entity; })).queryFactory();
+                    return (await Promise.resolve().then(function () { return index$1; })).queryFactory();
                 case RootConfig.entities.dataSource.name:
-                    return (await Promise.resolve().then(function () { return dataSource_entity; })).dataSourceEntityFactory();
+                    return (await Promise.resolve().then(function () { return index$3; })).dataSourceEntityFactory();
                 case RootConfig.entities.metaDataDefinition.name:
-                    return (await Promise.resolve().then(function () { return metaDataDefinition_entity; })).metaDataDefinitionFactory();
+                    return (await Promise.resolve().then(function () { return index$2; })).metaDataDefinitionFactory();
                 case RootConfig.entities.tag.name:
-                    return (await Promise.resolve().then(function () { return tag_entity; })).factory();
+                    return (await Promise.resolve().then(function () { return index; })).factoryTag();
             }
         }
         return null;
@@ -5474,28 +5721,6 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImpor
             type: Injectable
         }] });
 
-//#region ---- Datasource keys ----
-/** Data Management datasource registry names. */
-const AXMDataManagementDataSourceKeys = {
-    DataSourcesList: 'dataSources',
-    EditorWidgets: 'editor-widgets',
-    ChoiceOptions: {
-        YesNo: 'yes-no-options',
-        YesNoMaybe: 'yes-no-maybe-options',
-        YesNoNa: 'yes-no-na-options',
-        RatingScale: 'rating-scale-options',
-        Rating1To10: 'rating-1-10-options',
-        NpsScale: 'nps-scale-options',
-        AgreementScale: 'agreement-scale-options',
-        Frequency: 'frequency-options',
-        Satisfaction: 'satisfaction-options',
-        Priority: 'priority-options',
-        Gender: 'gender-options',
-        Availability: 'availability-options',
-    },
-};
-//#endregion
-
 /**
  * Provides common choice-option datasources (yes/no variants, rating scales, gender, agreement, frequency, etc.)
  * for use across forms, questionnaires, surveys, and other modules.
@@ -6942,159 +7167,57 @@ class ShowMetaDataFormPopupCommand {
             metadataExpression = `{{ metadata.fromEntity("${targetEntity}", context.eval('${path}')) }}`;
         }
         return {
-            groups: metadataExpression,
-            dialogTitle: metaDataFormExt.title,
-        };
-    }
-    /**
-     * 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: "21.2.9", ngImport: i0, type: ShowMetaDataFormPopupCommand, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: ShowMetaDataFormPopupCommand, providedIn: 'root' }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: ShowMetaDataFormPopupCommand, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: 'root',
-                }]
-        }] });
-
-var showMetaDataFormPopup_command = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    ShowMetaDataFormPopupCommand: ShowMetaDataFormPopupCommand
-});
-
-const AXPMetaDataBuilderWidget = {
-    name: 'meta-data-builder-editor',
-    title: '@data-management:metadata-definitions.components.meta-data-builder.title',
-    categories: AXP_WIDGETS_EDITOR_CATEGORY,
-    groups: [AXPWidgetGroupEnum.UtilityWidget],
-    description: '@data-management:metadata-definitions.components.meta-data-builder.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 metaDataBuilderView_component; }).then((c) => c.AXPMetaDataBuilderWidgetViewComponent),
-        },
-        edit: {
-            component: () => Promise.resolve().then(function () { return metaDataBuilderEdit_component; }).then((c) => c.AXPMetaDataBuilderWidgetEditComponent),
-        },
-        print: {
-            component: () => Promise.resolve().then(function () { return metaDataBuilderEdit_component; }).then((c) => c.AXPMetaDataBuilderWidgetEditComponent),
-        },
-    },
-};
-
-//#region ----   Meta-Data Builder Field / Group Types   ----
-//#endregion
-//#region ----   Utility Functions   ----
-function convertValueToState(value) {
-    if (!value) {
-        return {
-            groups: [createDefaultGroup()],
-            mode: 'designer',
-        };
-    }
-    if (Array.isArray(value)) {
-        return {
-            groups: [
-                {
-                    id: 'group-default',
-                    name: 'default',
-                    title: 'Default Section',
-                    description: undefined,
-                    order: 0,
-                    fields: value.map((item, index) => ({
-                        id: item.id || `field-${index}`,
-                        name: item.name,
-                        title: item.title,
-                        description: item.description,
-                        interface: item.interface,
-                        configuration: item.configuration,
-                        status: item.status || 'active',
-                        order: item.order ?? index,
-                        isNewlyAdded: item.isNewlyAdded,
-                    })),
-                },
-            ],
-            mode: 'designer',
-        };
-    }
-    const v = value;
-    if (v.groups && Array.isArray(v.groups)) {
-        const groups = v.groups.map((group, groupIndex) => ({
-            id: group.id || `group-${group.name}`,
-            name: group.name,
-            title: group.title,
-            description: group.description,
-            order: group.order ?? groupIndex,
-            fields: (group.fields || []).map((field, fieldIndex) => ({
-                id: field.id || `field-${fieldIndex}`,
-                name: field.name,
-                title: field.title,
-                description: field.description,
-                interface: field.interface,
-                configuration: field.configuration,
-                status: field.status || 'active',
-                order: field.order ?? fieldIndex,
-                isNewlyAdded: field.isNewlyAdded,
-            })),
-            isNewlyAdded: group.isNewlyAdded,
-        }));
-        const finalGroups = groups.length > 0 ? groups : [createDefaultGroup()];
-        return {
-            groups: finalGroups,
-            mode: 'designer',
+            groups: metadataExpression,
+            dialogTitle: metaDataFormExt.title,
         };
     }
-    return {
-        groups: [createDefaultGroup()],
-        mode: 'designer',
-    };
-}
-function convertStateToValue(state) {
-    return {
-        groups: state.groups.map((group) => {
-            const activeFields = group.fields.filter((field) => field.status !== 'deleted');
-            return {
-                name: group.name,
-                title: group.title,
-                description: group.description,
-                order: group.order,
-                fields: activeFields.map((field) => ({
-                    id: field.id,
-                    name: field.name,
-                    title: field.title,
-                    description: field.description,
-                    interface: field.interface,
-                    configuration: field.configuration,
-                    order: field.order,
-                })),
-            };
-        }),
-    };
-}
-function createDefaultGroup() {
-    return {
-        id: 'group-default',
-        name: 'default',
-        title: 'Default Section',
-        description: undefined,
-        order: 0,
-        fields: [],
-        isNewlyAdded: true,
-    };
+    /**
+     * 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: "21.2.9", ngImport: i0, type: ShowMetaDataFormPopupCommand, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: ShowMetaDataFormPopupCommand, providedIn: 'root' }); }
 }
-//#endregion
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: ShowMetaDataFormPopupCommand, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+
+var showMetaDataFormPopup_command = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    ShowMetaDataFormPopupCommand: ShowMetaDataFormPopupCommand
+});
+
+const AXPMetaDataBuilderWidget = {
+    name: 'meta-data-builder-editor',
+    title: '@data-management:metadata-definitions.components.meta-data-builder.title',
+    categories: AXP_WIDGETS_EDITOR_CATEGORY,
+    groups: [AXPWidgetGroupEnum.UtilityWidget],
+    description: '@data-management:metadata-definitions.components.meta-data-builder.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 metaDataBuilderView_component; }).then((c) => c.AXPMetaDataBuilderWidgetViewComponent),
+        },
+        edit: {
+            component: () => Promise.resolve().then(function () { return metaDataBuilderEdit_component; }).then((c) => c.AXPMetaDataBuilderWidgetEditComponent),
+        },
+        print: {
+            component: () => Promise.resolve().then(function () { return metaDataBuilderEdit_component; }).then((c) => c.AXPMetaDataBuilderWidgetEditComponent),
+        },
+    },
+};
 
 function asLocalizedFieldValue(v) {
     if (v == null)
@@ -9229,648 +9352,150 @@ class AXMDataManagementModule {
                 provide: AXP_PERMISSION_DEFINITION_PROVIDER,
                 useClass: AXMPermissionDefinitionProvider,
                 multi: true,
-            },
-            {
-                provide: AXP_MENU_PROVIDER,
-                useClass: AXMMenuProvider,
-                multi: true,
-            },
-            {
-                provide: AXP_ENTITY_DEFINITION_LOADER,
-                useClass: AXMEntityProvider,
-                multi: true,
-            },
-            {
-                provide: AXP_DATASOURCE_DEFINITION_PROVIDER,
-                useClass: AXMEditorWidgetsDataSourceDefinition,
-                multi: true,
-            },
-            {
-                provide: AXP_DATASOURCE_DEFINITION_PROVIDER,
-                useClass: AXMDataSourceListDataSourceDefinition,
-                multi: true,
-            },
-            {
-                provide: AXP_DATASOURCE_DEFINITION_PROVIDER,
-                useClass: AXMChoiceOptionsDataSourceDefinition,
-                multi: true,
-            },
-            {
-                provide: AXP_WIDGET_DEFINITION_PROVIDER,
-                useClass: AXMDataManagementWidgetsProvider,
-                multi: true,
-            },
-            provideLazyProvider(AXP_PAGE_COMPONENT_PROVIDER, () => import('./acorex-modules-data-management-index-CxVSgxTM.mjs').then((m) => m.AXMMetaDataBuilderPageComponentProvider)),
-        ], imports: [AXPWidgetCoreModule,
-            //
-            AXMMetaDataFeatureModule,
-            //
-            AXMTagsFeatureModule] }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXMDataManagementModule, decorators: [{
-            type: NgModule,
-            args: [{
-                    imports: [
-                        AXPWidgetCoreModule,
-                        //
-                        AXMMetaDataFeatureModule,
-                        //
-                        AXMTagsFeatureModule
-                    ],
-                    exports: [],
-                    declarations: [],
-                    providers: [
-                        // Module-specific providers (not part of manifest system)
-                        {
-                            provide: AXP_ENTITY_STORAGE_MIDDLEWARE,
-                            useValue: dataSourceStorageMiddleware,
-                            multi: true,
-                        },
-                        {
-                            provide: AXP_ENTITY_STORAGE_MIDDLEWARE,
-                            useValue: queryDataSourceCleanupMiddleware,
-                            multi: true,
-                        },
-                        {
-                            provide: AXP_EXPRESSION_EVALUATOR_SCOPE_PROVIDER,
-                            useClass: AXMMetadataEvaluatorScopeProvider,
-                            multi: true,
-                        },
-                        {
-                            provide: AXP_EXPRESSION_EVALUATOR_SCOPE_PROVIDER,
-                            useClass: AXMDataSourceEvaluatorScopeProvider,
-                            multi: true,
-                        },
-                        // Aggregate Function Provider - Default provider for built-in aggregate functions
-                        AXP_DEFAULT_AGGREGATE_FUNCTION_PROVIDER,
-                        // Aggregate Category Provider - Default provider for aggregate categories
-                        AXP_DEFAULT_AGGREGATE_CATEGORY_PROVIDER,
-                        // Database Type Provider - Default provider for database types (MySQL, PostgreSQL, etc.)
-                        AXP_DEFAULT_DATABASE_TYPE_PROVIDER,
-                        // Execute Query Command
-                        provideCommandSetups([
-                            {
-                                key: `${RootConfig.module.name}.${RootConfig.entities.query.name}:Execute`,
-                                command: () => Promise.resolve().then(function () { return executeQuery_command; }).then((c) => c.ExecuteQueryCommand),
-                            },
-                            {
-                                key: 'show-meta-data-form-popup',
-                                command: () => Promise.resolve().then(function () { return showMetaDataFormPopup_command; }).then((c) => c.ShowMetaDataFormPopupCommand),
-                            },
-                            {
-                                key: 'show-meta-data-builder-popup',
-                                command: () => Promise.resolve().then(function () { return showMetaDataBuilderPopup_command; }).then((c) => c.ShowMetaDataBuilderPopupCommand),
-                            },
-                        ]),
-                        // Module Manifest Provider
-                        {
-                            provide: AXP_MODULE_MANIFEST_PROVIDER,
-                            useValue: DataManagementManifest,
-                            multi: true,
-                        },
-                        // Provider references (now using tokens)
-                        {
-                            provide: AXP_FEATURE_DEFINITION_PROVIDER,
-                            useClass: AXPDataManagementFeatureDefinitionProvider,
-                            multi: true,
-                        },
-                        {
-                            provide: AXP_PERMISSION_DEFINITION_PROVIDER,
-                            useClass: AXMPermissionDefinitionProvider,
-                            multi: true,
-                        },
-                        {
-                            provide: AXP_MENU_PROVIDER,
-                            useClass: AXMMenuProvider,
-                            multi: true,
-                        },
-                        {
-                            provide: AXP_ENTITY_DEFINITION_LOADER,
-                            useClass: AXMEntityProvider,
-                            multi: true,
-                        },
-                        {
-                            provide: AXP_DATASOURCE_DEFINITION_PROVIDER,
-                            useClass: AXMEditorWidgetsDataSourceDefinition,
-                            multi: true,
-                        },
-                        {
-                            provide: AXP_DATASOURCE_DEFINITION_PROVIDER,
-                            useClass: AXMDataSourceListDataSourceDefinition,
-                            multi: true,
-                        },
-                        {
-                            provide: AXP_DATASOURCE_DEFINITION_PROVIDER,
-                            useClass: AXMChoiceOptionsDataSourceDefinition,
-                            multi: true,
-                        },
-                        {
-                            provide: AXP_WIDGET_DEFINITION_PROVIDER,
-                            useClass: AXMDataManagementWidgetsProvider,
-                            multi: true,
-                        },
-                        provideLazyProvider(AXP_PAGE_COMPONENT_PROVIDER, () => import('./acorex-modules-data-management-index-CxVSgxTM.mjs').then((m) => m.AXMMetaDataBuilderPageComponentProvider)),
-                    ]
-                }]
-        }] });
-
-async function queryFactory() {
-    const i18n = RootConfig.config.i18n;
-    const entityDef = {
-        module: RootConfig.module.name,
-        name: RootConfig.entities.query.name,
-        title: RootConfig.entities.query.title,
-        icon: RootConfig.entities.query.icon,
-        formats: {
-            individual: RootConfig.entities.query.title,
-            plural: RootConfig.entities.query.titlePlural,
-            searchResult: {
-                title: '{{ title }}',
-                description: RootConfig.module.title,
-            },
-        },
-        plugins: [
-            { name: 'history' },
-            { name: 'lock' },
-            { name: 'compare' },
-            { name: 'category' },
-        ],
-        relatedEntities: [],
-        groups: [
+            },
             {
-                id: 'basic-info',
-                title: `@${i18n}:queries.entities.query.groups.basic-info.title`,
+                provide: AXP_MENU_PROVIDER,
+                useClass: AXMMenuProvider,
+                multi: true,
             },
             {
-                id: 'query',
-                title: `@${i18n}:queries.entities.query.groups.query.title`,
+                provide: AXP_ENTITY_DEFINITION_LOADER,
+                useClass: AXMEntityProvider,
+                multi: true,
             },
-        ],
-        properties: [
             {
-                name: 'name',
-                title: '@general:terms.common.name',
-                groupId: 'basic-info',
-                options: {
-                    sort: {
-                        enabled: true,
-                    },
-                    filter: {
-                        advance: {
-                            enabled: true,
-                        },
-                        inline: {
-                            enabled: false,
-                        },
-                    },
-                },
-                schema: {
-                    dataType: 'string',
-                    interface: {
-                        type: AXPWidgetsCatalog.text,
-                    },
-                },
-                validations: [
-                    {
-                        rule: 'required',
-                    },
-                ],
+                provide: AXP_DATASOURCE_DEFINITION_PROVIDER,
+                useClass: AXMEditorWidgetsDataSourceDefinition,
+                multi: true,
             },
             {
-                name: 'title',
-                title: '@general:terms.common.title',
-                groupId: 'basic-info',
-                options: {
-                    sort: {
-                        enabled: true,
-                    },
-                    filter: {
-                        advance: {
-                            enabled: true,
-                        },
-                        inline: {
-                            enabled: false,
-                        },
-                    },
-                },
-                schema: {
-                    dataType: 'string',
-                    interface: {
-                        type: AXPWidgetsCatalog.text,
-                    },
-                },
-                validations: [
-                    {
-                        rule: 'required',
-                    },
-                ],
+                provide: AXP_DATASOURCE_DEFINITION_PROVIDER,
+                useClass: AXMDataSourceListDataSourceDefinition,
+                multi: true,
             },
             {
-                name: 'dataSource',
-                title: `@${i18n}:queries.entities.query.fields.dataSource.title`,
-                groupId: 'basic-info',
-                schema: {
-                    dataType: 'string',
-                    interface: {
-                        type: AXPWidgetsCatalog.select,
-                        options: {
-                            valueField: 'name',
-                            textField: 'title',
-                            dataSource: AXMDataManagementDataSourceKeys.DataSourcesList,
-                            multiple: false,
-                            expose: [
-                                { source: 'name', target: 'dataSource.name' },
-                                { source: 'title', target: 'dataSource.title' },
-                            ],
-                        },
-                        triggers: [
-                            {
-                                event: "{{ events.context('dataSource') }}",
-                                action: `{{ 
-                  var selectedDataSource = context.eval('dataSource');
-                  if (selectedDataSource) {
-                    // Pass the full datasource definition to query builder
-                    context.set('dataSourceDefinition', selectedDataSource);
-                  }
-                }}`,
-                            },
-                        ],
-                    },
-                },
-                validations: [
-                    {
-                        rule: 'required',
-                    },
-                ],
+                provide: AXP_DATASOURCE_DEFINITION_PROVIDER,
+                useClass: AXMChoiceOptionsDataSourceDefinition,
+                multi: true,
             },
             {
-                name: 'query',
-                title: `@${i18n}:queries.entities.query.fields.query.title`,
-                groupId: 'query',
-                schema: {
-                    dataType: 'object',
-                    interface: {
-                        type: AXPWidgetsList.Editors.QueryBuilder,
-                        options: {
-                            dataSource: '{{ context.eval("dataSourceDefinition") || context.eval("dataSource") }}',
-                        },
-                    },
-                },
+                provide: AXP_WIDGET_DEFINITION_PROVIDER,
+                useClass: AXMDataManagementWidgetsProvider,
+                multi: true,
             },
-        ],
-        columns: [
-            { name: 'name' },
-            { name: 'title' },
-            { name: 'dataSource' },
-            { name: 'query' },
-        ],
-        interfaces: {
-            master: {
-                create: {
-                    sections: [
-                        {
-                            id: 'basic-info',
-                        },
-                        {
-                            id: 'query',
-                        },
-                    ],
-                    properties: [
-                        {
-                            name: 'name',
-                            layout: {
-                                positions: {
-                                    lg: {
-                                        colSpan: 6,
-                                        order: 1,
-                                    },
-                                },
-                            },
-                        },
-                        {
-                            name: 'title',
-                            layout: {
-                                positions: {
-                                    lg: {
-                                        colSpan: 6,
-                                        order: 2,
-                                    },
-                                },
-                            },
-                        },
-                        {
-                            name: 'dataSource',
-                            layout: {
-                                positions: {
-                                    lg: {
-                                        colSpan: 12,
-                                        order: 3,
-                                    },
-                                },
-                            },
-                        },
-                        {
-                            name: 'query',
-                            layout: {
-                                positions: {
-                                    lg: {
-                                        colSpan: 12,
-                                        order: 1,
-                                    },
-                                },
-                            },
-                        },
-                    ],
-                },
-                update: {
-                    sections: [
-                        {
-                            id: 'basic-info',
-                        },
-                        {
-                            id: 'query',
-                        },
-                    ],
-                    properties: [
-                        {
-                            name: 'name',
-                            layout: {
-                                positions: {
-                                    lg: {
-                                        colSpan: 6,
-                                        order: 1,
-                                    },
-                                },
-                            },
-                        },
-                        {
-                            name: 'title',
-                            layout: {
-                                positions: {
-                                    lg: {
-                                        colSpan: 6,
-                                        order: 2,
-                                    },
-                                },
-                            },
-                        },
-                        {
-                            name: 'dataSource',
-                            layout: {
-                                positions: {
-                                    lg: {
-                                        colSpan: 12,
-                                        order: 3,
-                                    },
-                                },
-                            },
-                        },
-                        {
-                            name: 'query',
-                            layout: {
-                                positions: {
-                                    lg: {
-                                        colSpan: 12,
-                                        order: 1,
-                                    },
-                                },
-                            },
-                        },
+            provideLazyProvider(AXP_PAGE_COMPONENT_PROVIDER, () => import('./acorex-modules-data-management-index-CxVSgxTM.mjs').then((m) => m.AXMMetaDataBuilderPageComponentProvider)),
+        ], imports: [AXPWidgetCoreModule,
+            //
+            AXMMetaDataFeatureModule,
+            //
+            AXMTagsFeatureModule] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXMDataManagementModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [
+                        AXPWidgetCoreModule,
+                        //
+                        AXMMetaDataFeatureModule,
+                        //
+                        AXMTagsFeatureModule
                     ],
-                },
-                single: {
-                    title: '{{title}}',
-                    sections: [
+                    exports: [],
+                    declarations: [],
+                    providers: [
+                        // Module-specific providers (not part of manifest system)
                         {
-                            id: 'basic-info',
+                            provide: AXP_ENTITY_STORAGE_MIDDLEWARE,
+                            useValue: dataSourceStorageMiddleware,
+                            multi: true,
                         },
                         {
-                            id: 'query',
+                            provide: AXP_ENTITY_STORAGE_MIDDLEWARE,
+                            useValue: queryDataSourceCleanupMiddleware,
+                            multi: true,
                         },
-                    ],
-                    properties: [
                         {
-                            name: 'name',
-                            layout: {
-                                positions: {
-                                    lg: {
-                                        colSpan: 6,
-                                        order: 1,
-                                    },
-                                },
-                            },
+                            provide: AXP_EXPRESSION_EVALUATOR_SCOPE_PROVIDER,
+                            useClass: AXMMetadataEvaluatorScopeProvider,
+                            multi: true,
                         },
                         {
-                            name: 'title',
-                            layout: {
-                                positions: {
-                                    lg: {
-                                        colSpan: 6,
-                                        order: 2,
-                                    },
-                                },
-                            },
+                            provide: AXP_EXPRESSION_EVALUATOR_SCOPE_PROVIDER,
+                            useClass: AXMDataSourceEvaluatorScopeProvider,
+                            multi: true,
                         },
-                        {
-                            name: 'dataSource',
-                            layout: {
-                                positions: {
-                                    lg: {
-                                        colSpan: 12,
-                                        order: 3,
-                                    },
-                                },
+                        // Aggregate Function Provider - Default provider for built-in aggregate functions
+                        AXP_DEFAULT_AGGREGATE_FUNCTION_PROVIDER,
+                        // Aggregate Category Provider - Default provider for aggregate categories
+                        AXP_DEFAULT_AGGREGATE_CATEGORY_PROVIDER,
+                        // Database Type Provider - Default provider for database types (MySQL, PostgreSQL, etc.)
+                        AXP_DEFAULT_DATABASE_TYPE_PROVIDER,
+                        // Execute Query Command
+                        provideCommandSetups([
+                            {
+                                key: `${RootConfig.module.name}.${RootConfig.entities.query.name}:Execute`,
+                                command: () => Promise.resolve().then(function () { return executeQuery_command; }).then((c) => c.ExecuteQueryCommand),
+                            },
+                            {
+                                key: 'show-meta-data-form-popup',
+                                command: () => Promise.resolve().then(function () { return showMetaDataFormPopup_command; }).then((c) => c.ShowMetaDataFormPopupCommand),
+                            },
+                            {
+                                key: 'show-meta-data-builder-popup',
+                                command: () => Promise.resolve().then(function () { return showMetaDataBuilderPopup_command; }).then((c) => c.ShowMetaDataBuilderPopupCommand),
                             },
+                        ]),
+                        // Module Manifest Provider
+                        {
+                            provide: AXP_MODULE_MANIFEST_PROVIDER,
+                            useValue: DataManagementManifest,
+                            multi: true,
                         },
+                        // Provider references (now using tokens)
                         {
-                            name: 'query',
-                            layout: {
-                                positions: {
-                                    lg: {
-                                        colSpan: 12,
-                                        order: 1,
-                                    },
-                                },
-                            },
+                            provide: AXP_FEATURE_DEFINITION_PROVIDER,
+                            useClass: AXPDataManagementFeatureDefinitionProvider,
+                            multi: true,
                         },
-                    ],
-                    actions: [
-                        ...entityMasterRecordActions(),
                         {
-                            title: `@${i18n}:metadata-definitions.components.query.actions.execute.title`,
-                            command: {
-                                name: `${RootConfig.module.name}.${RootConfig.entities.query.name}:Execute`,
-                                options: {
-                                    queryId: '{{ context.eval("id") }}',
-                                    queryName: '{{ context.eval("name") }}',
-                                    queryTitle: '{{ context.eval("title") }}',
-                                },
-                            },
-                            priority: 'primary',
-                            type: 'action',
-                            icon: 'fa-light fa-play',
-                            scope: AXPEntityCommandScope.Individual,
+                            provide: AXP_PERMISSION_DEFINITION_PROVIDER,
+                            useClass: AXMPermissionDefinitionProvider,
+                            multi: true,
                         },
-                    ],
-                },
-                list: {
-                    actions: [...entityMasterCrudActions({
-                            create: false,
-                        }),
                         {
-                            title: '@general:actions.create.title',
-                            command: {
-                                name: 'create-entity',
-                                options: {
-                                    layout: {
-                                        size: 'lg'
-                                    }
-                                }
-                            },
-                            priority: 'primary',
-                            type: AXPSystemActionType.Create,
-                            scope: AXPEntityCommandScope.TypeLevel,
-                        }
-                    ],
-                    views: [
-                        createAllQueryView({
-                            sorts: [{ name: 'name', dir: 'asc' }],
-                        }),
-                    ],
-                },
-            },
-        },
-    };
-    return entityDef;
-}
-
-var query_entity = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    queryFactory: queryFactory
-});
-
-//#endregion
-
-//#region ----   Column Definition Widget   ----
-const AXM_COLUMN_DEF_WIDGET = [
-    {
-        type: 'grid-layout',
-        mode: 'view',
-        options: {
-            direction: 'horizontal',
-        },
-        children: [
-            {
-                type: 'grid-item-layout',
-                mode: 'view',
-                options: { colSpan: 3 },
-                children: [
-                    {
-                        type: 'text-editor',
-                        mode: 'edit',
-                        path: 'name',
-                        options: {
-                            placeholder: 'Column Name',
-                            required: true,
+                            provide: AXP_MENU_PROVIDER,
+                            useClass: AXMMenuProvider,
+                            multi: true,
                         },
-                    },
-                ],
-            },
-            {
-                type: 'grid-item-layout',
-                mode: 'view',
-                options: { colSpan: 3 },
-                children: [
-                    {
-                        type: 'text-editor',
-                        mode: 'edit',
-                        path: 'title',
-                        options: {
-                            placeholder: 'Display Title',
-                            required: true,
+                        {
+                            provide: AXP_ENTITY_DEFINITION_LOADER,
+                            useClass: AXMEntityProvider,
+                            multi: true,
                         },
-                    },
-                ],
-            },
-            {
-                type: 'grid-item-layout',
-                options: { colSpan: 3 },
-                mode: 'view',
-                children: [
-                    {
-                        type: 'select-editor',
-                        mode: 'edit',
-                        path: 'type',
-                        options: {
-                            placeholder: 'Widget Type',
-                            valueField: 'name',
-                            textField: 'title',
-                            dataSource: AXMDataManagementDataSourceKeys.EditorWidgets,
-                            direction: 'horizontal',
-                            multiple: false,
-                            required: true,
+                        {
+                            provide: AXP_DATASOURCE_DEFINITION_PROVIDER,
+                            useClass: AXMEditorWidgetsDataSourceDefinition,
+                            multi: true,
                         },
-                    },
-                ],
-            },
-            {
-                type: 'grid-item-layout',
-                options: { colSpan: 1 },
-                mode: 'view',
-                children: [
-                    {
-                        type: 'checkbox-editor',
-                        mode: 'edit',
-                        path: 'isValueField',
-                        options: {
-                            tooltip: 'Value Field (only one can be selected)',
-                            label: 'Value',
+                        {
+                            provide: AXP_DATASOURCE_DEFINITION_PROVIDER,
+                            useClass: AXMDataSourceListDataSourceDefinition,
+                            multi: true,
                         },
-                        triggers: [
-                            {
-                                event: "{{ events.context('columns.isValueField') }}",
-                                action: `{{ context.set('columns.isValueField', context.eval('columns.isValueField')[0]); }}`,
-                            },
-                        ],
-                    },
-                ],
-            },
-            {
-                type: 'grid-item-layout',
-                options: { colSpan: 1 },
-                mode: 'view',
-                children: [
-                    {
-                        type: 'checkbox-editor',
-                        mode: 'edit',
-                        path: 'isTextField',
-                        options: {
-                            tooltip: 'Text Field (multiple allowed)',
-                            label: 'Text',
+                        {
+                            provide: AXP_DATASOURCE_DEFINITION_PROVIDER,
+                            useClass: AXMChoiceOptionsDataSourceDefinition,
+                            multi: true,
                         },
-                    },
-                ],
-            },
-            {
-                type: 'grid-item-layout',
-                options: { colSpan: 1 },
-                mode: 'view',
-                children: [
-                    {
-                        type: 'checkbox-editor',
-                        mode: 'edit',
-                        path: 'isRequired',
-                        options: {
-                            label: 'Required',
-                            tooltip: 'Required field',
+                        {
+                            provide: AXP_WIDGET_DEFINITION_PROVIDER,
+                            useClass: AXMDataManagementWidgetsProvider,
+                            multi: true,
                         },
-                    },
-                ],
-            },
-        ],
-    },
-];
-//#endregion
+                        provideLazyProvider(AXP_PAGE_COMPONENT_PROVIDER, () => import('./acorex-modules-data-management-index-CxVSgxTM.mjs').then((m) => m.AXMMetaDataBuilderPageComponentProvider)),
+                    ]
+                }]
+        }] });
 
 //#region ----   Output Types   ----
 var AXMDataSourceOutputType;
@@ -9936,7 +9561,7 @@ async function dataSourceEntityFactory() {
                 schema: {
                     dataType: 'string',
                     interface: {
-                        type: AXPWidgetsCatalog.text,
+                        type: AXPWidgetsCatalog$1.text,
                     },
                 },
                 validations: [
@@ -9952,7 +9577,7 @@ async function dataSourceEntityFactory() {
                 schema: {
                     dataType: 'string',
                     interface: {
-                        type: AXPWidgetsCatalog.text,
+                        type: AXPWidgetsCatalog$1.text,
                         options: {},
                     },
                 },
@@ -9994,7 +9619,7 @@ async function dataSourceEntityFactory() {
                     ],
                     dataType: 'object',
                     interface: {
-                        type: AXPWidgetsCatalog.repeaterLayout,
+                        type: AXPWidgetsCatalog$1.repeaterLayout,
                         children: AXM_COLUMN_DEF_WIDGET,
                         triggers: [
                             {
@@ -10022,7 +9647,7 @@ async function dataSourceEntityFactory() {
                     },
                     dataType: 'object',
                     interface: {
-                        type: AXPWidgetsList.Editors.QueryBuilder,
+                        type: AXPWidgetsList$1.Editors.QueryBuilder,
                         options: {
                             availableColumns: '{{ context.eval("columns") || [] }}',
                         },
@@ -10036,7 +9661,7 @@ async function dataSourceEntityFactory() {
                 schema: {
                     dataType: 'object',
                     interface: {
-                        type: AXPWidgetsCatalog.table,
+                        type: AXPWidgetsCatalog$1.table,
                         options: {
                             columns: '{{context.eval("columns"); }}',
                             defaultRowCount: 2,
@@ -10060,7 +9685,7 @@ async function dataSourceEntityFactory() {
                     },
                     dataType: 'string',
                     interface: {
-                        type: AXPWidgetsCatalog.select,
+                        type: AXPWidgetsCatalog$1.select,
                         options: {
                             valueField: 'name',
                             textField: 'title',
@@ -10116,7 +9741,7 @@ async function dataSourceEntityFactory() {
                     },
                     dataType: 'string',
                     interface: {
-                        type: AXPWidgetsCatalog.select,
+                        type: AXPWidgetsCatalog$1.select,
                         options: {
                             valueField: 'name',
                             textField: 'title',
@@ -10161,7 +9786,7 @@ async function dataSourceEntityFactory() {
                 schema: {
                     dataType: 'string',
                     interface: {
-                        type: AXPWidgetsCatalog.table,
+                        type: AXPWidgetsCatalog$1.table,
                         options: {
                             visibility: '{{context.eval("sourceType")?.name == "static" }}',
                             columns: '{{context.eval("columns")}}',
@@ -10180,7 +9805,7 @@ async function dataSourceEntityFactory() {
                 schema: {
                     dataType: 'string',
                     interface: {
-                        type: AXPWidgetsCatalog.select,
+                        type: AXPWidgetsCatalog$1.select,
                         options: {
                             visibility: '{{context.eval("sourceType")?.name == "query" }}',
                             valueField: 'name',
@@ -10597,8 +10222,10 @@ async function dataSourceEntityFactory() {
     return entityDef;
 }
 
-var dataSource_entity = /*#__PURE__*/Object.freeze({
+var index$3 = /*#__PURE__*/Object.freeze({
     __proto__: null,
+    get AXMDataSourceOutputType () { return AXMDataSourceOutputType; },
+    get AXMDataSourceType () { return AXMDataSourceType; },
     dataSourceEntityFactory: dataSourceEntityFactory
 });
 
@@ -10660,7 +10287,7 @@ async function metaDataDefinitionFactory() {
                 schema: {
                     dataType: 'string',
                     interface: {
-                        type: AXPWidgetsList.Editors.TextBox,
+                        type: AXPWidgetsList$1.Editors.TextBox,
                     },
                 },
                 validations: [
@@ -10692,7 +10319,7 @@ async function metaDataDefinitionFactory() {
                 schema: {
                     dataType: 'string',
                     interface: {
-                        type: AXPWidgetsList.Editors.TextBox,
+                        type: AXPWidgetsList$1.Editors.TextBox,
                     },
                 },
                 validations: [
@@ -10709,48 +10336,268 @@ async function metaDataDefinitionFactory() {
                     sort: {
                         enabled: true,
                     },
-                    filter: {
-                        inline: {
-                            enabled: true,
-                        },
-                        advance: {
-                            enabled: true,
-                        },
-                    }
+                    filter: {
+                        inline: {
+                            enabled: true,
+                        },
+                        advance: {
+                            enabled: true,
+                        },
+                    }
+                },
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsList$1.Editors.LargeTextBox,
+                    },
+                },
+            },
+            {
+                name: 'interface',
+                title: `@general:terms.common.interface`,
+                groupId: 'presentation',
+                schema: {
+                    dataType: 'object',
+                    interface: {
+                        type: 'widget-field-configurator',
+                        options: {
+                            fieldName: "{{ context.eval('name') }}",
+                            fieldTitle: "{{ context.eval('title', { pipes: ['translate'] }) }}",
+                        },
+                    },
+                },
+                validations: [
+                    {
+                        rule: 'required',
+                    },
+                ],
+            },
+        ],
+        columns: [
+            { name: 'name' },
+            { name: 'title' },
+            { name: 'description' },
+            { name: 'interface' },
+        ],
+        interfaces: {
+            master: {
+                create: {
+                    sections: [
+                        {
+                            id: 'basic-info',
+                        },
+                        {
+                            id: 'presentation',
+                        },
+                    ],
+                    properties: [
+                        { name: 'name', layout: { positions: { lg: { colSpan: 6 } } } },
+                        { name: 'title', layout: { positions: { lg: { colSpan: 6 } } } },
+                        { name: 'description', layout: { positions: { lg: { colSpan: 12 } } } },
+                        { name: 'interface', layout: { label: { visible: false }, positions: { lg: { colSpan: 12 } } } },
+                    ],
+                },
+                update: {
+                    sections: [{ id: 'basic-info' }, { id: 'presentation' }],
+                    properties: [
+                        { name: 'name', layout: { positions: { lg: { colSpan: 6 } } } },
+                        { name: 'title', layout: { positions: { lg: { colSpan: 6 } } } },
+                        { name: 'description', layout: { positions: { lg: { colSpan: 12 } } } },
+                        { name: 'interface', layout: { label: { visible: false }, positions: { lg: { colSpan: 12 } } } },
+                    ],
+                },
+                single: {
+                    title: '{{title}}',
+                    sections: [{ id: 'basic-info' }, { id: 'presentation' }],
+                    properties: [
+                        { name: 'name', layout: { positions: { lg: { colSpan: 6 } } } },
+                        { name: 'title', layout: { positions: { lg: { colSpan: 6 } } } },
+                        { name: 'description', layout: { positions: { lg: { colSpan: 12 } } } },
+                        { name: 'interface', layout: { label: { visible: false }, positions: { lg: { colSpan: 12 } } } },
+                    ],
+                    actions: [...entityMasterRecordActions()],
+                },
+                list: {
+                    actions: [
+                        ...entityMasterCrudActions(),
+                        {
+                            title: '@data-management:metadata-definitions.entities.metadata-definition.actions.preview.title',
+                            command: {
+                                name: AXP_PREVIEW_WIDGET_FIELD_COMMAND_KEY,
+                                options: {
+                                    interface: "{{ context.eval('interface') }}",
+                                    fieldName: "{{ context.eval('name') }}",
+                                    fieldTitle: "{{ context.eval('title', { pipes: ['translate'] }) }}",
+                                },
+                            },
+                            priority: 'primary',
+                            type: 'action',
+                            icon: 'fa-light fa-eye',
+                            scope: AXPEntityCommandScope$1.Individual,
+                        },
+                    ],
+                    views: [createAllQueryView({ sorts: [{ name: 'title', dir: 'asc' }] })],
+                },
+            },
+        },
+    };
+    return entityDef;
+}
+
+var index$2 = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    metaDataDefinitionFactory: metaDataDefinitionFactory
+});
+
+async function queryFactory() {
+    const i18n = RootConfig.config.i18n;
+    const entityDef = {
+        module: RootConfig.module.name,
+        name: RootConfig.entities.query.name,
+        title: RootConfig.entities.query.title,
+        icon: RootConfig.entities.query.icon,
+        formats: {
+            individual: RootConfig.entities.query.title,
+            plural: RootConfig.entities.query.titlePlural,
+            searchResult: {
+                title: '{{ title }}',
+                description: RootConfig.module.title,
+            },
+        },
+        plugins: [
+            { name: 'history' },
+            { name: 'lock' },
+            { name: 'compare' },
+            { name: 'category' },
+        ],
+        relatedEntities: [],
+        groups: [
+            {
+                id: 'basic-info',
+                title: `@${i18n}:queries.entities.query.groups.basic-info.title`,
+            },
+            {
+                id: 'query',
+                title: `@${i18n}:queries.entities.query.groups.query.title`,
+            },
+        ],
+        properties: [
+            {
+                name: 'name',
+                title: '@general:terms.common.name',
+                groupId: 'basic-info',
+                options: {
+                    sort: {
+                        enabled: true,
+                    },
+                    filter: {
+                        advance: {
+                            enabled: true,
+                        },
+                        inline: {
+                            enabled: false,
+                        },
+                    },
+                },
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsCatalog$1.text,
+                    },
+                },
+                validations: [
+                    {
+                        rule: 'required',
+                    },
+                ],
+            },
+            {
+                name: 'title',
+                title: '@general:terms.common.title',
+                groupId: 'basic-info',
+                options: {
+                    sort: {
+                        enabled: true,
+                    },
+                    filter: {
+                        advance: {
+                            enabled: true,
+                        },
+                        inline: {
+                            enabled: false,
+                        },
+                    },
+                },
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsCatalog$1.text,
+                    },
+                },
+                validations: [
+                    {
+                        rule: 'required',
+                    },
+                ],
+            },
+            {
+                name: 'dataSource',
+                title: `@${i18n}:queries.entities.query.fields.dataSource.title`,
+                groupId: 'basic-info',
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsCatalog$1.select,
+                        options: {
+                            valueField: 'name',
+                            textField: 'title',
+                            dataSource: AXMDataManagementDataSourceKeys.DataSourcesList,
+                            multiple: false,
+                            expose: [
+                                { source: 'name', target: 'dataSource.name' },
+                                { source: 'title', target: 'dataSource.title' },
+                            ],
+                        },
+                        triggers: [
+                            {
+                                event: "{{ events.context('dataSource') }}",
+                                action: `{{ 
+                  var selectedDataSource = context.eval('dataSource');
+                  if (selectedDataSource) {
+                    // Pass the full datasource definition to query builder
+                    context.set('dataSourceDefinition', selectedDataSource);
+                  }
+                }}`,
+                            },
+                        ],
+                    },
                 },
-                schema: {
-                    dataType: 'string',
-                    interface: {
-                        type: AXPWidgetsList.Editors.LargeTextBox,
+                validations: [
+                    {
+                        rule: 'required',
                     },
-                },
+                ],
             },
             {
-                name: 'interface',
-                title: `@general:terms.common.interface`,
-                groupId: 'presentation',
+                name: 'query',
+                title: `@${i18n}:queries.entities.query.fields.query.title`,
+                groupId: 'query',
                 schema: {
                     dataType: 'object',
                     interface: {
-                        type: 'widget-field-configurator',
+                        type: AXPWidgetsList$1.Editors.QueryBuilder,
                         options: {
-                            fieldName: "{{ context.eval('name') }}",
-                            fieldTitle: "{{ context.eval('title') }}",
+                            dataSource: '{{ context.eval("dataSourceDefinition") || context.eval("dataSource") }}',
                         },
                     },
                 },
-                validations: [
-                    {
-                        rule: 'required',
-                    },
-                ],
             },
         ],
         columns: [
             { name: 'name' },
             { name: 'title' },
-            { name: 'description' },
-            { name: 'interface' },
+            { name: 'dataSource' },
+            { name: 'query' },
         ],
         interfaces: {
             master: {
@@ -10760,56 +10607,211 @@ async function metaDataDefinitionFactory() {
                             id: 'basic-info',
                         },
                         {
-                            id: 'presentation',
+                            id: 'query',
                         },
                     ],
                     properties: [
-                        { name: 'name', layout: { positions: { lg: { colSpan: 6 } } } },
-                        { name: 'title', layout: { positions: { lg: { colSpan: 6 } } } },
-                        { name: 'description', layout: { positions: { lg: { colSpan: 12 } } } },
-                        { name: 'interface', layout: { label: { visible: false }, positions: { lg: { colSpan: 12 } } } },
+                        {
+                            name: 'name',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                        order: 1,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'title',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                        order: 2,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'dataSource',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 12,
+                                        order: 3,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'query',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 12,
+                                        order: 1,
+                                    },
+                                },
+                            },
+                        },
                     ],
                 },
                 update: {
-                    sections: [{ id: 'basic-info' }, { id: 'presentation' }],
+                    sections: [
+                        {
+                            id: 'basic-info',
+                        },
+                        {
+                            id: 'query',
+                        },
+                    ],
                     properties: [
-                        { name: 'name', layout: { positions: { lg: { colSpan: 6 } } } },
-                        { name: 'title', layout: { positions: { lg: { colSpan: 6 } } } },
-                        { name: 'description', layout: { positions: { lg: { colSpan: 12 } } } },
-                        { name: 'interface', layout: { label: { visible: false }, positions: { lg: { colSpan: 12 } } } },
+                        {
+                            name: 'name',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                        order: 1,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'title',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                        order: 2,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'dataSource',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 12,
+                                        order: 3,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'query',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 12,
+                                        order: 1,
+                                    },
+                                },
+                            },
+                        },
                     ],
                 },
                 single: {
                     title: '{{title}}',
-                    sections: [{ id: 'basic-info' }, { id: 'presentation' }],
+                    sections: [
+                        {
+                            id: 'basic-info',
+                        },
+                        {
+                            id: 'query',
+                        },
+                    ],
                     properties: [
-                        { name: 'name', layout: { positions: { lg: { colSpan: 6 } } } },
-                        { name: 'title', layout: { positions: { lg: { colSpan: 6 } } } },
-                        { name: 'description', layout: { positions: { lg: { colSpan: 12 } } } },
-                        { name: 'interface', layout: { label: { visible: false }, positions: { lg: { colSpan: 12 } } } },
+                        {
+                            name: 'name',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                        order: 1,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'title',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                        order: 2,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'dataSource',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 12,
+                                        order: 3,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'query',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 12,
+                                        order: 1,
+                                    },
+                                },
+                            },
+                        },
                     ],
-                    actions: [...entityMasterRecordActions()],
-                },
-                list: {
                     actions: [
-                        ...entityMasterCrudActions(),
+                        ...entityMasterRecordActions(),
                         {
-                            title: '@data-management:metadata-definitions.entities.metadata-definition.actions.preview.title',
+                            title: `@${i18n}:metadata-definitions.components.query.actions.execute.title`,
                             command: {
-                                name: AXP_PREVIEW_WIDGET_FIELD_COMMAND_KEY,
+                                name: `${RootConfig.module.name}.${RootConfig.entities.query.name}:Execute`,
                                 options: {
-                                    interface: "{{ context.eval('interface') }}",
-                                    fieldName: "{{ context.eval('name') }}",
-                                    fieldTitle: "{{ context.eval('title') }}",
+                                    queryId: '{{ context.eval("id") }}',
+                                    queryName: '{{ context.eval("name") }}',
+                                    queryTitle: '{{ context.eval("title", { pipes: ["translate"] }) }}',
                                 },
                             },
                             priority: 'primary',
                             type: 'action',
-                            icon: 'fa-light fa-eye',
-                            scope: AXPEntityCommandScope.Individual,
+                            icon: 'fa-light fa-play',
+                            scope: AXPEntityCommandScope$1.Individual,
                         },
                     ],
-                    views: [createAllQueryView({ sorts: [{ name: 'title', dir: 'asc' }] })],
+                },
+                list: {
+                    actions: [...entityMasterCrudActions({
+                            create: false,
+                        }),
+                        {
+                            title: '@general:actions.create.title',
+                            command: {
+                                name: 'create-entity',
+                                options: {
+                                    layout: {
+                                        size: 'lg'
+                                    }
+                                }
+                            },
+                            priority: 'primary',
+                            type: AXPSystemActionType.Create,
+                            scope: AXPEntityCommandScope$1.TypeLevel,
+                        }
+                    ],
+                    views: [
+                        createAllQueryView({
+                            sorts: [{ name: 'name', dir: 'asc' }],
+                        }),
+                    ],
                 },
             },
         },
@@ -10817,13 +10819,15 @@ async function metaDataDefinitionFactory() {
     return entityDef;
 }
 
-var metaDataDefinition_entity = /*#__PURE__*/Object.freeze({
+//#endregion
+
+var index$1 = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    metaDataDefinitionFactory: metaDataDefinitionFactory
+    queryFactory: queryFactory
 });
 
 //#region ----   Tag Entity Factory   ----
-async function factory() {
+async function factoryTag() {
     const entityDef = {
         module: RootConfig.module.name,
         name: RootConfig.entities.tag.name,
@@ -10860,14 +10864,14 @@ async function factory() {
                     sort: { enabled: true },
                     filter: { advance: { enabled: true }, inline: { enabled: true } },
                 },
-                schema: { dataType: 'string', interface: { type: AXPWidgetsCatalog.text } },
+                schema: { dataType: 'string', interface: { type: AXPWidgetsCatalog$1.text } },
                 validations: [{ rule: 'required' }],
             },
             {
                 name: 'description',
                 title: '@general:terms.common.description',
                 groupId: 'basic-info',
-                schema: { dataType: 'string', interface: { type: AXPWidgetsCatalog.largeText } },
+                schema: { dataType: 'string', interface: { type: AXPWidgetsCatalog$1.largeText } },
             },
             {
                 name: 'scope',
@@ -10880,7 +10884,7 @@ async function factory() {
                 schema: {
                     dataType: 'string',
                     interface: {
-                        type: AXPWidgetsList.Editors.SelectBox,
+                        type: AXPWidgetsList$1.Editors.SelectBox,
                         options: {
                             valueField: 'value',
                             textField: 'text',
@@ -10939,22 +10943,19 @@ async function factory() {
 }
 //#endregion
 
-var tag_entity = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    factory: factory
-});
-
 //#region ----   Tag Entity Types   ----
 //#endregion
 
-// Entity Services
+var index = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    factoryTag: factoryTag
+});
 
-//#region ---- Contracts barrel ----
-//#endregion
+// Entity Services
 
 /**
  * Generated bundle index. Do not edit.
  */
 
-export { AXMDataManagementDataSourceKeys, AXMDataManagementFeatureKeys, AXMDataManagementModule, AXMDataSourceOutputType, AXMDataSourceType, AXMDefaultAggregateCategoryProvider, AXMDefaultAggregateFunctionProvider, AXMDefaultDatabaseTypeProvider, AXMDefaultMetaDataBuilderRecordService, AXMEntityProvider, AXMMenuProvider, AXMMetaDataBuilderRecordService, AXMMetaDataFeatureModule, AXMMetadataEvaluatorScopeProvider, AXMPermissionsKeys, AXMQueryService, AXMTagsFeatureModule, AXMetaDataConfiguratorComponent, AXPAggregateBuilderComponent, AXPAggregateFunctionService, AXPAggregateFunctionsRegistry, AXPColumnsBuilderComponent, AXPDataManagementMenuKeys, AXPDatabaseTypeService, AXPGroupByBuilderComponent, AXPMetaDataBuilderGroupsComponent, AXPMetaDataBuilderWidget, AXPMetaDataBuilderWidgetEditComponent, AXPMetaDataBuilderWidgetViewComponent, AXPMetaDataFormWidget, AXPMetaDataFormWidgetEditComponent, AXPQueryBuilderComponent, AXPQueryBuilderWidget, AXPQueryBuilderWidgetColumnComponent, AXPQueryBuilderWidgetDesignerComponent, AXPQueryBuilderWidgetEditComponent, AXPQueryBuilderWidgetViewComponent, AXPRawQueryBuilderComponent, AXPSortBuilderComponent, AXPSystemTagProvider, AXPWhereBuilderComponent, AXP_AGGREGATE_CATEGORY_PROVIDER, AXP_AGGREGATE_FUNCTION_PROVIDER, AXP_DATABASE_TYPE_PROVIDER, AXP_DEFAULT_AGGREGATE_CATEGORY_PROVIDER, AXP_DEFAULT_AGGREGATE_FUNCTION_PROVIDER, AXP_DEFAULT_DATABASE_TYPE_PROVIDER, ExecuteQueryCommand, META_DATA_BUILDER_PAGE_COMPONENT_KEY, META_DATA_FORM_FIELD, META_DATA_SELECTOR_FIELD, RootConfig, ShowMetaDataBuilderPopupCommand, ShowMetaDataFormPopupCommand, builderValueToMetaDataValue, convertStateToValue, convertValueToState, createDefaultGroup, dataSourceEntityFactory, factory, metaDataBuilderPlugin, metaDataDefinitionFactory, metaDataValueToBuilderValue, queryFactory, tagsPlugin };
+export { AXMDataManagementDataSourceKeys, AXMDataManagementFeatureKeys, AXMDataManagementModule, AXMDataSourceOutputType, AXMDataSourceType, AXMDefaultAggregateCategoryProvider, AXMDefaultAggregateFunctionProvider, AXMDefaultDatabaseTypeProvider, AXMDefaultMetaDataBuilderRecordService, AXMEntityProvider, AXMMenuProvider, AXMMetaDataBuilderRecordService, AXMMetaDataFeatureModule, AXMMetadataEvaluatorScopeProvider, AXMPermissionsKeys, AXMQueryService, AXMTagsFeatureModule, AXM_COLUMN_DEF_WIDGET, AXMetaDataConfiguratorComponent, AXPAggregateBuilderComponent, AXPAggregateFunctionService, AXPAggregateFunctionsRegistry, AXPColumnsBuilderComponent, AXPDataManagementMenuKeys, AXPDatabaseTypeService, AXPGroupByBuilderComponent, AXPMetaDataBuilderGroupsComponent, AXPMetaDataBuilderWidget, AXPMetaDataBuilderWidgetEditComponent, AXPMetaDataBuilderWidgetViewComponent, AXPMetaDataFormWidget, AXPMetaDataFormWidgetEditComponent, AXPQueryBuilderComponent, AXPQueryBuilderWidget, AXPQueryBuilderWidgetColumnComponent, AXPQueryBuilderWidgetDesignerComponent, AXPQueryBuilderWidgetEditComponent, AXPQueryBuilderWidgetViewComponent, AXPRawQueryBuilderComponent, AXPSortBuilderComponent, AXPSystemTagProvider, AXPWhereBuilderComponent, AXP_AGGREGATE_CATEGORY_PROVIDER, AXP_AGGREGATE_FUNCTION_PROVIDER, AXP_DATABASE_TYPE_PROVIDER, AXP_DEFAULT_AGGREGATE_CATEGORY_PROVIDER, AXP_DEFAULT_AGGREGATE_FUNCTION_PROVIDER, AXP_DEFAULT_DATABASE_TYPE_PROVIDER, ExecuteQueryCommand, META_DATA_BUILDER_PAGE_COMPONENT_KEY, META_DATA_FORM_FIELD, META_DATA_SELECTOR_FIELD, RootConfig, ShowMetaDataBuilderPopupCommand, ShowMetaDataFormPopupCommand, builderValueToMetaDataValue, convertStateToValue, convertValueToState, createDefaultGroup, dataSourceEntityFactory, factoryTag, metaDataBuilderPlugin, metaDataDefinitionFactory, metaDataValueToBuilderValue, queryFactory, tagsPlugin };
 //# sourceMappingURL=acorex-modules-data-management.mjs.map