/** @packageDocumentation
 * @module Tree
 */
import { BeEvent } from "@bentley/bentleyjs-core";
import { PropertyRecord } from "@bentley/ui-abstract";
import { CheckBoxState } from "@bentley/ui-core";
import { PageOptions } from "../common/PageOptions";
import { ItemStyle } from "../properties/ItemStyle";
/**
 * A node item which can be displayed in a tree.
 * @public
 */
export interface TreeNodeItem {
    id: string;
    parentId?: string;
    label: PropertyRecord;
    description?: string;
    autoExpand?: boolean;
    icon?: string;
    isCheckboxVisible?: boolean;
    isCheckboxDisabled?: boolean;
    checkBoxState?: CheckBoxState;
    isEditable?: boolean;
    style?: ItemStyle;
    /**
     * A key-value pairs data structure that can be used by data provider
     * to store some custom data for this node item.
     */
    extendedData?: {
        [key: string]: any;
    };
}
/** A [[TreeNodeItem]] for immediately loaded trees
 * @public
 */
export interface ImmediatelyLoadedTreeNodeItem extends TreeNodeItem {
    children?: TreeNodeItem[];
}
/** A [[TreeNodeItem]] for delay-loaded trees
 * @public
 */
export interface DelayLoadedTreeNodeItem extends TreeNodeItem {
    hasChildren?: boolean;
}
/** Array of tree node data elements
 * @public
 */
export declare type TreeDataProviderRaw = ImmediatelyLoadedTreeNodeItem[];
/** A Promise for TreeDataProviderRaw
 * @public
 */
export declare type TreeDataProviderPromise = Promise<TreeDataProviderRaw>;
/** Signature for a method that returns TreeDataProviderPromise for supplied parent node
 * @public
 */
export declare type TreeDataProviderMethod = (node?: TreeNodeItem) => Promise<DelayLoadedTreeNodeItem[]>;
/** Interface for a tree data provider class
 * @public
 */
export interface ITreeDataProvider {
    /** @deprecated */
    onTreeNodeChanged?: BeEvent<TreeDataChangesListener>;
    getNodesCount(parent?: TreeNodeItem): Promise<number>;
    getNodes(parent?: TreeNodeItem, page?: PageOptions): Promise<DelayLoadedTreeNodeItem[]>;
}
/** Type definition for all BeInspireTree data providers
 * @public
 */
export declare type TreeDataProvider = TreeDataProviderRaw | TreeDataProviderPromise | TreeDataProviderMethod | ITreeDataProvider;
/** Checks if [[TreeDataProvider]] is a [[TreeDataProviderRaw]]
 * @public
 */
export declare const isTreeDataProviderRaw: (provider: TreeDataProvider) => provider is TreeDataProviderRaw;
/** Checks if [[TreeDataProvider]] is a [[TreeDataProviderPromise]]
 * @public
 */
export declare const isTreeDataProviderPromise: (provider: TreeDataProvider) => provider is TreeDataProviderPromise;
/** Checks if [[TreeDataProvider]] is a [[TreeDataProviderMethod]]
 * @public
 */
export declare const isTreeDataProviderMethod: (provider: TreeDataProvider) => provider is TreeDataProviderMethod;
/** Checks if [[TreeDataProvider]] is an [[ITreeDataProvider]]
 * @public
 */
export declare const isTreeDataProviderInterface: (provider: TreeDataProvider) => provider is ITreeDataProvider;
/**
 * Determines whether node has children
 * @param node node to check
 * @returns whether node has children
 * @public
 */
export declare const hasChildren: (node: TreeNodeItem) => boolean;
/**
 * An interface tree data change listeners.
 * Contains a list of nodes that changed or undefined if root level changed.
 * @public
 */
export declare type TreeDataChangesListener = (nodes: Array<TreeNodeItem | undefined>) => void;
/**
 * EditableTreeDataProvider provides cell editing processing for the Tree.
 * @public
 */
export interface EditableTreeDataProvider extends ITreeDataProvider {
    updateLabel(nodeItem: TreeNodeItem, newLabel: string): void;
}
/**
 * MutableTreeDataProvider provides manipulation processing for the Tree.
 * Useful for Drag & Drop processing.
 * @beta
 */
export interface MutableTreeDataProvider extends ITreeDataProvider {
    insertNode(parent: TreeNodeItem | undefined, child: TreeNodeItem, index?: number): void;
    removeNode(parent: TreeNodeItem | undefined, child: TreeNodeItem): void;
    moveNode(parent: TreeNodeItem | undefined, newParent: TreeNodeItem | undefined, child: TreeNodeItem, index?: number): void;
    isDescendent(parent: TreeNodeItem | undefined, nodeItem: TreeNodeItem): boolean;
    getNodeIndex(parent: TreeNodeItem | undefined, child: TreeNodeItem): number;
}
//# sourceMappingURL=TreeDataProvider.d.ts.map