import { NumberInput } from '@angular/cdk/coercion';
import { ChangeDetectorRef, EventEmitter } from '@angular/core';
import { Destroy } from '@deja-js/component/core';
import { Observable } from 'rxjs';
import { IGroupInfo } from './grouping/group-infos';
import { GroupingService } from './grouping/grouping.service';
import { IItemBase } from './item-base';
import { IFindItemResult, IParentListInfoResult, ItemListService, IViewListResult } from './item-list.service';
import { IItemTree } from './item-tree';
import { ISortInfos } from './sorting/sort-infos.model';
import { SortingService } from './sorting/sorting.service';
import { IViewPort, ViewPortService } from './viewport.service';
/** Classe de base pour tous les composants à listes (deja-treelist, deja-select, deja-grid) */
export declare abstract class ItemListBase<T> extends Destroy {
    protected changeDetectorRef: ChangeDetectorRef;
    protected viewPort: ViewPortService;
    protected _waiter: boolean;
    protected _itemList: IItemBase<T>[];
    protected _multiSelect: boolean;
    protected _searchField: string;
    protected _maxHeight: number;
    protected _currentItemIndex: number;
    protected _currentItem: IItemBase<T>;
    protected _hintLabel: string;
    protected _nodataLabel: string;
    protected _hideSelected: boolean;
    protected _childrenField: string;
    protected _minSearchLength: number;
    protected _listElementId: string;
    protected _vpBeforeHeight: number;
    protected _vpAfterHeight: number;
    protected _vpStartRow: number;
    protected _vpEndRow: number;
    protected _pageSize: number;
    protected _depthMax: number;
    protected rowsCount: number;
    protected _sortInfos: ISortInfos;
    protected _viewPortChanged: EventEmitter<IViewPort>;
    protected _ddStartIndex: number;
    protected _ddTargetIndex: number;
    private _textField;
    private _valueField;
    private waiter$sub;
    private _itemListService;
    private allCollapsed;
    private _viewPortRowHeight;
    private _listElement;
    constructor(changeDetectorRef: ChangeDetectorRef, viewPort: ViewPortService);
    get isMultiSelect(): boolean;
    get itemList(): IItemBase<T>[];
    get treeItemList(): IItemTree<T>[];
    get ddStartIndex(): number;
    get vpBeforeHeight(): number;
    get vpAfterHeight(): number;
    get vpStartRow(): number;
    get vpEndRow(): number;
    /** Renvoie le modèle de tri appliqué à la liste.
     * @param sortInfos Modèle de tri appliqué.
     */
    get sortInfos(): ISortInfos;
    /** Renvoie le modèle de regroupement appliqué à la liste.
     * @param sortInfos Modèle de regroupement appliqué.
     */
    get groupInfos(): IGroupInfo[];
    /** Définit une valeur indiquant si les éléments selectionés doivent être masqué. Ce flag est principalement utilisé dans le cas d'un multi-select
     * @param value True si les éléments selectionés doivent être masqués
     */
    setHideSelected(value: boolean): void;
    /** Définit le champs utilisé comme collection pour les enfants d'un parent.
     * @param value Nom du champ à utiliser comme collection d'enfants
     */
    setChildrenField(value: string): void;
    /** Renvoie l'index de l'élément sur la liste plate corespondant à l'élément HTML spécifié
     * @return Index sur la liste plate corespondant à l'élément HTML
     */
    getItemIndexFromHTMLElement(element: HTMLElement): number;
    getItemFromHTMLElement(element: HTMLElement): IItemBase<T>;
    /** Retourne le service de liste utilisé par ce composant.
     * @return Service de liste utilisé par ce composant.
     */
    getItemListService(): ItemListService<T>;
    /** Retourne la liste des éléments sélectionés.
     * @return Liste des éléments selectionés.
     */
    getSelectedItems(): IItemBase<T>[];
    /** Définit la liste des éléments sélectionés.
     * @param items Liste des éléments a selectioner.
     */
    setSelectedItems(value: IItemBase<T>[]): void;
    /**
     * Set a promise or an observable called before an item selection
     */
    setLoadingItems(fn: (query: string | RegExp, selectedItems: IItemBase<T>[]) => Observable<IItemBase<T>[]>): void;
    /**
     * Set a promise or an observable called before an item deselection
     */
    setSelectingItem(fn: (item: IItemBase<T>) => Promise<IItemBase<T>> | Observable<IItemBase<T>>): void;
    /**
     * Set a promise or an observable called before an item deselection
     */
    setUnselectingItem(fn: (item: IItemBase<T>) => Promise<IItemBase<T>> | Observable<IItemBase<T>>): void;
    /**
     * Set a promise or an observable called before an item selection
     */
    setExpandingItem(fn: (item: IItemTree<T>) => Promise<IItemTree<T>> | Observable<IItemTree<T>>): void;
    /**
     * Set a promise or an observable called before an item deselection
     */
    setCollapsingItem(fn: (item: IItemTree<T>) => Promise<IItemTree<T>> | Observable<IItemTree<T>>): void;
    /** Evalue le texte à afficher pour l'élément spécifié.
     * @param value  Model à évaluer.
     * @return Texte à afficher pour le modèle spécifié.
     */
    getTextValue(value: unknown): string;
    /**
     * Set le viewport mode
     *
     * @param mode Mode du viewport (sans viewport, avec un viewport tailles des rows fixes ou dynamiques)
     */
    setViewportMode(mode: string): void;
    /** Trie la liste par le champs spécifié. */
    sort(name?: string): void;
    /** Trie la liste par le champs spécifié. */
    sort$(name?: string): Observable<IViewListResult<T>>;
    /** Groupe les éléments en fonction du modèle de groupe spécifié
     * @param groupInfos Modèle de groupe à appliquer.
     * @return Observable résolu par la fonction.
     */
    group$(groups: IGroupInfo[]): Observable<IViewListResult<T>>;
    /** Retire les groupe correspondants au modèle de groupe spécifié
     * @param groupInfos Modèle de groupe à retirer.
     * @return Observable résolu par la fonction.
     */
    ungroup$(groupInfo: IGroupInfo): Observable<IViewListResult<T>>;
    /** Change l'état d'expansion de tous les éléments.
     * @return Observable résolu par la fonction.
     */
    toggleAll$(collapsed?: boolean): Observable<IItemTree<T>[]>;
    /** Change l'état d'expansion de l'élément spécifié par son index sur la liste des éléments visibles.
     * @param index  Index sur la liste des éléments visibles de l'élément à changer.
     * @param collapse  Etat de l'élément. True pour réduire l'élément.
     * @return Observable résolu par la fonction.
     */
    toggleCollapse$(index: number, collapsed: boolean): Observable<IItemTree<T>>;
    /** Déselectionne tous les éléments sélectionés.
     * @return Observable résolu par la fonction.
     */
    unselectAll$(): Observable<IItemBase<T>[]>;
    /** Nettoye les caches et réaffiche le viewport. */
    refresh(): void;
    /** Recalcule le viewport. */
    refreshViewPort(item?: IItemBase<T> | IItemBase<T>[], clearMeasuredHeight?: boolean): void;
    /** Efface le viewport */
    clearViewPort(): void;
    /** Efface la hauteur calculée des lignes en mode automatique */
    clearRowsHeight(): void;
    /** Retrouve les informations du parent de l'élément spécifié
     * @param item Element enfant du parent à retrouver.
     * @return Observable résolu par la fonction, qui retourne les informations sur le parent de l'élément spécifié
     */
    getParentListInfos$(item: IItemTree<T>): Observable<IParentListInfoResult<T>>;
    get listElementId(): string;
    get listElement(): HTMLElement;
    set listElement(elem: HTMLElement);
    getViewPortRowHeight(): number;
    getCurrentItemIndex(): number;
    /** Retourne l'élément courant (actif).
     * @return Elément courant.
     */
    getCurrentItem(): IItemBase<T>;
    getItemHeight(item: IItemBase<T>): number;
    protected getSelectedModels(): (T | IItemBase<T>)[];
    protected setSelectedModels(values: unknown[]): void;
    /** Trouve l'élément suivant répondant à la fonction de comparaison spécifiée.
     * @param compare Function de comparaison pour la recherche de l'élément.
     * @param startIndex Index de départ sur la liste des éléments visibles.
     * @return Observable résolu par la fonction.
     */
    protected findNextMatch$(compare?: (item: IItemBase<T>, index: number) => boolean, startIndex?: number): Observable<IFindItemResult<T>>;
    /** Définit la hauteur d'une ligne pour le calcul du viewport. Le Viewport ne fonctionne qu'avec des hauteurs de lignes fixe.
     * Pour désactiver le viewport, mettre la hauteur de ligne à 0.
     * Attention, une désactivation du viewport dégrade considérablement les performances de la liste et ne doit pas être activée si la liste
     * est suceptible de contenir beaucoup d'éléments.
     * @param value Hauteur de ligne à utiliser pour le calcul du viewport.
     */
    protected setViewPortRowHeight(value: NumberInput): void;
    /** Definit le service de liste utilisé par ce composant.
     * @param value Service de liste utilisé par ce composant.
     */
    protected setItemListService(value: ItemListService<T>): void;
    /** Definit le service de tri utilisé par ce composant.
     * @param value Service de tri utilisé par ce composant.
     */
    protected setSortingService(value: SortingService): void;
    /** Definit le service de regroupement utilisé par ce composant.
     * @param value Service de regroupement utilisé par ce composant.
     */
    protected setGroupingService(value: GroupingService): void;
    /** Définit le texte à afficher dans la zone de conseil.
     * @param value Texte à afficher.
     */
    protected setHintLabel(value: string): void;
    /** Définit le texte à afficher si la liste est vide.
     * @param value Texte à afficher.
     */
    protected setNodataLabel(value: string): void;
    protected setCurrentItemIndex(value: number): void;
    /** Définit l'élément courant (actif).
     * @param item Elément courant.
     */
    protected setCurrentItem(item: IItemBase<T>): void;
    /** Retourne l'index correspondant à l'élément spéficié dans la liste des éléments visibles
     * @param item Element à chercher sur la liste des éléments visibles.
     * @return Index correspondant à l'élément recherché.
     */
    protected getItemIndex(item: IItemBase<T>): number;
    /** Définit si plusieurs éléments peuvent être sélectionés.
     * @param value True si plusieurs éléments peuvent être sélectionés.
     */
    protected setMultiSelect(value: boolean): void;
    /** Définit le modèle utilisé par la liste. Il est uniquement de type IItemBase<T>. Ce model peut ètre hierarchique sans limitation de la profondeur ou une chargé en asynchrone par une promise ou un observable.
     * @param items Provider de la liste des éléments de la liste.
     */
    protected setItems$(items: IItemBase<T>[] | Promise<IItemBase<T>[]> | Observable<IItemBase<T>[]>): Observable<unknown>;
    /** Définit le modèle utilisé par la liste. Il peut être de tout type d'objet. Ce model peut ètre hierarchique sans limitation de la profondeur ou une chargé en asynchrone par une promise ou un observable.
     * @param items Provider de la liste des éléments de la liste.
     */
    protected setModels$(models: unknown[] | Observable<unknown[]>): Observable<unknown>;
    protected getItems(): IItemBase<T>[];
    /** Usage interne. Termine le drag and drop en cours. */
    protected drop$(): Observable<boolean>;
    /** Usage interne. Retourne la portion de la liste à afficher en fonction des paramètres spécifiés. */
    protected getViewList$(query?: RegExp | string, ignoreCache?: boolean): Observable<IViewListResult<T>>;
    /** Sélectionne une plage d'éléments en fonction de l'index de début et l'index de fin sur la liste des éléments visibles.
     * @param indexFrom index sur la liste des éléments visibles du premier élément à sélectioner.
     * @param indexTo index sur la liste des éléments visibles du dernier élément à sélectioner.
     * @return Observable résolu par la fonction.
     */
    protected selectRange$(indexFrom: number, indexTo?: number): Observable<number>;
    /** Change l'état de selection de l'élément spécifié.
     * @param items Liste des éléments à modifier.
     * @param selected True si les éléments divent être sélectionés, False si ils doivent être déselectionés.
     * @return Observable résolu par la fonction.
     */
    protected toggleSelect$(items: IItemBase<T>[], selected: boolean): Observable<IItemBase<T>[]>;
    /** Définit si l'élément spécifié peut être réduit.
     * @param item Elément à analyser.
     * @return True si l'élément peut être réduit.
     */
    protected isCollapsible(item: IItemTree<T>): boolean;
    /** Définit si l'élément spécifié est selectionable.
     * @param item Elément à analyser.
     * @return True si l'élément est selectionable.
     */
    protected isSelectable(item: IItemBase<T>): boolean;
    /** Définit le champ à utiliser comme valeur d'affichage.
     * @param value Champ à utiliser comme valeur d'affichage.
     */
    protected setTextField(value: string): void;
    /** Retourne le champ utilisé comme valeur d'affichage.*/
    protected getTextField(): string;
    /** Définit le champ à utiliser comme valeur de comparaison.
     * @param value Champ à utiliser comme valeur de comparaison.
     */
    protected setValueField(value: string): void;
    /** Retourne le champ utilisé comme valeur de comparaison.*/
    protected getValueField(): string;
    /** Définit le champ à utiliser comme champ de recherche.
     * Ce champ peut indiquer, un champ contenant une valeur, un texte indexé, ou une fonction.
     * @param value Champ à utiliser comme champ de recherche.
     */
    protected setSearchField(value: string): void;
    /** Définit la hauteur maximum avant que le composant affiche une scrollbar
     * spécifier une grande valeur pour ne jamais afficher de scrollbar
     * Spécifier 0 pour que le composant determine sa hauteur à partir du container
     */
    protected setMaxHeight(value: NumberInput): void;
    /** Retourne la hauteur maximum avant que le composant affiche une scrollbar
     * spécifier une grande valeur pour ne jamais afficher de scrollbar
     * Spécifier 0 pour que le composant determine sa hauteur à partir du container
     */
    protected getMaxHeight(): number;
    /** Internal usage. Calc the best target when an item is drag and dropped */
    protected calcDragTargetIndex$(index: number, targetIndex: number): Observable<number>;
    /** Internal usage */
    protected getItemTreeInfo(items: IItemBase<T>[], item: IItemBase<T>): IItemTreeInfo<T>;
    /** Calcule le viewport pour le conteneur spécifié. */
    protected calcViewList$(query?: string): Observable<IViewListResult<T>>;
    protected ensureListCaches$(): Observable<IViewListResult<T>>;
    /** Calcul la position de la scrollbar pour que l'élément spécifié soit dans la zone visible. */
    protected ensureItemVisible(item: IItemBase<T> | number): void;
    protected mapToIItemBase(modls: any[], selected?: boolean): IItemBase<T>[];
    protected getVirtualSelectedEntities(value: any): unknown | unknown[];
}
export interface IItemTreeInfo<T> {
    item?: IItemBase<T>;
    children?: IItemBase<T>[];
    startIndex: number;
    lastIndex?: number;
}