@acorex-platform/module-data-management-client 0.0.21

package/types/acorex-platform-module-data-management-client.d.ts

@@ -0,0 +1,1798 @@
+import * as _angular_core from '@angular/core';
+import { InjectionToken, OnInit } from '@angular/core';
+import * as i1 from '@acorex-platform/framework-client/layout/widget-core';
+import { AXPValueWidgetComponent } from '@acorex-platform/framework-client/layout/widget-core';
+import { AXPMenuProvider, AXPMenuProviderContext } from '@acorex-platform/framework-client/common';
+import { AXPWidgetConfig } from '@acorex-platform/framework-shared/widget-core';
+import * as _acorex_platform_framework_shared_core from '@acorex-platform/framework-shared/core';
+import { AXPOptionsData, AXPFilterDefinition, AXPFilterClause, AXPExpressionEvaluatorScopeProvider, AXPExpressionEvaluatorScopeProviderContext, AXPMultiLanguageString, AXPActionMenuItem } from '@acorex-platform/framework-shared/core';
+import * as _acorex_platform_module_data_management_client_contracts from '@acorex-platform/module-data-management-client/contracts';
+import { AXPQueryBuilderData, AXPQueryOutputType, AXPQuerySortRule, AXPAggregateOperation, AXPQueryExecutionResult, AXMMetaDataBuilderValue, AXMMetaDataDefinitionEntityModel } from '@acorex-platform/module-data-management-client/contracts';
+export { AXPAggregateOperation, AXPQueryBuilderData, AXPQuerySortRule } from '@acorex-platform/module-data-management-client/contracts';
+import * as _acorex_platform_module_data_management_client from '@acorex-platform/module-data-management-client';
+import { AXDropListDroppedEvent } from '@acorex/cdk/drag-drop';
+import { AXDataSourceOperator, AXDataSource, AXFilterLogic } from '@acorex/cdk/common';
+import { AXPCommand, AXPCommandExecuteResultPromise } from '@acorex-platform/framework-shared/runtime';
+import { AXPDynamicFormGroupDefinition, AXPDynamicFormMode, AXPDynamicFormDefinition, AXPLayoutRendererComponent, AXPLayoutBuilderService } from '@acorex-platform/framework-client/layout/builder';
+import { AXTranslationService } from '@acorex/core/translation';
+import { AXPEntityService, AXPEntityDefinitionRegistryService, AXPEntityActionPlugin } from '@acorex-platform/framework-client/layout/entity';
+import { AXPBuilderValue, AXPStandardSectionItemsBuilderConfig, ItemConfiguratorListItem } from '@acorex-platform/framework-client/layout/components';
+import { AXPTagProvider, AXPTag } from '@acorex-platform/framework-client/core';
+
+declare class AXMMetaDataFeatureModule {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXMMetaDataFeatureModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<AXMMetaDataFeatureModule, never, never, never>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<AXMMetaDataFeatureModule>;
+}
+
+declare class AXMTagsFeatureModule {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXMTagsFeatureModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<AXMTagsFeatureModule, never, never, never>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<AXMTagsFeatureModule>;
+}
+
+declare class AXMDataManagementModule {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXMDataManagementModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<AXMDataManagementModule, never, [typeof i1.AXPWidgetCoreModule, typeof AXMMetaDataFeatureModule, typeof AXMTagsFeatureModule], never>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<AXMDataManagementModule>;
+}
+
+declare class AXMMenuProvider implements AXPMenuProvider {
+    private entityService;
+    provide(context: AXPMenuProviderContext): Promise<void>;
+}
+
+declare const AXPQueryBuilderWidget: AXPWidgetConfig<AXPQueryBuilderWidgetConfigType>;
+type AXPQueryBuilderWidgetConfigType = {
+    type: 'editor';
+};
+
+/**
+ * Aggregate function category
+ * Logical category name coming from aggregate providers
+ * (e.g., 'statistical', 'string', 'date', 'custom', or any custom category)
+ */
+type AXPAggregateCategory = string;
+/**
+ * Database type support
+ * Logical database type name coming from providers
+ * (e.g., 'mysql', 'postgresql', 'mongodb', 'sql', 'nosql', or any custom type)
+ */
+type AXPDatabaseType = string;
+/**
+ * Aggregate function definition
+ * Defines an aggregate function with its properties and database support
+ */
+interface AXPAggregateFunctionDefinition {
+    /**
+     * Function name/identifier (e.g., 'sum', 'avg', 'count')
+     */
+    name: string;
+    /**
+     * Display title
+     */
+    title: string;
+    /**
+     * Description of what the function does
+     */
+    description?: string;
+    /**
+     * Category for grouping functions
+     */
+    category: AXPAggregateCategory;
+    /**
+     * Database types that support this function
+     * If 'all' is included, the function is universally supported
+     */
+    supportedDatabases: AXPDatabaseType[];
+    /**
+     * Whether this function requires a field parameter
+     * Some functions like COUNT(*) don't require a field
+     */
+    requiresField: boolean;
+    /**
+     * Whether this function supports DISTINCT modifier
+     */
+    supportsDistinct?: boolean;
+    /**
+     * Whether this function supports nested aggregates
+     * Functions like CONCAT can contain other aggregate functions as parameters
+     * Example: CONCAT(MIN(field1), MAX(field2))
+     */
+    supportsNested?: boolean;
+}
+/** Column / field metadata used by query-builder UIs. */
+interface AXPQueryBuilderDataFieldDefinition {
+    name: string;
+    title: string;
+    datatype: string;
+    type: string;
+    options?: AXPOptionsData;
+}
+/**
+ * Structural datasource schema passed into the query builder
+ * (columns + optional filters). Formerly DI-registry `AXPDataSourceDefinition`.
+ */
+interface AXPQueryBuilderDataSourceDefinition {
+    name?: string;
+    title?: string;
+    columns: AXPQueryBuilderDataFieldDefinition[];
+    filters?: AXPFilterDefinition[];
+    valueField?: {
+        name: string;
+        title: string;
+    };
+    textField?: {
+        name: string;
+        title: string;
+    };
+}
+
+declare class AXPQueryBuilderWidgetEditComponent extends AXPValueWidgetComponent<AXPQueryBuilderData> {
+    /**
+     * Default empty query data structure
+     */
+    protected readonly defaultQueryData: AXPQueryBuilderData;
+    /**
+     * Get datasource definition from options (passed from entity context)
+     * The entity passes the selected datasource definition via context
+     */
+    protected readonly dataSourceDefinition: _angular_core.Signal<AXPQueryBuilderDataSourceDefinition | undefined>;
+    /**
+     * Handle value change from query builder
+     */
+    onValueChange(data: AXPQueryBuilderData): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPQueryBuilderWidgetEditComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXPQueryBuilderWidgetEditComponent, "axp-query-builder-widget-edit", never, {}, {}, never, never, true, never>;
+}
+
+declare class AXPQueryBuilderWidgetViewComponent extends AXPValueWidgetComponent<AXPFilterClause> {
+    protected queryData: _angular_core.Signal<AXPFilterClause>;
+    getTotalItemsCount(): number;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPQueryBuilderWidgetViewComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXPQueryBuilderWidgetViewComponent, "axp-query-builder-widget-view", never, {}, {}, never, never, true, never>;
+}
+
+declare class AXPQueryBuilderWidgetColumnComponent extends AXPValueWidgetComponent<AXPFilterClause> {
+    protected queryData: _angular_core.Signal<AXPFilterClause>;
+    getTotalItemsCount(): number;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPQueryBuilderWidgetColumnComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXPQueryBuilderWidgetColumnComponent, "axp-query-builder-widget-column", never, {}, {}, never, never, true, never>;
+}
+
+declare class AXPQueryBuilderWidgetDesignerComponent extends AXPValueWidgetComponent<any> {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPQueryBuilderWidgetDesignerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXPQueryBuilderWidgetDesignerComponent, "axp-query-builder-widget-designer", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Full Query Builder Component
+ *
+ * Provides a complete query builder interface with:
+ * - Columns: Multi-select from datasource columns
+ * - Where: WHERE clause builder (groups + conditions)
+ * - Sort: Sort rules with field and direction
+ * - Group By: Multi-select from datasource columns
+ *
+ * Receives AXPQueryBuilderDataSourceDefinition as input and distributes data to child components.
+ */
+declare class AXPQueryBuilderComponent {
+    private readonly databaseTypeService;
+    /**
+     * Current query builder value
+     */
+    value: _angular_core.InputSignal<AXPQueryBuilderData>;
+    /**
+     * Datasource definition containing columns and filters
+     */
+    dataSourceDefinition: _angular_core.InputSignal<AXPQueryBuilderDataSourceDefinition | undefined>;
+    /**
+     * Emitted when query structure changes
+     */
+    valueChange: _angular_core.OutputEmitterRef<AXPQueryBuilderData>;
+    protected queryData: _angular_core.WritableSignal<AXPQueryBuilderData>;
+    protected activeTab: _angular_core.WritableSignal<number>;
+    protected isRawMode: _angular_core.WritableSignal<boolean>;
+    /**
+     * Extract columns from datasource definition
+     */
+    protected readonly columns: _angular_core.Signal<_acorex_platform_module_data_management_client.AXPQueryBuilderDataFieldDefinition[]>;
+    /**
+     * Extract filter definitions from datasource definition
+     */
+    protected readonly filterDefinitions: _angular_core.Signal<_acorex_platform_framework_shared_core.AXPFilterDefinition[]>;
+    /**
+     * Validation warnings/errors for query builder
+     */
+    protected readonly validationWarnings: _angular_core.Signal<string[]>;
+    constructor();
+    /**
+     * Update columns selection
+     */
+    protected onColumnsChange(selectedColumns: string[]): void;
+    /**
+     * Update WHERE clause
+     */
+    protected onWhereChange(where: AXPQueryBuilderData['where']): void;
+    /**
+     * Update sort rules
+     */
+    protected onSortChange(sort: AXPQueryBuilderData['sort']): void;
+    /**
+     * Update group by selection
+     */
+    protected onGroupByChange(selectedColumns: string[]): void;
+    /**
+     * Update aggregate operations
+     */
+    protected onAggregatesChange(aggregates: AXPQueryBuilderData['aggregates']): void;
+    /**
+     * Update raw query
+     */
+    protected onRawQueryChange(rawQuery: string): void;
+    /**
+     * Update query language
+     */
+    protected onQueryLanguageChange(language: string): Promise<void>;
+    /**
+     * Update output type
+     */
+    protected onOutputTypeChange(outputType: AXPQueryOutputType): void;
+    /**
+     * Generate SQL from structured query
+     */
+    protected generateSqlFromStructured(): Promise<void>;
+    private updateValue;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPQueryBuilderComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXPQueryBuilderComponent, "axp-query-builder", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "dataSourceDefinition": { "alias": "dataSourceDefinition"; "required": false; "isSignal": true; }; }, { "valueChange": "valueChange"; }, never, never, true, never>;
+}
+
+/**
+ * Selected field data emitted when condition changes
+ */
+type SelectedField = {
+    id: string;
+    field: string;
+    operator: AXDataSourceOperator['type'];
+    value: any;
+    /**
+     * When true, this condition should be filled by user as a parameter (isParametric).
+     */
+    isParametric: boolean;
+};
+
+/**
+ * Where Builder Component
+ *
+ * Handles WHERE clause building with groups (AND/OR) and conditions (field/operator/value).
+ * This component is used as a child component within the full QueryBuilderComponent.
+ *
+ * Layout Architecture:
+ *
+ * Grid-Based Group Layout:
+ * - Each group uses CSS Grid: `grid-template-columns: auto 1fr`
+ * - Left column: connector line with AND/OR selector (fixed width: 3.5rem)
+ * - Right column: conditions container (flexible width)
+ * - Both columns stretch to same height via `align-items: stretch`
+ *
+ * Single Connector Line Per Group:
+ * - ONE continuous vertical connector line per group (root and nested)
+ * - Line spans full height of the group using `top: 0; bottom: 0` positioning
+ * - Rendered using `border-left: 2px solid` for clean appearance
+ * - The AND/OR selector chip is absolutely positioned in the center of this line
+ * - Selector uses `left: 50%; top: 50%; transform: translate(-50%, -50%)` for perfect centering
+ * - All conditions in the group visually attach to this single line on the right side
+ * - Nested groups create their own connector line, indented appropriately
+ *
+ * Typography:
+ * - Uses standard platform font sizes (ax-sm for buttons/selects)
+ * - AND/OR chip: 0.8125rem (13px) font size for readability
+ * - Condition rows: standard padding and spacing matching form controls
+ * - No reduced font sizes - relies on spacing and subtle borders for visual lightness
+ *
+ * Empty Group State:
+ * - Compact empty state with just an "Add condition" button
+ * - No nested boxes or heavy borders
+ * - Minimal height, aligned with group padding
+ *
+ * Visual Design:
+ * - Subtle borders (1px) using platform border tokens
+ * - Soft colors with light surface elevation
+ * - Standard spacing throughout (gap-3, px-3, py-2.5)
+ * - Consistent styling for root and nested groups (except root has no border/background)
+ */
+declare class AXPWhereBuilderComponent {
+    private readonly widgetRegistry;
+    private readonly elementRef;
+    private readonly destroyRef;
+    private readonly platformId;
+    private readonly isBrowser;
+    /**
+     * Current query builder value (root group with conditions/groups)
+     */
+    value: _angular_core.InputSignal<AXPFilterDefinition>;
+    /**
+     * Available filter definitions from entity/context
+     * Each filterDefinition contains field metadata and widget configuration
+     */
+    filterDefinitions: _angular_core.InputSignal<AXPFilterDefinition[]>;
+    /**
+     * Emitted when query structure changes
+     * Parent components can consume this to build queries
+     */
+    valueChange: _angular_core.OutputEmitterRef<AXPFilterDefinition>;
+    protected queryData: _angular_core.WritableSignal<AXPFilterDefinition>;
+    protected readonly logicalOperatorsItems: {
+        value: string;
+        text: string;
+    }[];
+    protected readonly logicalOperators: AXDataSource<{
+        value: string;
+        text: string;
+    } | undefined>;
+    /**
+     * Computed filter definitions for field selector
+     * Maps filterDefinitions to a format suitable for select-box
+     */
+    protected readonly availableFilterDefinitions: _angular_core.Signal<{
+        value: string | undefined;
+        text: string;
+        definition: AXPFilterDefinition;
+    }[]>;
+    constructor();
+    private connectorLayoutRafId;
+    private connectorResizeObserver;
+    /**
+     * Initialize a ResizeObserver to keep connector line bounds synced with the DOM.
+     * This is browser-only and safely skipped during SSR.
+     */
+    private initConnectorAutoLayout;
+    private scheduleConnectorLayoutUpdate;
+    /**
+     * Sets CSS variables on each group element so the vertical connector line
+     * starts/ends exactly at the center of the first/last rendered row.
+     *
+     * This fixes cases where an item grows vertically (nested groups), which
+     * cannot be handled accurately by fixed CSS insets.
+     */
+    private updateConnectorCssVars;
+    private generateId;
+    private updateValue;
+    /**
+     * Normalize order property for all items in the query structure
+     * Ensures all items have order property and filters are sorted by order
+     */
+    private normalizeOrder;
+    /**
+     * Get sorted filters for a group (used in template)
+     * Ensures filters are sorted by order property
+     */
+    protected getSortedFilters(filters: AXPFilterClause[]): AXPFilterClause[];
+    private findGroupById;
+    /**
+     * Add a new condition (rule) to the root group
+     * All conditions must be inside a group, so this adds to the root group
+     */
+    addCondition(): void;
+    /**
+     * Add a new nested group to the root group
+     * All groups must be inside the root group
+     */
+    addGroup(): void;
+    /**
+     * Add a new condition to a specific group
+     */
+    addConditionToGroup(groupId: string): void;
+    /**
+     * Get filter definition by field ID
+     * Used to resolve widget type and metadata for a condition
+     */
+    getFilterDefinition(fieldId: string): AXPFilterDefinition | undefined;
+    /**
+     * Resolve default filter widget type for a field
+     * Uses widget registry to get the defaultFilterWidgetName from the field's widget config
+     */
+    resolveDefaultFilterWidget(fieldId: string): string;
+    /**
+     * Convert QueryBuilderData to AXPFilterClause format
+     *
+     * This method transforms the internal query builder structure to the platform's filter clause format
+     * that can be consumed by data sources and query services.
+     *
+     * Conversion Logic:
+     * - Conditions (rules) are converted to AXDataSourceFilterOption with field, operator, and value
+     * - Groups are converted to nested filter structures with logic (AND/OR) and filters array
+     * - Empty conditions (no field or value) are skipped
+     * - Single-item groups are flattened (no nested structure needed)
+     *
+     * @returns AXPFilterClause compatible with AXDataSourceFilterOption structure
+     *
+     * Example output:
+     * {
+     *   logic: 'and',
+     *   filters: [
+     *     { field: 'name', operator: { type: 'contains' }, value: 'John' },
+     *     {
+     *       logic: 'or',
+     *       filters: [
+     *         { field: 'age', operator: { type: 'gt' }, value: 18 },
+     *         { field: 'status', operator: { type: 'equal' }, value: 'active' }
+     *       ]
+     *     }
+     *   ]
+     * }
+     */
+    toFilterClause(): AXPFilterClause;
+    addGroupToGroup(parentGroupId: string): void;
+    removeItem(id: string): void;
+    updateCondition(condition: SelectedField): void;
+    updateRootLogicalOperator(operator: AXFilterLogic): void;
+    updateGroupLogicalOperator(groupId: string, operator: AXFilterLogic): void;
+    clearAll(): void;
+    getTotalItemsCount(): number;
+    reorderRootItems(event: AXDropListDroppedEvent): void;
+    reorderGroupItems(groupId: string, previousIndex: number, currentIndex: number): void;
+    reorderGroupItemsEvent(groupId: string, event: AXDropListDroppedEvent): void;
+    moveItemUp(index: number, parentId: string): void;
+    moveItemDown(index: number, parentId: string): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPWhereBuilderComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXPWhereBuilderComponent, "axp-where-builder", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "filterDefinitions": { "alias": "filterDefinitions"; "required": false; "isSignal": true; }; }, { "valueChange": "valueChange"; }, never, never, true, never>;
+}
+
+/**
+ * Columns Builder Component
+ *
+ * Handles column selection for query builder.
+ * Provides multi-select interface with select all/clear all functionality.
+ */
+declare class AXPColumnsBuilderComponent {
+    /**
+     * Available columns from datasource definition
+     */
+    columns: _angular_core.InputSignal<AXPQueryBuilderDataFieldDefinition[]>;
+    /**
+     * Selected column names
+     */
+    value: _angular_core.InputSignal<string[]>;
+    /**
+     * Emitted when selection changes
+     */
+    valueChange: _angular_core.OutputEmitterRef<string[]>;
+    /**
+     * Columns data source for multi-select
+     */
+    protected readonly columnsDataSource: _angular_core.Signal<AXDataSource<{
+        value: string;
+        text: string;
+        definition: AXPQueryBuilderDataFieldDefinition;
+    } | null>>;
+    /**
+     * Handle columns selection change
+     */
+    protected onColumnsChange(selectedColumns: string[]): void;
+    /**
+     * Select all columns
+     */
+    protected selectAll(): void;
+    /**
+     * Clear all columns
+     */
+    protected clearAll(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPColumnsBuilderComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXPColumnsBuilderComponent, "axp-columns-builder", never, { "columns": { "alias": "columns"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "valueChange": "valueChange"; }, never, never, true, never>;
+}
+
+/**
+ * Sort Builder Component
+ *
+ * Handles sort rules for query builder.
+ * Allows adding/removing sort rules with field and direction selection.
+ */
+declare class AXPSortBuilderComponent {
+    /**
+     * Available columns from datasource definition
+     */
+    columns: _angular_core.InputSignal<AXPQueryBuilderDataFieldDefinition[]>;
+    /**
+     * Current sort rules
+     */
+    value: _angular_core.InputSignal<AXPQuerySortRule[]>;
+    /**
+     * Emitted when sort rules change
+     */
+    valueChange: _angular_core.OutputEmitterRef<AXPQuerySortRule[]>;
+    /**
+     * Sort field data source (from columns)
+     */
+    protected readonly sortFieldDataSource: _angular_core.Signal<AXDataSource<{
+        value: string;
+        text: string;
+    } | null>>;
+    /**
+     * Sort direction options
+     */
+    protected readonly sortDirectionItems: {
+        value: string;
+        text: string;
+    }[];
+    protected readonly sortDirectionDataSource: AXDataSource<{
+        value: string;
+        text: string;
+    } | undefined>;
+    /**
+     * Add a new sort rule
+     */
+    protected addSortRule(): void;
+    /**
+     * Remove a sort rule
+     */
+    protected removeSortRule(index: number): void;
+    /**
+     * Update a sort rule field
+     */
+    protected updateSortRuleField(index: number, field: string): void;
+    /**
+     * Update a sort rule direction
+     */
+    protected updateSortRuleDirection(index: number, dir: string): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPSortBuilderComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXPSortBuilderComponent, "axp-sort-builder", never, { "columns": { "alias": "columns"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "valueChange": "valueChange"; }, never, never, true, never>;
+}
+
+/**
+ * Group By Builder Component
+ *
+ * Handles group by column selection for query builder.
+ * Provides multi-select interface with select all/clear all functionality.
+ */
+declare class AXPGroupByBuilderComponent {
+    /**
+     * Available columns from datasource definition
+     */
+    columns: _angular_core.InputSignal<AXPQueryBuilderDataFieldDefinition[]>;
+    /**
+     * Selected column names for group by
+     */
+    value: _angular_core.InputSignal<string[]>;
+    /**
+     * Emitted when selection changes
+     */
+    valueChange: _angular_core.OutputEmitterRef<string[]>;
+    /**
+     * Group By columns data source (same as columns)
+     */
+    protected readonly groupByDataSource: _angular_core.Signal<AXDataSource<{
+        value: string;
+        text: string;
+        definition: AXPQueryBuilderDataFieldDefinition;
+    } | null>>;
+    /**
+     * Handle group by selection change
+     */
+    protected onGroupByChange(selectedColumns: string[]): void;
+    /**
+     * Select all columns
+     */
+    protected selectAll(): void;
+    /**
+     * Clear all columns
+     */
+    protected clearAll(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPGroupByBuilderComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXPGroupByBuilderComponent, "axp-group-by-builder", never, { "columns": { "alias": "columns"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "valueChange": "valueChange"; }, never, never, true, never>;
+}
+
+/**
+ * Aggregate Builder Component
+ *
+ * Handles aggregate function selection and configuration for query builder.
+ * Provides filtering by category and database type, and allows adding/removing aggregate operations.
+ */
+declare class AXPAggregateBuilderComponent {
+    private readonly aggregateFunctionService;
+    /**
+     * Available columns from datasource definition
+     */
+    columns: _angular_core.InputSignal<AXPQueryBuilderDataFieldDefinition[]>;
+    /**
+     * Current aggregate operations
+     */
+    value: _angular_core.InputSignal<AXPAggregateOperation[]>;
+    /**
+     * Database type for filtering functions (optional)
+     * If provided, only functions supported by this database will be shown
+     */
+    databaseType: _angular_core.InputSignal<string | undefined>;
+    /**
+     * Emitted when aggregate operations change
+     */
+    valueChange: _angular_core.OutputEmitterRef<AXPAggregateOperation[]>;
+    protected selectedCategory: _angular_core.WritableSignal<string>;
+    protected searchText: _angular_core.WritableSignal<string>;
+    protected showAddForm: _angular_core.WritableSignal<boolean>;
+    protected newAggregate: _angular_core.WritableSignal<Partial<AXPAggregateOperation>>;
+    protected availableFunctionsList: _angular_core.WritableSignal<AXPAggregateFunctionDefinition[]>;
+    protected availableCategoriesList: _angular_core.WritableSignal<string[]>;
+    protected editingNestedIndex: _angular_core.WritableSignal<{
+        parentIndex: number;
+        nestedIndex: number;
+    } | null>;
+    protected maxNestingDepth: _angular_core.WritableSignal<number>;
+    constructor();
+    /**
+     * Load max nesting depth from service
+     */
+    private loadMaxNestingDepth;
+    /**
+     * Available aggregate functions filtered by category, database, and search
+     */
+    protected readonly availableFunctions: _angular_core.Signal<AXPAggregateFunctionDefinition[]>;
+    /**
+     * Available categories
+     */
+    protected readonly categories: _angular_core.Signal<{
+        value: string;
+        text: string;
+    }[]>;
+    /**
+     * Categories data source for filter dropdown
+     */
+    protected readonly categoriesDataSource: _angular_core.Signal<AXDataSource<{
+        value: string;
+        text: string;
+    } | null>>;
+    /**
+     * Columns data source for field selection
+     */
+    protected readonly columnsDataSource: _angular_core.Signal<AXDataSource<{
+        value: string;
+        text: string;
+    } | null>>;
+    /**
+     * Functions data source for function selection
+     */
+    protected readonly functionsDataSource: _angular_core.Signal<AXDataSource<{
+        value: string;
+        text: string;
+        definition: AXPAggregateFunctionDefinition;
+    } | null>>;
+    /**
+     * Add a new aggregate operation
+     */
+    protected addAggregate(): void;
+    /**
+     * Remove an aggregate operation
+     */
+    protected removeAggregate(index: number): void;
+    /**
+     * Update an aggregate operation
+     */
+    protected updateAggregate(index: number, updates: Partial<AXPAggregateOperation>): void;
+    /**
+     * Load functions from service
+     */
+    private loadFunctions;
+    /**
+     * Load categories from service
+     */
+    private loadCategories;
+    /**
+     * Get function definition for display (synchronous, uses cache)
+     */
+    protected getFunctionDefinition(functionName: string): AXPAggregateFunctionDefinition | undefined;
+    /**
+     * Check if function requires field
+     * Note: Functions that support nested aggregates don't require a field (they can use nestedAggregates instead)
+     */
+    protected functionRequiresField(functionName: string): boolean;
+    /**
+     * Check if function supports distinct
+     */
+    protected functionSupportsDistinct(functionName: string): boolean;
+    /**
+     * Get category title for display
+     */
+    protected getCategoryTitle(category: AXPAggregateCategory | 'all'): string;
+    /**
+     * Toggle add form visibility
+     */
+    protected toggleAddForm(): void;
+    /**
+     * Reset new aggregate form
+     */
+    protected resetNewAggregate(): void;
+    /**
+     * Handle function selection change
+     */
+    protected onFunctionChange(functionName: string): void;
+    /**
+     * Handle field selection change
+     */
+    protected onFieldChange(field: string): void;
+    /**
+     * Handle alias change
+     */
+    protected onAliasChange(alias: string): void;
+    /**
+     * Handle distinct change
+     */
+    protected onDistinctChange(distinct: boolean): void;
+    /**
+     * Check if function supports nested aggregates
+     */
+    protected functionSupportsNested(functionName: string): boolean;
+    /**
+     * Check if can add more nested aggregates (based on depth)
+     */
+    protected canAddNestedAggregate(parentIndex: number, currentDepth?: number): boolean;
+    /**
+     * Get current nesting depth for an aggregate operation
+     */
+    protected getNestingDepth(agg: AXPAggregateOperation, currentDepth?: number): number;
+    /**
+     * Add nested aggregate to an existing aggregate operation
+     */
+    protected addNestedAggregate(parentIndex: number): void;
+    /**
+     * Remove nested aggregate from an aggregate operation
+     */
+    protected removeNestedAggregate(parentIndex: number, nestedIndex: number): void;
+    /**
+     * Update nested aggregate
+     */
+    protected updateNestedAggregate(parentIndex: number, nestedIndex: number, updates: Partial<AXPAggregateOperation>): void;
+    /**
+     * Add nested aggregate to new aggregate form
+     */
+    protected addNestedToNewAggregate(): void;
+    /**
+     * Remove nested aggregate from new aggregate form
+     */
+    protected removeNestedFromNewAggregate(nestedIndex: number): void;
+    /**
+     * Update nested aggregate in new aggregate form
+     */
+    protected updateNestedInNewAggregate(nestedIndex: number, updates: Partial<AXPAggregateOperation>): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPAggregateBuilderComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXPAggregateBuilderComponent, "axp-aggregate-builder", never, { "columns": { "alias": "columns"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "databaseType": { "alias": "databaseType"; "required": false; "isSignal": true; }; }, { "valueChange": "valueChange"; }, never, never, true, never>;
+}
+
+/**
+ * Standard Aggregate Functions Registry
+ *
+ * Provides a comprehensive list of aggregate functions with their properties,
+ * categories, and database support information.
+ *
+ * Based on SQL standard (ISO/IEC 9075) and common NoSQL implementations.
+ */
+declare class AXPAggregateFunctionsRegistry {
+    private static readonly functions;
+    /**
+     * Get all aggregate functions
+     */
+    static getAll(): AXPAggregateFunctionDefinition[];
+    /**
+     * Get functions by category
+     */
+    static getByCategory(category: AXPAggregateCategory): AXPAggregateFunctionDefinition[];
+    /**
+     * Get functions by database support
+     */
+    static getByDatabase(database: AXPDatabaseType): AXPAggregateFunctionDefinition[];
+    /**
+     * Get functions filtered by category and/or database
+     */
+    static getFiltered(options: {
+        category?: AXPAggregateCategory;
+        database?: AXPDatabaseType;
+        search?: string;
+    }): AXPAggregateFunctionDefinition[];
+    /**
+     * Get function by name
+     */
+    static getByName(name: string): AXPAggregateFunctionDefinition | undefined;
+    /**
+     * Get all categories
+     */
+    static getCategories(): AXPAggregateCategory[];
+}
+
+/**
+ * Aggregate Function Provider Token
+ * Can be a provider instance or a Promise that resolves to a provider
+ */
+type AXPAggregateFunctionProviderToken = AXPAggregateFunctionProvider | Promise<AXPAggregateFunctionProvider>;
+/**
+ * Injection token for aggregate function providers
+ * Multiple providers can be registered to extend aggregate function definitions
+ */
+declare const AXP_AGGREGATE_FUNCTION_PROVIDER: InjectionToken<AXPAggregateFunctionProviderToken[]>;
+/**
+ * Aggregate Function Provider Interface
+ *
+ * Allows modules to provide custom aggregate functions that extend
+ * the default set of aggregate functions available in the query builder.
+ *
+ * Example usage:
+ * ```typescript
+ * @Injectable()
+ * export class MyCustomAggregateProvider implements AXPAggregateFunctionProvider {
+ *   async getFunctions(databaseType?: AXPDatabaseType): Promise<AXPAggregateFunctionDefinition[]> {
+ *     return [
+ *       {
+ *         name: 'custom_avg',
+ *         title: 'CUSTOM_AVG',
+ *         description: 'Custom average function',
+ *         category: 'statistical',
+ *         supportedDatabases: ['mysql'],
+ *         requiresField: true,
+ *         supportsDistinct: true,
+ *       }
+ *     ];
+ *   }
+ * }
+ * ```
+ */
+interface AXPAggregateFunctionProvider {
+    /**
+     * Get list of aggregate functions
+     *
+     * @param databaseType - Optional database type filter. If provided, only functions
+     *                       supported by this database type should be returned.
+     *                       If undefined, return all functions.
+     * @returns Promise that resolves to array of aggregate function definitions
+     */
+    getFunctions(databaseType?: AXPDatabaseType): Promise<AXPAggregateFunctionDefinition[]>;
+    /**
+     * Get a single aggregate function by name
+     *
+     * @param name - Function name/identifier (e.g., 'sum', 'avg', 'count')
+     * @returns Promise that resolves to function definition or undefined if not found
+     */
+    getByName(name: string): Promise<AXPAggregateFunctionDefinition | undefined>;
+    /**
+     * Get all unique categories available from this provider
+     *
+     * @returns Promise that resolves to array of category names
+     */
+    getCategories(): Promise<AXPAggregateCategory[]>;
+    /**
+     * Get maximum nesting depth for nested aggregates
+     *
+     * @returns Maximum allowed nesting depth (default: 3)
+     */
+    getMaxNestingDepth(): number;
+}
+
+/**
+ * Aggregate Function Service
+ *
+ * Aggregates functions from all registered providers and provides a unified API
+ * for accessing aggregate function definitions.
+ *
+ * Performance optimizations:
+ * 1. Aggressive caching prevents duplicate API calls
+ * 2. Single pending request per resource prevents race conditions
+ * 3. Lazy loading - only loads data when needed
+ * 4. Merges results from all providers
+ */
+declare class AXPAggregateFunctionService {
+    private readonly providers;
+    private readonly categoryProviders;
+    /** Cache for all functions by database type - O(1) lookup */
+    private functionsByDatabaseType;
+    /** Cache for functions by name - O(1) lookup */
+    private functionsByName;
+    /** Cache for categories */
+    private categoriesCache;
+    /** Pending API requests to prevent duplicate calls */
+    private pendingFunctionsRequests;
+    private pendingFunctionRequests;
+    private pendingCategoriesRequest;
+    /**
+     * Get all aggregate functions with optional database type filter
+     *
+     * Optimization: Returns cached result immediately if available,
+     * preventing unnecessary API calls
+     *
+     * @param databaseType - Optional database type filter
+     * @returns Array of aggregate function definitions
+     */
+    getFunctions(databaseType?: AXPDatabaseType): Promise<AXPAggregateFunctionDefinition[]>;
+    /**
+     * Get single function by name with O(1) lookup
+     *
+     * Optimization: Uses Map for instant retrieval, falls back to
+     * searching cache, then providers if not found
+     */
+    getByName(name: string): Promise<AXPAggregateFunctionDefinition | undefined>;
+    /**
+     * Get all unique categories from all providers
+     *
+     * @returns Array of category names
+     */
+    getCategories(): Promise<AXPAggregateCategory[]>;
+    /**
+     * Get maximum nesting depth for nested aggregates
+     * Returns the minimum depth from all providers (most restrictive)
+     *
+     * @returns Maximum allowed nesting depth
+     */
+    getMaxNestingDepth(): number;
+    /**
+     * Load functions from all providers and merge results
+     *
+     * Optimization: Merges results from all providers, removes duplicates by name
+     */
+    private loadFunctionsFromProviders;
+    /**
+     * Load single function from providers
+     */
+    private loadFunctionFromProviders;
+    /**
+     * Load categories from all providers and merge unique values
+     */
+    private loadCategoriesFromProviders;
+    /**
+     * Clear all caches
+     */
+    clearAllCache(): void;
+    /**
+     * Clear functions cache only
+     */
+    clearFunctionsCache(): void;
+    /**
+     * Clear categories cache only
+     */
+    clearCategoriesCache(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPAggregateFunctionService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AXPAggregateFunctionService>;
+}
+
+/**
+ * Default Aggregate Function Provider
+ *
+ * Provides the standard set of aggregate functions defined in the registry.
+ * This is the default provider that includes all built-in aggregate functions
+ * (SUM, AVG, COUNT, MIN, MAX, CONCAT, etc.).
+ *
+ * This provider is automatically registered and provides the base set of
+ * aggregate functions. Additional providers can be registered to extend
+ * this functionality.
+ */
+declare class AXMDefaultAggregateFunctionProvider implements AXPAggregateFunctionProvider {
+    /**
+     * Get list of aggregate functions
+     *
+     * @param databaseType - Optional database type filter
+     * @returns Promise that resolves to array of aggregate function definitions
+     */
+    getFunctions(databaseType?: AXPDatabaseType): Promise<AXPAggregateFunctionDefinition[]>;
+    /**
+     * Get a single aggregate function by name
+     *
+     * @param name - Function name/identifier
+     * @returns Promise that resolves to function definition or undefined
+     */
+    getByName(name: string): Promise<AXPAggregateFunctionDefinition | undefined>;
+    /**
+     * Get all unique categories available
+     *
+     * @returns Promise that resolves to array of category names
+     */
+    getCategories(): Promise<AXPAggregateCategory[]>;
+    getMaxNestingDepth(): number;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXMDefaultAggregateFunctionProvider, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AXMDefaultAggregateFunctionProvider>;
+}
+/**
+ * Default Aggregate Function Provider Registration
+ *
+ * This constant can be used in module providers to register the default provider:
+ *
+ * ```typescript
+ * @NgModule({
+ *   providers: [
+ *     AXP_DEFAULT_AGGREGATE_FUNCTION_PROVIDER,
+ *   ],
+ * })
+ * ```
+ */
+declare const AXP_DEFAULT_AGGREGATE_FUNCTION_PROVIDER: {
+    provide: _angular_core.InjectionToken<_acorex_platform_module_data_management_client.AXPAggregateFunctionProviderToken[]>;
+    useClass: typeof AXMDefaultAggregateFunctionProvider;
+    multi: boolean;
+};
+
+/**
+ * Raw Query Builder Component
+ *
+ * Provides a text area for writing raw SQL/queries with:
+ * - Query language selector (MySQL, PostgreSQL, MongoDB, etc.)
+ * - Syntax validation with error highlighting
+ * - Two-way sync with structured query builder
+ */
+declare class AXPRawQueryBuilderComponent {
+    private readonly databaseTypeService;
+    /**
+     * Current raw query string
+     */
+    value: _angular_core.InputSignal<string>;
+    /**
+     * Current query language (database type name)
+     */
+    queryLanguage: _angular_core.InputSignal<string>;
+    /**
+     * Emitted when raw query changes
+     */
+    valueChange: _angular_core.OutputEmitterRef<string>;
+    /**
+     * Emitted when query language changes
+     */
+    queryLanguageChange: _angular_core.OutputEmitterRef<string>;
+    protected rawQuery: _angular_core.WritableSignal<string>;
+    protected selectedLanguage: _angular_core.WritableSignal<string>;
+    protected validationError: _angular_core.WritableSignal<string | null>;
+    protected isValid: _angular_core.Signal<boolean>;
+    protected databaseTypes: _angular_core.WritableSignal<{
+        value: string;
+        text: string;
+    }[]>;
+    /**
+     * Available query languages (loaded from database type service)
+     */
+    protected queryLanguageDataSource: _angular_core.WritableSignal<AXDataSource<{
+        value: string;
+        text: string;
+    } | null>>;
+    constructor();
+    /**
+     * Handle raw query text change
+     */
+    protected onQueryChange(query: string): void;
+    /**
+     * Load database types from service
+     */
+    private loadDatabaseTypes;
+    /**
+     * Handle query language change
+     */
+    protected onLanguageChange(language: string): void;
+    /**
+     * Validate SQL query syntax using database type service
+     */
+    protected validateQuery(query: string): Promise<void>;
+    /**
+     * Format/beautify the query
+     */
+    protected formatQuery(): void;
+    /**
+     * Clear the query
+     */
+    protected clearQuery(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPRawQueryBuilderComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXPRawQueryBuilderComponent, "axp-raw-query-builder", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "queryLanguage": { "alias": "queryLanguage"; "required": false; "isSignal": true; }; }, { "valueChange": "valueChange"; "queryLanguageChange": "queryLanguageChange"; }, never, never, true, never>;
+}
+
+/**
+ * Database Type Definition
+ * Defines a database type with its properties and capabilities
+ */
+interface AXPDatabaseTypeDefinition {
+    /**
+     * Unique identifier for the database type (e.g., 'mysql', 'postgresql', 'mongodb')
+     */
+    name: string;
+    /**
+     * Display title (e.g., 'MySQL', 'PostgreSQL', 'MongoDB')
+     */
+    title: string;
+    /**
+     * Description of the database type
+     */
+    description: string;
+    /**
+     * SQL identifier escape character (e.g., '`' for MySQL, '"' for PostgreSQL)
+     */
+    identifierQuote: string;
+    /**
+     * Whether this database supports SQL syntax
+     */
+    supportsSql: boolean;
+    /**
+     * Whether this database is NoSQL
+     */
+    isNoSql: boolean;
+}
+/**
+ * Database Type Provider Token
+ */
+type AXPDatabaseTypeProviderToken = AXPDatabaseTypeProvider | Promise<AXPDatabaseTypeProvider>;
+/**
+ * Injection token for database type providers
+ */
+declare const AXP_DATABASE_TYPE_PROVIDER: InjectionToken<AXPDatabaseTypeProviderToken[]>;
+/**
+ * Database Type Provider Interface
+ *
+ * Allows modules to provide custom database types and their conversion/validation logic.
+ */
+interface AXPDatabaseTypeProvider {
+    /**
+     * Get list of all database types
+     */
+    getTypes(): Promise<AXPDatabaseTypeDefinition[]>;
+    /**
+     * Get a single database type by name
+     */
+    getByName(name: string): Promise<AXPDatabaseTypeDefinition | undefined>;
+    /**
+     * Escape SQL identifier for the given database type
+     */
+    escapeIdentifier(identifier: string, databaseType: string): string;
+    /**
+     * Escape SQL value for the given database type
+     */
+    escapeValue(value: unknown, databaseType: string): string;
+    /**
+     * Convert operator type to SQL operator for the given database type
+     */
+    convertOperatorToSql(operatorType: string, databaseType: string): string;
+    /**
+     * Validate SQL query syntax for the given database type
+     */
+    validateQuery(sql: string, databaseType: string): {
+        valid: boolean;
+        error?: string;
+    };
+    /**
+     * Convert QueryBuilderData model to query string (SQL or JSON for NoSQL)
+     *
+     * @param queryData - The structured query builder data model
+     * @param databaseType - Target database type
+     * @returns Promise that resolves to query string (SQL for SQL databases, JSON string for MongoDB)
+     */
+    toQuery(queryData: AXPQueryBuilderData, databaseType: string): Promise<string>;
+    /**
+     * Parse query string (SQL or JSON) back to QueryBuilderData model
+     *
+     * @param query - The query string (SQL or JSON)
+     * @param databaseType - Source database type
+     * @returns Promise that resolves to partial QueryBuilderData model
+     */
+    fromQuery(query: string, databaseType: string): Promise<Partial<AXPQueryBuilderData>>;
+}
+
+/**
+ * Database Type Service
+ *
+ * Aggregates database types from all registered providers and provides a unified API
+ * for accessing database type definitions and conversion/validation logic.
+ */
+declare class AXPDatabaseTypeService {
+    private readonly providers;
+    /** Cache for all database types */
+    private typesCache;
+    /** Cache for types by name */
+    private typesByName;
+    /** Pending requests */
+    private pendingTypesRequest;
+    private pendingTypeRequests;
+    /**
+     * Get all database types
+     */
+    getTypes(): Promise<AXPDatabaseTypeDefinition[]>;
+    /**
+     * Get single database type by name
+     */
+    getByName(name: string): Promise<AXPDatabaseTypeDefinition | undefined>;
+    /**
+     * Escape SQL identifier for the given database type
+     */
+    escapeIdentifier(identifier: string, databaseType: string): Promise<string>;
+    /**
+     * Escape SQL value for the given database type
+     */
+    escapeValue(value: unknown, databaseType: string): Promise<string>;
+    /**
+     * Convert operator type to SQL operator
+     */
+    convertOperatorToSql(operatorType: string, databaseType: string): Promise<string>;
+    /**
+     * Validate SQL query syntax
+     */
+    validateQuery(sql: string, databaseType: string): Promise<{
+        valid: boolean;
+        error?: string;
+    }>;
+    /**
+     * Convert QueryBuilderData model to query string (SQL or JSON for NoSQL)
+     *
+     * @param queryData - The structured query builder data model
+     * @param databaseType - Target database type
+     * @returns Promise that resolves to query string
+     */
+    toQuery(queryData: AXPQueryBuilderData, databaseType: string): Promise<string>;
+    /**
+     * Parse query string (SQL or JSON) back to QueryBuilderData model
+     *
+     * @param query - The query string (SQL or JSON)
+     * @param databaseType - Source database type
+     * @returns Promise that resolves to partial QueryBuilderData model
+     */
+    fromQuery(query: string, databaseType: string): Promise<Partial<AXPQueryBuilderData>>;
+    private loadTypesFromProviders;
+    private loadTypeFromProviders;
+    clearCache(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPDatabaseTypeService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AXPDatabaseTypeService>;
+}
+
+/**
+ * Default Database Type Provider
+ *
+ * Provides standard database types (MySQL, PostgreSQL, SQL Server, MongoDB) with
+ * their conversion and validation logic.
+ */
+declare class AXMDefaultDatabaseTypeProvider implements AXPDatabaseTypeProvider {
+    private readonly types;
+    getTypes(): Promise<AXPDatabaseTypeDefinition[]>;
+    getByName(name: string): Promise<AXPDatabaseTypeDefinition | undefined>;
+    escapeIdentifier(identifier: string, databaseType: string): string;
+    escapeValue(value: unknown, databaseType: string): string;
+    convertOperatorToSql(operatorType: string, databaseType: string): string;
+    validateQuery(sql: string, databaseType: string): {
+        valid: boolean;
+        error?: string;
+    };
+    toQuery(queryData: AXPQueryBuilderData, databaseType: string): Promise<string>;
+    fromQuery(query: string, databaseType: string): Promise<Partial<AXPQueryBuilderData>>;
+    /**
+     * Convert QueryBuilderData to SQL query string
+     */
+    private toSql;
+    /**
+     * Convert WHERE clause (AXPFilterDefinition) to SQL WHERE clause
+     */
+    private convertWhereToSql;
+    /**
+     * Convert a single filter item (condition or group) to SQL condition
+     */
+    private convertFilterItemToSql;
+    /**
+     * Convert aggregate operation to SQL expression
+     */
+    private convertAggregateToSql;
+    /**
+     * Parse SQL query back to QueryBuilderData (basic implementation)
+     */
+    private fromSql;
+    /**
+     * Convert QueryBuilderData to MongoDB aggregation pipeline
+     */
+    private toMongoDb;
+    /**
+     * Convert WHERE clause to MongoDB $match expression
+     */
+    private convertWhereToMongoDb;
+    /**
+     * Parse MongoDB aggregation pipeline back to QueryBuilderData
+     */
+    private fromMongoDb;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXMDefaultDatabaseTypeProvider, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AXMDefaultDatabaseTypeProvider>;
+}
+/**
+ * Default Database Type Provider Registration
+ */
+declare const AXP_DEFAULT_DATABASE_TYPE_PROVIDER: {
+    provide: _angular_core.InjectionToken<_acorex_platform_module_data_management_client.AXPDatabaseTypeProviderToken[]>;
+    useClass: typeof AXMDefaultDatabaseTypeProvider;
+    multi: boolean;
+};
+
+/**
+ * Executes saved query-builder definitions by query entity id.
+ * Implementations resolve query metadata and run the configured data source pipeline.
+ */
+declare abstract class AXMQueryService {
+    /**
+     * Executes a saved query by its entity id.
+     */
+    abstract execute(id: string): Promise<AXPQueryExecutionResult>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXMQueryService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AXMQueryService>;
+}
+
+/**
+ * Aggregate category definition.
+ * Used by providers to describe available aggregate categories.
+ */
+interface AXPAggregateCategoryDefinition {
+    /**
+     * Unique category name (e.g., 'statistical', 'string', 'date', or any custom value)
+     */
+    name: AXPAggregateCategory;
+    /**
+     * Display title for UI
+     */
+    title: string;
+    /**
+     * Optional description for tooltips or help text
+     */
+    description?: string;
+    /**
+     * Optional order index for sorting in UI
+     */
+    order?: number;
+}
+/**
+ * Aggregate Category Provider Token
+ * Can be a provider instance or a Promise that resolves to a provider.
+ */
+type AXPAggregateCategoryProviderToken = AXPAggregateCategoryProvider | Promise<AXPAggregateCategoryProvider>;
+/**
+ * Injection token for aggregate category providers.
+ * Multiple providers can be registered to extend category definitions.
+ */
+declare const AXP_AGGREGATE_CATEGORY_PROVIDER: InjectionToken<AXPAggregateCategoryProviderToken[]>;
+/**
+ * Aggregate Category Provider Interface
+ *
+ * Allows modules to provide custom aggregate categories that are used
+ * by the query builder UI for filtering aggregate functions.
+ */
+interface AXPAggregateCategoryProvider {
+    /**
+     * Get list of aggregate categories.
+     */
+    getList(): Promise<AXPAggregateCategoryDefinition[]>;
+    /**
+     * Get a single category by name.
+     */
+    getByName(name: AXPAggregateCategory): Promise<AXPAggregateCategoryDefinition | undefined>;
+}
+
+/**
+ * Default Aggregate Category Provider
+ *
+ * Provides the standard set of aggregate categories used by the built‑in
+ * aggregate functions. Other modules can extend or override these categories
+ * by registering additional providers for `AXP_AGGREGATE_CATEGORY_PROVIDER`.
+ */
+declare class AXMDefaultAggregateCategoryProvider implements AXPAggregateCategoryProvider {
+    private readonly categories;
+    getList(): Promise<AXPAggregateCategoryDefinition[]>;
+    getByName(name: AXPAggregateCategory): Promise<AXPAggregateCategoryDefinition | undefined>;
+    private getTitle;
+    private getDescription;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXMDefaultAggregateCategoryProvider, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AXMDefaultAggregateCategoryProvider>;
+}
+declare const AXP_DEFAULT_AGGREGATE_CATEGORY_PROVIDER: {
+    provide: _angular_core.InjectionToken<_acorex_platform_module_data_management_client.AXPAggregateCategoryProviderToken[]>;
+    useClass: typeof AXMDefaultAggregateCategoryProvider;
+    multi: boolean;
+};
+
+/**
+ * Input for ExecuteQuery command.
+ */
+interface ExecuteQueryCommandInput {
+    /**
+     * Query ID to execute.
+     */
+    queryId: string;
+    /**
+     * Query name (for display).
+     */
+    queryName?: string;
+    /**
+     * Query title (for display).
+     */
+    queryTitle?: string;
+}
+/**
+ * Command that executes a query and displays the result in a dialog.
+ */
+declare class ExecuteQueryCommand implements AXPCommand<ExecuteQueryCommandInput, void> {
+    private readonly queryService;
+    private readonly layoutBuilder;
+    private readonly toastService;
+    private readonly translationService;
+    execute(input: ExecuteQueryCommandInput): AXPCommandExecuteResultPromise<void>;
+    /**
+     * Formats query result for display.
+     */
+    private formatResult;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ExecuteQueryCommand, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<ExecuteQueryCommand>;
+}
+
+declare const META_DATA_SELECTOR_FIELD = "metaDataList";
+declare const META_DATA_FORM_FIELD = "metaDataForm";
+
+declare const AXPMetaDataFormWidget: AXPWidgetConfig<AXPMetaDataFormWidgetConfigType>;
+type AXPMetaDataFormWidgetConfigType = {
+    type: 'editor';
+    metadataDefinitions: any[];
+    layoutLook?: 'normal' | 'compact' | 'borderless';
+    layoutDirection?: 'vertical' | 'horizontal' | 'grid';
+    groupByCategory?: boolean;
+    showCategoryHeaders?: boolean;
+};
+
+declare class AXPMetaDataFormWidgetEditComponent extends AXPValueWidgetComponent implements OnInit {
+    #private;
+    /**
+     * Groups structure from meta-data-selector or evaluated expression
+     */
+    groups: _angular_core.Signal<AXPDynamicFormGroupDefinition[]>;
+    /** Inherits parent widget render mode (`view` on Entity:View / single forms). */
+    protected get layoutRenderMode(): AXPDynamicFormMode;
+    /**
+     * Check if there are any valid metadata definitions available
+     */
+    hasDefinitions: _angular_core.Signal<boolean>;
+    /**
+     * Emitted when form context changes
+     */
+    contextChange: _angular_core.OutputEmitterRef<any>;
+    /**
+     * Emitted when form validity changes
+     */
+    validityChange: _angular_core.OutputEmitterRef<boolean>;
+    private layoutRenderer;
+    /**
+     * Form definition signal that only updates when structure actually changes
+     */
+    protected formDefinition: _angular_core.WritableSignal<AXPDynamicFormDefinition>;
+    ngOnInit(): void;
+    /**
+     * Handle context change from dynamic form
+     */
+    protected onContextChange(context: any): void;
+    /**
+     * Handle validity change from dynamic form
+     */
+    protected onValidityChange(isValid: boolean): void;
+    private resolveLayoutRenderMode;
+    /**
+     * Initialize form definition based on current inputs
+     */
+    private initializeFormDefinition;
+    /**
+     * Convert groups structure from meta-data-selector to form definition
+     * Each metadata group becomes a separate form group with visual separation (card look)
+     */
+    private convertGroupsToFormDefinition;
+    /**
+     * Ensures nested dynamic fields use view components when the parent form is read-only.
+     */
+    private applyRenderModeToFieldDefinition;
+    /**
+     * Convert single metadata definition to field definition
+     */
+    private convertMetadataToFieldDefinition;
+    /**
+     * Parse interface configuration from metadata
+     */
+    private parseInterfaceConfig;
+    /**
+     * Parse validations from interface configuration
+     */
+    private parseValidations;
+    /**
+     * Sanitize group name for use as identifier
+     */
+    private sanitizeGroupName;
+    /**
+     * Get the layout renderer component instance
+     */
+    getLayoutRenderer(): AXPLayoutRendererComponent | undefined;
+    /**
+     * Validate the form
+     */
+    validate(): Promise<boolean>;
+    /**
+     * Get current form context
+     */
+    getContext(): any;
+    /**
+     * Update form context programmatically
+     */
+    updateContext(context: any): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPMetaDataFormWidgetEditComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXPMetaDataFormWidgetEditComponent, "axp-meta-data-form-widget-edit", never, {}, { "contextChange": "contextChange"; "validityChange": "validityChange"; }, never, never, true, never>;
+}
+
+interface ShowMetaDataFormPopupInput {
+    entity: string;
+    id: string;
+    field?: string;
+    title?: string;
+    path: string;
+}
+/** Result of resolveGroups; dialogTitle is optional fallback when input.title is not set. */
+interface ResolveGroupsResult {
+    /** Expression string (evaluated at runtime) or groups array */
+    groups: string | AXPDynamicFormGroupDefinition[];
+    dialogTitle?: string;
+}
+declare class ShowMetaDataFormPopupCommand implements AXPCommand<ShowMetaDataFormPopupInput, any> {
+    protected readonly layoutBuilder: AXPLayoutBuilderService;
+    protected readonly translationService: AXTranslationService;
+    protected readonly entityService: AXPEntityService;
+    protected readonly entityRegistry: AXPEntityDefinitionRegistryService;
+    execute(input: ShowMetaDataFormPopupInput | any): AXPCommandExecuteResultPromise<any>;
+    /**
+     * Loads a record by entity and id. Override to use custom data sources or key handling.
+     * @param input - Optional; overrides can use input.data or other fields to return custom record.
+     */
+    protected findRecord(entity: string, id: string, input?: ShowMetaDataFormPopupInput): Promise<Record<string, unknown> | null>;
+    /**
+     * Resolves groups for the meta-data-form-editor.
+     * Override to load groups from custom APIs instead of entity metadata.
+     * @returns Expression string (evaluated at runtime) or groups array; dialogTitle is optional fallback.
+     */
+    protected resolveGroups(input: ShowMetaDataFormPopupInput, currentRecord: Record<string, unknown>): Promise<ResolveGroupsResult>;
+    /**
+     * Persists meta-data form changes. Override to use custom persistence or validation.
+     */
+    protected updateRecord(entity: string, id: string, data: Record<string, unknown>): Promise<Record<string, unknown>>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ShowMetaDataFormPopupCommand, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<ShowMetaDataFormPopupCommand>;
+}
+
+declare const AXPMetaDataBuilderWidget: AXPWidgetConfig<AXPMetaDataBuilderWidgetConfigType>;
+type AXPMetaDataBuilderWidgetConfigType = {
+    type: 'editor';
+};
+
+declare class AXPMetaDataBuilderWidgetEditComponent extends AXPValueWidgetComponent<AXMMetaDataBuilderValue> {
+    #private;
+    private readonly currentValue;
+    protected valueForGroups: _angular_core.Signal<AXMMetaDataBuilderValue>;
+    protected optionsForGroups: _angular_core.Signal<Record<string, any>>;
+    protected onValueChange(value: AXMMetaDataBuilderValue): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPMetaDataBuilderWidgetEditComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXPMetaDataBuilderWidgetEditComponent, "axp-meta-data-builder-widget-edit", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Meta-data builder: groups/fields editing via {@link AXPStandardSectionItemsBuilder}.
+ */
+declare class AXPMetaDataBuilderGroupsComponent {
+    #private;
+    private readonly entityService;
+    readonly value: _angular_core.InputSignal<AXMMetaDataBuilderValue | null | undefined>;
+    readonly options: _angular_core.InputSignal<Record<string, unknown>>;
+    readonly contextPath: _angular_core.InputSignal<string | undefined>;
+    readonly valueChange: _angular_core.OutputEmitterRef<AXMMetaDataBuilderValue>;
+    private readonly standardRef;
+    private readonly entityDataSelector;
+    private readonly metaDataService;
+    private readonly entityResolver;
+    private readonly dialogService;
+    private readonly translationService;
+    private readonly layoutBuilder;
+    private readonly widgetPropertyViewerService;
+    private readonly contextStore;
+    protected readonly builderValue: _angular_core.WritableSignal<AXPBuilderValue>;
+    protected readonly standardConfig: _angular_core.Signal<AXPStandardSectionItemsBuilderConfig>;
+    protected hideHeaderActions: _angular_core.Signal<boolean>;
+    protected readonly: _angular_core.Signal<boolean>;
+    protected previewGroups: _angular_core.Signal<{
+        name: string;
+        title: _acorex_platform_module_data_management_client_contracts.AXMMetaDataLocalizedString | undefined;
+        description: _acorex_platform_module_data_management_client_contracts.AXMMetaDataLocalizedString | undefined;
+        fields: {
+            name: string;
+            title: _acorex_platform_module_data_management_client_contracts.AXMMetaDataLocalizedString;
+            description: _acorex_platform_module_data_management_client_contracts.AXMMetaDataLocalizedString | undefined;
+            interface: string;
+            configuration: Record<string, any> | undefined;
+            defaultValue: any;
+        }[];
+    }[]>;
+    protected previewFormDefinition: _angular_core.Signal<AXPDynamicFormDefinition>;
+    protected isPreviewDisabled: _angular_core.Signal<boolean>;
+    private syncBuilderToHost;
+    protected onBuilderValueChange(next: AXPBuilderValue): void;
+    /** Page toolbar / header: open standardized add-section dialog. */
+    addSection(): Promise<void>;
+    private mapItemToView;
+    private parseInterfaceConfig;
+    private parseValidations;
+    private sanitizeGroupName;
+    private convertFieldToFormDefinition;
+    private getWidgetTitle;
+    private promptAddItems;
+    private promptEditItem;
+    private buildFieldOverrideProperties;
+    private collectItemNames;
+    private generateUniqueItemName;
+    handlePreviewClick(): Promise<void>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPMetaDataBuilderGroupsComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXPMetaDataBuilderGroupsComponent, "axp-meta-data-builder-groups", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "options": { "alias": "options"; "required": false; "isSignal": true; }; "contextPath": { "alias": "contextPath"; "required": false; "isSignal": true; }; }, { "valueChange": "valueChange"; }, never, never, true, never>;
+}
+
+/** Component key used when display is 'page'. Register via AXP_PAGE_COMPONENT_PROVIDER. */
+declare const META_DATA_BUILDER_PAGE_COMPONENT_KEY = "entity-meta-data-builder-page";
+/** Display configuration for section (builder shown inline in entity views) */
+type MetaDataBuilderSectionConfig = {
+    enabled?: boolean;
+    title?: string;
+    order?: number;
+};
+/** Display configuration for popup (action opens builder in dialog) */
+type MetaDataBuilderPopupConfig = {
+    enabled?: boolean;
+    title?: string;
+    order?: number;
+};
+/** Display configuration for page (builder shown as entity tab with toolbar actions) */
+type MetaDataBuilderPageConfig = {
+    enabled?: boolean;
+    title?: string;
+    icon?: string;
+    order?: number;
+};
+/** Flexible display configuration object for the meta-data-builder */
+type MetaDataBuilderDisplayConfig = {
+    section?: MetaDataBuilderSectionConfig;
+    popup?: MetaDataBuilderPopupConfig;
+    page?: MetaDataBuilderPageConfig;
+};
+/** Display option - where to show the meta-data-builder: section, popup, page, or both */
+type MetaDataBuilderDisplay = MetaDataBuilderDisplayConfig | 'section' | 'popup' | 'page' | 'both';
+type MetaDataBuilderPluginOptions = {
+    /** Field and group title */
+    title?: string;
+    /** How to display the meta-data-builder: section (inline), popup (button opens dialog), page (entity tab with toolbar actions), or both */
+    display?: MetaDataBuilderDisplay;
+    /** If true, each metadata group becomes a separate entity section (TODO) */
+    renderGroupsAsSections?: boolean;
+};
+/**
+ * meta-data-builder plugin
+ *
+ * Dynamic behavior:
+ * - Creates a single property for metadata builder configuration
+ * - Dynamically generates entity groups and meta-data-form widgets based on configured groups
+ * - Reads group configuration at runtime from the field value
+ */
+declare const metaDataBuilderPlugin: AXPEntityActionPlugin;
+
+/**
+ * Contract for loading and persisting the record that holds the meta-data builder field.
+ */
+declare abstract class AXMMetaDataBuilderRecordService {
+    abstract findRecord(entity: string, id: string): Promise<Record<string, unknown> | null>;
+    abstract updateRecord(entity: string, id: string, data: Record<string, unknown>): Promise<Record<string, unknown>>;
+}
+declare class AXMDefaultMetaDataBuilderRecordService extends AXMMetaDataBuilderRecordService {
+    private readonly entityService;
+    findRecord(entity: string, id: string): Promise<Record<string, unknown> | null>;
+    updateRecord(entity: string, id: string, data: Record<string, unknown>): Promise<Record<string, unknown>>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXMDefaultMetaDataBuilderRecordService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AXMDefaultMetaDataBuilderRecordService>;
+}
+
+declare function metaDataValueToBuilderValue(val: AXMMetaDataBuilderValue | null | undefined): AXPBuilderValue;
+declare function builderValueToMetaDataValue(v: AXPBuilderValue): AXMMetaDataBuilderValue;
+
+declare class AXPMetaDataBuilderWidgetViewComponent extends AXPValueWidgetComponent<unknown> {
+    get display(): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPMetaDataBuilderWidgetViewComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXPMetaDataBuilderWidgetViewComponent, "axp-meta-data-builder-widget-view", never, {}, {}, never, never, true, never>;
+}
+
+interface ShowMetaDataBuilderPopupInput {
+    entity: string;
+    id: string;
+    /** Selector field name (default: META_DATA_SELECTOR_FIELD) */
+    field?: string;
+    title?: string;
+}
+/**
+ * Opens the meta-data-builder (configuration UI for groups/fields) in a popup.
+ * Used when meta-data-builder plugin has display: 'popup' or 'both'.
+ */
+declare class ShowMetaDataBuilderPopupCommand implements AXPCommand<ShowMetaDataBuilderPopupInput, any> {
+    protected readonly layoutBuilder: AXPLayoutBuilderService;
+    protected readonly translationService: AXTranslationService;
+    protected readonly recordService: AXMMetaDataBuilderRecordService;
+    execute(input: ShowMetaDataBuilderPopupInput | any): AXPCommandExecuteResultPromise<any>;
+    /**
+     * Loads a record by entity and id. Delegates to {@link AXMMetaDataBuilderRecordService}.
+     * Override in a subclass to use custom logic instead of the injected service.
+     */
+    protected findRecord(entity: string, id: string): Promise<Record<string, unknown> | null>;
+    /**
+     * Persists meta-data changes. Delegates to {@link AXMMetaDataBuilderRecordService}.
+     * Override in a subclass to use custom logic instead of the injected service.
+     */
+    protected updateRecord(entity: string, id: string, data: Record<string, unknown>): Promise<Record<string, unknown>>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ShowMetaDataBuilderPopupCommand, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<ShowMetaDataBuilderPopupCommand>;
+}
+
+/**
+ * Metadata Evaluator Scope Provider
+ *
+ * Provides expression evaluation capabilities for metadata operations:
+ * - Get category IDs from context/expressions
+ * - Retrieve metadata by category IDs
+ * - Access category metadata inheritance
+ * - Filter metadata definitions by group name
+ */
+declare class AXMMetadataEvaluatorScopeProvider implements AXPExpressionEvaluatorScopeProvider {
+    private readonly queryService;
+    private readonly entityDefinitionRegistryService;
+    private readonly entityService;
+    provide(context: AXPExpressionEvaluatorScopeProviderContext): Promise<void>;
+    /**
+     * Merge interface overrides from meta-data-builder into fetched groups
+     * Matches fields by id or name and applies overridden interfaces
+     */
+    private mergeInterfaceOverrides;
+}
+
+/**
+ * Select a meta-data definition (entity record) and preview its interface widget, mirroring
+ * {@link AXPWidgetFieldConfiguratorComponent} but backed by {@link AXMMetaDataDefinitionService}.
+ */
+declare class AXMetaDataConfiguratorComponent {
+    private readonly entityService;
+    /** When set, uses this list instead of loading from {@link AXMMetaDataDefinitionService}. */
+    items: _angular_core.InputSignal<AXMMetaDataDefinitionEntityModel<string>[] | undefined>;
+    label: _angular_core.InputSignal<string>;
+    /** Selected meta-data definition id (entity id). */
+    definitionId: _angular_core.ModelSignal<string>;
+    /** Optional preview field name override; defaults to the selected definition's `name`. */
+    fieldName: _angular_core.InputSignal<string | undefined>;
+    /** Optional preview field title override; defaults to the selected definition's `title`. */
+    fieldTitle: _angular_core.InputSignal<AXPMultiLanguageString | undefined>;
+    readonly: _angular_core.InputSignal<boolean>;
+    private readonly metaDataDefinitionService;
+    private readonly translation;
+    private readonly widgetRegistry;
+    /** Recomputes list labels when the active locale changes. */
+    private readonly activeLocale;
+    private readonly loadedItems;
+    private readonly fetchOnce;
+    protected definitions: _angular_core.Signal<AXMMetaDataDefinitionEntityModel<string>[]>;
+    protected configuratorItems: _angular_core.Signal<ItemConfiguratorListItem[]>;
+    protected selectedDefinition: _angular_core.Signal<AXMMetaDataDefinitionEntityModel<string> | null>;
+    protected previewHeaderActions: _angular_core.Signal<AXPActionMenuItem[]>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXMetaDataConfiguratorComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXMetaDataConfiguratorComponent, "axm-meta-data-configurator", never, { "items": { "alias": "items"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "definitionId": { "alias": "definitionId"; "required": false; "isSignal": true; }; "fieldName": { "alias": "fieldName"; "required": false; "isSignal": true; }; "fieldTitle": { "alias": "fieldTitle"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; }, { "definitionId": "definitionIdChange"; }, never, never, true, never>;
+}
+
+/**
+ * Default system tag provider
+ * Provides readonly system-level tags
+ */
+declare class AXPSystemTagProvider extends AXPTagProvider {
+    name: string;
+    /**
+     * Provide default system tags
+     */
+    provide(): Promise<AXPTag[]>;
+}
+
+interface AXPTagPluginOptions {
+    propertyName?: string;
+    placeholder?: string;
+    hasClearButton?: boolean;
+    allowDuplicate?: boolean;
+    showInList?: boolean;
+    /** Persist each tag as a locale map; chip globe opens translate popup. Default true. */
+    multiLanguage?: boolean;
+}
+declare const tagsPlugin: AXPEntityActionPlugin;
+
+export { AXMDataManagementModule, AXMDefaultAggregateCategoryProvider, AXMDefaultAggregateFunctionProvider, AXMDefaultDatabaseTypeProvider, AXMDefaultMetaDataBuilderRecordService, AXMMenuProvider, AXMMetaDataBuilderRecordService, AXMMetaDataFeatureModule, AXMMetadataEvaluatorScopeProvider, AXMQueryService, AXMTagsFeatureModule, AXMetaDataConfiguratorComponent, AXPAggregateBuilderComponent, AXPAggregateFunctionService, AXPAggregateFunctionsRegistry, AXPColumnsBuilderComponent, 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, ShowMetaDataBuilderPopupCommand, ShowMetaDataFormPopupCommand, builderValueToMetaDataValue, metaDataBuilderPlugin, metaDataValueToBuilderValue, tagsPlugin };
+export type { AXPAggregateCategory, AXPAggregateCategoryDefinition, AXPAggregateCategoryProvider, AXPAggregateCategoryProviderToken, AXPAggregateFunctionDefinition, AXPAggregateFunctionProvider, AXPAggregateFunctionProviderToken, AXPDatabaseType, AXPDatabaseTypeDefinition, AXPDatabaseTypeProvider, AXPDatabaseTypeProviderToken, AXPMetaDataBuilderWidgetConfigType, AXPMetaDataFormWidgetConfigType, AXPQueryBuilderDataFieldDefinition, AXPQueryBuilderDataSourceDefinition, AXPQueryBuilderWidgetConfigType, AXPTagPluginOptions, ExecuteQueryCommandInput, MetaDataBuilderDisplay, MetaDataBuilderDisplayConfig, MetaDataBuilderPageConfig, MetaDataBuilderPluginOptions, MetaDataBuilderPopupConfig, MetaDataBuilderSectionConfig, ResolveGroupsResult, ShowMetaDataBuilderPopupInput, ShowMetaDataFormPopupInput };