import * as DG from 'datagrok-api/dg';
import { Subject } from 'rxjs';
import '../../css/query-builder.css';
export declare const SUGGESTIONS_FUNCTION = "suggestionsFunction";
export declare namespace Operators {
    const CONTAINS = "contains";
    const IN = "in";
    const STARTS_WITH = "starts with";
    const ENDS_WITH = "ends with";
    const GT = ">";
    const GTE = ">=";
    const LT = "<";
    const LTE = "<=";
    const EQ = "=";
    const NOT_EQ = "!=";
    const BEFORE = "before";
    const AFTER = "after";
    const ON = "on";
    const BETWEEN = "between";
    const IS_SIMILAR = "is similar";
    const IS_CONTAINED = "is contained";
    enum Logical {
        and = "and",
        or = "or"
    }
}
export declare enum QueryBuilderLayout {
    Standard = "standard",
    Narrow = "narrow"
}
export interface SimpleCondition<T = any> {
    field: string;
    operator: string;
    value: T;
}
export interface ComplexCondition {
    logicalOperator: Operators.Logical;
    conditions: Expression[];
}
export type Expression<T = any> = SimpleCondition<T> | ComplexCondition;
export declare class BaseConditionEditor<T = any> {
    root: HTMLDivElement;
    condition: SimpleCondition<T>;
    onChanged: Subject<SimpleCondition<T>>;
    onValidationError: Subject<boolean>;
    showSuggestions: boolean;
    suggestionsMenuClicked: boolean;
    constructor(prop: DG.Property, operator: string, initialCondition?: SimpleCondition<T>);
    protected initializeEditor(prop: DG.Property): Promise<DG.InputBase[]>;
    initializeSuggestions(prop: DG.Property, input: DG.InputBase): void;
    addSuggestions(prop: DG.Property, input: DG.InputBase): Promise<void>;
}
export declare class BetweenConditionEditor extends BaseConditionEditor {
    initializeEditor(prop: DG.Property): Promise<DG.InputBase[]>;
}
export declare class BooleanConditionEditor extends BaseConditionEditor {
    initializeEditor(prop: DG.Property): Promise<DG.InputBase[]>;
}
export declare class MoleculeConditionEditor extends BaseConditionEditor<string> {
    initializeEditor(prop: DG.Property): Promise<DG.InputBase[]>;
}
export type MoleculeSimilarity = {
    molecule: string;
    threshold: number;
};
export declare class MoleculeSimilarityConditionEditor extends BaseConditionEditor<MoleculeSimilarity> {
    initializeEditor(prop: DG.Property): Promise<DG.InputBase[]>;
}
export declare class MultiValueConditionEditorString extends BaseConditionEditor<string[]> {
    initializeEditor(prop: DG.Property): Promise<DG.InputBase[]>;
}
export declare class MultiValueConditionEditorInt extends BaseConditionEditor<number[]> {
    initializeEditor(prop: DG.Property): Promise<DG.InputBase[]>;
}
export declare class MultiValueConditionEditorFloat extends BaseConditionEditor<number[]> {
    initializeEditor(prop: DG.Property): Promise<DG.InputBase[]>;
}
export declare class ConditionRegistry {
    private static instance;
    private typeOperators;
    private semTypeOperators;
    private editorRegistry;
    private constructor();
    static getInstance(): ConditionRegistry;
    private initializeDefaultOperators;
    private initializeDefaultEditors;
    registerTypeOperators(propertyType: string, operators: string[]): void;
    registerSemTypeOperators(semType: string, operators: string[]): void;
    getOperatorsForProperty(property: DG.Property): string[];
    isOperatorSupported(property: DG.Property, operator: string): boolean;
    registerEditor<T>(propertyType: string, semType: string, operator: string, editorClass: new (prop: DG.Property, operator: string) => BaseConditionEditor<T>): void;
    createEditor<T>(property: DG.Property, operator: string, initialCondition?: SimpleCondition<T>): BaseConditionEditor<T>;
    getConditionEditor<T = any>(property: DG.Property, operator: string, condition?: SimpleCondition<T>): BaseConditionEditor<T>;
    private createEditorKey;
}
export type HistoryItem = {
    date: DG.TYPE.DATE_TIME;
    value: string;
};
export declare function saveHistory(key: string, value: string): void;
export declare function getHistory(key: string): HistoryItem[];
export declare class QueryBuilder {
    root: HTMLElement;
    condition: ComplexCondition;
    properties: DG.Property[];
    structureChanged: Subject<ComplexCondition>;
    filterValueChanged: Subject<SimpleCondition>;
    validationError: Subject<boolean>;
    invalid: boolean;
    layout: QueryBuilderLayout;
    private _historyCacheKey;
    private historyIcon;
    private historyIconOnTop;
    constructor(properties: DG.Property[], initialCondition?: ComplexCondition, layout?: QueryBuilderLayout, historyCacheKey?: string, historyIconOnTop?: boolean);
    set historyCache(key: string);
    saveConditionToHistory(): void;
    private setupHistoryIcon;
    private showHistoryMenu;
    loadCondition(condition: ComplexCondition): void;
    conditionToString(condition: ComplexCondition): string;
    private expressionToString;
    private simpleConditionToString;
    createDefaultSimpleCondition(): SimpleCondition;
    rebuildUI(): void;
    setLayout(layout: QueryBuilderLayout): void;
    getLayout(): QueryBuilderLayout;
    buildUI(condition: ComplexCondition, parentCondition?: ComplexCondition, nestingLevel?: number): HTMLElement;
    generateNestingColor(level: number): string;
}
//# sourceMappingURL=query-builder.d.ts.map