/** @packageDocumentation
 * @module Tree
 */
import "./Tree.scss";
import * as React from "react";
import { CheckBoxInfo, CheckBoxState, CommonProps, NodeCheckboxRenderer } from "@bentley/ui-core";
import { OnItemsDeselectedCallback, OnItemsSelectedCallback } from "../../../common/selection/SelectionHandler";
import { SelectionMode } from "../../../common/selection/SelectionModes";
import { PropertyValueRendererManager } from "../../../properties/ValueRendererManager";
import { HighlightableTreeProps, HighlightingEngine } from "../../HighlightingEngine";
import { ITreeImageLoader } from "../../ImageLoader";
import { TreeDataProvider, TreeNodeItem } from "../../TreeDataProvider";
import { CellEditingEngine, EditableTreeProps } from "../CellEditingEngine";
import { NodeEventManager } from "../NodeEventManager";
import { NodeLoadingOrchestrator } from "../NodeLoadingOrchestrator";
import { BeInspireTree, BeInspireTreeNode, BeInspireTreeNodeConfig, MapPayloadToInspireNodeCallback } from "./BeInspireTree";
import { TreeNodeProps } from "./Node";
/** Type for nodesSelected callback
 * @internal @deprecated
 */
export declare type NodesSelectedCallback = OnItemsSelectedCallback<TreeNodeItem>;
/** Type for nodesDeselected callback
 * @internal @deprecated
 */
export declare type NodesDeselectedCallback = OnItemsDeselectedCallback<TreeNodeItem>;
/** Type for node renderer
 * @internal @deprecated
 */
export declare type NodeRenderer = (item: BeInspireTreeNode<TreeNodeItem>, props: TreeNodeProps) => React.ReactNode;
/** Properties for the [DEPRECATED_Tree]($ui-components) component
 * @public
 * @deprecated Use [ControlledTree]($ui-components) instead. Will be removed in iModel.js 3.0.
 */
export interface TreeProps extends CommonProps {
    /** Nodes provider */
    dataProvider: TreeDataProvider;
    /**
     * Size of a single page that's requested from `dataProvider` (only
     * applies when the provider is `ITreeDataProvider`). Defaults to
     * disabled pagination.
     */
    pageSize?: number;
    /**
     * Should child nodes be disposed when parent node is collapsed. Saves some
     * memory in exchange of performance. Disabled by default.
     */
    disposeChildrenOnCollapse?: boolean;
    /**
     * Describes nodes that should be selected. May be defined as:
     * - an array of node ids
     * - a callback that takes a node and returns a boolean
     */
    selectedNodes?: string[] | ((node: TreeNodeItem) => boolean);
    /**
     * Mode of nodes' selection in the tree
     */
    selectionMode?: SelectionMode;
    /**
     * Callback that's called when nodes are selected. In case of
     * delayed loading (`pageSize != 0`), called only after all selected
     * nodes are fully loaded
     * @internal
     */
    onNodesSelected?: NodesSelectedCallback;
    /**
     * Callback that's called when nodes are deselected. In case of
     * delayed loading (`pageSize != 0`), called only after all deselected
     * nodes are fully loaded
     * @internal
     */
    onNodesDeselected?: NodesDeselectedCallback;
    /**
     * Called to report progress of selection load. Arguments:
     * - `loaded` - number of items loaded
     * - `total` - total number of items that need to be loaded
     * - `cancel` - callback method to cancel the load
     *
     * Note: the callback is only called when selection change involves some
     * not-loaded nodes.
     */
    onSelectionLoadProgress?: (loaded: number, total: number, cancel: () => void) => void;
    /**
     * Called when selection load is canceled. Common cases when that happens:
     * - `cancel` method called from `onSelectionLoadProgress` callback
     * - selection change during nodes' load
     *
     * Note: the callback is only called when selection change involves some
     * not-loaded nodes.
     */
    onSelectionLoadCanceled?: () => void;
    /**
     * Called when selection load is finished
     *
     * Note: the callback is only called when selection change involves some
     * not-loaded nodes.
     */
    onSelectionLoadFinished?: () => void;
    /**
     * Callback that's called when node is expanded
     */
    onNodeExpanded?: (node: TreeNodeItem) => void;
    /**
     * Callback that's called when node is collapsed
     */
    onNodeCollapsed?: (node: TreeNodeItem) => void;
    /**
     * Callback that's called when root nodes are loaded. If pagination
     * is enabled, it's called once per every loaded page.
     */
    onRootNodesLoaded?: (nodes: TreeNodeItem[]) => void;
    /**
     * Callback that's called when child nodes are loaded. If pagination
     * is enabled, it's called once per every loaded page.
     */
    onChildrenLoaded?: (parent: TreeNodeItem, children: TreeNodeItem[]) => void;
    /** Contains render overrides for different pieces of the tree component */
    renderOverrides?: {
        /** Callback to render a node @internal */
        renderNode?: NodeRenderer;
        /** Callback to render a node checkbox. When a custom node renderer is used, it's responsible for calling this callback. */
        renderCheckbox?: NodeCheckboxRenderer;
    };
    /** @internal */
    onRender?: () => void;
    /** @internal */
    onNodesRender?: () => void;
    /** Properties for node highlighting logic. If not provided, node highlighting is disabled. @internal */
    nodeHighlightingProps?: HighlightableTreeProps;
    /** Properties for cell editing logic. If not provided, cell editing is disabled. @beta */
    cellEditing?: EditableTreeProps;
    /**
     * Alternative source of truth for node checkbox information.
     * > **Note:** when set, this property overrides checkbox-related TreeNodeItem attributes
     */
    checkboxInfo?: (node: TreeNodeItem) => CheckBoxInfo | Promise<CheckBoxInfo>;
    /**
     * Set to `true` to remove the ability to control multiple checkboxes using a single click.
     *
     * By default, this is set to `false` and checking a selected node's checkbox results in all selected nodes'
     * checkboxes being checked.
     */
    bulkCheckboxActionsDisabled?: boolean;
    /** Called when nodes change their checkbox state. */
    onCheckboxClick?: (stateChanges: Array<{
        node: TreeNodeItem;
        newState: CheckBoxState;
    }>) => void;
    /** Custom property value renderer manager */
    propertyValueRendererManager?: PropertyValueRendererManager;
    /** Turns on node description rendering when enabled */
    showDescriptions?: boolean;
    /** Turns on icon rendering when enabled */
    showIcons?: boolean;
    /** Custom image loader. Default ImageLoader loads icons already bundled in the library */
    imageLoader?: ITreeImageLoader;
    /** A constant value for row height, or a function that calculates row height based on rendered node */
    rowHeight?: ((node?: TreeNodeItem, index?: number) => number) | number;
}
/** State for the [[DEPRECATED_Tree]] component
 * @internal @deprecated
 */
interface TreeState {
    prev: {
        dataProvider: TreeDataProvider;
        modelReady: boolean;
        selectedNodes?: string[] | ((node: TreeNodeItem) => boolean);
        checkboxInfo?: (node: TreeNodeItem) => CheckBoxInfo | Promise<CheckBoxInfo>;
        bulkCheckboxActionsDisabled?: boolean;
        nodeHighlightingProps?: HighlightableTreeProps;
        cellEditing?: EditableTreeProps;
    };
    model: BeInspireTree<TreeNodeItem>;
    modelReady: boolean;
    currentlyEditedNode?: BeInspireTreeNode<TreeNodeItem>;
    /** @internal */
    highlightingEngine?: HighlightingEngine;
    /** @internal */
    cellEditingEngine?: CellEditingEngine;
    nodeLoadingOrchestrator: NodeLoadingOrchestrator;
    nodeEventManager: NodeEventManager;
}
/**
 * A Tree React component that uses the core of BeInspireTree but renders with TreeBase and TreeNodeBase from ui-core.
 * @public
 * @deprecated Use [ControlledTree]($ui-components) instead. Will be removed in iModel.js 3.0.
 */
export declare class DEPRECATED_Tree extends React.Component<TreeProps, TreeState> {
    private _mounted;
    private _treeRef;
    private _scrollableContainerRef;
    private _selectionHandler;
    private _nodesSelectionHandlers?;
    private _pressedItemSelected;
    /** Used to find out when all of the nodes finish rendering */
    private _nodesRenderInfo?;
    /** Used to delay the automatic scrolling when stepping through highlighted text */
    private _shouldScrollToActiveNode;
    private _defaultImageLoader;
    static readonly defaultProps: Partial<TreeProps>;
    /** @internal */
    constructor(props: TreeProps);
    private _setCellEditorState;
    private _getCellEditorState;
    private static createModel;
    private static createNodeLoadingOrchestrator;
    private static createNodeEventManager;
    /** @internal */
    static getDerivedStateFromProps(props: TreeProps, state: TreeState): TreeState | null;
    /** @internal */
    componentDidMount(): void;
    /** @internal */
    componentWillUnmount(): void;
    shouldComponentUpdate(nextProps: TreeProps, nextState: TreeState): boolean;
    /** @internal */
    componentDidUpdate(prevProps: TreeProps, prevState: TreeState): void;
    private handleCheckboxes;
    private assignModelListeners;
    private dropModelListeners;
    private assignDataProviderListeners;
    private dropDataProviderListeners;
    private _onModelChanged;
    private _onModelReady;
    private scrollToActiveNode;
    private _onNodesSelected;
    private _onNodesDeselected;
    private _onNodeExpanded;
    private _onNodeCollapsed;
    private onNodesLoaded;
    private _onModelLoaded;
    private _onChildrenLoaded;
    private _onTreeNodeChanged;
    private _onMouseDown;
    private _onMouseUp;
    private get nodesSelectionHandlers();
    private _getNodeHeight;
    /** map TreeNodeItem into an InspireNode
     * @internal
     */
    static inspireNodeFromTreeNodeItem(item: TreeNodeItem, remapper: MapPayloadToInspireNodeCallback<TreeNodeItem>, base?: BeInspireTreeNodeConfig): BeInspireTreeNodeConfig;
    private _createItemSelectionHandler;
    private _multiSelectionHandler;
    private _onCheckboxClick;
    private defaultRenderNode;
    private _onNodeFullyRendered;
    private createTreeNodeProps;
    /** Get loaded node by its ID */
    getLoadedNode(id: string): TreeNodeItem | undefined;
    /** @internal */
    render(): JSX.Element;
}
export {};
//# sourceMappingURL=Tree.d.ts.map