import { BehaviorSubject, Observable } from 'rxjs';
import { IGroupInfo } from './grouping/group-infos';
import { GroupingService } from './grouping/grouping.service';
import { IItemBase } from './item-base';
import { IItemTree } from './item-tree';
import { ISortInfos } from './sorting/sort-infos.model';
import { SortingService } from './sorting/sorting.service';
/** Service de gestion des listes (deja-treelist, deja-select et deja-grid).
 * Ce service permet la gestion du viewport et la gestion des caches des listes.
 * Il peut-être surchargé pour faire du lazy loading ou du paging.
 */
export declare class ItemListService<T> {
    static defaultChildrenField: string;
    static defaultTextField: string;
    static defaultValueField: string;
    private _waiter$;
    private _items;
    private _cache;
    private selectedList;
    private _hideSelected;
    private _lastQuery;
    private internalQuery;
    private _sortingService;
    private _groupInfos;
    private _groupingService;
    private _ddList;
    private _ddCurrentIndex;
    private _ddChildCount;
    private _childrenField;
    private loadingItems$;
    private selectingItem$;
    private unselectingItem$;
    private expandingItem$;
    private collapsingItem$;
    private _valueField;
    /** Evalue la valeur à comparer pour l'élément spécifié.
     * @param value  Model à évaluer.
     * @param valueField (optional) Champs à traiter comme valeur.
     * @return Valeur à comparer pour le modèle spécifié.
     */
    static getItemValue(item: any, valueField?: string): unknown;
    /** Evalue le texte à afficher pour l'élément spécifié.
     * @param value  Model à évaluer.
     * @param textField (optional) Champs à traiter comme source du texte.
     * @return Texte à afficher pour le modèle spécifié.
     */
    static getItemText(value: any, textField?: string): string;
    get lastQuery(): RegExp | string;
    /**
     * Set a observable called before the list will be displayed
     */
    setLoadingItems(fn: (query: string | RegExp, selectedItems: IItemBase<T>[]) => Observable<IItemBase<T>[]>): void;
    /**
     * Set a promise or an observable called before an item selection
     */
    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 expand
     */
    setExpandingItem(fn: (item: IItemTree<T>) => Promise<IItemTree<T>> | Observable<IItemTree<T>>): void;
    /**
     * Set a promise or an observable called before an item collapse
     */
    setCollapsingItem(fn: (item: IItemTree<T>) => Promise<IItemTree<T>> | Observable<IItemTree<T>>): void;
    /**
     * Permet de controler l'affichage du waiter
     * @return un sujet contenant la valeur du waiter
     */
    get waiter$(): BehaviorSubject<boolean>;
    /** Définit le champs utilisé comme collection pour les enfants d'un parent.
     * @param value Nom du champ à utiliser comme collection d'enfants
     */
    set childrenField(value: string);
    /** Renvoie le champs utilisé comme collection pour les enfants d'un parent
     * @return value Nom du champ à utilisé comme collection d'enfants.
     */
    get childrenField(): string;
    /** 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
     */
    set hideSelected(value: boolean);
    /** Renvoie une valeur indiquant si les éléments selectionés doivent être masqué.
     * @return value True si les éléments selectionés sont masqués
     */
    get hideSelected(): boolean;
    /** Définit le champs à utiliser comme valeur de comparaison */
    set valueField(valueField: string);
    /** Renvoie le champs à utiliser comme valeur de comparaison */
    get valueField(): string;
    get hasCache(): boolean;
    private set items(value);
    private get items();
    /** Définit le modèle utilisé par la liste. 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.
     */
    setItems$(items: IItemBase<T>[] | Promise<IItemBase<T>[]> | Observable<IItemBase<T>[]>): Observable<unknown>;
    setModels$(items: any[] | Promise<any[]> | Observable<any[]>): Observable<unknown>;
    /** Renvoie le modèle de grouping ajouté à la liste de base par le service. Ce modèle ne modifie pas la donée, mais est jsute ajouté à l'affichage
     * @return value Modèle de grouping d'affichage de la liste.
     */
    get groupInfos(): IGroupInfo[];
    getItems(): IItemBase<T>[];
    /** Retourne l'élément corresondant à l'index spéficié dans la liste des éléments visibles.
     * @param index Index de l'élément à chercher sur la liste des éléments visibles.
     * @return Element correspondant à l'index recherché.
     */
    getItemFromIndex(index: number): IItemBase<T>;
    /** 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é.
     */
    getItemIndex(item: IItemBase<T>): number;
    /** Renvoie le service utilisé pour le tri de la liste
     * @return Service utilisé pour le tri.
     */
    getSortingService(): SortingService;
    /** Définit le service utilisé pour le tri de la liste
     * @param value  Service à utiliser pour le tri.
     */
    setSortingService(value: SortingService): void;
    /** Renvoie le service utilisé pour le regroupement de la liste
     * @return Service utilisé pour le regroupement.
     */
    getGroupingService(): GroupingService;
    /** Définit le service utilisé pour le regroupement de la liste
     * @param value Service à utiliser pour le regroupement.
     */
    setGroupingService(value: GroupingService): void;
    /** Evalue le texte à afficher pour l'élément spécifié.
     * @param value  Model à évaluer.
     * @param textField (optional) Champs à traiter comme source du texte.
     * @return Texte à afficher pour le modèle spécifié.
     */
    getTextValue(value: any, textField?: string): string;
    /** Evalue la valeur à comparer pour l'élément spécifié.
     * @param value  Model à évaluer.
     * @param valueField (optional) Champs à traiter comme valeur.
     * @return Valeur à comparer pour le modèle spécifié.
     */
    getValue(item: any, valueField?: string): unknown;
    /** Usage interne. Termine le drag and drop en cours. */
    drop$(): Observable<boolean>;
    /** Usage interne. Calcul l'élément cible d'un drag and drop en fonction de l'index spécifié. */
    calcDragTargetIndex$(index: number, targetIndex: number): Observable<number>;
    /** Change l'état d'expansion de tous les éléments.
     * @param collapsed True si les éléments doivent être réduits.
     * @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, collapse?: boolean): Observable<IItemTree<T>>;
    /** Etends les éléments spécifiés.
     * @param items Liste des éléments à étendre.
     * @return Observable résolu par la fonction.
     */
    expandItems$(items: IItemBase<T>[]): Observable<IItemBase<T>[]>;
    /** Reduits les éléments spécifiés.
     * @param items Liste des éléments à réduire.
     * @return Observable résolu par la fonction.
     */
    collapseItems$(items: IItemBase<T>[]): Observable<IItemBase<T>[]>;
    /** Etends l'élément spécifié.
     * @param items Eléments à étendre.
     * @return Observable résolu par la fonction.
     */
    expandItem$(item: IItemTree<T>): Observable<IItemTree<T>>;
    /** Réduit l'élément spécifié.
     * @param items Eléments à réduire.
     * @return Observable résolu par la fonction.
     */
    collapseItem$(item: IItemTree<T>): Observable<IItemTree<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(items: IItemBase<T>[]): void;
    /** Déselectionne tous les éléments sélectionés.
     * @return Observable résolu par la fonction.
     */
    unselectAll$(): Observable<IItemBase<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.
     */
    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.
     */
    toggleSelect$(items: IItemBase<T>[], selected: boolean): Observable<IItemBase<T>[]>;
    /** Sélectionne les éléments spécifiés
     * @param items Liste des éléments à sélectioner.
     * @return Observable résolu par la fonction.
     */
    selectItems$(items: IItemBase<T>[]): Observable<IItemBase<T>[]>;
    /** Déselectionne les éléments spécifiés
     * @param items Liste des éléments à déselectioner.
     * @return Observable résolu par la fonction.
     */
    unSelectItems$(items: IItemBase<T>[]): Observable<IItemBase<T>[]>;
    /** Sélectionne l'élément spécifié
     * @param item Elément à sélectioner.
     * @return Observable résolu par la fonction.
     */
    selectItem$(item: IItemBase<T>): Observable<IItemBase<T>>;
    /** Déselectionne l'élément spécifié
     * @param item Elément à déselectioner.
     * @return Observable résolu par la fonction.
     */
    unSelectItem$(item: IItemBase<T>): Observable<IItemBase<T>>;
    /** 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.
     */
    findNextMatch$(compare?: (item: IItemBase<T>, index: number) => boolean, startIndex?: number): Observable<IFindItemResult<T>>;
    /** Trie les éléments en fonction du modèle de tri spécifié
     * @param sortInfos Modèle de tri à appliquer.
     * @return Observable résolu par la fonction.
     */
    sort$(sortInfos: ISortInfos): Observable<IItemTree<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$(groupInfos: IGroupInfo[]): Observable<IGroupInfo[]>;
    /** 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<IGroupInfo>;
    /** 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>, multiSelect: boolean): Observable<IParentListInfoResult<T>>;
    /** Supprime tous les caches internes. Ils seront recréés à la première demande de la portion de la liste à afficher. */
    invalidateCache(): void;
    /** Efface la hauteur calculée des lignes en mode automatique */
    invalidateRowsHeightCache(): void;
    /** Usage interne. Retourne la portion de la liste à afficher en fonction des paramètres spécifiés. */
    getViewList$(searchField: string, query?: RegExp | string, ignoreCache?: boolean, ddStartIndex?: number, ddTargetIndex?: number, multiSelect?: boolean): Observable<IViewListResult<T>>;
    ensureSelection(): IItemBase<T>;
    /** Retourne la liste à utilise pour la création des caches. Surcharger cetee méthode pour fournir une liste de façon lazy.
     * En cas de surcharge, retourner une nouvelle instance de la liste originale pour que le service regénère ses caches.
     * @param query Texte ou regular expression par laquelle la liste doit être filtrée.
     * @param selectedItems Liste des éléments selectionés.
     * @return Observable résolu par la fonction, qui retourne la liste à utiliser.
     */
    protected getItemList$(query?: RegExp | string, selectedItems?: IItemBase<T>[]): Observable<IItemBase<T>[]>;
    /** Retourne une valeur indiquant si l'élément spécifié correspond aux critères de recherche spécifiés
     * @param item Elément à analyser.
     * @param searchField Nom du champ à utiliser pour la recherche. Le champ représenté peut-être une valeur ou une function.
     * @param regExp Expression de test sur le champs spécifié.
     * @return True si l'élément correspond aux critères de recherche.
     */
    protected itemMatch(item: IItemBase<T>, searchField: string, regExp: RegExp): boolean;
    /** Retourne une liste groupée si un modèle de groupe interne est spécifié.
     * En cas de surcharge, retourner une nouvelle instance de la liste originale pour que le service regénère ses caches.
     * @param items Liste des éléments à grouper.
     * @return Observable résolu par la fonction, qui retourne la liste groupés.
     */
    protected getGroupedList$(items: IItemBase<T>[]): Observable<IItemTree<T>[]>;
    /** Retourne la liste des éléments visibles. Si la liste des éléments est hièrarchique, cette fonction retourne une liste plate. Cette liste est utilisé pour calculer la portion de la liste à afficher.
     * En cas de surcharge, retourner une nouvelle instance de la liste originale pour que le service regénère ses caches.
     * @param items Liste des éléments à traiter.
     * @param searchField Nom du champ à utiliser pour la recherche. Le champ représenté peut-être une valeur ou une function.
     * @param regExp Expression de test à appliquer sur le champ de recherche.
     * @param Auto expand parents on search query.
     * @return Observable résolu par la fonction, qui retourne la liste visibles.
     */
    protected getVisibleList$(items: IItemBase<T>[], searchField: string, regExp: RegExp, expandTree: boolean, multiSelect: boolean): Observable<IItemBase<T>[]>;
    /** Retourne une liste plate depuis la liste originale sans hierarchie.
     * En cas de surcharge, retourner une nouvelle instance de la liste originale pour que le service regénère ses caches.
     * @param items Liste des éléments hierarchique.
     * @return Observable résolu par la fonction, qui retourne la liste hierarchique mise à plat.
     */
    protected getFlatList$(items: IItemBase<T>[], isFiltered: boolean, multiSelect: boolean): Observable<IItemBase<T>[]>;
    /** Efface une partie des caches  */
    protected invalidateViewCache(): void;
    private ensureSelectedItems;
    private compareItems;
    private ensureVisibleListCache$;
    private ensureFlatListCache$;
    private ensureGroupedListCache$;
    private ensureChildrenProperties;
    private isVisible;
}
/** Structure de retour de getViewList. */
export interface IViewListResult<T> {
    depthMax?: number;
    visibleList?: IItemBase<T>[];
}
/** Structure de retour de findNextMatch. */
export interface IFindItemResult<T> {
    /** Elément trouvé. */
    item: IItemBase<T>;
    /** Index de l'élément dans la liste des éléments visibles. */
    index: number;
}
/** Structure de retour de getParentListInfos. */
export interface IParentListInfoResult<T> {
    /** Elément parent. */
    parent?: IItemTree<T>;
    /** Index de l'élément enfant dans la liste des enfants du parent. */
    index: number;
}
