@itwin/components-react 4.0.0-dev.12 → 4.0.0-dev.14

package/lib/esm/components-react/tree/controlled/TreeEventHandler.d.ts

@@ -1,62 +1,62 @@
-/** @packageDocumentation
- * @module Tree
- */
-import { IDisposable } from "@itwin/core-bentley";
-import { Subscription } from "./Observable";
-import { TreeCheckboxStateChangeEventArgs, TreeEvents, TreeNodeEventArgs, TreeSelectionModificationEventArgs, TreeSelectionReplacementEventArgs } from "./TreeEvents";
-import { TreeModelNode } from "./TreeModel";
-import { TreeModelSource } from "./TreeModelSource";
-import { ITreeNodeLoader } from "./TreeNodeLoader";
-/**
- * Params used for tree node editing.
- * @public
- */
-export interface TreeEditingParams {
-    /** Callback that is called when node is updated. */
-    onNodeUpdated: (node: TreeModelNode, newValue: string) => void;
-}
-/**
- * Data structure that describes tree event handler params.
- * @public
- */
-export interface TreeEventHandlerParams {
-    /** Model source used to modify tree model while handling events. */
-    modelSource: TreeModelSource;
-    /** Node loader used to load children when node is expanded. */
-    nodeLoader: ITreeNodeLoader;
-    /** Specifies whether children should be disposed when parent node is collapsed or not. */
-    collapsedChildrenDisposalEnabled?: boolean;
-    /** Parameters used for node editing. */
-    editingParams?: TreeEditingParams;
-}
-/**
- * Default tree event handler.
- * @public
- */
-export declare class TreeEventHandler implements TreeEvents, IDisposable {
-    private _modelMutator;
-    private _editingParams?;
-    private _disposed;
-    private _selectionReplaced;
-    constructor(params: TreeEventHandlerParams);
-    /** Disposes tree event handler. */
-    dispose(): void;
-    get modelSource(): TreeModelSource;
-    /** Expands node and starts loading children. */
-    onNodeExpanded({ nodeId }: TreeNodeEventArgs): void;
-    /** Collapses node */
-    onNodeCollapsed({ nodeId }: TreeNodeEventArgs): void;
-    /** Selects and deselects nodes until event is handled, handler is disposed or selection replaced event occurs. */
-    onSelectionModified({ modifications }: TreeSelectionModificationEventArgs): Subscription | undefined;
-    /** Replaces currently selected nodes until event is handled, handler is disposed or another selection replaced event occurs. */
-    onSelectionReplaced({ replacements }: TreeSelectionReplacementEventArgs): Subscription | undefined;
-    /** Changes nodes checkbox states. */
-    onCheckboxStateChanged({ stateChanges }: TreeCheckboxStateChangeEventArgs): Subscription | undefined;
-    /** Activates node editing if editing parameters are supplied and node is editable. */
-    onDelayedNodeClick({ nodeId }: TreeNodeEventArgs): void;
-    /** Activates node editing if editing parameters are supplied and node is editable. */
-    onNodeEditorActivated({ nodeId }: TreeNodeEventArgs): void;
-    /** Activates node editing if editing parameters are supplied and node is editable. */
-    private activateEditor;
-}
+/** @packageDocumentation
+ * @module Tree
+ */
+import { IDisposable } from "@itwin/core-bentley";
+import { Subscription } from "./Observable";
+import { TreeCheckboxStateChangeEventArgs, TreeEvents, TreeNodeEventArgs, TreeSelectionModificationEventArgs, TreeSelectionReplacementEventArgs } from "./TreeEvents";
+import { TreeModelNode } from "./TreeModel";
+import { TreeModelSource } from "./TreeModelSource";
+import { ITreeNodeLoader } from "./TreeNodeLoader";
+/**
+ * Params used for tree node editing.
+ * @public
+ */
+export interface TreeEditingParams {
+    /** Callback that is called when node is updated. */
+    onNodeUpdated: (node: TreeModelNode, newValue: string) => void;
+}
+/**
+ * Data structure that describes tree event handler params.
+ * @public
+ */
+export interface TreeEventHandlerParams {
+    /** Model source used to modify tree model while handling events. */
+    modelSource: TreeModelSource;
+    /** Node loader used to load children when node is expanded. */
+    nodeLoader: ITreeNodeLoader;
+    /** Specifies whether children should be disposed when parent node is collapsed or not. */
+    collapsedChildrenDisposalEnabled?: boolean;
+    /** Parameters used for node editing. */
+    editingParams?: TreeEditingParams;
+}
+/**
+ * Default tree event handler.
+ * @public
+ */
+export declare class TreeEventHandler implements TreeEvents, IDisposable {
+    private _modelMutator;
+    private _editingParams?;
+    private _disposed;
+    private _selectionReplaced;
+    constructor(params: TreeEventHandlerParams);
+    /** Disposes tree event handler. */
+    dispose(): void;
+    get modelSource(): TreeModelSource;
+    /** Expands node and starts loading children. */
+    onNodeExpanded({ nodeId }: TreeNodeEventArgs): void;
+    /** Collapses node */
+    onNodeCollapsed({ nodeId }: TreeNodeEventArgs): void;
+    /** Selects and deselects nodes until event is handled, handler is disposed or selection replaced event occurs. */
+    onSelectionModified({ modifications }: TreeSelectionModificationEventArgs): Subscription | undefined;
+    /** Replaces currently selected nodes until event is handled, handler is disposed or another selection replaced event occurs. */
+    onSelectionReplaced({ replacements }: TreeSelectionReplacementEventArgs): Subscription | undefined;
+    /** Changes nodes checkbox states. */
+    onCheckboxStateChanged({ stateChanges }: TreeCheckboxStateChangeEventArgs): Subscription | undefined;
+    /** Activates node editing if editing parameters are supplied and node is editable. */
+    onDelayedNodeClick({ nodeId }: TreeNodeEventArgs): void;
+    /** Activates node editing if editing parameters are supplied and node is editable. */
+    onNodeEditorActivated({ nodeId }: TreeNodeEventArgs): void;
+    /** Activates node editing if editing parameters are supplied and node is editable. */
+    private activateEditor;
+}
 //# sourceMappingURL=TreeEventHandler.d.ts.map

package/lib/esm/components-react/tree/controlled/TreeEventHandler.js

@@ -1,81 +1,81 @@
-/*---------------------------------------------------------------------------------------------
-* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
-* See LICENSE.md in the project root for license terms and full copyright notice.
-*--------------------------------------------------------------------------------------------*/
-/** @packageDocumentation
- * @module Tree
- */
-import { takeUntil } from "rxjs/internal/operators/takeUntil";
-import { Subject } from "rxjs/internal/Subject";
-import { TreeModelMutator } from "./internal/TreeModelMutator";
-import { toRxjsObservable } from "./Observable";
-/**
- * Default tree event handler.
- * @public
- */
-export class TreeEventHandler {
-    constructor(params) {
-        this._disposed = new Subject();
-        this._selectionReplaced = new Subject();
-        this._modelMutator = new TreeModelMutator(params.modelSource, params.nodeLoader, !!params.collapsedChildrenDisposalEnabled);
-        this._editingParams = params.editingParams;
-    }
-    /** Disposes tree event handler. */
-    dispose() {
-        this._disposed.next();
-    }
-    get modelSource() { return this._modelMutator.modelSource; }
-    /** Expands node and starts loading children. */
-    onNodeExpanded({ nodeId }) {
-        toRxjsObservable(this._modelMutator.expandNode(nodeId)).pipe(takeUntil(this._disposed)).subscribe();
-    }
-    /** Collapses node */
-    onNodeCollapsed({ nodeId }) {
-        this._modelMutator.collapseNode(nodeId);
-    }
-    /** Selects and deselects nodes until event is handled, handler is disposed or selection replaced event occurs. */
-    onSelectionModified({ modifications }) {
-        return toRxjsObservable(modifications)
-            .pipe(takeUntil(this._disposed), takeUntil(this._selectionReplaced))
-            .subscribe({
-            next: ({ selectedNodeItems, deselectedNodeItems }) => {
-                this._modelMutator.modifySelection(selectedNodeItems, deselectedNodeItems);
-            },
-        });
-    }
-    /** Replaces currently selected nodes until event is handled, handler is disposed or another selection replaced event occurs. */
-    onSelectionReplaced({ replacements }) {
-        this._selectionReplaced.next();
-        let firstEmission = true;
-        return toRxjsObservable(replacements)
-            .pipe(takeUntil(this._disposed), takeUntil(this._selectionReplaced))
-            .subscribe({
-            next: ({ selectedNodeItems }) => {
-                if (firstEmission) {
-                    firstEmission = false;
-                    this._modelMutator.replaceSelection(selectedNodeItems);
-                }
-                this._modelMutator.modifySelection(selectedNodeItems, []);
-            },
-        });
-    }
-    /** Changes nodes checkbox states. */
-    onCheckboxStateChanged({ stateChanges }) {
-        return stateChanges.subscribe((changes) => this._modelMutator.setCheckboxStates(changes));
-    }
-    /** Activates node editing if editing parameters are supplied and node is editable. */
-    onDelayedNodeClick({ nodeId }) {
-        this.activateEditor(nodeId);
-    }
-    /** Activates node editing if editing parameters are supplied and node is editable. */
-    onNodeEditorActivated({ nodeId }) {
-        this.activateEditor(nodeId);
-    }
-    /** Activates node editing if editing parameters are supplied and node is editable. */
-    activateEditor(nodeId) {
-        if (this._editingParams === undefined)
-            return;
-        this._modelMutator.activateEditing(nodeId, this._editingParams.onNodeUpdated);
-    }
-}
+/*---------------------------------------------------------------------------------------------
+* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+* See LICENSE.md in the project root for license terms and full copyright notice.
+*--------------------------------------------------------------------------------------------*/
+/** @packageDocumentation
+ * @module Tree
+ */
+import { takeUntil } from "rxjs/internal/operators/takeUntil";
+import { Subject } from "rxjs/internal/Subject";
+import { TreeModelMutator } from "./internal/TreeModelMutator";
+import { toRxjsObservable } from "./Observable";
+/**
+ * Default tree event handler.
+ * @public
+ */
+export class TreeEventHandler {
+    constructor(params) {
+        this._disposed = new Subject();
+        this._selectionReplaced = new Subject();
+        this._modelMutator = new TreeModelMutator(params.modelSource, params.nodeLoader, !!params.collapsedChildrenDisposalEnabled);
+        this._editingParams = params.editingParams;
+    }
+    /** Disposes tree event handler. */
+    dispose() {
+        this._disposed.next();
+    }
+    get modelSource() { return this._modelMutator.modelSource; }
+    /** Expands node and starts loading children. */
+    onNodeExpanded({ nodeId }) {
+        toRxjsObservable(this._modelMutator.expandNode(nodeId)).pipe(takeUntil(this._disposed)).subscribe();
+    }
+    /** Collapses node */
+    onNodeCollapsed({ nodeId }) {
+        this._modelMutator.collapseNode(nodeId);
+    }
+    /** Selects and deselects nodes until event is handled, handler is disposed or selection replaced event occurs. */
+    onSelectionModified({ modifications }) {
+        return toRxjsObservable(modifications)
+            .pipe(takeUntil(this._disposed), takeUntil(this._selectionReplaced))
+            .subscribe({
+            next: ({ selectedNodeItems, deselectedNodeItems }) => {
+                this._modelMutator.modifySelection(selectedNodeItems, deselectedNodeItems);
+            },
+        });
+    }
+    /** Replaces currently selected nodes until event is handled, handler is disposed or another selection replaced event occurs. */
+    onSelectionReplaced({ replacements }) {
+        this._selectionReplaced.next();
+        let firstEmission = true;
+        return toRxjsObservable(replacements)
+            .pipe(takeUntil(this._disposed), takeUntil(this._selectionReplaced))
+            .subscribe({
+            next: ({ selectedNodeItems }) => {
+                if (firstEmission) {
+                    firstEmission = false;
+                    this._modelMutator.replaceSelection(selectedNodeItems);
+                }
+                this._modelMutator.modifySelection(selectedNodeItems, []);
+            },
+        });
+    }
+    /** Changes nodes checkbox states. */
+    onCheckboxStateChanged({ stateChanges }) {
+        return stateChanges.subscribe((changes) => this._modelMutator.setCheckboxStates(changes));
+    }
+    /** Activates node editing if editing parameters are supplied and node is editable. */
+    onDelayedNodeClick({ nodeId }) {
+        this.activateEditor(nodeId);
+    }
+    /** Activates node editing if editing parameters are supplied and node is editable. */
+    onNodeEditorActivated({ nodeId }) {
+        this.activateEditor(nodeId);
+    }
+    /** Activates node editing if editing parameters are supplied and node is editable. */
+    activateEditor(nodeId) {
+        if (this._editingParams === undefined)
+            return;
+        this._modelMutator.activateEditing(nodeId, this._editingParams.onNodeUpdated);
+    }
+}
 //# sourceMappingURL=TreeEventHandler.js.map

package/lib/esm/components-react/tree/controlled/TreeEvents.d.ts

@@ -1,109 +1,109 @@
-/** @packageDocumentation
- * @module Tree
- */
-import { CheckBoxState } from "@itwin/core-react";
-import { TreeNodeItem } from "../TreeDataProvider";
-import { Observable, Subscription } from "./Observable";
-/**
- * Tree events that can occur while interacting with tree.
- *
- * **Note:** Selection and checkbox state change events payload is an Observable.
- * Observable is a stream of data over time (e.g. in case of selection replaced event
- * it is a stream of selected node items arrays). To access data inside stream `subscribe()` method
- * should be called. This method accepts any subset of 'next', 'error' and 'complete' callbacks.
- * Once subscribe is called observable will start emitting data and calls 'next' callback each time new
- * data is emitted. If some selected nodes are not loaded yet they will be loaded and observable will
- * emit loaded node items. When all selected node items are emitted observable completes and calls
- * 'complete' callback if supplied.
- *
- * @public
- */
-export interface TreeEvents {
-    /** Called when tree node is expanded. */
-    onNodeExpanded?(event: TreeNodeEventArgs): void;
-    /** Called when tree node is collapsed. */
-    onNodeCollapsed?(event: TreeNodeEventArgs): void;
-    /** Called when selected tree node is clicked. */
-    onDelayedNodeClick?(event: TreeNodeEventArgs): void;
-    /** Called when selected tree node editor is activated. */
-    onNodeEditorActivated?(event: TreeNodeEventArgs): void;
-    /**
-     * Called when tree selection is modified.
-     * If Subscription is returned it can be used to stop event handling by calling `unsubscribe()`.
-     */
-    onSelectionModified?(event: TreeSelectionModificationEventArgs): Subscription | undefined;
-    /**
-     * Called when tree selection is replaced.
-     * If Subscription is returned it can be used to stop event handling by calling `unsubscribe()`.
-     */
-    onSelectionReplaced?(event: TreeSelectionReplacementEventArgs): Subscription | undefined;
-    /**
-     * Called when checkbox states for nodes are changed.
-     * If Subscription is returned it can be used to stop event handling by calling `unsubscribe()`.
-     */
-    onCheckboxStateChanged?(event: TreeCheckboxStateChangeEventArgs): Subscription | undefined;
-}
-/**
- * Data structure that describes tree node event payload.
- * @public
- */
-export interface TreeNodeEventArgs {
-    /** Id of node that is affected by event. */
-    nodeId: string;
-}
-/**
- * Data structure that describes tree selection modification event payload.
- * @public
- */
-export interface TreeSelectionModificationEventArgs {
-    /**
-     * An observable that emits tree selection changes.
-     * It starts emitting values when '.subscribe()' is called.
-     */
-    modifications: Observable<TreeSelectionChange>;
-}
-/**
- * Data structure that describes tree selection change.
- * @public
- */
-export interface TreeSelectionChange {
-    /** Tree node items that where selected. */
-    selectedNodeItems: TreeNodeItem[];
-    /** Tree node items that where deselected. */
-    deselectedNodeItems: TreeNodeItem[];
-}
-/**
- * Data structure that describes tree selection replacement event payload.
- * @public
- */
-export interface TreeSelectionReplacementEventArgs {
-    /**
-     * An observable that emits tree selection replacements containing selected tree node items.
-     * It starts emitting values when '.subscribe()' is called.
-     */
-    replacements: Observable<{
-        selectedNodeItems: TreeNodeItem[];
-    }>;
-}
-/**
- * Data structure that describes tree checkbox state change event payload.
- * @public
- */
-export interface TreeCheckboxStateChangeEventArgs {
-    /**
-     * An observable that emits checkbox state changes.
-     * It starts emitting values when '.subscribe()' is called.
-     */
-    stateChanges: Observable<CheckboxStateChange[]>;
-}
-/**
- * Data structure that describes checkbox state change.
- * @public
- */
-export interface CheckboxStateChange {
-    /** Tree node item that was affected by checkbox state change. */
-    nodeItem: TreeNodeItem;
-    /** New state of the checkbox. */
-    newState: CheckBoxState;
-}
+/** @packageDocumentation
+ * @module Tree
+ */
+import { CheckBoxState } from "@itwin/core-react";
+import { TreeNodeItem } from "../TreeDataProvider";
+import { Observable, Subscription } from "./Observable";
+/**
+ * Tree events that can occur while interacting with tree.
+ *
+ * **Note:** Selection and checkbox state change events payload is an Observable.
+ * Observable is a stream of data over time (e.g. in case of selection replaced event
+ * it is a stream of selected node items arrays). To access data inside stream `subscribe()` method
+ * should be called. This method accepts any subset of 'next', 'error' and 'complete' callbacks.
+ * Once subscribe is called observable will start emitting data and calls 'next' callback each time new
+ * data is emitted. If some selected nodes are not loaded yet they will be loaded and observable will
+ * emit loaded node items. When all selected node items are emitted observable completes and calls
+ * 'complete' callback if supplied.
+ *
+ * @public
+ */
+export interface TreeEvents {
+    /** Called when tree node is expanded. */
+    onNodeExpanded?(event: TreeNodeEventArgs): void;
+    /** Called when tree node is collapsed. */
+    onNodeCollapsed?(event: TreeNodeEventArgs): void;
+    /** Called when selected tree node is clicked. */
+    onDelayedNodeClick?(event: TreeNodeEventArgs): void;
+    /** Called when selected tree node editor is activated. */
+    onNodeEditorActivated?(event: TreeNodeEventArgs): void;
+    /**
+     * Called when tree selection is modified.
+     * If Subscription is returned it can be used to stop event handling by calling `unsubscribe()`.
+     */
+    onSelectionModified?(event: TreeSelectionModificationEventArgs): Subscription | undefined;
+    /**
+     * Called when tree selection is replaced.
+     * If Subscription is returned it can be used to stop event handling by calling `unsubscribe()`.
+     */
+    onSelectionReplaced?(event: TreeSelectionReplacementEventArgs): Subscription | undefined;
+    /**
+     * Called when checkbox states for nodes are changed.
+     * If Subscription is returned it can be used to stop event handling by calling `unsubscribe()`.
+     */
+    onCheckboxStateChanged?(event: TreeCheckboxStateChangeEventArgs): Subscription | undefined;
+}
+/**
+ * Data structure that describes tree node event payload.
+ * @public
+ */
+export interface TreeNodeEventArgs {
+    /** Id of node that is affected by event. */
+    nodeId: string;
+}
+/**
+ * Data structure that describes tree selection modification event payload.
+ * @public
+ */
+export interface TreeSelectionModificationEventArgs {
+    /**
+     * An observable that emits tree selection changes.
+     * It starts emitting values when '.subscribe()' is called.
+     */
+    modifications: Observable<TreeSelectionChange>;
+}
+/**
+ * Data structure that describes tree selection change.
+ * @public
+ */
+export interface TreeSelectionChange {
+    /** Tree node items that where selected. */
+    selectedNodeItems: TreeNodeItem[];
+    /** Tree node items that where deselected. */
+    deselectedNodeItems: TreeNodeItem[];
+}
+/**
+ * Data structure that describes tree selection replacement event payload.
+ * @public
+ */
+export interface TreeSelectionReplacementEventArgs {
+    /**
+     * An observable that emits tree selection replacements containing selected tree node items.
+     * It starts emitting values when '.subscribe()' is called.
+     */
+    replacements: Observable<{
+        selectedNodeItems: TreeNodeItem[];
+    }>;
+}
+/**
+ * Data structure that describes tree checkbox state change event payload.
+ * @public
+ */
+export interface TreeCheckboxStateChangeEventArgs {
+    /**
+     * An observable that emits checkbox state changes.
+     * It starts emitting values when '.subscribe()' is called.
+     */
+    stateChanges: Observable<CheckboxStateChange[]>;
+}
+/**
+ * Data structure that describes checkbox state change.
+ * @public
+ */
+export interface CheckboxStateChange {
+    /** Tree node item that was affected by checkbox state change. */
+    nodeItem: TreeNodeItem;
+    /** New state of the checkbox. */
+    newState: CheckBoxState;
+}
 //# sourceMappingURL=TreeEvents.d.ts.map

package/lib/esm/components-react/tree/controlled/TreeEvents.js

@@ -1,9 +1,9 @@
-/*---------------------------------------------------------------------------------------------
-* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
-* See LICENSE.md in the project root for license terms and full copyright notice.
-*--------------------------------------------------------------------------------------------*/
-/** @packageDocumentation
- * @module Tree
- */
-export {};
+/*---------------------------------------------------------------------------------------------
+* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+* See LICENSE.md in the project root for license terms and full copyright notice.
+*--------------------------------------------------------------------------------------------*/
+/** @packageDocumentation
+ * @module Tree
+ */
+export {};
 //# sourceMappingURL=TreeEvents.js.map

package/lib/esm/components-react/tree/controlled/TreeHooks.d.ts

@@ -1,48 +1,48 @@
-/** @packageDocumentation
- * @module Tree
- */
-import { TreeDataProvider } from "../TreeDataProvider";
-import { TreeEventHandler, TreeEventHandlerParams } from "./TreeEventHandler";
-import { TreeModel } from "./TreeModel";
-import { TreeModelSource } from "./TreeModelSource";
-import { PagedTreeNodeLoader, TreeNodeLoader } from "./TreeNodeLoader";
-/**
- * React hook that returns an immutable `TreeModel` whenever it changes in the given
- * `TreeModelSource`.
- *
- * @public
- */
-export declare function useTreeModel(modelSource: TreeModelSource): TreeModel;
-/**
- * Custom hook which creates a nodes' loader using the supplied data provider and model source. The
- * loader pulls nodes from the data provider and puts them into the model source.
- *
- * @public
- */
-export declare function useTreeNodeLoader<TDataProvider extends TreeDataProvider>(dataProvider: TDataProvider, modelSource: TreeModelSource): TreeNodeLoader<TDataProvider>;
-/**
- * Custom hook which creates a paging nodes' loader using the supplied data provider and model source. The loader pulls
- * nodes from the data provider and puts them into the model source.
- * @public
- */
-export declare function usePagedTreeNodeLoader<TDataProvider extends TreeDataProvider>(dataProvider: TDataProvider, pageSize: number, modelSource: TreeModelSource): PagedTreeNodeLoader<TDataProvider>;
-/**
- * Custom hook which creates a `TreeModelSource`.
- *
- * @note The model source has no direct dependency on the data provider, but we want a fresh model
- * source whenever the data provider changes - that's the reason the hook takes a data provider.
- *
- * @public
- */
-export declare function useTreeModelSource(dataProvider: TreeDataProvider): TreeModelSource;
-/**
- * Custom hook which creates and takes care of disposing a TreeEventsHandler. The input is either a factory method
- * for a custom `TreeEventHandler` implementation or parameters for the default implementation.
- *
- * @note Caller must ensure `factoryOrParams` changes only when a new handler needs to be created. `useCallback` or `useMemo` can
- * be used for that purpose based on whether the input is a factory function or params object.
- *
- * @public
- */
-export declare function useTreeEventsHandler<TEventsHandler extends TreeEventHandler>(factoryOrParams: (() => TEventsHandler) | TreeEventHandlerParams): TreeEventHandler;
+/** @packageDocumentation
+ * @module Tree
+ */
+import { TreeDataProvider } from "../TreeDataProvider";
+import { TreeEventHandler, TreeEventHandlerParams } from "./TreeEventHandler";
+import { TreeModel } from "./TreeModel";
+import { TreeModelSource } from "./TreeModelSource";
+import { PagedTreeNodeLoader, TreeNodeLoader } from "./TreeNodeLoader";
+/**
+ * React hook that returns an immutable `TreeModel` whenever it changes in the given
+ * `TreeModelSource`.
+ *
+ * @public
+ */
+export declare function useTreeModel(modelSource: TreeModelSource): TreeModel;
+/**
+ * Custom hook which creates a nodes' loader using the supplied data provider and model source. The
+ * loader pulls nodes from the data provider and puts them into the model source.
+ *
+ * @public
+ */
+export declare function useTreeNodeLoader<TDataProvider extends TreeDataProvider>(dataProvider: TDataProvider, modelSource: TreeModelSource): TreeNodeLoader<TDataProvider>;
+/**
+ * Custom hook which creates a paging nodes' loader using the supplied data provider and model source. The loader pulls
+ * nodes from the data provider and puts them into the model source.
+ * @public
+ */
+export declare function usePagedTreeNodeLoader<TDataProvider extends TreeDataProvider>(dataProvider: TDataProvider, pageSize: number, modelSource: TreeModelSource): PagedTreeNodeLoader<TDataProvider>;
+/**
+ * Custom hook which creates a `TreeModelSource`.
+ *
+ * @note The model source has no direct dependency on the data provider, but we want a fresh model
+ * source whenever the data provider changes - that's the reason the hook takes a data provider.
+ *
+ * @public
+ */
+export declare function useTreeModelSource(dataProvider: TreeDataProvider): TreeModelSource;
+/**
+ * Custom hook which creates and takes care of disposing a TreeEventsHandler. The input is either a factory method
+ * for a custom `TreeEventHandler` implementation or parameters for the default implementation.
+ *
+ * @note Caller must ensure `factoryOrParams` changes only when a new handler needs to be created. `useCallback` or `useMemo` can
+ * be used for that purpose based on whether the input is a factory function or params object.
+ *
+ * @public
+ */
+export declare function useTreeEventsHandler<TEventsHandler extends TreeEventHandler>(factoryOrParams: (() => TEventsHandler) | TreeEventHandlerParams): TreeEventHandler;
 //# sourceMappingURL=TreeHooks.d.ts.map