@acorex/modules 20.2.3 → 20.2.4-next.1

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

@@ -1,10 +1,10 @@
 import * as i0 from '@angular/core';
 import { inject, Injector, Injectable, computed, effect, HostBinding, ChangeDetectionStrategy, Component, EventEmitter, signal, Output, Input, NgModule } from '@angular/core';
 import { AXP_PERMISSION_DEFINITION_PROVIDER } from '@acorex/platform/auth';
-import { AXPSearchCommandProvider, createAllQueryView, AXPEntityCommandScope, AXPEntityQueryType, createQueryView, AXP_MENU_PROVIDER, AXP_SETTING_DEFINITION_PROVIDER, AXP_SEARCH_PROVIDER } from '@acorex/platform/common';
+import { AXPSearchCommandProvider, createAllQueryView, createQueryView, AXPEntityCommandScope, AXPEntityQueryType, AXP_MENU_PROVIDER, AXP_SETTING_DEFINITION_PROVIDER, AXP_SEARCH_PROVIDER } from '@acorex/platform/common';
 import { AXPEntityService, AXMEntityCrudServiceImpl, AXP_ENTITY_DEFINITION_LOADER } from '@acorex/platform/layout/entity';
 import * as i4 from '@acorex/platform/layout/builder';
-import { AXPWidgetsCatalog, AXPWidgetRegistryService, AXP_WIDGETS_EDITOR_CATEGORY, AXPValueWidgetComponent, AXPLayoutBuilderModule, AXPWidgetGroupEnum } from '@acorex/platform/layout/builder';
+import { AXPWidgetRegistryService, AXPWidgetsCatalog, AXP_WIDGETS_EDITOR_CATEGORY, AXPValueWidgetComponent, AXPLayoutBuilderModule, AXPWidgetGroupEnum } from '@acorex/platform/layout/builder';
 import { AXDataSource } from '@acorex/cdk/common';
 import { AXPWidgetsList } from '@acorex/modules/common';
 import { AXTranslationService } from '@acorex/core/translation';
@@ -64,23 +64,12 @@ const RootConfig = {
             titlePlural: `t("dataSourceCategoryPlural", { scope: "${config.i18n}" })`,
             icon: 'fa-regular fa-layer-group',
         },
-        metaDataDefinitionCategory: {
-            name: 'MetaDataDefinitionCategory',
-            title: `t('metaDataDefinitionCategory', { scope: "${config.i18n}" })`,
-            titlePlural: `t('metaDataDefinitionCategoryPlural', { scope: "${config.i18n}" })`,
-            icon: 'fa-light fa-list',
-        },
         metaDataDefinition: {
             name: 'MetaDataDefinition',
             title: `t('metaDataDefinition', { scope: "${config.i18n}" })`,
             titlePlural: `t('metaDataDefinitionPlural', { scope: "${config.i18n}" })`,
             icon: 'fa-light fa-server',
         },
-        // category: {
-        //   name: 'Category',
-        //  title: 't("category", { scope: "common" })',
-        //  icon: 'fa-light fa-list'
-        // },
     },
 };
 
@@ -96,12 +85,6 @@ class AXMMenuProvider {
                 icon: module.icon,
                 priority: 90001,
                 children: [
-                    {
-                        text: RootConfig.entities.queryCategory.title,
-                        path: this.entityService.createPath(RootConfig.module.name, RootConfig.entities.queryCategory.name),
-                        icon: RootConfig.entities.queryCategory.icon,
-                        priority: 9001,
-                    },
                     {
                         text: RootConfig.entities.query.title,
                         path: this.entityService.createPath(RootConfig.module.name, RootConfig.entities.query.name),
@@ -114,24 +97,12 @@ class AXMMenuProvider {
                         icon: RootConfig.entities.dataSource.icon,
                         priority: 9003,
                     },
-                    {
-                        text: RootConfig.entities.dataSourceCategory.title,
-                        path: this.entityService.createPath(RootConfig.module.name, RootConfig.entities.dataSourceCategory.name),
-                        icon: RootConfig.entities.dataSourceCategory.icon,
-                        priority: 9004,
-                    },
                     {
                         text: RootConfig.entities.metaDataDefinition.title,
                         path: this.entityService.createPath(RootConfig.module.name, RootConfig.entities.metaDataDefinition.name),
                         icon: RootConfig.entities.metaDataDefinition.icon,
                         priority: 9005,
                     },
-                    {
-                        text: RootConfig.entities.metaDataDefinitionCategory.title,
-                        path: this.entityService.createPath(RootConfig.module.name, RootConfig.entities.metaDataDefinitionCategory.name),
-                        icon: RootConfig.entities.metaDataDefinitionCategory.icon,
-                        priority: 9006,
-                    },
                 ]
             }
         ]);
@@ -152,16 +123,10 @@ class AXMEntityProvider {
     async get(moduleName, entityName) {
         if (moduleName == RootConfig.module.name) {
             switch (entityName) {
-                case RootConfig.entities.queryCategory.name:
-                    return (await Promise.resolve().then(function () { return queryCategory_entity; })).queryCategoryFactory(this.injector);
                 case RootConfig.entities.query.name:
                     return (await Promise.resolve().then(function () { return query_entity; })).queryFactory(this.injector);
                 case RootConfig.entities.dataSource.name:
                     return (await Promise.resolve().then(function () { return dataSource_entity; })).dataSourceEntityFactory(this.injector);
-                case RootConfig.entities.dataSourceCategory.name:
-                    return (await Promise.resolve().then(function () { return dataSourceCategory_entity; })).dataSourceCategoryFactory(this.injector);
-                case RootConfig.entities.metaDataDefinitionCategory.name:
-                    return (await Promise.resolve().then(function () { return metaDataDefinitionCategory_entity; })).metaDataDefinitionCategoryEntityFactory(this.injector);
                 case RootConfig.entities.metaDataDefinition.name:
                     return (await Promise.resolve().then(function () { return metaDataDefinition_entity; })).metaDataDefinitionFactory(this.injector);
             }
@@ -234,243 +199,6 @@ class AXMSearchCommandProvider extends AXPSearchCommandProvider {
     }
 }
 
-class AXMQueryCategoryService extends AXMEntityCrudServiceImpl {
-}
-class AXMQueryCategoryServiceImpl extends AXMQueryCategoryService {
-    constructor() {
-        super(`${RootConfig.module.name}.${RootConfig.entities.queryCategory.name}`);
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.6", ngImport: i0, type: AXMQueryCategoryServiceImpl, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.6", ngImport: i0, type: AXMQueryCategoryServiceImpl }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.6", ngImport: i0, type: AXMQueryCategoryServiceImpl, decorators: [{
-            type: Injectable
-        }], ctorParameters: () => [] });
-
-async function queryCategoryFactory(injector) {
-    const dataService = injector.get(AXMQueryCategoryService);
-    const i18n = RootConfig.config.i18n;
-    const entityDef = {
-        module: RootConfig.module.name,
-        name: RootConfig.entities.queryCategory.name,
-        parentKey: 'parentId',
-        source: '',
-        title: RootConfig.entities.queryCategory.title,
-        formats: {
-            individual: RootConfig.entities.queryCategory.title,
-            plural: RootConfig.entities.queryCategory.titlePlural,
-            searchResult: {
-                title: '{{ title }}',
-                description: RootConfig.module.title,
-            },
-        },
-        relatedEntities: [],
-        groups: [
-            {
-                id: 'section',
-                title: `t("queryCategory", { scope: "common" })`,
-            },
-        ],
-        properties: [
-            {
-                name: 'title',
-                title: `t("title", { scope: "common" })`,
-                groupId: 'section',
-                schema: {
-                    dataType: 'string',
-                    interface: {
-                        type: AXPWidgetsCatalog.text,
-                        options: {
-                            width: '400px',
-                        },
-                    },
-                },
-                validations: [
-                    {
-                        rule: 'required',
-                    },
-                ],
-            },
-            {
-                name: 'parentId',
-                title: `t("parent", { scope: "${i18n}" })`,
-                groupId: 'section',
-                schema: {
-                    dataType: 'string',
-                    interface: {
-                        type: AXPWidgetsCatalog.lookup,
-                        options: {
-                            entity: `${RootConfig.module.name}.${RootConfig.entities.queryCategory.name}`,
-                        },
-                    },
-                },
-            },
-        ],
-        columns: [{ name: 'title' }],
-        commands: {
-            create: {
-                execute: async (data) => {
-                    const res = await dataService.insertOne(data);
-                    return { id: res };
-                },
-            },
-            delete: {
-                execute: async (id) => {
-                    return await dataService.deleteOne(id);
-                },
-            },
-            update: {
-                execute: async (data) => {
-                    return await dataService.updateOne(data.id, data);
-                },
-            },
-        },
-        queries: {
-            byKey: {
-                execute: async (id) => {
-                    return await dataService.getOne(id);
-                },
-                type: AXPEntityQueryType.Single,
-            },
-            list: {
-                execute: async (e) => {
-                    return await dataService.query({ skip: e.skip, take: e.take, filter: e.filter });
-                },
-                type: AXPEntityQueryType.List,
-            },
-        },
-        interfaces: {
-            master: {
-                create: {
-                    sections: [
-                        {
-                            id: 'section',
-                        },
-                    ],
-                    properties: [
-                        {
-                            name: 'title',
-                            layout: {
-                                positions: {
-                                    lg: {
-                                        colSpan: 12,
-                                    },
-                                },
-                            },
-                        },
-                        {
-                            name: 'parentId',
-                            layout: {
-                                positions: {
-                                    lg: {
-                                        colSpan: 12,
-                                    },
-                                },
-                            },
-                        },
-                    ],
-                },
-                update: {
-                    sections: [
-                        {
-                            id: 'section',
-                        },
-                    ],
-                    properties: [
-                        {
-                            name: 'title',
-                            layout: {
-                                positions: {
-                                    lg: {
-                                        colSpan: 12,
-                                    },
-                                },
-                            },
-                        },
-                        {
-                            name: 'parentId',
-                            layout: {
-                                positions: {
-                                    lg: {
-                                        colSpan: 12,
-                                    },
-                                },
-                            },
-                        },
-                    ],
-                },
-                single: {
-                    title: '{{title}}',
-                    sections: [
-                        {
-                            id: 'section',
-                            layout: {
-                                positions: {
-                                    lg: {
-                                        colSpan: 12,
-                                    },
-                                },
-                            },
-                        },
-                    ],
-                    properties: [
-                        {
-                            name: 'title',
-                            layout: {
-                                positions: {
-                                    lg: {
-                                        colSpan: 6,
-                                    },
-                                },
-                            },
-                        },
-                    ],
-                    actions: [],
-                },
-                list: {
-                    actions: [
-                        {
-                            title: `t("create", { scope: "common" })`,
-                            command: 'create-entity',
-                            priority: 'primary',
-                            type: 'create',
-                            scope: AXPEntityCommandScope.TypeLevel,
-                        },
-                        {
-                            title: 't("deleteItems", { scope: "common" })',
-                            command: 'delete-entity',
-                            priority: 'primary',
-                            type: 'delete',
-                            scope: AXPEntityCommandScope.Selected,
-                        },
-                        {
-                            title: 't("detail", { scope: "common" })',
-                            command: 'open-entity',
-                            priority: 'secondary',
-                            type: 'view',
-                            scope: AXPEntityCommandScope.Individual,
-                        },
-                        {
-                            title: 't("delete", { scope: "common" })',
-                            command: 'delete-entity',
-                            priority: 'secondary',
-                            type: 'delete',
-                            scope: AXPEntityCommandScope.Individual,
-                        },
-                    ],
-                    views: [createAllQueryView()],
-                },
-            },
-        },
-    };
-    return entityDef;
-}
-
-var queryCategory_entity = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    queryCategoryFactory: queryCategoryFactory
-});
-
 //#region ----   Column Definition Widget   ----
 const AXM_COLUMN_DEF_WIDGET = [
     {
@@ -604,6 +332,36 @@ const AXM_COLUMN_DEF_WIDGET = [
 ];
 //#endregion
 
+class AXMDataSourceService extends AXMEntityCrudServiceImpl {
+}
+class AXMDataSourceServiceImpl extends AXMEntityCrudServiceImpl {
+    constructor() {
+        super(`${RootConfig.module.name}.${RootConfig.entities.dataSource.name}`);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.6", ngImport: i0, type: AXMDataSourceServiceImpl, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.6", ngImport: i0, type: AXMDataSourceServiceImpl }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.6", ngImport: i0, type: AXMDataSourceServiceImpl, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [] });
+
+//#region ----   Output Types   ----
+var AXMDataSourceOutputType;
+(function (AXMDataSourceOutputType) {
+    AXMDataSourceOutputType["Table"] = "table";
+    AXMDataSourceOutputType["SingleObject"] = "single_object";
+    AXMDataSourceOutputType["Value"] = "value";
+})(AXMDataSourceOutputType || (AXMDataSourceOutputType = {}));
+//#endregion
+//#region ----   Source Types   ----
+var AXMDataSourceType;
+(function (AXMDataSourceType) {
+    AXMDataSourceType["Static"] = "static";
+    AXMDataSourceType["Query"] = "query";
+    // ExternalApi = 'external_api' // TODO: Will be implemented later
+})(AXMDataSourceType || (AXMDataSourceType = {}));
+//#endregion
+
 //#region ----   Filter Definition Widget   ----
 const AXM_FILTER_DEF_WIDGET = [
     {
@@ -669,36 +427,6 @@ const AXM_FILTER_DEF_WIDGET = [
 ];
 //#endregion
 
-class AXMDataSourceService extends AXMEntityCrudServiceImpl {
-}
-class AXMDataSourceServiceImpl extends AXMEntityCrudServiceImpl {
-    constructor() {
-        super(`${RootConfig.module.name}.${RootConfig.entities.dataSource.name}`);
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.6", ngImport: i0, type: AXMDataSourceServiceImpl, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.6", ngImport: i0, type: AXMDataSourceServiceImpl }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.6", ngImport: i0, type: AXMDataSourceServiceImpl, decorators: [{
-            type: Injectable
-        }], ctorParameters: () => [] });
-
-//#region ----   Output Types   ----
-var AXMDataSourceOutputType;
-(function (AXMDataSourceOutputType) {
-    AXMDataSourceOutputType["Table"] = "table";
-    AXMDataSourceOutputType["SingleObject"] = "single_object";
-    AXMDataSourceOutputType["Value"] = "value";
-})(AXMDataSourceOutputType || (AXMDataSourceOutputType = {}));
-//#endregion
-//#region ----   Source Types   ----
-var AXMDataSourceType;
-(function (AXMDataSourceType) {
-    AXMDataSourceType["Static"] = "static";
-    AXMDataSourceType["Query"] = "query";
-    // ExternalApi = 'external_api' // TODO: Will be implemented later
-})(AXMDataSourceType || (AXMDataSourceType = {}));
-//#endregion
-
 async function dataSourceEntityFactory(injector) {
     const dataService = injector.get(AXMDataSourceService);
     const i18n = RootConfig.config.i18n;
@@ -717,22 +445,13 @@ async function dataSourceEntityFactory(injector) {
                 description: RootConfig.module.title,
             },
         },
+        plugins: [
+            { name: 'history' },
+            { name: 'lock' },
+            { name: 'compare' },
+            { name: 'category' },
+        ],
         relatedEntities: [],
-        category: {
-            entity: `${RootConfig.module.name}.${RootConfig.entities.dataSourceCategory.name}`,
-            title: 'Categories',
-            textField: 'title',
-            valueField: 'id',
-            applyConditions: [
-                {
-                    name: 'categoryIds',
-                    operator: {
-                        type: 'contains',
-                    },
-                    value: 'id',
-                },
-            ],
-        },
         groups: [
             {
                 id: 'dataSource',
@@ -1055,7 +774,12 @@ async function dataSourceEntityFactory(injector) {
                 ],
             },
         ],
-        columns: [{ name: 'name' }, { name: 'title' }, { name: 'categoryIds', options: { dataPath: 'categories' } }, { name: 'sourceType' }, { name: 'outputType' }],
+        columns: [
+            { name: 'name' },
+            { name: 'title' },
+            { name: 'sourceType' },
+            { name: 'outputType' },
+        ],
         commands: {
             create: {
                 execute: async (data) => {
@@ -1107,7 +831,7 @@ async function dataSourceEntityFactory(injector) {
             },
             list: {
                 execute: async (e) => {
-                    return await dataService.query({ skip: e.skip, take: e.take, filter: e.filter });
+                    return await dataService.query(e);
                 },
                 type: AXPEntityQueryType.List,
             },
@@ -1152,17 +876,6 @@ async function dataSourceEntityFactory(injector) {
                                 },
                             },
                         },
-                        {
-                            name: 'categoryIds',
-                            layout: {
-                                positions: {
-                                    lg: {
-                                        colSpan: 6,
-                                        order: 3,
-                                    },
-                                },
-                            },
-                        },
                         {
                             name: 'columns',
                             layout: {
@@ -1280,17 +993,6 @@ async function dataSourceEntityFactory(injector) {
                                 },
                             },
                         },
-                        {
-                            name: 'categoryIds',
-                            layout: {
-                                positions: {
-                                    lg: {
-                                        colSpan: 6,
-                                        order: 3,
-                                    },
-                                },
-                            },
-                        },
                         {
                             name: 'columns',
                             layout: {
@@ -1398,18 +1100,6 @@ async function dataSourceEntityFactory(injector) {
                                 },
                             },
                         },
-                        {
-                            name: 'categoryIds',
-                            dataPath: 'categories',
-                            layout: {
-                                positions: {
-                                    lg: {
-                                        colSpan: 6,
-                                        order: 3,
-                                    },
-                                },
-                            },
-                        },
                         {
                             name: 'columns',
                             layout: {
@@ -1530,7 +1220,8 @@ async function dataSourceEntityFactory(injector) {
                         {
                             title: 't("entity.modify", { scope: "common" })',
                             command: {
-                                name: 'quick-modify-entity', options: {
+                                name: 'quick-modify-entity',
+                                options: {
                                     layout: {
                                         size: 'lg',
                                     },
@@ -2066,22 +1757,13 @@ async function queryFactory(injector) {
                 description: RootConfig.module.title,
             },
         },
+        plugins: [
+            { name: 'history' },
+            { name: 'lock' },
+            { name: 'compare' },
+            { name: 'category' },
+        ],
         relatedEntities: [],
-        category: {
-            entity: `${RootConfig.module.name}.${RootConfig.entities.queryCategory.name}`,
-            title: 'Categories',
-            textField: 'title',
-            valueField: 'id',
-            applyConditions: [
-                {
-                    name: 'categoryIds',
-                    operator: {
-                        type: 'contains',
-                    },
-                    value: 'id',
-                },
-            ],
-        },
         groups: [
             {
                 id: 'section',
@@ -2147,30 +1829,6 @@ async function queryFactory(injector) {
                     },
                 ],
             },
-            {
-                name: 'categoryIds',
-                title: `t("category", { scope: "common" })`,
-                groupId: 'section',
-                schema: {
-                    dataType: 'string',
-                    interface: {
-                        type: AXPWidgetsCatalog.lookup,
-                        options: {
-                            entity: `${RootConfig.module.name}.${RootConfig.entities.queryCategory.name}`,
-                            multiple: true,
-                            expose: [
-                                { source: 'id', target: 'categories.{id}' },
-                                { source: 'title', target: 'categories.{title}' },
-                            ],
-                        },
-                    },
-                },
-                validations: [
-                    {
-                        rule: 'required',
-                    },
-                ],
-            },
             {
                 name: 'dataSource',
                 title: `t("dataSource", { scope: "${i18n}" })`,
@@ -2220,390 +1878,25 @@ async function queryFactory(injector) {
                 schema: {
                     dataType: 'object',
                     interface: {
-                        type: AXPWidgetsList.Editors.QueryBuilder,
-                        options: {
-                            dataSources: '{{ [context.eval("dataSource")] }}',
-                            availableColumns: '{{ context.eval("availableColumns") || [] }}',
-                        },
-                    },
-                },
-            },
-        ],
-        columns: [
-            { name: 'name' },
-            { name: 'title' },
-            { name: 'categoryIds', options: { dataPath: 'categories' } },
-            { name: 'dataSource' },
-            { name: 'query' },
-        ],
-        commands: {
-            create: {
-                execute: async (data) => {
-                    console.log(data.query);
-                    const res = await dataService.insertOne(data);
-                    return { id: res };
-                },
-            },
-            delete: {
-                execute: async (id) => {
-                    return await dataService.deleteOne(id);
-                },
-            },
-            update: {
-                execute: async (data) => {
-                    return await dataService.updateOne(data.id, data);
-                },
-            },
-        },
-        queries: {
-            byKey: {
-                execute: async (id) => {
-                    return await dataService.getOne(id);
-                },
-                type: AXPEntityQueryType.Single,
-            },
-            list: {
-                execute: async (e) => {
-                    return await dataService.query({ skip: e.skip, take: e.take, filter: e.filter });
-                },
-                type: AXPEntityQueryType.List,
-            },
-        },
-        interfaces: {
-            master: {
-                create: {
-                    sections: [
-                        {
-                            id: 'section',
-                        },
-                    ],
-                    properties: [
-                        {
-                            name: 'name',
-                            layout: {
-                                positions: {
-                                    lg: {
-                                        colSpan: 6,
-                                        order: 1,
-                                    },
-                                },
-                            },
-                        },
-                        {
-                            name: 'title',
-                            layout: {
-                                positions: {
-                                    lg: {
-                                        colSpan: 6,
-                                        order: 2,
-                                    },
-                                },
-                            },
-                        },
-                        {
-                            name: 'categoryIds',
-                            layout: {
-                                positions: {
-                                    lg: {
-                                        colSpan: 6,
-                                        order: 3,
-                                    },
-                                },
-                            },
-                        },
-                        {
-                            name: 'dataSource',
-                            layout: {
-                                positions: {
-                                    lg: {
-                                        colSpan: 6,
-                                        order: 4,
-                                    },
-                                },
-                            },
-                        },
-                        {
-                            name: 'query',
-                            layout: {
-                                positions: {
-                                    lg: {
-                                        colSpan: 12,
-                                        order: 5,
-                                    },
-                                },
-                            },
-                        },
-                    ],
-                },
-                update: {
-                    sections: [
-                        {
-                            id: 'section',
-                        },
-                    ],
-                    properties: [
-                        {
-                            name: 'name',
-                            layout: {
-                                positions: {
-                                    lg: {
-                                        colSpan: 6,
-                                        order: 1,
-                                    },
-                                },
-                            },
-                        },
-                        {
-                            name: 'title',
-                            layout: {
-                                positions: {
-                                    lg: {
-                                        colSpan: 6,
-                                        order: 2,
-                                    },
-                                },
-                            },
-                        },
-                        {
-                            name: 'categoryIds',
-                            layout: {
-                                positions: {
-                                    lg: {
-                                        colSpan: 6,
-                                        order: 3,
-                                    },
-                                },
-                            },
-                        },
-                        {
-                            name: 'dataSource',
-                            layout: {
-                                positions: {
-                                    lg: {
-                                        colSpan: 6,
-                                        order: 4,
-                                    },
-                                },
-                            },
-                        },
-                        {
-                            name: 'query',
-                            layout: {
-                                positions: {
-                                    lg: {
-                                        colSpan: 12,
-                                        order: 5,
-                                    },
-                                },
-                            },
-                        },
-                    ],
-                },
-                single: {
-                    title: '{{title}}',
-                    sections: [
-                        {
-                            id: 'section',
-                            layout: {
-                                positions: {
-                                    lg: {
-                                        colSpan: 12,
-                                    },
-                                },
-                            },
-                        },
-                    ],
-                    properties: [
-                        {
-                            name: 'name',
-                            layout: {
-                                positions: {
-                                    lg: {
-                                        colSpan: 6,
-                                        order: 1,
-                                    },
-                                },
-                            },
-                        },
-                        {
-                            name: 'title',
-                            layout: {
-                                positions: {
-                                    lg: {
-                                        colSpan: 6,
-                                        order: 2,
-                                    },
-                                },
-                            },
-                        },
-                        {
-                            name: 'categoryIds',
-                            dataPath: 'categories',
-                            layout: {
-                                positions: {
-                                    lg: {
-                                        colSpan: 6,
-                                        order: 3,
-                                    },
-                                },
-                            },
-                        },
-                        {
-                            name: 'dataSource',
-                            layout: {
-                                positions: {
-                                    lg: {
-                                        colSpan: 6,
-                                        order: 4,
-                                    },
-                                },
-                            },
-                        },
-                        {
-                            name: 'query',
-                            layout: {
-                                positions: {
-                                    lg: {
-                                        colSpan: 12,
-                                        order: 5,
-                                    },
-                                },
-                            },
-                        },
-                    ],
-                    actions: [],
-                },
-                list: {
-                    actions: [
-                        {
-                            title: `t("create", { scope: "common" })`,
-                            command: {
-                                name: 'create-entity',
-                                options: {
-                                    layout: {
-                                        size: 'lg',
-                                    },
-                                },
-                            },
-                            priority: 'primary',
-                            type: 'create',
-                            scope: AXPEntityCommandScope.TypeLevel,
-                        },
-                        {
-                            title: 't("deleteItems", { scope: "common" })',
-                            command: 'delete-entity',
-                            priority: 'primary',
-                            type: 'delete',
-                            scope: AXPEntityCommandScope.Selected,
-                        },
-                        {
-                            title: 't("detail", { scope: "common" })',
-                            command: 'open-entity',
-                            priority: 'secondary',
-                            type: 'view',
-                            scope: AXPEntityCommandScope.Individual,
-                        },
-                        {
-                            title: 't("delete", { scope: "common" })',
-                            command: 'delete-entity',
-                            priority: 'secondary',
-                            type: 'delete',
-                            scope: AXPEntityCommandScope.Individual,
-                        },
-                    ],
-                    views: [
-                        createAllQueryView({
-                            sorts: [{ name: 'name', dir: 'asc' }],
-                        }),
-                    ],
-                },
-            },
-        },
-    };
-    return entityDef;
-}
-
-var query_entity = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    queryFactory: queryFactory
-});
-
-class AXMDataSourceCategoryService extends AXMEntityCrudServiceImpl {
-}
-class AXMDataSourceCategoryServiceImpl extends AXMDataSourceCategoryService {
-    constructor() {
-        super(`${RootConfig.module.name}.${RootConfig.entities.dataSourceCategory.name}`);
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.6", ngImport: i0, type: AXMDataSourceCategoryServiceImpl, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.6", ngImport: i0, type: AXMDataSourceCategoryServiceImpl }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.6", ngImport: i0, type: AXMDataSourceCategoryServiceImpl, decorators: [{
-            type: Injectable
-        }], ctorParameters: () => [] });
-
-async function dataSourceCategoryFactory(injector) {
-    const dataService = injector.get(AXMDataSourceCategoryService);
-    const i18n = RootConfig.config.i18n;
-    const entityDef = {
-        module: RootConfig.module.name,
-        name: RootConfig.entities.dataSourceCategory.name,
-        parentKey: 'parentId',
-        source: '',
-        title: RootConfig.entities.dataSourceCategory.title,
-        formats: {
-            individual: RootConfig.entities.dataSourceCategory.title,
-            plural: RootConfig.entities.dataSourceCategory.titlePlural,
-            searchResult: {
-                title: '{{ title }}',
-                description: RootConfig.module.title,
-            },
-        },
-        relatedEntities: [],
-        groups: [
-            {
-                id: 'section',
-                title: `t("dataSourceCategory", { scope: "${i18n}" })`,
-            },
-        ],
-        properties: [
-            {
-                name: 'title',
-                title: `t("title", { scope: "common" })`,
-                groupId: 'section',
-                schema: {
-                    dataType: 'string',
-                    interface: {
-                        type: AXPWidgetsCatalog.text,
-                        options: {
-                            width: '400px',
-                        },
-                    },
-                },
-                validations: [
-                    {
-                        rule: 'required',
-                    },
-                ],
-            },
-            {
-                name: 'parentId',
-                title: `t("parent", { scope: "${i18n}" })`,
-                groupId: 'section',
-                schema: {
-                    dataType: 'string',
-                    interface: {
-                        type: AXPWidgetsCatalog.lookup,
+                        type: AXPWidgetsList.Editors.QueryBuilder,
                         options: {
-                            entity: `${RootConfig.module.name}.${RootConfig.entities.dataSourceCategory.name}`,
+                            dataSources: '{{ [context.eval("dataSource")] }}',
+                            availableColumns: '{{ context.eval("availableColumns") || [] }}',
                         },
                     },
                 },
             },
         ],
-        columns: [{ name: 'title' }],
+        columns: [
+            { name: 'name' },
+            { name: 'title' },
+            { name: 'dataSource' },
+            { name: 'query' },
+        ],
         commands: {
             create: {
                 execute: async (data) => {
+                    console.log(data.query);
                     const res = await dataService.insertOne(data);
                     return { id: res };
                 },
@@ -2628,7 +1921,7 @@ async function dataSourceCategoryFactory(injector) {
             },
             list: {
                 execute: async (e) => {
-                    return await dataService.query({ skip: e.skip, take: e.take, filter: e.filter });
+                    return await dataService.query(e);
                 },
                 type: AXPEntityQueryType.List,
             },
@@ -2643,7 +1936,7 @@ async function dataSourceCategoryFactory(injector) {
                     ],
                     properties: [
                         {
-                            name: 'title',
+                            name: 'name',
                             layout: {
                                 positions: {
                                     lg: {
@@ -2654,7 +1947,7 @@ async function dataSourceCategoryFactory(injector) {
                             },
                         },
                         {
-                            name: 'parentId',
+                            name: 'title',
                             layout: {
                                 positions: {
                                     lg: {
@@ -2664,6 +1957,28 @@ async function dataSourceCategoryFactory(injector) {
                                 },
                             },
                         },
+                        {
+                            name: 'dataSource',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                        order: 4,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'query',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 12,
+                                        order: 5,
+                                    },
+                                },
+                            },
+                        },
                     ],
                 },
                 update: {
@@ -2674,7 +1989,7 @@ async function dataSourceCategoryFactory(injector) {
                     ],
                     properties: [
                         {
-                            name: 'title',
+                            name: 'name',
                             layout: {
                                 positions: {
                                     lg: {
@@ -2685,7 +2000,7 @@ async function dataSourceCategoryFactory(injector) {
                             },
                         },
                         {
-                            name: 'parentId',
+                            name: 'title',
                             layout: {
                                 positions: {
                                     lg: {
@@ -2695,6 +2010,28 @@ async function dataSourceCategoryFactory(injector) {
                                 },
                             },
                         },
+                        {
+                            name: 'dataSource',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                        order: 4,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'query',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 12,
+                                        order: 5,
+                                    },
+                                },
+                            },
+                        },
                     ],
                 },
                 single: {
@@ -2713,7 +2050,7 @@ async function dataSourceCategoryFactory(injector) {
                     ],
                     properties: [
                         {
-                            name: 'title',
+                            name: 'name',
                             layout: {
                                 positions: {
                                     lg: {
@@ -2724,7 +2061,7 @@ async function dataSourceCategoryFactory(injector) {
                             },
                         },
                         {
-                            name: 'parentId',
+                            name: 'title',
                             layout: {
                                 positions: {
                                     lg: {
@@ -2734,6 +2071,28 @@ async function dataSourceCategoryFactory(injector) {
                                 },
                             },
                         },
+                        {
+                            name: 'dataSource',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                        order: 4,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'query',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 12,
+                                        order: 5,
+                                    },
+                                },
+                            },
+                        },
                     ],
                     actions: [],
                 },
@@ -2741,7 +2100,14 @@ async function dataSourceCategoryFactory(injector) {
                     actions: [
                         {
                             title: `t("create", { scope: "common" })`,
-                            command: 'create-entity',
+                            command: {
+                                name: 'create-entity',
+                                options: {
+                                    layout: {
+                                        size: 'lg',
+                                    },
+                                },
+                            },
                             priority: 'primary',
                             type: 'create',
                             scope: AXPEntityCommandScope.TypeLevel,
@@ -2770,7 +2136,7 @@ async function dataSourceCategoryFactory(injector) {
                     ],
                     views: [
                         createAllQueryView({
-                            sorts: [{ name: 'title', dir: 'asc' }],
+                            sorts: [{ name: 'name', dir: 'asc' }],
                         }),
                     ],
                 },
@@ -2780,9 +2146,9 @@ async function dataSourceCategoryFactory(injector) {
     return entityDef;
 }
 
-var dataSourceCategory_entity = /*#__PURE__*/Object.freeze({
+var query_entity = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    dataSourceCategoryFactory: dataSourceCategoryFactory
+    queryFactory: queryFactory
 });
 
 class AXMMetaDataDefinitionService extends AXMEntityCrudServiceImpl {
@@ -2819,21 +2185,12 @@ async function metaDataDefinitionFactory(injector) {
             showInList: true,
             showInDetail: true,
         },
-        category: {
-            entity: `${RootConfig.module.name}.${RootConfig.entities.metaDataDefinitionCategory.name}`,
-            title: 'Categories',
-            textField: 'title',
-            valueField: 'id',
-            applyConditions: [
-                {
-                    name: 'categoryIds',
-                    operator: {
-                        type: 'contains',
-                    },
-                    value: 'id',
-                },
-            ],
-        },
+        plugins: [
+            { name: 'history' },
+            { name: 'lock' },
+            { name: 'compare' },
+            { name: 'category' },
+        ],
         groups: [
             {
                 id: 'section',
@@ -2889,30 +2246,6 @@ async function metaDataDefinitionFactory(injector) {
                     },
                 },
             },
-            {
-                name: 'categoryIds',
-                title: 't("category", { scope: "common" })',
-                groupId: 'section',
-                schema: {
-                    dataType: 'string',
-                    interface: {
-                        type: AXPWidgetsCatalog.lookup,
-                        options: {
-                            entity: `${RootConfig.module.name}.${RootConfig.entities.metaDataDefinitionCategory.name}`,
-                            multiple: true,
-                            expose: [
-                                { source: 'id', target: 'categories.{id}' },
-                                { source: 'title', target: 'categories.{title}' },
-                            ],
-                        },
-                    },
-                },
-                validations: [
-                    {
-                        rule: 'required',
-                    },
-                ],
-            },
             {
                 name: 'interface',
                 title: `t("interface", { scope: "${RootConfig.config.i18n}" })`,
@@ -2937,7 +2270,6 @@ async function metaDataDefinitionFactory(injector) {
             { name: 'name' },
             { name: 'title' },
             { name: 'description' },
-            { name: 'categoryIds', options: { dataPath: 'categories' } },
         ],
         commands: {
             create: {
@@ -2966,7 +2298,7 @@ async function metaDataDefinitionFactory(injector) {
             },
             list: {
                 execute: async (e) => {
-                    return await dataService.query({ skip: e.skip, take: e.take, filter: e.filter });
+                    return await dataService.query(e);
                 },
                 type: AXPEntityQueryType.List,
             },
@@ -2983,32 +2315,25 @@ async function metaDataDefinitionFactory(injector) {
                         { name: 'name', layout: { positions: { lg: { colSpan: 6 } } } },
                         { name: 'title', layout: { positions: { lg: { colSpan: 6 } } } },
                         { name: 'description', layout: { positions: { lg: { colSpan: 12 } } } },
-                        { name: 'categoryIds', layout: { positions: { lg: { colSpan: 6 } } } },
                         { name: 'interface', layout: { positions: { lg: { colSpan: 6 } } } },
                     ],
                 },
                 update: {
-                    sections: [
-                        { id: 'section' },
-                    ],
+                    sections: [{ id: 'section' }],
                     properties: [
                         { name: 'name', layout: { positions: { lg: { colSpan: 6 } } } },
                         { name: 'title', layout: { positions: { lg: { colSpan: 6 } } } },
                         { name: 'description', layout: { positions: { lg: { colSpan: 12 } } } },
-                        { name: 'categoryIds', layout: { positions: { lg: { colSpan: 6 } } } },
                         { name: 'interface', layout: { positions: { lg: { colSpan: 6 } } } },
                     ],
                 },
                 single: {
                     title: '{{title}}',
-                    sections: [
-                        { id: 'section', layout: { positions: { lg: { colSpan: 12 } } } },
-                    ],
+                    sections: [{ id: 'section', layout: { positions: { lg: { colSpan: 12 } } } }],
                     properties: [
                         { name: 'name', layout: { positions: { lg: { colSpan: 6 } } } },
                         { name: 'title', layout: { positions: { lg: { colSpan: 6 } } } },
                         { name: 'description', layout: { positions: { lg: { colSpan: 12 } } } },
-                        { name: 'categoryIds', dataPath: 'categories', layout: { positions: { lg: { colSpan: 6 } } } },
                         { name: 'interface', layout: { positions: { lg: { colSpan: 6 } } } },
                     ],
                     actions: [],
@@ -3057,156 +2382,6 @@ var metaDataDefinition_entity = /*#__PURE__*/Object.freeze({
     metaDataDefinitionFactory: metaDataDefinitionFactory
 });
 
-class AXMMetaDataDefinitionCategoryService extends AXMEntityCrudServiceImpl {
-}
-class AXMMetaDataDefinitionCategoryServiceImpl extends AXMMetaDataDefinitionCategoryService {
-    constructor() {
-        super(`${RootConfig.module.name}.${RootConfig.entities.metaDataDefinitionCategory.name}`);
-    }
-    getAllWithItems() {
-        throw new Error('Not implemented');
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.6", ngImport: i0, type: AXMMetaDataDefinitionCategoryServiceImpl, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.6", ngImport: i0, type: AXMMetaDataDefinitionCategoryServiceImpl }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.6", ngImport: i0, type: AXMMetaDataDefinitionCategoryServiceImpl, decorators: [{
-            type: Injectable
-        }], ctorParameters: () => [] });
-
-async function metaDataDefinitionCategoryEntityFactory(injector) {
-    const dataService = injector.get(AXMMetaDataDefinitionCategoryService);
-    const i18n = RootConfig.config.i18n;
-    const entityDef = {
-        module: RootConfig.module.name,
-        name: RootConfig.entities.metaDataDefinitionCategory.name,
-        parentKey: 'parentId',
-        source: '',
-        title: RootConfig.entities.metaDataDefinitionCategory.title,
-        formats: {
-            individual: `t("metaDataDefinitionCategory", { scope: "${i18n}" })`,
-            plural: `t("metaDataDefinitionCategories", { scope: "${i18n}" })`,
-            searchResult: {
-                title: '{{ title }}',
-                description: RootConfig.module.title,
-            },
-        },
-        relatedEntities: [],
-        groups: [
-            {
-                id: 'section',
-                title: `t("metaDataDefinitionCategory", { scope: "common" })`,
-            },
-        ],
-        properties: [
-            {
-                name: 'title',
-                title: `t("title",{ scope:  "common" })`,
-                groupId: 'section',
-                schema: {
-                    dataType: 'string',
-                    interface: {
-                        type: AXPWidgetsCatalog.text,
-                        options: { width: '400px' },
-                    },
-                },
-                validations: [
-                    { rule: 'required' },
-                ],
-            },
-            {
-                name: 'parentId',
-                title: `t("parent",{ scope: "${i18n}" })`,
-                groupId: 'section',
-                schema: {
-                    dataType: 'string',
-                    interface: {
-                        type: AXPWidgetsCatalog.lookup,
-                        options: {
-                            entity: `${RootConfig.module.name}.${RootConfig.entities.metaDataDefinitionCategory.name}`,
-                        },
-                    },
-                },
-            },
-        ],
-        columns: [{ name: 'title' }],
-        commands: {
-            create: {
-                execute: async (data) => {
-                    const res = await dataService.insertOne(data);
-                    return { id: res };
-                },
-            },
-            delete: {
-                execute: async (id) => {
-                    return await dataService.deleteOne(id);
-                },
-            },
-            update: {
-                execute: async (data) => {
-                    return await dataService.updateOne(data.id, data);
-                },
-            },
-        },
-        queries: {
-            byKey: {
-                execute: async (id) => {
-                    return await dataService.getOne(id);
-                },
-                type: AXPEntityQueryType.Single,
-            },
-            list: {
-                execute: async (e) => {
-                    return await dataService.query({ skip: e.skip, take: e.take, filter: e.filter });
-                },
-                type: AXPEntityQueryType.List,
-            },
-        },
-        interfaces: {
-            master: {
-                create: {
-                    sections: [{ id: 'section' }],
-                    properties: [
-                        { name: 'title', layout: { positions: { lg: { colSpan: 12 } } } },
-                        { name: 'parentId', layout: { positions: { lg: { colSpan: 12 } } } },
-                    ],
-                },
-                update: {
-                    sections: [{ id: 'section' }],
-                    properties: [
-                        { name: 'title', layout: { positions: { lg: { colSpan: 12 } } } },
-                        { name: 'parentId', layout: { positions: { lg: { colSpan: 12 } } } },
-                    ],
-                },
-                single: {
-                    title: '{{title}}',
-                    sections: [
-                        { id: 'section', layout: { positions: { lg: { colSpan: 12 } } } },
-                    ],
-                    properties: [
-                        { name: 'title', layout: { positions: { lg: { colSpan: 6 } } } },
-                    ],
-                    actions: [],
-                },
-                list: {
-                    actions: [
-                        { title: `t("create", { scope: "common" })`, command: 'create-entity', priority: 'primary', type: 'create', scope: AXPEntityCommandScope.TypeLevel },
-                        { title: 't("deleteItems", { scope: "common" })', command: 'delete-entity', priority: 'primary', type: 'delete', scope: AXPEntityCommandScope.Selected },
-                        { title: 't("detail", { scope: "common" })', command: 'open-entity', priority: 'secondary', type: 'view', scope: AXPEntityCommandScope.Individual },
-                        { title: 't("delete", { scope: "common" })', command: 'delete-entity', priority: 'secondary', type: 'delete', scope: AXPEntityCommandScope.Individual },
-                    ],
-                    views: [createAllQueryView()],
-                },
-            },
-        },
-    };
-    return entityDef;
-}
-
-var metaDataDefinitionCategory_entity = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    metaDataDefinitionCategoryEntityFactory: metaDataDefinitionCategoryEntityFactory
-});
-
 const AXPQueryBuilderWidget = {
     name: 'query-builder-editor',
     title: 'Query Builder',
@@ -4647,10 +3822,6 @@ class AXMDataManagementModule {
                 useClass: AXMPermissionDefinitionProvider,
                 multi: true,
             },
-            {
-                provide: AXMQueryCategoryService,
-                useClass: AXMQueryCategoryServiceImpl,
-            },
             {
                 provide: AXMQueryService,
                 useClass: AXMQueryServiceImpl,
@@ -4659,18 +3830,10 @@ class AXMDataManagementModule {
                 provide: AXMDataSourceService,
                 useClass: AXMDataSourceServiceImpl,
             },
-            {
-                provide: AXMDataSourceCategoryService,
-                useClass: AXMDataSourceCategoryServiceImpl,
-            },
             {
                 provide: AXMMetaDataDefinitionService,
                 useClass: AXMPMetaDataDefinitionServiceImpl,
             },
-            {
-                provide: AXMMetaDataDefinitionCategoryService,
-                useClass: AXMMetaDataDefinitionCategoryServiceImpl,
-            },
             {
                 provide: AXP_DATASOURCE_DEFINITION_PROVIDER,
                 useClass: AXMDataSourceListDataSourceDefinition,
@@ -4716,10 +3879,6 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.6", ngImpor
                             useClass: AXMPermissionDefinitionProvider,
                             multi: true,
                         },
-                        {
-                            provide: AXMQueryCategoryService,
-                            useClass: AXMQueryCategoryServiceImpl,
-                        },
                         {
                             provide: AXMQueryService,
                             useClass: AXMQueryServiceImpl,
@@ -4728,18 +3887,10 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.6", ngImpor
                             provide: AXMDataSourceService,
                             useClass: AXMDataSourceServiceImpl,
                         },
-                        {
-                            provide: AXMDataSourceCategoryService,
-                            useClass: AXMDataSourceCategoryServiceImpl,
-                        },
                         {
                             provide: AXMMetaDataDefinitionService,
                             useClass: AXMPMetaDataDefinitionServiceImpl,
                         },
-                        {
-                            provide: AXMMetaDataDefinitionCategoryService,
-                            useClass: AXMMetaDataDefinitionCategoryServiceImpl,
-                        },
                         {
                             provide: AXP_DATASOURCE_DEFINITION_PROVIDER,
                             useClass: AXMDataSourceListDataSourceDefinition,
@@ -4753,5 +3904,5 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.6", ngImpor
  * Generated bundle index. Do not edit.
  */
 
-export { AXMColumnFilterSelectorWidget, AXMColumnFilterSelectorWidgetColumnComponent, AXMColumnFilterSelectorWidgetEditComponent, AXMColumnFilterSelectorWidgetFilterComponent, AXMColumnFilterSelectorWidgetPrintComponent, AXMColumnFilterSelectorWidgetViewComponent, AXMDataManagementModule, AXMDataSourceCategoryService, AXMDataSourceCategoryServiceImpl, AXMDataSourceOutputType, AXMDataSourceService, AXMDataSourceServiceImpl, AXMDataSourceType, AXMEntityProvider, AXMMenuProvider, AXMMetaDataDefinitionCategoryService, AXMMetaDataDefinitionCategoryServiceImpl, AXMMetaDataDefinitionService, AXMPMetaDataDefinitionServiceImpl, AXMQueryCategoryService, AXMQueryCategoryServiceImpl, AXMQueryService, AXMQueryServiceImpl, AXMSearchCommandProvider, AXMSettingProvider, AXM_COLUMN_DEF_WIDGET, AXM_FILTER_DEF_WIDGET, AXPQueryBuilderWidget, AXPQueryBuilderWidgetColumnComponent, AXPQueryBuilderWidgetDesignerComponent, AXPQueryBuilderWidgetEditComponent, AXPQueryBuilderWidgetViewComponent, RootConfig, dataSourceCategoryFactory, dataSourceEntityFactory, metaDataDefinitionCategoryEntityFactory, metaDataDefinitionFactory, queryCategoryFactory, queryFactory };
+export { AXMColumnFilterSelectorWidget, AXMColumnFilterSelectorWidgetColumnComponent, AXMColumnFilterSelectorWidgetEditComponent, AXMColumnFilterSelectorWidgetFilterComponent, AXMColumnFilterSelectorWidgetPrintComponent, AXMColumnFilterSelectorWidgetViewComponent, AXMDataManagementModule, AXMDataSourceOutputType, AXMDataSourceService, AXMDataSourceServiceImpl, AXMDataSourceType, AXMEntityProvider, AXMMenuProvider, AXMMetaDataDefinitionService, AXMPMetaDataDefinitionServiceImpl, AXMQueryService, AXMQueryServiceImpl, AXMSearchCommandProvider, AXMSettingProvider, AXM_COLUMN_DEF_WIDGET, AXM_FILTER_DEF_WIDGET, AXPQueryBuilderWidget, AXPQueryBuilderWidgetColumnComponent, AXPQueryBuilderWidgetDesignerComponent, AXPQueryBuilderWidgetEditComponent, AXPQueryBuilderWidgetViewComponent, RootConfig, dataSourceEntityFactory, metaDataDefinitionFactory, queryFactory };
 //# sourceMappingURL=acorex-modules-data-management.mjs.map