import * as _angular_core from '@angular/core';
import { Injector, InjectionToken } from '@angular/core';
import * as i1 from '@acorex/platform/layout/widget-core';
import { AXPWidgetConfig, AXPValueWidgetComponent, AXPWidgetNode, AXPWidgetCoreContextChangeEvent, AXPMetaDataDefinition } from '@acorex/platform/layout/widget-core';
import { AXPEntity, AXPMenuProvider, AXPMenuProviderContext } from '@acorex/platform/common';
import { AXPEntityModel, AXMEntityCrudServiceImpl, AXPEntityDefinitionLoader, AXPEntityDefinitionPreloader, AXPEntityPreloadEntity, AXPEntityService, AXPEntityDefinitionRegistryService, AXPEntityActionPlugin } from '@acorex/platform/layout/entity';
import * as _acorex_platform_core from '@acorex/platform/core';
import { AXPFilterDefinition, AXPDataSourceDefinition, AXPFilterClause, AXPDataSourceDataFieldDefinition, AXPExecuteCommandResult, AXPOptionsData, AXPExpressionEvaluatorScopeProvider, AXPExpressionEvaluatorScopeProviderContext, AXPTagProvider, AXPTag } from '@acorex/platform/core';
import { AXDataSource, AXDataSourceOperator, AXFilterLogic } from '@acorex/cdk/common';
import { AXDropListDroppedEvent } from '@acorex/cdk/drag-drop';
import * as _acorex_modules_data_management from '@acorex/modules/data-management';
import { AXPDynamicFormGroupDefinition, AXPDynamicFormDefinition, AXPLayoutRendererComponent, AXPLayoutBuilderService } from '@acorex/platform/layout/builder';
import { AXTranslationService } from '@acorex/core/translation';
import { AXPCommand } from '@acorex/platform/runtime';
import { CdkDragDrop } from '@angular/cdk/drag-drop';
import { AXDialogService } from '@acorex/components/dialog';
import { AXPDataSelectorService, AXPWidgetPropertyViewerService } from '@acorex/platform/layout/components';

declare class AXMQueryEntityModule {
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXMQueryEntityModule, never>;
    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<AXMQueryEntityModule, never, never, never>;
    static ɵinj: _angular_core.ɵɵInjectorDeclaration<AXMQueryEntityModule>;
}

declare class AXMDataSourceEntityModule {
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXMDataSourceEntityModule, never>;
    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<AXMDataSourceEntityModule, never, never, never>;
    static ɵinj: _angular_core.ɵɵInjectorDeclaration<AXMDataSourceEntityModule>;
}

declare class AXMMetaDataDefinitionEntityModule {
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXMMetaDataDefinitionEntityModule, never>;
    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<AXMMetaDataDefinitionEntityModule, never, never, never>;
    static ɵinj: _angular_core.ɵɵInjectorDeclaration<AXMMetaDataDefinitionEntityModule>;
}

declare class AXMMetaDataFeatureModule {
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXMMetaDataFeatureModule, never>;
    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<AXMMetaDataFeatureModule, never, [typeof i1.AXPWidgetCoreModule], never>;
    static ɵinj: _angular_core.ɵɵInjectorDeclaration<AXMMetaDataFeatureModule>;
}

declare class AXMTagEntityModule {
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXMTagEntityModule, never>;
    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<AXMTagEntityModule, never, never, never>;
    static ɵinj: _angular_core.ɵɵInjectorDeclaration<AXMTagEntityModule>;
}

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 AXMQueryEntityModule, typeof AXMDataSourceEntityModule, typeof AXMMetaDataDefinitionEntityModule, typeof AXMMetaDataFeatureModule, typeof AXMTagEntityModule, typeof AXMTagsFeatureModule], never>;
    static ɵinj: _angular_core.ɵɵInjectorDeclaration<AXMDataManagementModule>;
}

declare const RootConfig: {
    config: {
        i18n: string;
    };
    module: {
        route: string;
        name: string;
        title: string;
        icon: string;
    };
    entities: {
        query: {
            name: string;
            title: string;
            titlePlural: string;
            icon: string;
        };
        queryCategory: {
            name: string;
            title: string;
            titlePlural: string;
            icon: string;
        };
        dataSource: {
            name: string;
            title: string;
            titlePlural: string;
            icon: string;
        };
        dataSourceCategory: {
            name: string;
            title: string;
            titlePlural: string;
            icon: string;
        };
        metaDataDefinition: {
            name: string;
            title: string;
            titlePlural: string;
            icon: string;
        };
        tag: {
            name: string;
            source: string;
            title: string;
            icon: string;
        };
        equipmentCategory: {
            name: string;
            title: string;
            titlePlural: string;
            icon: string;
        };
        equipment: {
            name: string;
            source: string;
            title: string;
            titlePlural: string;
            icon: string;
        };
    };
};

declare function queryFactory(injector: Injector): Promise<AXPEntity | null>;

declare function dataSourceEntityFactory(injector: Injector): Promise<AXPEntity | null>;

declare enum AXMDataSourceOutputType {
    Table = "table",
    SingleObject = "single_object",
    Value = "value"
}
interface AXMDataSourceOutputTypeOption {
    name: AXMDataSourceOutputType;
    title: string;
}
declare enum AXMDataSourceType {
    Static = "static",
    Query = "query"
}
interface AXMDataSourceTypeOption {
    name: AXMDataSourceType;
    title: string;
}
interface AXMDataSourceFilter {
    columnName: string;
    defaultValue: any;
    isSystemFilter: boolean;
    isRequired: boolean;
}
interface AXMDataSourceEntityModel<T = string> extends AXPEntityModel<T> {
    name: string;
    title: string;
    categoryIds?: string[];
    sourceStatic: any[];
    sourceEntity: T;
    sourceType: AXMDataSourceTypeOption;
    outputType: AXMDataSourceOutputTypeOption;
    filters?: AXMDataSourceFilter[];
}

declare abstract class AXMDataSourceService<T = string> extends AXMEntityCrudServiceImpl<T, AXMDataSourceEntityModel<T>> {
}
declare class AXMDataSourceServiceImpl extends AXMEntityCrudServiceImpl<string, AXMDataSourceEntityModel> {
    constructor();
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXMDataSourceServiceImpl, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AXMDataSourceServiceImpl>;
}

declare const AXM_COLUMN_DEF_WIDGET: {
    type: string;
    mode: string;
    options: {
        direction: string;
    };
    children: ({
        type: string;
        mode: string;
        options: {
            colSpan: number;
        };
        children: {
            type: string;
            mode: string;
            path: string;
            options: {
                placeholder: string;
                required: boolean;
            };
        }[];
    } | {
        type: string;
        options: {
            colSpan: number;
        };
        mode: string;
        children: {
            type: string;
            mode: string;
            path: string;
            options: {
                placeholder: string;
                valueField: string;
                textField: string;
                dataSource: AXDataSource<i1.AXPWidgetConfig<any> | undefined>;
                direction: string;
                multiple: boolean;
                required: boolean;
            };
        }[];
    } | {
        type: string;
        options: {
            colSpan: number;
        };
        mode: string;
        children: {
            type: string;
            mode: string;
            path: string;
            options: {
                tooltip: string;
                label: string;
            };
            triggers: {
                event: string;
                action: string;
            }[];
        }[];
    } | {
        type: string;
        options: {
            colSpan: number;
        };
        mode: string;
        children: {
            type: string;
            mode: string;
            path: string;
            options: {
                tooltip: string;
                label: string;
            };
        }[];
    })[];
}[];

declare const AXM_FILTER_DEF_WIDGET: {
    type: string;
    mode: string;
    children: ({
        type: string;
        mode: string;
        options: {
            colSpan: number;
        };
        children: {
            type: string;
            mode: string;
            path: string;
            options: {
                columns: string;
                placeholder: string;
            };
        }[];
        triggers: {
            event: string;
            action: string;
        }[];
    } | {
        type: string;
        options: {
            colSpan: number;
        };
        mode: string;
        children: {
            type: string;
            mode: string;
            path: string;
            options: {
                label: string;
                tooltip: string;
            };
        }[];
        triggers?: undefined;
    })[];
}[];

interface AXMColumnFilterSelectorWidgetConfigType {
    columns?: Array<{
        name: string;
        title: string;
        type: string;
    }>;
}
declare const AXMColumnFilterSelectorWidget: AXPWidgetConfig<AXMColumnFilterSelectorWidgetConfigType>;

interface ColumnFilterValue {
    columnName?: string;
    value?: any;
}
declare class AXMColumnFilterSelectorWidgetEditComponent extends AXPValueWidgetComponent<ColumnFilterValue> {
    #private;
    protected disabled: _angular_core.Signal<boolean>;
    protected columns: _angular_core.Signal<{
        name: string;
        title: string;
        type: string;
    }[]>;
    protected columnsDataSource: _angular_core.Signal<AXDataSource<{
        name: string;
        title: string;
        type: string;
    }>>;
    protected selectedColumn: _angular_core.Signal<{
        name: string;
        title: string;
        type: string;
    } | null | undefined>;
    protected filterWidgetNode: _angular_core.Signal<AXPWidgetNode | null>;
    protected handleColumnChange(event: any): void;
    protected handleWidgetValueChange(event: AXPWidgetCoreContextChangeEvent): void;
    protected getWidgetTypeForColumn(columnType: string): string;
    private get __hostClass();
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXMColumnFilterSelectorWidgetEditComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXMColumnFilterSelectorWidgetEditComponent, "axm-column-filter-selector-widget-edit", never, {}, {}, never, never, true, never>;
}

declare class AXMColumnFilterSelectorWidgetViewComponent extends AXPValueWidgetComponent<ColumnFilterValue> {
    protected currentValue: _angular_core.Signal<ColumnFilterValue>;
    protected displayValue: _angular_core.Signal<string>;
    private get __hostClass();
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXMColumnFilterSelectorWidgetViewComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXMColumnFilterSelectorWidgetViewComponent, "axm-column-filter-selector-widget-view", never, {}, {}, never, never, true, never>;
}

declare class AXMColumnFilterSelectorWidgetColumnComponent extends AXPValueWidgetComponent<ColumnFilterValue> {
    protected currentValue: _angular_core.Signal<ColumnFilterValue>;
    protected displayValue: _angular_core.Signal<string>;
    private get __hostClass();
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXMColumnFilterSelectorWidgetColumnComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXMColumnFilterSelectorWidgetColumnComponent, "axm-column-filter-selector-widget-column", never, {}, {}, never, never, true, never>;
}

declare class AXMColumnFilterSelectorWidgetFilterComponent extends AXPValueWidgetComponent<ColumnFilterValue> {
    protected handleValueChange(event: any): void;
    private get __hostClass();
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXMColumnFilterSelectorWidgetFilterComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXMColumnFilterSelectorWidgetFilterComponent, "axm-column-filter-selector-widget-filter", never, {}, {}, never, never, true, never>;
}

declare class AXMColumnFilterSelectorWidgetPrintComponent extends AXPValueWidgetComponent<ColumnFilterValue> {
    protected currentValue: _angular_core.Signal<ColumnFilterValue>;
    protected displayValue: _angular_core.Signal<string>;
    private get __hostClass();
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXMColumnFilterSelectorWidgetPrintComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXMColumnFilterSelectorWidgetPrintComponent, "axm-column-filter-selector-widget-print", never, {}, {}, never, never, true, never>;
}

/**
 * Query output type
 * Defines the expected structure of the query result
 */
type AXPQueryOutputType = 'value' | 'table' | 'object';
/**
 * Sort rule for query builder
 */
interface AXPQuerySortRule {
    field: string;
    dir: 'asc' | 'desc';
}
/**
 * Aggregate operation in query
 * Represents an aggregate function applied to a field
 * Supports nested aggregates (e.g., CONCAT(MIN(field1), MAX(field2)))
 */
interface AXPAggregateOperation {
    /**
     * Field name to aggregate (optional if nestedAggregates is provided)
     */
    field?: string;
    /**
     * Aggregate function name
     */
    function: string;
    /**
     * Output alias/name for the aggregated result
     */
    alias?: string;
    /**
     * Whether to use DISTINCT modifier
     */
    distinct?: boolean;
    /**
     * Nested aggregate operations (for functions like CONCAT that can contain other aggregates)
     * Example: CONCAT(MIN(price), MAX(price)) would have:
     * - function: 'concat'
     * - nestedAggregates: [
     *     { function: 'min', field: 'price' },
     *     { function: 'max', field: 'price' }
     *   ]
     */
    nestedAggregates?: AXPAggregateOperation[];
}
/**
 * Complete query builder data model
 * Includes all query components: dataSource, columns, where, sort, groupBy, aggregates, and raw query
 */
interface AXPQueryBuilderData {
    /**
     * Data source name (optional, can be set from context)
     */
    dataSource?: string;
    /**
     * Selected column names (array of column keys)
     */
    columns: string[];
    /**
     * WHERE clause (filter definition with groups and conditions)
     */
    where: AXPFilterDefinition;
    /**
     * Sort rules (array of field + direction)
     */
    sort: AXPQuerySortRule[];
    /**
     * Group by columns (array of column keys)
     */
    groupBy: string[];
    /**
     * Aggregate operations (array of field + function + alias)
     */
    aggregates: AXPAggregateOperation[];
    /**
     * Raw SQL/query string (optional, used when user wants to write raw query)
     */
    rawQuery?: string;
    /**
     * Query language/dialect for raw query (e.g., 'mysql', 'postgresql', 'mongodb')
     */
    queryLanguage?: string;
    /**
     * Expected output type for the query result
     * - 'value': Single value result (e.g., COUNT, SUM, AVG)
     * - 'table': Table result with items array and total
     * - 'object': Custom object structure
     */
    outputType?: AXPQueryOutputType;
}
/**
 * Query execution result
 * Can be:
 * - A single value (for aggregate queries like SUM, COUNT, etc.)
 * - A table with items and total (for regular queries)
 * - An object with custom structure
 */
type AXPQueryExecutionResult = {
    /**
     * Table result with items array
     */
    items: Record<string, unknown>[];
    total: number;
    metadata?: Record<string, unknown>;
} | {
    /**
     * Single aggregate value result
     */
    value: unknown;
    metadata?: Record<string, unknown>;
} | Record<string, unknown> | unknown[];
interface AXMDataManagementQueryEntityModel extends AXPEntityModel<string> {
    name: string;
    title: string;
    dataSource?: AXMDataSourceEntityModel;
    query?: AXPQueryBuilderData;
    categoryIds?: string[];
    categories?: Array<{
        id: string;
        title: string;
    }>;
}
type AXMQueryEntityModel = AXMDataManagementQueryEntityModel;

declare abstract class AXMQueryService extends AXMEntityCrudServiceImpl<string, AXMDataManagementQueryEntityModel> {
    abstract execute(name: string): Promise<AXPQueryExecutionResult>;
}
declare class AXMQueryServiceImpl extends AXMQueryService {
    constructor();
    execute(name: string): Promise<AXPQueryExecutionResult>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXMQueryServiceImpl, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AXMQueryServiceImpl>;
}

declare function metaDataDefinitionFactory(injector: Injector): Promise<AXPEntity | null>;

interface AXMMetaDataDefinitionEntityModel<T = string> extends AXPEntityModel<T>, AXPMetaDataDefinition {
}

declare abstract class AXMMetaDataDefinitionService<T = string> extends AXMEntityCrudServiceImpl<T, AXMMetaDataDefinitionEntityModel<T>> {
}
declare class AXMPMetaDataDefinitionServiceImpl extends AXMMetaDataDefinitionService<string> {
    constructor();
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXMPMetaDataDefinitionServiceImpl, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AXMPMetaDataDefinitionServiceImpl>;
}

declare function factory(injector: Injector): Promise<AXPEntity | null>;

declare class AXMTagEntityService extends AXMEntityCrudServiceImpl<any, any> {
    constructor();
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXMTagEntityService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AXMTagEntityService>;
}

/**
 * Tag entity model
 */
interface AXMTag {
    id: string;
    text: string;
    color: string;
    icon?: string;
    description?: string;
    scope: 'system' | 'tenant' | 'user';
    isReadonly?: boolean;
    createdBy?: string;
    createdAt?: Date;
    updatedAt?: Date;
}

declare function equipmentFactory(injector: Injector): Promise<AXPEntity | null>;

interface AXMDataManagementEquipmentEntityModel extends AXPEntityModel<string> {
    code?: string;
    title: string;
    description?: string;
    categoryIds?: string[];
    categories?: Array<{
        id: string;
        title: string;
    }>;
    statusId?: string;
}

declare class AXMEntityProvider implements AXPEntityDefinitionLoader, AXPEntityDefinitionPreloader {
    private injector;
    preload(): AXPEntityPreloadEntity[];
    get(moduleName: string, entityName: string): Promise<AXPEntity | null>;
    list(): Promise<{
        name: string;
        module: string;
    }[]>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXMEntityProvider, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AXMEntityProvider>;
}

declare class AXMMenuProvider implements AXPMenuProvider {
    private entityService;
    provide(context: AXPMenuProviderContext): Promise<void>;
}

declare const AXPDataManagementMenuKeys: {
    readonly Root: "DataManagement:Menu";
    readonly Queries: "DataManagement:Menu:Queries";
    readonly DataSources: "DataManagement:Menu:DataSources";
    readonly MetaDataDefinitions: "DataManagement:Menu:MetaDataDefinitions";
    readonly Equipments: "DataManagement:Menu:Equipments";
    readonly EquipmentCategories: "DataManagement:Menu:EquipmentCategories";
    readonly Tags: "DataManagement:Menu:Tags";
};

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;
}

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<AXPDataSourceDefinition<any> | 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 AXPDataSourceDefinition 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<AXPDataSourceDefinition<any> | 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_core.AXPDataSourceDataFieldDefinition[]>;
    /**
     * Extract filter definitions from datasource definition
     */
    protected readonly filterDefinitions: _angular_core.Signal<_acorex_platform_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<AXPDataSourceDataFieldDefinition[]>;
    /**
     * 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: AXPDataSourceDataFieldDefinition;
    } | 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<AXPDataSourceDataFieldDefinition[]>;
    /**
     * 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<AXPDataSourceDataFieldDefinition[]>;
    /**
     * 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: AXPDataSourceDataFieldDefinition;
    } | 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<AXPDataSourceDataFieldDefinition[]>;
    /**
     * 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_modules_data_management.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_modules_data_management.AXPDatabaseTypeProviderToken[]>;
    useClass: typeof AXMDefaultDatabaseTypeProvider;
    multi: boolean;
};

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 {
    #private;
    /**
     * Groups structure from meta-data-selector or evaluated expression
     */
    groups: _angular_core.Signal<AXPDynamicFormGroupDefinition[]>;
    /**
     * 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>;
    /**
     * Handle context change from dynamic form
     */
    protected onContextChange(context: any): void;
    /**
     * Handle validity change from dynamic form
     */
    protected onValidityChange(isValid: boolean): void;
    /**
     * 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;
    /**
     * 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): Promise<AXPExecuteCommandResult<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 AXPMetaDataSelectorWidget: AXPWidgetConfig<AXPMetaDataSelectorWidgetConfigType>;
type AXPMetaDataSelectorWidgetConfigType = {
    type: 'editor';
};

/**
 * Represents a single metadata field within a group
 */
interface AXMMetaDataSelectorField {
    id: string;
    name: string;
    title: string;
    description?: string;
    interface: string;
    configuration?: {
        isRequired?: boolean;
        placeholder?: string;
        [key: string]: any;
    };
    status: 'active' | 'deleted' | 'temporary';
    order: number;
    isNewlyAdded?: boolean;
}
/**
 * Represents a group of metadata fields
 */
interface AXMMetaDataSelectorGroup {
    id: string;
    name: string;
    title?: string;
    description?: string;
    order: number;
    fields: AXMMetaDataSelectorField[];
    isNewlyAdded?: boolean;
}
/**
 * Overall state for the meta-data selector widget
 */
interface AXMMetaDataSelectorState {
    groups: AXMMetaDataSelectorGroup[];
    mode: 'designer' | 'preview';
    selectedFieldId?: string;
    selectedGroupId?: string;
}
/**
 * Value structure stored in entity (simplified for persistence)
 */
interface AXMMetaDataSelectorValue {
    groups: Array<{
        name: string;
        title?: string;
        description?: string;
        order: number;
        fields: Array<{
            id: string;
            name: string;
            title: string;
            description?: string;
            interface: string;
            configuration?: AXPOptionsData;
            order: number;
        }>;
    }>;
}
/**
 * Convert raw value to designer state
 */
declare function convertValueToState(value: any): AXMMetaDataSelectorState;
/**
 * Convert designer state to value for persistence
 */
declare function convertStateToValue(state: AXMMetaDataSelectorState): AXMMetaDataSelectorValue;
/**
 * Create a default group
 */
declare function createDefaultGroup(): AXMMetaDataSelectorGroup;

declare class AXPMetaDataSelectorWidgetEditComponent extends AXPValueWidgetComponent<AXMMetaDataSelectorValue> {
    #private;
    protected dataSelectorService: AXPDataSelectorService;
    protected metaDataService: AXMMetaDataDefinitionService<any>;
    protected entityResolver: AXPEntityDefinitionRegistryService;
    protected dialogService: AXDialogService;
    protected translationService: AXTranslationService;
    protected layoutBuilder: AXPLayoutBuilderService;
    protected widgetPropertyViewerService: AXPWidgetPropertyViewerService;
    private readonly DEFAULT_GROUP_NAME;
    protected designerState: _angular_core.WritableSignal<AXMMetaDataSelectorState>;
    /**
     * Check if the widget is in readonly mode
     */
    protected readonly: _angular_core.Signal<boolean>;
    /**
     * Check if a group is the default group
     */
    protected isDefaultGroup: (groupName: string) => boolean;
    /**
     * Check if we can delete a group (more than 1 group exists)
     */
    protected canDeleteGroup: _angular_core.Signal<boolean>;
    /**
     * Disable preview when no groups or all groups are empty
     */
    protected isPreviewDisabled: _angular_core.Signal<boolean>;
    /**
     * Get all groups for rendering
     */
    protected groups: _angular_core.Signal<AXMMetaDataSelectorGroup[]>;
    /**
     * Get groups data formatted for meta-data-form component (only active fields)
     */
    protected previewGroups: _angular_core.Signal<{
        name: string;
        title: string | undefined;
        description: string | undefined;
        fields: {
            name: string;
            title: string;
            description: string | undefined;
            interface: string;
            configuration: {
                [key: string]: any;
                isRequired?: boolean;
                placeholder?: string;
            } | undefined;
            defaultValue: any;
        }[];
    }[]>;
    /**
     * Convert preview groups to form definition for layout renderer
     */
    protected previewFormDefinition: _angular_core.Signal<AXPDynamicFormDefinition>;
    /**
     * Convert a field to form field definition
     */
    private convertFieldToFormDefinition;
    /**
     * Parse interface configuration from metadata
     */
    private parseInterfaceConfig;
    /**
     * Parse validations from interface configuration
     */
    private parseValidations;
    /**
     * Sanitize group name for use as identifier
     */
    private sanitizeGroupName;
    /**
     * Handle adding a new group
     */
    handleAddGroupClick(): Promise<void>;
    /**
     * Handle editing a group
     */
    handleGroupEdit(group: AXMMetaDataSelectorGroup): Promise<void>;
    /**
     * Handle removing a group
     * Ensures at least 1 group always exists
     */
    handleGroupRemove(group: AXMMetaDataSelectorGroup): Promise<void>;
    /**
     * Handle group drag and drop
     */
    handleGroupDrop(event: CdkDragDrop<AXMMetaDataSelectorGroup[]>): void;
    /**
     * Handle adding fields to a group
     */
    handleAddFieldToGroup(group: AXMMetaDataSelectorGroup): Promise<void>;
    /**
     * Handle field editing - allows overriding the field's interface property
     */
    handleFieldEdit(field: AXMMetaDataSelectorField): Promise<void>;
    /**
     * Handle field removal
     */
    handleFieldRemove(field: AXMMetaDataSelectorField, groupId: string): void;
    /**
     * Handle field revert (undo deletion)
     */
    handleFieldRevert(field: AXMMetaDataSelectorField, groupId: string): void;
    /**
     * Handle field drag and drop (within and between groups)
     */
    handleFieldDrop(event: CdkDragDrop<AXMMetaDataSelectorField[]>, targetGroupName: string): void;
    /**
     * Get all group drop list IDs for connected drag & drop
     */
    getAllGroupDropLists(): string[];
    /**
     * Handle preview button click - opens preview in a dialog using layout builder
     */
    handlePreviewClick(): Promise<void>;
    /**
     * Sync internal state to external value
     * Ensures at least 1 group always exists
     */
    private syncStateToValue;
    /**
     * Parse interface field to extract widget type
     */
    protected parseInterfaceType(interfaceValue: string): string;
    /**
     * Get widget icon for a field
     */
    protected getWidgetIcon(interfaceValue: string): string;
    /**
     * Get widget title for a field
     */
    protected getWidgetTitle(interfaceValue: string): string;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPMetaDataSelectorWidgetEditComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXPMetaDataSelectorWidgetEditComponent, "axp-meta-data-selector-widget-edit", never, {}, {}, never, never, true, never>;
}

/** Display configuration for section (selector shown inline in entity views) */
type MetaDataSelectorSectionConfig = {
    enabled?: boolean;
    title?: string;
    order?: number;
};
/** Display configuration for popup (action opens selector in dialog) */
type MetaDataSelectorPopupConfig = {
    enabled?: boolean;
    title?: string;
    order?: number;
};
/** Flexible display configuration object for the meta-data-selector */
type MetaDataSelectorDisplayConfig = {
    section?: MetaDataSelectorSectionConfig;
    popup?: MetaDataSelectorPopupConfig;
};
/** Display option - where to show the meta-data-selector: section, popup, or both */
type MetaDataSelectorDisplay = MetaDataSelectorDisplayConfig | 'section' | 'popup' | 'both';
type MetaDataSelectorPluginOptions = {
    /** Field and group title */
    title?: string;
    /** How to display the meta-data-selector: section (inline), popup (button opens dialog), or both */
    display?: MetaDataSelectorDisplay;
    /** If true, each metadata group becomes a separate entity section (TODO) */
    renderGroupsAsSections?: boolean;
};
/**
 * meta-data-selector plugin
 *
 * Dynamic behavior:
 * - Creates a single property for metadata selector configuration
 * - Dynamically generates entity groups and meta-data-form widgets based on configured groups
 * - Each metadata group becomes a separate entity section with its own meta-data-form widget
 * - Reads group configuration at runtime from the field value
 */
declare const metaDataSelectorPlugin: AXPEntityActionPlugin;

declare class AXPMetaDataSelectorWidgetViewComponent extends AXPValueWidgetComponent<any> {
    /**
     * Returns a comma-separated list of selected meta titles.
     * Extracting this logic into a getter keeps the template simple and
     * avoids using arrow functions, which are not allowed in Angular
     * interpolation expressions.
     */
    get display(): string;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPMetaDataSelectorWidgetViewComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXPMetaDataSelectorWidgetViewComponent, "axp-meta-data-selector-widget-view", never, {}, {}, never, never, true, never>;
}

interface ShowMetaDataSelectorPopupInput {
    entity: string;
    id: string;
    /** Selector field name (default: META_DATA_SELECTOR_FIELD) */
    field?: string;
    title?: string;
}
/**
 * Opens the meta-data-selector (configuration UI for groups/fields) in a popup.
 * Used when meta-data-selector plugin has display: 'popup' or 'both'.
 */
declare class ShowMetaDataSelectorPopupCommand implements AXPCommand<ShowMetaDataSelectorPopupInput, any> {
    protected readonly layoutBuilder: AXPLayoutBuilderService;
    protected readonly translationService: AXTranslationService;
    protected readonly entityService: AXPEntityService;
    execute(input: ShowMetaDataSelectorPopupInput | any): Promise<AXPExecuteCommandResult<any>>;
    /**
     * Loads a record by entity and id. Override to use custom data sources or key handling.
     */
    protected findRecord(entity: string, id: string): Promise<Record<string, unknown> | null>;
    /**
     * Persists meta-data 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<ShowMetaDataSelectorPopupCommand, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<ShowMetaDataSelectorPopupCommand>;
}

/**
 * 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-selector into fetched groups
     * Matches fields by id or name and applies overridden interfaces
     */
    private mergeInterfaceOverrides;
}

/**
 * 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;
}
declare const tagsPlugin: AXPEntityActionPlugin;

declare const AXMDataManagementFeatureKeys: {
    readonly Queries: "DataManagement:Feature:Queries";
    readonly DataSources: "DataManagement:Feature:DataSources";
    readonly MetaDataDefinitions: "DataManagement:Feature:MetaDataDefinitions";
    readonly Equipments: "DataManagement:Feature:Equipments";
};

declare const AXMPermissionsKeys: {
    DataManagement: {
        Query: {
            Management: string;
        };
        DataSource: {
            Management: string;
        };
        MetaDataDefinition: {
            Management: string;
        };
        Equipment: {
            Management: string;
        };
        Tag: {
            Management: string;
        };
    };
};

export { AXMColumnFilterSelectorWidget, AXMColumnFilterSelectorWidgetColumnComponent, AXMColumnFilterSelectorWidgetEditComponent, AXMColumnFilterSelectorWidgetFilterComponent, AXMColumnFilterSelectorWidgetPrintComponent, AXMColumnFilterSelectorWidgetViewComponent, AXMDataManagementFeatureKeys, AXMDataManagementModule, AXMDataSourceEntityModule, AXMDataSourceOutputType, AXMDataSourceService, AXMDataSourceServiceImpl, AXMDataSourceType, AXMDefaultAggregateFunctionProvider, AXMDefaultDatabaseTypeProvider, AXMEntityProvider, AXMMenuProvider, AXMMetaDataDefinitionEntityModule, AXMMetaDataDefinitionService, AXMMetaDataFeatureModule, AXMMetadataEvaluatorScopeProvider, AXMPMetaDataDefinitionServiceImpl, AXMPermissionsKeys, AXMQueryEntityModule, AXMQueryService, AXMQueryServiceImpl, AXMTagEntityModule, AXMTagEntityService, AXMTagsFeatureModule, AXM_COLUMN_DEF_WIDGET, AXM_FILTER_DEF_WIDGET, AXPAggregateBuilderComponent, AXPAggregateFunctionService, AXPAggregateFunctionsRegistry, AXPColumnsBuilderComponent, AXPDataManagementMenuKeys, AXPDatabaseTypeService, AXPGroupByBuilderComponent, AXPMetaDataFormWidget, AXPMetaDataFormWidgetEditComponent, AXPMetaDataSelectorWidget, AXPMetaDataSelectorWidgetEditComponent, AXPMetaDataSelectorWidgetViewComponent, AXPQueryBuilderComponent, AXPQueryBuilderWidget, AXPQueryBuilderWidgetColumnComponent, AXPQueryBuilderWidgetDesignerComponent, AXPQueryBuilderWidgetEditComponent, AXPQueryBuilderWidgetViewComponent, AXPRawQueryBuilderComponent, AXPSortBuilderComponent, AXPSystemTagProvider, AXPWhereBuilderComponent, AXP_AGGREGATE_FUNCTION_PROVIDER, AXP_DATABASE_TYPE_PROVIDER, AXP_DEFAULT_AGGREGATE_FUNCTION_PROVIDER, AXP_DEFAULT_DATABASE_TYPE_PROVIDER, META_DATA_FORM_FIELD, META_DATA_SELECTOR_FIELD, RootConfig, ShowMetaDataFormPopupCommand, ShowMetaDataSelectorPopupCommand, convertStateToValue, convertValueToState, createDefaultGroup, dataSourceEntityFactory, equipmentFactory, factory, metaDataDefinitionFactory, metaDataSelectorPlugin, queryFactory, tagsPlugin };
export type { AXMColumnFilterSelectorWidgetConfigType, AXMDataManagementEquipmentEntityModel, AXMDataManagementQueryEntityModel, AXMDataSourceEntityModel, AXMDataSourceFilter, AXMDataSourceOutputTypeOption, AXMDataSourceTypeOption, AXMMetaDataDefinitionEntityModel, AXMMetaDataSelectorField, AXMMetaDataSelectorGroup, AXMMetaDataSelectorState, AXMMetaDataSelectorValue, AXMQueryEntityModel, AXMTag, AXPAggregateCategory, AXPAggregateFunctionDefinition, AXPAggregateFunctionProvider, AXPAggregateFunctionProviderToken, AXPAggregateOperation, AXPDatabaseType, AXPDatabaseTypeDefinition, AXPDatabaseTypeProvider, AXPDatabaseTypeProviderToken, AXPMetaDataFormWidgetConfigType, AXPMetaDataSelectorWidgetConfigType, AXPQueryBuilderData, AXPQueryBuilderWidgetConfigType, AXPQueryExecutionResult, AXPQueryOutputType, AXPQuerySortRule, AXPTagPluginOptions, ColumnFilterValue, MetaDataSelectorDisplay, MetaDataSelectorDisplayConfig, MetaDataSelectorPluginOptions, MetaDataSelectorPopupConfig, MetaDataSelectorSectionConfig, ResolveGroupsResult, ShowMetaDataFormPopupInput, ShowMetaDataSelectorPopupInput };
