import * as i0 from '@angular/core';
import { OnInit, EventEmitter } from '@angular/core';
import { FormGroup, FormControl, FormArray } from '@angular/forms';
import { ComponentHarness, BaseHarnessFilters, HarnessPredicate } from '@angular/cdk/testing';

type ConditionType = 'string' | 'number' | 'date' | 'boolean';
type ConditionModelBase<T extends ConditionType> = {
    field: string;
    label: string;
    type: T;
    map?: {
        type: 'Map';
        key1Values?: string[] | {
            value: string;
            label: string;
        }[];
        key1Value?: string | null;
    } | {
        type: 'MultiMap';
        key1Value?: string | null;
        key1Values?: string[];
        key2Value?: string | null;
    };
};
type StringConditionModel = ConditionModelBase<'string'> & {
    values?: string[] | {
        value: string;
        label: string;
    }[];
};
type NumberConditionModel = ConditionModelBase<'number'> & {
    min?: number;
    max?: number;
};
type DateConditionModel = ConditionModelBase<'date'>;
type BooleanConditionModel = ConditionModelBase<'boolean'>;
type ConditionModel = StringConditionModel | NumberConditionModel | DateConditionModel | BooleanConditionModel;

type ParentConditionModel = {
    field: string;
    label: string;
    conditions: (ParentConditionModel | ConditionModel)[];
};
type ConditionsModel = (ParentConditionModel | ConditionModel)[];
declare const isConditionModel: (conditions: ParentConditionModel | ConditionModel) => conditions is ConditionModel;

type Operator = 'EQUALS' | 'NOT_EQUALS' | 'LESS_THAN' | 'LESS_THAN_OR_EQUALS' | 'GREATER_THAN' | 'GREATER_THAN_OR_EQUALS' | 'CONTAINS' | 'NOT_CONTAINS' | 'STARTS_WITH' | 'ENDS_WITH';

type ConditionForm = {
    field: FormControl<ConditionModel | null>;
    operator: FormControl<Operator | null>;
    value: FormControl<string | boolean | Date | number | null>;
};
type ConditionGroupForm = {
    condition: FormControl<'AND' | 'OR'>;
    conditions: FormArray<FormGroup<ConditionForm> | FormGroup<ConditionGroupForm>>;
};
declare class GioElEditorComponent implements OnInit {
    private readonly destroyRef;
    conditionsModel: ConditionsModel;
    elChange: EventEmitter<string>;
    protected conditionGroupFormGroup: FormGroup<ConditionGroupForm>;
    protected elOutput?: string;
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<GioElEditorComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<GioElEditorComponent, "gio-el-editor", never, { "conditionsModel": { "alias": "conditionsModel"; "required": true; }; }, { "elChange": "elChange"; }, never, never, true, never>;
}

type ConditionGroupHarnessValues = {
    condition: 'AND' | 'OR';
    conditions: (ConditionGroupHarnessValues | ConditionHarnessValues)[];
};
type ConditionHarnessValues = {
    field: {
        field: string;
        key1?: string;
        key2?: string;
    };
    operator?: string;
    value?: string | boolean | number;
};
declare class GioElEditorConditionGroupHarness extends ComponentHarness {
    static hostSelector: string;
    static with(options?: BaseHarnessFilters): HarnessPredicate<GioElEditorConditionGroupHarness>;
    getNodeLvl: () => Promise<string | null>;
    private getAddMenuButton;
    private getConditionButtonToggleGroup;
    private getConditionsHarness;
    private getConditionHarness;
    private getConditionTypeHarness;
    private getConditionField;
    clickAddNewConditionButton(): Promise<void>;
    clickAddNewGroupButton(): Promise<void>;
    getConditionValue(): Promise<'AND' | 'OR'>;
    selectConditionValue(operator: 'AND' | 'OR'): Promise<void>;
    selectConditionField(index: number, field: string, key1?: string, key2?: string): Promise<void>;
    selectConditionOperator(index: number, operator: string): Promise<void>;
    getConditionAvailableOperators(index: number): Promise<string[]>;
    setConditionValue(index: number, value: string | boolean | number | Date): Promise<void>;
    getConditionGroup(index: number): Promise<GioElEditorConditionGroupHarness>;
    getConditions(): Promise<ConditionGroupHarnessValues>;
}

declare class GioElEditorHarness extends ComponentHarness {
    static hostSelector: string;
    getMainConditionGroup: () => Promise<GioElEditorConditionGroupHarness>;
    static with(options?: BaseHarnessFilters): HarnessPredicate<GioElEditorHarness>;
}

type ConditionValue<T> = T extends 'string' ? string : T extends 'number' ? number : T extends 'date' ? Date : T extends 'boolean' ? boolean : unknown;
declare class Condition<T extends ConditionType> {
    field: string | {
        field: string;
        key1Value?: string;
        key2Value?: string;
    };
    type: T;
    operator: Operator;
    value?: ConditionValue<T> | undefined;
    constructor(field: string | {
        field: string;
        key1Value?: string;
        key2Value?: string;
    }, type: T, operator: Operator, value?: ConditionValue<T> | undefined);
}

declare class ConditionGroup {
    condition: 'AND' | 'OR';
    conditions: (Condition<ConditionType> | ConditionGroup)[];
    constructor(condition: 'AND' | 'OR', conditions: (Condition<ConditionType> | ConditionGroup)[]);
}

declare class ExpressionLanguageBuilder {
    private conditionGroup;
    private static CONDITION_MAP;
    private static OPERATOR_MAP;
    private static buildConditionGroup;
    private static buildCondition;
    private static valueToString;
    private static toFieldString;
    constructor(conditionGroup: ConditionGroup);
    build(): string;
}

export { Condition, ExpressionLanguageBuilder, GioElEditorComponent, GioElEditorHarness, isConditionModel };
export type { BooleanConditionModel, ConditionModel, ConditionModelBase, ConditionType, ConditionsModel, DateConditionModel, NumberConditionModel, Operator, ParentConditionModel, StringConditionModel };