import * as i0 from '@angular/core';
import { EventEmitter, OnInit, OnChanges, SimpleChanges, OnDestroy, QueryList } from '@angular/core';
import * as _angular_forms from '@angular/forms';
import { ValidatorFn, FormGroup, FormControl, AbstractControl, ValidationErrors } from '@angular/forms';
import * as lucide_angular from 'lucide-angular';
import { LucideIconData } from 'lucide-angular';
import * as kif_lib_toolbar from 'kif-lib/toolbar';
import { MatDialog, MatDialogRef } from '@angular/material/dialog';
import * as rxjs from 'rxjs';
import { BehaviorSubject, Observable, Subject } from 'rxjs';
import { MatOptionSelectionChange } from '@angular/material/core';
import { MatExpansionPanel } from '@angular/material/expansion';

interface OptionSelect {
    value: string;
    label: string;
}

declare enum BUTTON_ICON {
    ADD = "add-icon",
    FILTER = "filter-icon"
}

declare enum FILTER_TYPE {
    BASE = "base",
    INPUT = "input",
    SELECT = "select",
    AUTOCOMPLETE = "autocomplete",
    DATE = "datepicker",
    DATE_RANGE = "daterange",
    BUTTON = "button",
    SELECT_STATE = "select_state",
    CHIP_SELECTOR = "chip_selector"
}

declare enum BUTTON_STYLE {
    RAISED = "raised",
    STROKED = "stroked",
    FLAT = "flat",
    ICON = "icon",
    FAB = "fab",
    MINI_FAB = "mini_fab"
}

declare enum ACTION_TYPE {
    BUTTON = 0,
    ICON = 1
}

declare enum INPUT_TYPE {
    SEARCH = "search",
    BUTTON = "button",
    DATE = "date",
    LABEL = "label",
    FILTER_BUTTON = "filterButton",
    TEXT = "text",
    SELECT = "select"
}

declare enum VALIDATOR_ERROR_KEY {
    REQUIRED = "required",
    MINLENGTH = "minlength",
    MAXLENGTH = "maxlength",
    PATTERN = "pattern",
    MIN = "min",
    MAX = "max",
    EMAIL = "email"
}

declare enum TOOLBAR_FILTER_ACTION {
    SEARCH = "search",
    CLEAR = "clear"
}

interface ErrorValidatorCondition {
    hasError?: string[];
    notError?: string[];
}

interface ErrorValidator {
    errorValidator: string | VALIDATOR_ERROR_KEY;
    errorDescription: string;
    conditions?: ErrorValidatorCondition[];
}

interface Mask {
    dropSpecialCharacters?: boolean | undefined;
    prefix?: string;
    suffix?: string;
    mask: string | undefined;
    showMaskTyped?: boolean;
    allowNegativeNumbers?: boolean;
    placeHolderCharacter?: string | null;
    clearIfNotMatch?: boolean;
    specialCharacters?: Array<string> | null;
    thousandSeparator?: string;
    decimalMarker?: string;
    customPatterns?: any;
    validation?: boolean;
}

interface LucideIcon {
    iconSvg: LucideIconData;
    size?: string;
    color?: string;
    strokeWidth?: number;
    class?: string;
    absoluteStrokeWidth?: boolean;
}

interface Filter {
    id: string;
    type: FILTER_TYPE;
    main?: boolean;
    disabled?: boolean;
    hide?: boolean;
    required?: boolean;
    value?: string | string[] | number | OptionSelect;
    values?: OptionSelect[];
    validators?: ValidatorFn[];
    placeholder?: string;
    label?: string;
    inputType?: INPUT_TYPE;
    minLength?: number;
    maxLength?: number;
    minDate?: string;
    maxDate?: string;
    placeholderEnd?: string;
    pattern?: RegExp;
    mask?: Mask;
    errors?: ErrorValidator[];
    autocompleteSelected?: boolean;
    multiple?: boolean;
    customErrorMessage?: string;
    group?: number;
    lucideIcon?: LucideIcon;
}

interface Action {
    id: string;
    type: ACTION_TYPE;
    description?: string;
    icon?: LucideIcon;
    color?: string;
    style?: string;
    class?: string;
    hide?: boolean;
    disable?: boolean;
    useSpinner?: boolean;
}

interface Group {
    id: number;
    label: string;
}

interface Autocomplete {
    autocompleteSelected?: boolean;
}

interface FilterChange {
    id: string;
    value: string | number | OptionSelect;
}

interface ToolbarFilterAction {
    clear?: boolean;
    search?: boolean;
    searchGroup?: number;
}

declare class ToolbarComponent {
    actions: Action[];
    groups: Group[];
    changeFilters: EventEmitter<FilterChange>;
    toolbarFilterAction: EventEmitter<ToolbarFilterAction>;
    toolbarAction: EventEmitter<string>;
    ACTION_TYPE: typeof ACTION_TYPE;
    private _filters;
    constructor();
    set filters(filters: Filter[]);
    get filters(): Filter[];
    onChangeFilters($event: FilterChange): void;
    onToolbarFilterAction(toolbarFilterAction: ToolbarFilterAction): void;
    onToolbarAction(action: string): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ToolbarComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ToolbarComponent, "kit-toolbar", never, { "actions": { "alias": "actions"; "required": false; }; "groups": { "alias": "groups"; "required": false; }; "filters": { "alias": "filters"; "required": false; }; }, { "changeFilters": "changeFilters"; "toolbarFilterAction": "toolbarFilterAction"; "toolbarAction": "toolbarAction"; }, never, never, true, never>;
}

declare class ToolbarActionComponent {
    action: Action;
    toolbarAction: EventEmitter<string>;
    BUTTON_STYLE: typeof BUTTON_STYLE;
    constructor();
    onAction(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ToolbarActionComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ToolbarActionComponent, "kit-toolbar-action", never, { "action": { "alias": "action"; "required": false; }; }, { "toolbarAction": "toolbarAction"; }, never, never, true, never>;
}

declare class ToolbarFilterComponent implements OnInit {
    private dialog;
    groups: Group[];
    valueChange: EventEmitter<FilterChange>;
    actionFilter: EventEmitter<ToolbarFilterAction>;
    filters$: BehaviorSubject<Filter[]>;
    iconFilter: lucide_angular.LucideIconData;
    filtersToComponents: Filter[];
    FILTER_TYPE: typeof FILTER_TYPE;
    singleFilterForm: FormGroup;
    filtersCount: number;
    groupIdPanelOpen: number;
    groupFilterForm: any;
    private _filters;
    private fb;
    private isFilterGroup;
    private previousFilterForm;
    private previousGroupFilterForm;
    private INDEX_GROUP_MAIN;
    private groupsIds;
    constructor(dialog: MatDialog);
    set filters(filters: Filter[]);
    get filters(): Filter[];
    ngOnInit(): void;
    showFilterButton(): boolean;
    setGroupFiltersCount(): void;
    setSingleFiltersCount(): void;
    onAction(): void;
    openVersionHistoryDialog(): void;
    resetGroupFilterFormWhitoutOpenPanel(): void;
    private resetMainFilterControls;
    resetSingleFilterForm(): void;
    resetGroupFilterForm(groupId: number): void;
    getFilterForm(filter: Filter): FormControl<any>;
    getFilter(filter: Filter): {
        id: string;
        type: FILTER_TYPE;
        main?: boolean;
        disabled?: boolean;
        hide?: boolean;
        required?: boolean;
        value?: string | string[] | number | kif_lib_toolbar.OptionSelect;
        values?: kif_lib_toolbar.OptionSelect[];
        validators?: _angular_forms.ValidatorFn[];
        placeholder?: string;
        label?: string;
        inputType?: kif_lib_toolbar.INPUT_TYPE;
        minLength?: number;
        maxLength?: number;
        minDate?: string;
        maxDate?: string;
        placeholderEnd?: string;
        pattern?: RegExp;
        mask?: kif_lib_toolbar.Mask;
        errors?: kif_lib_toolbar.ErrorValidator[];
        autocompleteSelected?: boolean;
        multiple?: boolean;
        customErrorMessage?: string;
        group?: number;
        lucideIcon?: kif_lib_toolbar.LucideIcon;
    };
    private emptySingleFormValues;
    private createForm;
    private createSingleForm;
    private createGroupForm;
    private updateGroupFilterForm;
    private updateSingleFilterForm;
    private updateFilterFormControl;
    private addFilterFormControl;
    private singleFilterFormSubscribes;
    private groupFilterFormSubscribes;
    static ɵfac: i0.ɵɵFactoryDeclaration<ToolbarFilterComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ToolbarFilterComponent, "kit-toolbar-filter", never, { "groups": { "alias": "groups"; "required": false; }; "filters": { "alias": "filters"; "required": false; }; }, { "valueChange": "valueChange"; "actionFilter": "actionFilter"; }, never, never, true, never>;
}

declare class ToolbarFilterAutocompleteComponent {
    filterForm: FormControl;
    iconArrow: boolean;
    filteredOptions: Observable<OptionSelect[]> | undefined;
    readonly searchI: lucide_angular.LucideIconData;
    private _filter;
    constructor();
    set filter(filter: Filter);
    get filter(): Filter;
    displayFn(option: any): string;
    setFilteredOptions(): void;
    isControlRequired(): boolean;
    validateError(): string[];
    static ɵfac: i0.ɵɵFactoryDeclaration<ToolbarFilterAutocompleteComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ToolbarFilterAutocompleteComponent, "kit-toolbar-filter-autocomplete", never, { "filterForm": { "alias": "filterForm"; "required": false; }; "iconArrow": { "alias": "iconArrow"; "required": false; }; "filter": { "alias": "filter"; "required": false; }; }, {}, never, never, true, never>;
}

declare class ToolbarFilterSelectComponent implements OnInit, OnChanges {
    filterForm: FormControl;
    filteredOptions$: Observable<OptionSelect[]> | undefined;
    iconChevronDown: lucide_angular.LucideIconData;
    iconClose: lucide_angular.LucideIconData;
    private _filter;
    constructor();
    set filter(filter: Filter);
    get filter(): Filter;
    ngOnInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    onChange(event: MatOptionSelectionChange): void;
    compareFn(option1: string, option2: OptionSelect | string): boolean;
    isControlRequired(): boolean;
    displayFn(option: OptionSelect): string;
    clearSelection(): void;
    validateError(): string[] | "";
    private validateOption;
    private setFilterObservable;
    static ɵfac: i0.ɵɵFactoryDeclaration<ToolbarFilterSelectComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ToolbarFilterSelectComponent, "kit-toolbar-filter-select", never, { "filterForm": { "alias": "filterForm"; "required": false; }; "filter": { "alias": "filter"; "required": false; }; }, {}, never, never, true, never>;
}

declare class ToolbarFilterInputComponent {
    filterForm: FormControl;
    INPUT_TYPE: typeof INPUT_TYPE;
    private _filter;
    constructor();
    set filter(filter: Filter);
    get filter(): Filter;
    validateError(): string[] | "";
    isControlRequired(): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<ToolbarFilterInputComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ToolbarFilterInputComponent, "kit-toolbar-filter-input", never, { "filterForm": { "alias": "filterForm"; "required": false; }; "filter": { "alias": "filter"; "required": false; }; }, {}, never, never, true, never>;
}

declare class ToolbarFilterDateComponent {
    filterForm: FormControl;
    iconCalendar: lucide_angular.LucideIconData;
    private _filter;
    constructor();
    set filter(filter: Filter);
    get filter(): Filter;
    isControlRequired(): boolean;
    validateError(): string[] | "";
    static ɵfac: i0.ɵɵFactoryDeclaration<ToolbarFilterDateComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ToolbarFilterDateComponent, "kit-toolbar-filter-date", never, { "filterForm": { "alias": "filterForm"; "required": false; }; "filter": { "alias": "filter"; "required": false; }; }, {}, never, never, true, never>;
}

declare class ToolbarFilterDateRangeComponent implements OnInit {
    filterForm: FormControl;
    iconCalendar: lucide_angular.LucideIconData;
    rangeGroup: FormGroup;
    startFocused: boolean;
    endFocused: boolean;
    private _filter;
    constructor();
    set filter(filter: Filter);
    get filter(): Filter;
    private readonly endBeforeStartValidator;
    private readonly startRequiredValidator;
    ngOnInit(): void;
    validateError(): string[] | "";
    static ɵfac: i0.ɵɵFactoryDeclaration<ToolbarFilterDateRangeComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ToolbarFilterDateRangeComponent, "kit-toolbar-filter-date-range", never, { "filterForm": { "alias": "filterForm"; "required": false; }; "filter": { "alias": "filter"; "required": false; }; }, {}, never, never, true, never>;
}

interface SidebarInstance {
    emitEvent?: boolean;
    groupId?: number;
}

declare class ToolbarFilterSidebarComponent implements OnInit, OnDestroy {
    data: any;
    dialogRef: MatDialogRef<ToolbarFilterSidebarComponent>;
    private dialog;
    panels: QueryList<MatExpansionPanel>;
    private filtersSub;
    _filters: Filter[];
    filterForm: any;
    groups: Group[];
    filtersCount: number;
    iconFilter: lucide_angular.LucideIconData;
    iconClose: lucide_angular.LucideIconData;
    iconChevronUp: lucide_angular.LucideIconData;
    iconChevronDown: lucide_angular.LucideIconData;
    FILTER_TYPE: typeof FILTER_TYPE;
    groupIdPanelOpen: number;
    filterGroupList: any[];
    resetFilterFormSubject: Subject<SidebarInstance>;
    resetFilterForm$: rxjs.Observable<SidebarInstance>;
    private isFilterGroup;
    constructor(data: any, dialogRef: MatDialogRef<ToolbarFilterSidebarComponent>, dialog: MatDialog);
    set filters(filters: Filter[]);
    get filters(): Filter[];
    get hasChipSelector(): boolean;
    get validForm(): boolean;
    ngOnInit(): void;
    ngOnDestroy(): void;
    getFilter(filterIndex: number): {
        id: string;
        type: FILTER_TYPE;
        main?: boolean;
        disabled?: boolean;
        hide?: boolean;
        required?: boolean;
        value?: string | string[] | number | kif_lib_toolbar.OptionSelect;
        values?: kif_lib_toolbar.OptionSelect[];
        validators?: _angular_forms.ValidatorFn[];
        placeholder?: string;
        label?: string;
        inputType?: kif_lib_toolbar.INPUT_TYPE;
        minLength?: number;
        maxLength?: number;
        minDate?: string;
        maxDate?: string;
        placeholderEnd?: string;
        pattern?: RegExp;
        mask?: kif_lib_toolbar.Mask;
        errors?: kif_lib_toolbar.ErrorValidator[];
        autocompleteSelected?: boolean;
        multiple?: boolean;
        customErrorMessage?: string;
        group?: number;
        lucideIcon?: kif_lib_toolbar.LucideIcon;
    };
    getSingleFilterFormControl(filter: Filter): FormControl;
    getGroupFilterFormControl(filter: Filter, groupId: number): FormControl;
    getFilterWhitValues(): number;
    setAccordionPanel(index: number): void;
    onFilterGroup(groupId: number): void;
    onFilterSingle(): void;
    onClear(groupId?: number): void;
    private validateSimpleForm;
    private validateGroupForm;
    private validateForm;
    private isEmptyValue;
    static ɵfac: i0.ɵɵFactoryDeclaration<ToolbarFilterSidebarComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ToolbarFilterSidebarComponent, "kit-toolbar-filter-sidebar", never, {}, {}, never, never, true, never>;
}

declare class KitToolbarFilterSelectStateComponent implements OnInit, OnChanges {
    filterForm: FormControl;
    filteredOptions$: Observable<OptionSelect[]> | undefined;
    private _filter;
    options: OptionSelect[];
    set filter(filter: Filter);
    constructor();
    get filter(): Filter;
    onChange(event: any): void;
    setFilterObservable(): void;
    ngOnInit(): void;
    isControlRequired(): boolean;
    defaultCompareWithFn: (o1: any, o2: any) => boolean;
    compareWithFn(o1: any, o2: any): boolean;
    ngOnChanges(changes: SimpleChanges): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<KitToolbarFilterSelectStateComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<KitToolbarFilterSelectStateComponent, "kit-toolbar-filter-select-state", never, { "filterForm": { "alias": "filterForm"; "required": false; }; "filter": { "alias": "filter"; "required": false; }; }, {}, never, never, true, never>;
}

declare class KifToolbarModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<KifToolbarModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<KifToolbarModule, never, [typeof ToolbarComponent, typeof ToolbarActionComponent, typeof ToolbarFilterComponent, typeof ToolbarFilterAutocompleteComponent, typeof ToolbarFilterSelectComponent, typeof ToolbarFilterInputComponent, typeof ToolbarFilterDateComponent, typeof ToolbarFilterDateRangeComponent, typeof ToolbarFilterSidebarComponent, typeof KitToolbarFilterSelectStateComponent, typeof lucide_angular.LucideAngularModule], [typeof ToolbarComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<KifToolbarModule>;
}

declare abstract class FilterBase implements Filter {
    id: string;
    main?: boolean;
    hide?: boolean;
    disabled?: boolean;
    required?: boolean;
    values?: OptionSelect[];
    validators?: ValidatorFn[];
    placeholder?: string;
    minLength?: number;
    maxLength?: number;
    minDate?: string;
    maxDate?: string;
    placeholderEnd?: string;
    label?: string;
    pattern?: RegExp;
    mask?: Mask;
    inputType?: INPUT_TYPE;
    errors?: ErrorValidator[];
    description?: string;
    group?: number;
    disable?: boolean;
    defaultValue?: string | string[];
    errorDescriptions?: string[];
    customErrorMessage?: string;
    value?: string | string[] | number | OptionSelect;
    lucideIcon?: LucideIcon;
    abstract type: FILTER_TYPE;
}

declare class FilterAutocomplete extends FilterBase implements Autocomplete {
    type: FILTER_TYPE;
    autocompleteSelected?: boolean;
}

declare class FilterButton extends FilterBase {
    type: FILTER_TYPE;
    style: string;
    icon: BUTTON_ICON;
    color?: string;
}

declare class FilterChipSelector extends FilterBase {
    type: FILTER_TYPE;
    multiple?: boolean;
}

declare class FilterDate extends FilterBase {
    type: FILTER_TYPE;
}

declare class FilterDateRange extends FilterBase {
    type: FILTER_TYPE;
}

declare class FilterInput extends FilterBase {
    type: FILTER_TYPE;
}

declare class FilterSelect extends FilterBase {
    type: FILTER_TYPE;
    multiple?: boolean;
}

declare abstract class ActionBase implements Action {
    id: string;
    description?: string;
    icon?: LucideIcon;
    color?: string;
    style?: string;
    class?: string;
    hide?: boolean;
    disable?: boolean;
    useSpinner?: boolean;
    abstract type: ACTION_TYPE;
}

declare class ActionButton extends ActionBase {
    type: ACTION_TYPE;
}

declare class ActionIcon extends ActionBase {
    type: ACTION_TYPE;
}

declare class FilterSelectState extends FilterBase {
    type: FILTER_TYPE;
}

declare class CustomValidators {
    static optionSelect(control: AbstractControl): ValidationErrors | null;
}

export { ACTION_TYPE, ActionBase, ActionButton, ActionIcon, BUTTON_ICON, BUTTON_STYLE, CustomValidators, FILTER_TYPE, FilterAutocomplete, FilterBase, FilterButton, FilterChipSelector, FilterDate, FilterDateRange, FilterInput, FilterSelect, FilterSelectState, INPUT_TYPE, KifToolbarModule, TOOLBAR_FILTER_ACTION, ToolbarComponent, VALIDATOR_ERROR_KEY };
export type { Action, Autocomplete, ErrorValidator, ErrorValidatorCondition, Filter, FilterChange, Group, LucideIcon, Mask, OptionSelect, ToolbarFilterAction };