import * as i0 from '@angular/core';
import { ElementRef, EventEmitter, ChangeDetectorRef, ViewContainerRef, InjectionToken, OnDestroy, AfterViewInit, DestroyRef, QueryList, TemplateRef, TrackByFunction, IterableDiffers } from '@angular/core';
import { Observable, Subscription, BehaviorSubject, Subject } from 'rxjs';
import * as _lucca_front_ng_option from '@lucca-front/ng/option';
import { ILuTree, LuTranslation, ILuGroup, ILuOnScrollBottomSubscriber, ILuOnOpenSubscriber, ILuOnCloseSubscriber } from '@lucca-front/ng/core';
import { ILuInputDisplayer } from '@lucca-front/ng/input';
import { ALuPickerPanel, ILuPickerPanel } from '@lucca-front/ng/picker';
import * as i1 from '@angular/common';
import { NgForOf, NgForOfContext } from '@angular/common';
import * as i2 from '@angular/cdk/overlay';
import * as i3 from '@lucca-front/ng/scroll';
import * as i4 from '@angular/cdk/a11y';
import { FormControl } from '@angular/forms';

interface ILuOptionItem<T> {
    value: T;
    onSelect: Observable<this>;
    element: ElementRef<HTMLElement>;
    selected: boolean;
    highlighted: boolean;
    disabled: boolean;
}
declare abstract class ALuOptionItem<T> implements ILuOptionItem<T> {
    abstract value: T;
    abstract onSelect: Observable<this>;
    abstract element: ElementRef;
    abstract selected: boolean;
    abstract highlighted: boolean;
    abstract disabled: boolean;
}

/**
 * @deprecated
 */
declare class LuOptionItemComponent<T> extends ALuOptionItem<T> implements ILuOptionItem<T> {
    private _cdr;
    protected _selected: boolean;
    get selected(): boolean;
    set selected(s: boolean);
    protected _highlighted: boolean;
    get highlighted(): boolean;
    set highlighted(h: boolean);
    value: T;
    onSelect: EventEmitter<this>;
    select(): void;
    protected _disabled: boolean;
    get disabled(): boolean;
    set disabled(d: boolean);
    element: ElementRef;
    constructor(_cdr: ChangeDetectorRef);
    static ɵfac: i0.ɵɵFactoryDeclaration<LuOptionItemComponent<any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LuOptionItemComponent<any>, "lu-option", never, { "selected": { "alias": "selected"; "required": false; }; "highlighted": { "alias": "highlighted"; "required": false; }; "value": { "alias": "value"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, { "onSelect": "onSelect"; }, never, ["*"], true, never>;
}

/**
 * @deprecated use `LuOptionItemComponent` instead
 */
declare class LuOptionItemModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<LuOptionItemModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<LuOptionItemModule, never, [typeof LuOptionItemComponent], [typeof LuOptionItemComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<LuOptionItemModule>;
}

interface ILuTreeOptionItem<T> extends ILuOptionItem<T> {
    children: this[];
    allChildren: this[];
    onSelectSelf: Observable<this>;
    onSelectChildren: Observable<this>;
}
declare abstract class ALuTreeOptionItem<T> extends ALuOptionItem<T> implements ILuTreeOptionItem<T> {
    abstract children: this[];
    get allChildren(): this[];
    abstract onSelectSelf: Observable<this>;
    abstract onSelectChildren: Observable<this>;
}

/**
 * @deprecated
 */
declare class LuTreeOptionItemComponent<T> extends ALuTreeOptionItem<T> implements ILuTreeOptionItem<T> {
    private _cdr;
    protected _children: this[];
    protected _tree: ILuTree<T>;
    protected _displayer: ILuInputDisplayer<T>;
    protected _valueVCR: ViewContainerRef;
    protected _childrenVCR: ViewContainerRef;
    element: ElementRef;
    onSelect: EventEmitter<this>;
    onSelectSelf: EventEmitter<this>;
    onSelectChildren: EventEmitter<this>;
    select(): void;
    selectSelf(): void;
    selectChildren(): void;
    set tree(t: ILuTree<T>);
    get value(): T;
    get children(): this[];
    set children(c: this[]);
    get hasChildren(): boolean;
    protected _selected: boolean;
    get selected(): boolean;
    set selected(s: boolean);
    protected _highlighted: boolean;
    get highlighted(): boolean;
    set highlighted(h: boolean);
    get disabled(): boolean;
    set _contentChildDisplayer(displayer: ILuInputDisplayer<T>);
    intl: i0.InputSignalWithTransform<_lucca_front_ng_option.ILuTreeOptionItemLabel, Partial<_lucca_front_ng_option.ILuTreeOptionItemLabel>>;
    constructor(_cdr: ChangeDetectorRef);
    private _renderValue;
    private _renderChildren;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuTreeOptionItemComponent<any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LuTreeOptionItemComponent<any>, "lu-tree-option", never, { "tree": { "alias": "tree"; "required": false; }; "selected": { "alias": "selected"; "required": false; }; "highlighted": { "alias": "highlighted"; "required": false; }; "intl": { "alias": "intl"; "required": false; "isSignal": true; }; }, { "onSelect": "onSelect"; "onSelectSelf": "onSelectSelf"; "onSelectChildren": "onSelectChildren"; }, ["_contentChildDisplayer"], never, true, never>;
}

/**
 * @deprecated use `LuTreeOptionItemComponent` instead
 */
declare class LuTreeOptionItemModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<LuTreeOptionItemModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<LuTreeOptionItemModule, never, [typeof LuTreeOptionItemComponent], [typeof LuTreeOptionItemComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<LuTreeOptionItemModule>;
}

declare const LU_TREE_OPTION_ITEM_TRANSLATIONS: InjectionToken<LuTranslation<ILuTreeOptionItemLabel>>;
interface ILuTreeOptionItemLabel {
    parentOnly: string;
    childrenOnly: string;
}
declare const luTreeOptionItemTranslations: LuTranslation<ILuTreeOptionItemLabel>;

type ILuOptionPickerPanel<T> = ILuPickerPanel<T>;
type LuOptionComparer<T> = (option1: T, option2: T) => boolean;
declare abstract class ALuOptionPicker<T, O extends ILuOptionItem<T> = ILuOptionItem<T>> extends ALuPickerPanel<T> implements ILuOptionPickerPanel<T> {
    protected _subs: Subscription;
    onSelectValue: Observable<T | T[]>;
    protected _value: T | T[];
    setValue(value: T | T[]): void;
    private __options$;
    protected get _options$(): Observable<O[]>;
    protected set _options$(options$: Observable<O[]>);
    protected optionComparer: LuOptionComparer<T>;
    protected _toggle(option: O): void;
    protected _select(val: T | T[]): void;
    protected abstract _applySelected(): any;
    protected abstract _applyHighlight(): any;
    protected destroy(): void;
    _handleKeydown(event: KeyboardEvent): void;
    protected abstract _emitSelectValue(value: T | T[]): any;
}

/**
 * @deprecated
 */
declare abstract class ALuOptionPickerComponent<T, O extends ILuOptionItem<T> = ILuOptionItem<T>> extends ALuOptionPicker<T, O> implements ILuOptionPickerPanel<T>, OnDestroy, AfterViewInit {
    protected _changeDetectorRef: ChangeDetectorRef;
    protected document: Document;
    protected destroyRef: DestroyRef;
    /**
     * This method takes classes set on the host lu-popover element and applies them on the
     * popover template that displays in the overlay container.  Otherwise, it's difficult
     * to style the containing popover from outside the component.
     * @param classes list of class names
     */
    set inputPanelClasses(classes: string);
    /**
     * This method takes classes set on the host lu-popover element and applies them on the
     * popover template that displays in the overlay container. Otherwise, it's difficult
     * to style the containing popover from outside the component.
     * @param classes list of class names
     */
    set inputContentClasses(classes: string);
    /**
     * This method take a function that compare options from feeder and options from form value.
     * By default, compare JSON values.
     */
    set inputOptionComparer(comparer: LuOptionComparer<T>);
    close: EventEmitter<void>;
    open: EventEmitter<void>;
    hovered: EventEmitter<boolean>;
    onSelectValue: EventEmitter<T>;
    protected _isOptionItemsInitialized: boolean;
    protected _defaultOverlayPaneClasses: string[];
    protected _options: O[];
    protected _optionsQL: QueryList<O>;
    set optionsQL(ql: QueryList<O>);
    constructor(_changeDetectorRef: ChangeDetectorRef, document: Document);
    protected _emitSelectValue(val: T): void;
    ngOnDestroy(): void;
    _emitOpenEvent(): void;
    _emitCloseEvent(): void;
    _emitHoveredEvent(h: boolean): void;
    onOpen(): void;
    set vcTemplateRef(tr: TemplateRef<HTMLElement>);
    _handleKeydown(event: KeyboardEvent): void;
    protected _highlightIndex: number;
    get highlightIndex(): number;
    set highlightIndex(i: number);
    protected _initHighlight(): void;
    protected _incrHighlight(): void;
    protected _decrHighlight(): void;
    protected _applyHighlight(reScroll?: boolean): void;
    protected _scrollToHighlight(targetElt: HTMLElement): void;
    protected _selectHighlighted(): void;
    protected _initSelected(): void;
    protected _applySelected(): void;
    protected initItems(): void;
    ngAfterViewInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ALuOptionPickerComponent<any, any>, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ALuOptionPickerComponent<any, any>, never, never, { "inputPanelClasses": { "alias": "panel-classes"; "required": false; }; "inputContentClasses": { "alias": "content-classes"; "required": false; }; "inputOptionComparer": { "alias": "option-comparer"; "required": false; }; }, { "close": "close"; "open": "open"; "hovered": "hovered"; "onSelectValue": "onSelectValue"; }, ["optionsQL"], never, true, never>;
}
/**
 * basic option picker panel
 * @deprecated
 */
declare class LuOptionPickerComponent<T, O extends ILuOptionItem<T> = ILuOptionItem<T>> extends ALuOptionPickerComponent<T, O> {
    constructor(_changeDetectorRef: ChangeDetectorRef, document: Document);
    static ɵfac: i0.ɵɵFactoryDeclaration<LuOptionPickerComponent<any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LuOptionPickerComponent<any, any>, "lu-option-picker", ["LuOptionPicker"], {}, {}, never, ["*"], true, never>;
}

interface ILuOptionOperator<T> {
    inOptions$?: Observable<T[]>;
    outOptions$?: Observable<T[]>;
}
declare abstract class ALuOptionOperator<T> implements ILuOptionOperator<T> {
    abstract inOptions$?: Observable<T[]>;
    abstract outOptions$?: Observable<T[]>;
}

declare class LuOptionFeederComponent<T> implements ILuOptionOperator<T> {
    outOptions$: BehaviorSubject<T[]>;
    set options(options: T[]);
    static ɵfac: i0.ɵɵFactoryDeclaration<LuOptionFeederComponent<any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LuOptionFeederComponent<any>, "lu-option-feeder", never, { "options": { "alias": "options"; "required": false; }; }, {}, never, never, true, never>;
}

/**
 * @deprecated use `LuOptionFeederComponent` instead
 */
declare class LuOptionFeederModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<LuOptionFeederModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<LuOptionFeederModule, never, [typeof LuOptionFeederComponent], [typeof LuOptionFeederComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<LuOptionFeederModule>;
}

type ILuTreeOptionOperator<T> = ILuOptionOperator<ILuTree<T>>;
declare abstract class ALuTreeOptionOperator<T> extends ALuOptionOperator<ILuTree<T>> implements ILuTreeOptionOperator<T> {
}

/**
 * @deprecated
 */
declare class LuTreeOptionFeederComponent<T> implements ILuTreeOptionOperator<T> {
    outOptions$: BehaviorSubject<ILuTree<T>[]>;
    set options(options: ILuTree<T>[]);
    static ɵfac: i0.ɵɵFactoryDeclaration<LuTreeOptionFeederComponent<any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LuTreeOptionFeederComponent<any>, "lu-tree-option-feeder", never, { "options": { "alias": "options"; "required": false; }; }, {}, never, never, true, never>;
}

/**
 * @deprecated use `LuTreeOptionFeederComponent` instead
 */
declare class LuTreeOptionFeederModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<LuTreeOptionFeederModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<LuTreeOptionFeederModule, never, [typeof LuTreeOptionFeederComponent], [typeof LuTreeOptionFeederComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<LuTreeOptionFeederModule>;
}

declare class LuForGroupContext<T> {
    $implicit: T;
    index: number;
    count: number;
    constructor($implicit: T, index: number, count: number);
    get first(): boolean;
    get last(): boolean;
    get even(): boolean;
    get odd(): boolean;
}
declare class LuForGroupsDirective<TItem, TKey> implements ILuOptionOperator<TItem>, OnDestroy {
    protected _vcr: ViewContainerRef;
    protected _cdr: ChangeDetectorRef;
    protected _templateRef: TemplateRef<LuForGroupContext<ILuGroup<TItem, TKey>>>;
    outOptions$?: Observable<TItem[]>;
    private _groupByFn;
    set attrGroupBy(fn: (item: TItem) => TKey);
    protected _subs: Subscription;
    set inOptions$(options$: Observable<TItem[]>);
    constructor(_vcr: ViewContainerRef, _cdr: ChangeDetectorRef, _templateRef: TemplateRef<LuForGroupContext<ILuGroup<TItem, TKey>>>);
    ngOnDestroy(): void;
    render(options: TItem[]): void;
    protected groupBy(items: TItem[]): ILuGroup<TItem, TKey>[];
    static ɵfac: i0.ɵɵFactoryDeclaration<LuForGroupsDirective<any, any>, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<LuForGroupsDirective<any, any>, "[luForGroups]", never, { "attrGroupBy": { "alias": "luForGroupsGroupBy"; "required": false; }; }, {}, never, never, true, never>;
}

declare class LuForOptionsDirective<T> extends NgForOf<T> implements ILuOptionOperator<T>, OnDestroy {
    protected _changeDetectionRef: ChangeDetectorRef;
    outOptions$: any;
    protected _subs: Subscription;
    set inOptions$(options$: Observable<T[]>);
    set luForOptionsTrackBy(fn: TrackByFunction<T>);
    constructor(_viewContainer: ViewContainerRef, _template: TemplateRef<NgForOfContext<T>>, _differs: IterableDiffers, _changeDetectionRef: ChangeDetectorRef);
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuForOptionsDirective<any>, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<LuForOptionsDirective<any>, "[luForOptions]", never, { "luForOptionsTrackBy": { "alias": "luForOptionsTrackBy"; "required": false; }; }, {}, never, never, true, never>;
}

/**
 * @deprecated use `LuForOptionsDirective` instead
 */
declare class LuForOptionsModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<LuForOptionsModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<LuForOptionsModule, never, [typeof LuForOptionsDirective], [typeof LuForOptionsDirective]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<LuForOptionsModule>;
}

/**
 * @deprecated
 */
declare class LuForTreeOptionsDirective<T> extends LuForOptionsDirective<ILuTree<T>> implements ILuTreeOptionOperator<T>, OnDestroy {
    static ɵfac: i0.ɵɵFactoryDeclaration<LuForTreeOptionsDirective<any>, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<LuForTreeOptionsDirective<any>, "[luForTreeOptions]", never, {}, {}, never, never, true, never>;
}

/**
 * @deprecated use `LuForTreeOptionsDirective` instead
 */
declare class LuForTreeOptionsModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<LuForTreeOptionsModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<LuForTreeOptionsModule, never, [typeof LuForTreeOptionsDirective], [typeof LuForTreeOptionsDirective]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<LuForTreeOptionsModule>;
}

declare class LuOptionPagerComponent<T> extends ALuOptionOperator<T> implements ILuOptionOperator<T>, ILuOnScrollBottomSubscriber {
    outOptions$: Observable<T[]>;
    set inOptions$(in$: Observable<T[]>);
    paging$: BehaviorSubject<number>;
    next(): void;
    onScrollBottom(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuOptionPagerComponent<any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LuOptionPagerComponent<any>, "lu-option-pager", never, {}, {}, never, never, true, never>;
}

/**
 * @deprecated use `LuOptionPagerComponent` instead
 */
declare class LuOptionPagerModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<LuOptionPagerModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<LuOptionPagerModule, never, [typeof LuOptionPagerComponent], [typeof LuOptionPagerComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<LuOptionPagerModule>;
}

/**
 * @deprecated
 */
declare class LuTreeOptionPagerComponent<T> extends ALuTreeOptionOperator<T> implements ILuTreeOptionOperator<T>, ILuOnScrollBottomSubscriber {
    outOptions$: Observable<ILuTree<T>[]>;
    set inOptions$(in$: Observable<ILuTree<T>[]>);
    paging$: BehaviorSubject<number>;
    next(): void;
    onScrollBottom(): void;
    trim(trees?: ILuTree<T>[], paging?: number): ILuTree<T>[];
    flatten(trees?: ILuTree<T>[]): T[];
    filter(trees: ILuTree<T>[], values: T[]): ILuTree<T>[];
    static ɵfac: i0.ɵɵFactoryDeclaration<LuTreeOptionPagerComponent<any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LuTreeOptionPagerComponent<any>, "lu-tree-option-pager", never, {}, {}, never, never, true, never>;
}

declare class LuOptionSearcherComponent<T> extends ALuOptionOperator<T> implements ILuOptionOperator<T>, ILuOnOpenSubscriber {
    searchControl: FormControl<any>;
    clue$: Observable<string>;
    empty$: Observable<boolean>;
    searchInput: ElementRef<HTMLElement>;
    outOptions$: Observable<T[]>;
    set inOptions$(in$: Observable<T[]>);
    searchFn: (option: T, clue: string) => boolean;
    onOpen(): void;
    resetClue(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuOptionSearcherComponent<any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LuOptionSearcherComponent<any>, "lu-option-searcher", never, { "searchFn": { "alias": "searchFn"; "required": false; }; }, {}, never, never, true, never>;
}

/**
 * @deprecated use `LuOptionSearcherComponent` instead
 */
declare class LuOptionSearcherModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<LuOptionSearcherModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<LuOptionSearcherModule, never, [typeof LuOptionSearcherComponent], [typeof LuOptionSearcherComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<LuOptionSearcherModule>;
}

/**
 * @deprecated
 */
declare class LuTreeOptionSearcherComponent<T> extends ALuTreeOptionOperator<T> implements ILuTreeOptionOperator<T>, ILuOnOpenSubscriber {
    searchControl: FormControl<any>;
    clue$: Observable<string>;
    empty$: Observable<boolean>;
    searchInput: ElementRef<HTMLElement>;
    outOptions$: Observable<ILuTree<T>[]>;
    set inOptions$(in$: Observable<ILuTree<T>[]>);
    searchFn: (option: T, clue: string) => boolean;
    onOpen(): void;
    trim(options: ILuTree<T>[], clue: string): ILuTree<T>[];
    resetClue(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuTreeOptionSearcherComponent<any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LuTreeOptionSearcherComponent<any>, "lu-tree-option-searcher", never, { "searchFn": { "alias": "searchFn"; "required": false; }; }, {}, never, never, true, never>;
}

/**
 * @deprecated use `LuTreeOptionSearcherComponent` instead
 */
declare class LuTreeOptionSearcherModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<LuTreeOptionSearcherModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<LuTreeOptionSearcherModule, never, [typeof LuTreeOptionSearcherComponent], [typeof LuTreeOptionSearcherComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<LuTreeOptionSearcherModule>;
}

/**
 * @deprecated use `LuTreeOptionFeederComponent, LuForTreeOptionsDirective, LuTreeOptionPagerComponent, LuTreeOptionSearcherComponent` instead
 */
declare class LuTreeOptionOperatorModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<LuTreeOptionOperatorModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<LuTreeOptionOperatorModule, never, [typeof LuTreeOptionFeederComponent, typeof LuForTreeOptionsDirective, typeof LuTreeOptionPagerComponent, typeof LuTreeOptionSearcherModule], [typeof LuTreeOptionFeederComponent, typeof LuForTreeOptionsDirective, typeof LuTreeOptionPagerComponent, typeof LuTreeOptionSearcherModule]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<LuTreeOptionOperatorModule>;
}

interface ILuOptionSelector<T> {
    multiple: boolean;
    onSelectValue: Observable<T | T[]>;
    setValue(value: T | T[]): void;
}
declare abstract class ALuOptionSelector<T> implements ILuOptionSelector<T> {
    multiple: boolean;
    abstract onSelectValue: Observable<T | T[]>;
    abstract setValue(value: T | T[]): void;
}

type ILuTreeOptionSelector<T> = ILuOptionSelector<T>;
declare abstract class ALuTreeOptionSelector<T> extends ALuOptionSelector<T> implements ILuTreeOptionSelector<T> {
}

/**
 * @deprecated
 */
declare class LuOptionSelectAllComponent<T> extends ALuOptionOperator<T> implements ILuOptionSelector<T> {
    multiple: boolean;
    onSelectValue: Subject<T | T[]>;
    private _values;
    fixed: boolean;
    options: T[];
    outOptions$: Observable<T[]>;
    set inOptions$(in$: Observable<T[]>);
    intl: i0.InputSignalWithTransform<_lucca_front_ng_option.ILuOptionSelectAllLabel, Partial<_lucca_front_ng_option.ILuOptionSelectAllLabel>>;
    selectAll(): void;
    deselectAll(): void;
    setValue(values: T | T[]): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuOptionSelectAllComponent<any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LuOptionSelectAllComponent<any>, "lu-option-select-all", never, { "intl": { "alias": "intl"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

/**
 * @deprecated use `LuOptionSelectAllComponent` instead
 */
declare class LuOptionSelectAllModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<LuOptionSelectAllModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<LuOptionSelectAllModule, never, [typeof LuOptionSelectAllComponent], [typeof LuOptionSelectAllComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<LuOptionSelectAllModule>;
}

declare const LU_OPTION_SELECT_ALL_TRANSLATIONS: InjectionToken<LuTranslation<ILuOptionSelectAllLabel>>;
interface ILuOptionSelectAllLabel {
    select: string;
    deselect: string;
}
declare const luOptionSelectAllTranslations: LuTranslation<ILuOptionSelectAllLabel>;

/**
 * @deprecated
 */
declare class LuTreeOptionSelectAllComponent<T> extends ALuTreeOptionOperator<T> implements ILuTreeOptionSelector<T> {
    multiple: boolean;
    onSelectValue: Subject<T | T[]>;
    private _values;
    fixed: boolean;
    flatOptions: T[];
    outOptions$: Observable<ILuTree<T>[]>;
    set inOptions$(in$: Observable<ILuTree<T>[]>);
    intl: i0.InputSignalWithTransform<_lucca_front_ng_option.ILuOptionSelectAllLabel, Partial<_lucca_front_ng_option.ILuOptionSelectAllLabel>>;
    selectAll(): void;
    deselectAll(): void;
    setValue(values: T | T[]): void;
    private flattenTree;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuTreeOptionSelectAllComponent<any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LuTreeOptionSelectAllComponent<any>, "lu-tree-option-select-all", never, { "intl": { "alias": "intl"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

/**
 * @deprecated
 */
declare abstract class ALuOptionPickerAdvancedComponent<T, O extends ILuOptionItem<T> = ILuOptionItem<T>> extends ALuOptionPickerComponent<T, O> implements AfterViewInit {
    loading$: Observable<boolean>;
    protected _operators: ILuOptionOperator<T>[];
    protected _operatorsQL: QueryList<ILuOptionOperator<T>>;
    set operatorsQL(ql: QueryList<ILuOptionOperator<T>>);
    protected _onOpenSubscribers: ILuOnOpenSubscriber[];
    set onOpenSubsQL(ql: QueryList<ILuOnOpenSubscriber>);
    protected _onCloseSubscribers: ILuOnCloseSubscriber[];
    set onCloseSubsQL(ql: QueryList<ILuOnCloseSubscriber>);
    protected _onScrollBottomSubscribers: ILuOnScrollBottomSubscriber[];
    set onScrollBottomSubsQL(ql: QueryList<ILuOnScrollBottomSubscriber>);
    protected _selectors: ILuOptionSelector<T>[];
    protected _selectorsQL: QueryList<ILuOptionSelector<T>>;
    set selectorsQL(ql: QueryList<ILuOptionSelector<T>>);
    constructor(_changeDetectorRef: ChangeDetectorRef, document: Document);
    onScrollBottom(): void;
    onOpen(): void;
    onClose(): void;
    setValue(value: T | T[]): void;
    protected initOperators(): void;
    protected initSelectors(): void;
    ngAfterViewInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ALuOptionPickerAdvancedComponent<any, any>, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ALuOptionPickerAdvancedComponent<any, any>, never, never, {}, {}, ["operatorsQL", "onOpenSubsQL", "onCloseSubsQL", "onScrollBottomSubsQL", "selectorsQL"], never, true, never>;
}
/**
 * advanced option picker panel
 * @deprecated
 */
declare class LuOptionPickerAdvancedComponent<T, O extends ILuOptionItem<T> = ILuOptionItem<T>> extends ALuOptionPickerAdvancedComponent<T, O> {
    constructor(_changeDetectorRef: ChangeDetectorRef, document: Document);
    static ɵfac: i0.ɵɵFactoryDeclaration<LuOptionPickerAdvancedComponent<any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LuOptionPickerAdvancedComponent<any, any>, "lu-option-picker-advanced", ["LuOptionPickerAdvanced"], {}, {}, never, ["*"], true, never>;
}

/**
 * @deprecated use `LuOptionPickerComponent, LuOptionPickerAdvancedComponent, LuOptionItemComponent` instead
 */
declare class LuOptionPickerModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<LuOptionPickerModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<LuOptionPickerModule, never, [typeof LuOptionPickerComponent, typeof LuOptionPickerAdvancedComponent, typeof LuOptionItemComponent], [typeof LuOptionPickerComponent, typeof LuOptionPickerAdvancedComponent, typeof LuOptionItemComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<LuOptionPickerModule>;
}

type ILuTreeOptionPickerPanel<T> = ILuOptionPickerPanel<T>;
declare abstract class ALuTreeOptionPicker<T, I extends ILuTreeOptionItem<T> = ILuTreeOptionItem<T>> extends ALuOptionPicker<T, I> implements ILuTreeOptionPickerPanel<T> {
}

declare enum ToggleMode {
    all = 0,
    self = 1,
    children = 2
}
/**
 * @deprecated
 */
declare abstract class ALuTreeOptionPickerComponent<T, O extends ILuTreeOptionItem<T> = ILuTreeOptionItem<T>> extends ALuOptionPickerComponent<T, O> implements ILuTreeOptionPickerPanel<T>, OnDestroy, AfterViewInit {
    set optionsQL(ql: QueryList<O>);
    optionsQLVR: QueryList<ViewContainerRef>;
    protected set _options$(optionItems$: Observable<O[]>);
    constructor(_changeDetectorRef: ChangeDetectorRef, document: Document);
    protected _toggle(option: O, mod?: ToggleMode): void;
    protected _toggleAll(option: O): void;
    protected _toggleSelf(option: O): void;
    protected _toggleChildren(option: O): void;
    protected _add(values: T[], entries: T[]): T[];
    protected _remove(values: T[], entries: T[]): T[];
    protected initItems(): void;
    ngAfterViewInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ALuTreeOptionPickerComponent<any, any>, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ALuTreeOptionPickerComponent<any, any>, never, never, {}, {}, ["optionsQL", "optionsQLVR"], never, true, never>;
}
/**
 * basic tree option picker panel
 * @deprecated
 */
declare class LuTreeOptionPickerComponent<T, O extends ILuTreeOptionItem<T> = ILuTreeOptionItem<T>> extends ALuTreeOptionPickerComponent<T, O> {
    constructor(_changeDetectorRef: ChangeDetectorRef, document: Document);
    static ɵfac: i0.ɵɵFactoryDeclaration<LuTreeOptionPickerComponent<any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LuTreeOptionPickerComponent<any, any>, "lu-tree-option-picker", ["LuTreeOptionPicker"], {}, {}, never, ["*"], true, never>;
}

/**
 * @deprecated
 */
declare abstract class ALuTreeOptionPickerAdvancedComponent<T, O extends ILuTreeOptionItem<T> = ILuTreeOptionItem<T>> extends ALuTreeOptionPickerComponent<T, O> implements AfterViewInit {
    loading$: Observable<boolean>;
    protected _operators: ILuTreeOptionOperator<T>[];
    protected _operatorsQL: QueryList<ILuTreeOptionOperator<T>>;
    set operatorsQL(ql: QueryList<ILuTreeOptionOperator<T>>);
    protected _onOpenSubscribers: ILuOnOpenSubscriber[];
    set onOpenSubsQL(ql: QueryList<ILuOnOpenSubscriber>);
    protected _onCloseSubscribers: ILuOnCloseSubscriber[];
    set onCloseSubsQL(ql: QueryList<ILuOnCloseSubscriber>);
    protected _onScrollBottomSubscribers: ILuOnScrollBottomSubscriber[];
    set onScrollBottomSubsQL(ql: QueryList<ILuOnScrollBottomSubscriber>);
    protected _selectorsQL: QueryList<ILuTreeOptionSelector<T>>;
    protected _selectors: ILuTreeOptionSelector<T>[];
    set selectorsQL(ql: QueryList<ILuTreeOptionSelector<T>>);
    constructor(_changeDetectorRef: ChangeDetectorRef, document: Document);
    onScrollBottom(): void;
    onOpen(): void;
    onClose(): void;
    setValue(value: T | T[]): void;
    protected initOperators(): void;
    protected initSelectors(): void;
    ngAfterViewInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ALuTreeOptionPickerAdvancedComponent<any, any>, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ALuTreeOptionPickerAdvancedComponent<any, any>, never, never, {}, {}, ["operatorsQL", "onOpenSubsQL", "onCloseSubsQL", "onScrollBottomSubsQL", "selectorsQL"], never, true, never>;
}
/**
 * advanced option picker panel
 * @deprecated
 */
declare class LuTreeOptionPickerAdvancedComponent<T, O extends ILuTreeOptionItem<T> = ILuTreeOptionItem<T>> extends ALuTreeOptionPickerAdvancedComponent<T, O> {
    constructor(_changeDetectorRef: ChangeDetectorRef, document: Document);
    static ɵfac: i0.ɵɵFactoryDeclaration<LuTreeOptionPickerAdvancedComponent<any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LuTreeOptionPickerAdvancedComponent<any, any>, "lu-tree-option-picker-advanced", ["LuOptionPicker"], {}, {}, never, ["*"], true, never>;
}

/**
 * @deprecated
 */
declare class LuTreeOptionPickerModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<LuTreeOptionPickerModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<LuTreeOptionPickerModule, never, [typeof i1.CommonModule, typeof i2.OverlayModule, typeof i3.LuScrollDirective, typeof i4.A11yModule, typeof LuTreeOptionPickerAdvancedComponent, typeof LuTreeOptionPickerComponent], [typeof LuTreeOptionPickerComponent, typeof LuTreeOptionPickerAdvancedComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<LuTreeOptionPickerModule>;
}

/**
 * @deprecated
 */
declare class LuOptionPlaceholderComponent {
    onClear: EventEmitter<any>;
    intl: i0.InputSignalWithTransform<_lucca_front_ng_option.ILuOptionPlaceholderLabel, Partial<_lucca_front_ng_option.ILuOptionPlaceholderLabel>>;
    clear(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuOptionPlaceholderComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LuOptionPlaceholderComponent, "lu-option-placeholder", never, { "intl": { "alias": "intl"; "required": false; "isSignal": true; }; }, { "onClear": "onClear"; }, never, never, true, never>;
}

declare const LU_OPTION_PLACEHOLDER_TRANSLATIONS: InjectionToken<LuTranslation<ILuOptionPlaceholderLabel>>;
interface ILuOptionPlaceholderLabel {
    placeholderDescription: string;
    placeholderAction: string;
}
declare const luOptionPlaceholderTranslations: LuTranslation<ILuOptionPlaceholderLabel>;

/**
 * @deprecated use `LuOptionItemComponent, LuOptionPickerComponent, LuOptionPickerAdvancedComponent, LuOptionPagerComponent,
        LuOptionFeederComponent,
        LuOptionSearcherComponent,
        LuForOptionsDirective,
        LuForGroupsDirective,
        LuOptionSelectAllComponent,
        LuOptionPlaceholderComponent` instead
 */
declare class LuOptionModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<LuOptionModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<LuOptionModule, never, [typeof LuOptionItemComponent, typeof LuOptionPickerComponent, typeof LuOptionPickerAdvancedComponent, typeof LuOptionPagerComponent, typeof LuOptionFeederComponent, typeof LuOptionSearcherComponent, typeof LuForOptionsDirective, typeof LuForGroupsDirective, typeof LuOptionSelectAllComponent, typeof LuOptionPlaceholderComponent], [typeof LuOptionItemComponent, typeof LuOptionPickerAdvancedComponent, typeof LuOptionPickerComponent, typeof LuOptionPagerComponent, typeof LuOptionFeederComponent, typeof LuOptionSearcherComponent, typeof LuForOptionsDirective, typeof LuForGroupsDirective, typeof LuOptionSelectAllComponent, typeof LuOptionPlaceholderComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<LuOptionModule>;
}

/**
 * @deprecated use `LuTreeOptionSelectAllComponent` instead
 */
declare class LuTreeOptionModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<LuTreeOptionModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<LuTreeOptionModule, never, [typeof LuTreeOptionItemModule, typeof LuTreeOptionPickerModule, typeof LuTreeOptionOperatorModule, typeof LuTreeOptionSelectAllComponent], [typeof LuTreeOptionItemModule, typeof LuTreeOptionPickerModule, typeof LuTreeOptionOperatorModule, typeof LuTreeOptionSelectAllComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<LuTreeOptionModule>;
}

export { ALuOptionItem, ALuOptionOperator, ALuOptionPicker, ALuOptionPickerAdvancedComponent, ALuOptionPickerComponent, ALuOptionSelector, ALuTreeOptionItem, ALuTreeOptionOperator, ALuTreeOptionPicker, ALuTreeOptionPickerAdvancedComponent, ALuTreeOptionPickerComponent, ALuTreeOptionSelector, LU_OPTION_PLACEHOLDER_TRANSLATIONS, LU_OPTION_SELECT_ALL_TRANSLATIONS, LU_TREE_OPTION_ITEM_TRANSLATIONS, LuForGroupContext, LuForGroupsDirective, LuForOptionsDirective, LuForOptionsModule, LuForTreeOptionsDirective, LuForTreeOptionsModule, LuOptionFeederComponent, LuOptionFeederModule, LuOptionItemComponent, LuOptionItemModule, LuOptionModule, LuOptionPagerComponent, LuOptionPagerModule, LuOptionPickerAdvancedComponent, LuOptionPickerComponent, LuOptionPickerModule, LuOptionPlaceholderComponent, LuOptionSearcherComponent, LuOptionSearcherModule, LuOptionSelectAllComponent, LuOptionSelectAllModule, LuTreeOptionFeederComponent, LuTreeOptionFeederModule, LuTreeOptionItemComponent, LuTreeOptionItemModule, LuTreeOptionModule, LuTreeOptionOperatorModule, LuTreeOptionPagerComponent, LuTreeOptionPickerAdvancedComponent, LuTreeOptionPickerComponent, LuTreeOptionPickerModule, LuTreeOptionSearcherComponent, LuTreeOptionSearcherModule, LuTreeOptionSelectAllComponent, luOptionPlaceholderTranslations, luOptionSelectAllTranslations, luTreeOptionItemTranslations };
export type { ILuOptionItem, ILuOptionOperator, ILuOptionPickerPanel, ILuOptionPlaceholderLabel, ILuOptionSelectAllLabel, ILuOptionSelector, ILuTreeOptionItem, ILuTreeOptionItemLabel, ILuTreeOptionOperator, ILuTreeOptionPickerPanel, ILuTreeOptionSelector, LuOptionComparer };