/** @packageDocumentation
 * @module Tree
 */
import { Observable as RxjsObservable } from "rxjs/internal/Observable";
import { BeEvent, IDisposable } from "@bentley/bentleyjs-core";
import { TreeDataChangesListener, TreeDataProvider, TreeNodeItem } from "../TreeDataProvider";
import { Observable } from "./Observable";
import { TreeModelNode, TreeModelRootNode, TreeNodeItemData } from "./TreeModel";
import { TreeModelSource } from "./TreeModelSource";
/**
 * Data structure that describes node load result
 * @public
 */
export interface TreeNodeLoadResult {
    loadedNodes: TreeNodeItem[];
}
/**
 * Tree node loader which is used to load tree nodes.
 * @public
 */
export interface ITreeNodeLoader {
    /**
     * Loads node at specified place in tree.
     * @param parentId specifies tree branch
     * @param childIndex specifies offset in the branch.
     */
    loadNode(parentId: TreeModelNode | TreeModelRootNode, childIndex: number): Observable<TreeNodeLoadResult>;
}
/**
 * Tree node loader which uses `TreeDataProvider` to load nodes.
 * @public
 */
export interface ITreeNodeLoaderWithProvider<TDataProvider extends TreeDataProvider> extends ITreeNodeLoader {
    /** Returns `TreeDataProvider` used to load nodes. */
    readonly dataProvider: TDataProvider;
}
/**
 * Abstract node loader implementation which loads nodes into provided model source.
 * @public
 */
export declare abstract class AbstractTreeNodeLoader implements ITreeNodeLoader {
    private _treeModelSource;
    private _loadScheduler;
    protected constructor(modelSource: TreeModelSource);
    get modelSource(): TreeModelSource;
    /** Do not override this method. @see `load` */
    loadNode(parent: TreeModelNode | TreeModelRootNode, childIndex: number): Observable<TreeNodeLoadResult>;
    /**
     * A method that's called when `load` loads some nodes and we need to put them into model source. The
     * default implementation simply puts loaded child nodes under their parent at correct positions. Concrete
     * implementation may override this method to handle loaded nodes in a a custom way (put them at custom locations
     * in the hierarchy, etc.)
     */
    protected updateModel(loadedHierarchy: LoadedNodeHierarchy): void;
    /** An abstract method to load a node at the specific index for the specified parent. */
    protected abstract load(parent: TreeModelNode | TreeModelRootNode, childIndex: number): Observable<LoadedNodeHierarchy>;
}
/**
 * Abstract node loader with tree data provider which loads nodes into provided model source.
 * @public
 */
export declare abstract class AbstractTreeNodeLoaderWithProvider<TDataProvider extends TreeDataProvider> extends AbstractTreeNodeLoader implements ITreeNodeLoaderWithProvider<TDataProvider> {
    private _dataProvider;
    protected constructor(modelSource: TreeModelSource, dataProvider: TDataProvider);
    get dataProvider(): TDataProvider;
}
/**
 * Default tree node loader with `TreeDataProvider` implementation.
 * @public
 */
export declare class TreeNodeLoader<TDataProvider extends TreeDataProvider> extends AbstractTreeNodeLoaderWithProvider<TDataProvider> implements IDisposable {
    private _treeDataSource;
    private _activeRequests;
    constructor(dataProvider: TDataProvider, modelSource: TreeModelSource);
    /** Disposes data source */
    dispose(): void;
    /**
     * Schedules to load children of node and returns an Observable.
     * @note It does not start loading node until '.subscribe()' is called on returned Observable.
     */
    protected load(parentNode: TreeModelNode | TreeModelRootNode): Observable<LoadedNodeHierarchy>;
    private loadForParent;
}
/**
 * Default paged tree node loader with `TreeDataProvider` implementation.
 * @public
 */
export declare class PagedTreeNodeLoader<TDataProvider extends TreeDataProvider> extends AbstractTreeNodeLoaderWithProvider<TDataProvider> implements IDisposable {
    private _pageLoader;
    private _pageSize;
    constructor(dataProvider: TDataProvider, modelSource: TreeModelSource, pageSize: number);
    /** Disposes data source */
    dispose(): void;
    /** Returns page size used by tree node loader. */
    get pageSize(): number;
    /**
     * Schedules to load one page of node children and returns an Observable.
     * @note It does not start loading node page until '.subscribe()' is called on returned Observable.
     */
    protected load(parentNode: TreeModelNode | TreeModelRootNode, childIndex: number): Observable<LoadedNodeHierarchy>;
}
/**
 * Data structure that describes hierarchy loaded for parent node.
 * @public
 */
export interface LoadedNodeHierarchy {
    /** Node id of the parent node for loaded hierarchy. */
    parentId: string | undefined;
    /** Hierarchy items offset in parent node children array. */
    offset: number;
    /** Loaded hierarchy items. */
    hierarchyItems: LoadedNodeHierarchyItem[];
    /** Number of children parent node has. */
    numChildren?: number;
}
/**
 * Data structure that describes one loaded hierarchy item.
 * @public
 */
export interface LoadedNodeHierarchyItem {
    /** Loaded tree node item. */
    item: TreeNodeItemData;
    /** Children of loaded tree node item. */
    children?: LoadedNodeHierarchyItem[];
    /** Number of children tree node item has. */
    numChildren?: number;
}
/** @internal */
export declare function handleLoadedNodeHierarchy(modelSource: TreeModelSource, loadedHierarchy: LoadedNodeHierarchy): void;
interface TreeDataSourceResult {
    loadedItems: TreeNodeItemData[];
    numChildren?: number;
}
/**
 * Wrapper to handle different types of `TreeDataProvider`. Provides one method
 * to request items from `TreeDataProviderRaw`, `TreeDataProviderMethod`,
 * `TreeDataProviderPromise` or `TreeDataProviderInterface`.
 *
 * @internal
 */
export declare class TreeDataSource implements IDisposable {
    private _dataProvider;
    private _disposeTreeNodesChangedListener?;
    readonly onItemsChanged: BeEvent<TreeDataChangesListener>;
    constructor(dataProvider: TreeDataProvider);
    dispose(): void;
    requestItems(parent: TreeNodeItem | undefined, firstItemIndex: number, numItems: number, requestNumChildren: boolean): RxjsObservable<TreeDataSourceResult>;
    private getItems;
    private getChildren;
}
export {};
//# sourceMappingURL=TreeNodeLoader.d.ts.map