import { Action, ContextMenuPopup, DesktopPopupOpenEvent, DoubleClickSupport, DragAndDropHandler, DropType, EnumObject, EventHandler, Filter, Filterable, FilterOrFunction, FilterResult, FilterSupport, InitModelOf, KeyStrokeContext, Menu, MenuBar, MenuDestinations, MenuFilter, ObjectOrChildModel, ObjectOrModel, Range, Rectangle, ScrollDirection, ScrollToAlignment, ScrollToOptions, TreeBreadcrumbFilter, TreeCheckNodesResult, TreeEventMap, TreeModel, TreeNode, TreeNodeModel, UpdateFilteredElementsOptions, Widget } from '../index'; export declare class Tree extends Widget implements TreeModel, Filterable { model: TreeModel; eventMap: TreeEventMap; self: Tree; toggleBreadcrumbStyleEnabled: boolean; breadcrumbTogglingThreshold: number; autoCheckChildren: boolean; checkable: boolean; checkableStyle: TreeCheckableStyle; displayStyle: TreeDisplayStyle; dropType: DropType; dropMaximumSize: number; lazyExpandingEnabled: boolean; menus: Menu[]; contextMenu: ContextMenuPopup; menuBar: MenuBar; keyStrokes: Action[]; multiCheck: boolean; nodes: TreeNode[]; /** all nodes by id */ nodesMap: Record; nodePaddingLevelCheckable: number; nodePaddingLevelNotCheckable: number; nodePaddingLevelDiffParentHasIcon: number; nodePaddingLeft: number; /** is read from CSS */ nodeCheckBoxPaddingLeft: number; nodeControlPaddingLeft: number; /** is read from CSS */ nodePaddingLevel: number; scrollToSelection: boolean; /** Only necessary for breadcrumb mode */ scrollTopHistory: number[]; selectedNodes: TreeNode[]; /** The previously selected node, relevant for breadcrumb in compact mode */ prevSelectedNode: TreeNode; focusedNode: TreeNode; nodesFocusable: boolean; filters: Filter[]; textFilterEnabled: boolean; filterSupport: FilterSupport; filteredElementsDirty: boolean; filterAnimated: boolean; rebuildSuppressed: boolean; breadcrumbFilter: TreeBreadcrumbFilter; dragAndDropHandler: DragAndDropHandler; groupedNodes: Record; visibleNodesFlat: TreeNode[]; visibleNodesMap: Record; viewRangeRendered: Range; viewRangeDirty: boolean; viewRangeSize: number; startAnimationFunc: () => void; runningAnimations: number; runningAnimationsFinishFunc: () => void; nodeHeight: number; nodeWidth: number; maxNodeWidth: number; nodeWidthDirty: boolean; initialTraversing: boolean; defaultMenuTypes: string[]; $data: JQuery; $fillBefore: JQuery; $fillAfter: JQuery; /** may be used by subclasses to set additional CSS classes */ protected _additionalContainerClasses: string; protected _renderViewportBlocked: boolean; protected _doubleClickSupport: DoubleClickSupport; /** used by _renderExpansion() */ protected _$animationWrapper: JQuery; protected _$expandAnimationWrappers: JQuery[]; protected _filterMenusHandler: MenuFilter; protected _popupOpenHandler: EventHandler; /** contains all parents of a selected node, the selected node and the first level children */ protected _inSelectionPathList: Record; protected _scrollDirections: ScrollDirection; protected _changeNodeTaskScheduled: boolean; protected _$mouseDownNode: JQuery; constructor(); static DisplayStyle: { readonly DEFAULT: "default"; readonly BREADCRUMB: "breadcrumb"; }; static CheckableStyle: { /** * Node check is only possible by checking the checkbox. */ readonly CHECKBOX: "checkbox"; /** * Node check is possible by clicking anywhere on the node. */ readonly CHECKBOX_TREE_NODE: "checkbox_tree_node"; }; static MenuType: { readonly EmptySpace: "Tree.EmptySpace"; readonly SingleSelection: "Tree.SingleSelection"; readonly MultiSelection: "Tree.MultiSelection"; readonly Header: "Tree.Header"; }; /** * Used to calculate the view range size. See {@link calculateViewRangeSize}. */ static VIEW_RANGE_DIVISOR: number; protected _init(model: InitModelOf): void; /** * Initialize nodes, applies filters and updates flat list */ protected _initNodes(nodes: TreeNode[], parentNode?: TreeNode): void; /** * Iterates through the given array and converts node-models to instances of {@link TreeNode} (or a subclass). * If the array element is already a {@link TreeNode} the function leaves the element untouched. This function also * ensures that the attribute {@link TreeNode.childNodeIndex} is set. */ ensureTreeNodes(nodes: ObjectOrModel[], parentNode?: TreeNode): void; protected _createTreeNode(nodeModel?: TreeNodeModel): TreeNode; protected _createKeyStrokeContext(): KeyStrokeContext; protected _initKeyStrokeContext(): void; protected _initTreeKeyStrokeContext(): void; setAutoCheckChildren(autoCheckChildren: boolean): void; /** @see TreeModel.menus */ setMenus(menus: ObjectOrChildModel[]): void; protected _setMenus(argMenus: Menu[]): void; protected _updateMenuBar(): void; protected _setKeyStrokes(keyStrokes: Action[]): void; protected _resetTreeNode(node: TreeNode, parentNode: TreeNode): void; isSelectedNode(node: TreeNode): boolean; protected _updateSelectionPath(): void; protected _initTreeNode(node: TreeNode, parentNode: TreeNode): void; /** * Override this function if you want a custom node init before filtering. * The default implementation does nothing. */ protected _initTreeNodeInternal(node: TreeNode, parentNode: TreeNode): void; protected _destroy(): void; protected _destroyTreeNode(node: TreeNode): void; protected _onNodeDeleted(node: TreeNode): void; /** * pre-order (top-down) traversal of the tree-nodes of this tree. * * If func returns true the children of the visited node are not visited. */ visitNodes(func: (node: TreeNode, parentNode?: TreeNode) => boolean | void, parentNode?: TreeNode): void; protected _render(): void; protected _renderData(): void; protected _renderProperties(): void; protected _postRender(): void; protected _remove(): void; isHorizontalScrollingEnabled(): boolean; isTreeNodeCheckEnabled(): boolean; protected _onScroll(event: JQuery.ScrollEvent): void; setScrollTop(scrollTop: number): void; /** @internal */ _renderScrollTop(): void; get$Scrollable(): JQuery; get$Focusable(): JQuery; protected _onFocus(event: JQuery.FocusEvent): void; /** @internal */ _renderViewport(): void; protected _calculateCurrentViewRange(): Range; protected _rerenderViewport(): void; protected _removeRenderedNodes(): void; protected _renderViewRangeForNode(node: TreeNode): void; protected _renderNodesInRange(range: Range): void; ensureRangeVisible(range: Range): number; /** @internal */ _renderFiller(): void; protected _calculateFillerDimension(range: Range): { width: number; height: number; }; protected _removeNodesInRange(range: Range): void; /** * Just removes the node, does NOT adjust this.viewRangeRendered */ protected _removeNode(node: TreeNode): void; /** * Renders the rows visible in the viewport and removes the other rows */ protected _renderViewRange(viewRange: Range): void; protected _postRenderViewRange(): void; protected _visibleNodesInViewRange(): TreeNode[]; protected _updateDomNodeWidth(): void; protected _cleanupNodes($nodes: JQuery): void; /** * Returns the TreeNode which is at position scrollTop. */ protected _nodeAtScrollTop(scrollTop: number): TreeNode; protected _heightForNode(node: TreeNode): number; protected _widthForNode(node: TreeNode): number; /** * Returns a range of size this.viewRangeSize. Start of range is nodeIndex - viewRangeSize / 4. * -> 1/4 of the nodes are before the viewport 2/4 in the viewport 1/4 after the viewport, * assuming viewRangeSize is 2*number of possible nodes in the viewport (see calculateViewRangeSize). */ protected _calculateViewRangeForNode(node: TreeNode): Range; /** * Calculates the optimal view range size (number of nodes to be rendered). * It uses the default node height to estimate how many nodes fit in the view port. * The view range size is this value * 2. *

* Note: the value calculated by this function is important for calculating the * 'insertBatch'. When the value becomes smaller than 4 ({@link Tree.VIEW_RANGE_DIVISOR}) this * will cause errors on inserting nodes at the right position. See #262890. */ calculateViewRangeSize(): number; setViewRangeSize(viewRangeSize: number): void; protected _updateNodeDimensions(): void; /** * Updates the node heights for every visible node and clears the height of the others */ updateNodeHeights(): void; removeAllNodes(): void; /** * @param parentNode * Optional. If provided, this node's state will be updated (e.g. it will be collapsed * if it does no longer have child nodes). Can also be an array, in which case all of * those nodes are updated. */ protected _removeNodes(nodes: TreeNode[], parentNode?: TreeNode | TreeNode[]): void; protected _renderNode(node: TreeNode): JQuery; protected _removeMenus(): void; protected _filterMenus(argMenus: Menu[], destination: MenuDestinations, onlyVisible?: boolean, enableDisableKeyStrokes?: boolean): Menu[]; protected _renderEnabled(): void; protected _renderTabbable(): void; protected _renderDisabledStyle(): void; setCheckable(checkable: boolean): void; protected _setCheckable(checkable: boolean): void; protected _updateNodePaddingLevel(): void; setCheckableStyle(checkableStyle: TreeCheckableStyle): void; protected _renderCheckable(): void; protected _renderDisplayStyle(): void; protected _renderExpansion(node: TreeNode, options?: TreeRenderExpansionOptions): void; protected _renderSelection(): void; protected _renderCheckableStyle(): void; protected _highlightPrevSelectedNode(): void; protected _removeSelection(): void; protected _removeNodeSelection(node: TreeNode): void; setDropType(dropType: DropType): void; protected _renderDropType(): void; setDropMaximumSize(dropMaximumSize: number): void; protected _installOrUninstallDragAndDropHandler(): void; protected _updateChildrenChecked(nodes: TreeNode[]): void; /** * Processes a {@link TreeCheckNodesResult} object. It renders all updated nodes and triggers * a `nodesChecked` event. * * @param checkNodesResult object with tree node check update * @param triggerEvent indicates whether events should be triggered or not. Default is true. */ protected _processTreeCheckNodesResult(checkNodesResult: TreeCheckNodesResult, triggerEvent?: boolean): void; protected _installNodeTooltipSupport(): void; protected _treeNodeTooltipOrigin($node: JQuery): Rectangle; protected _uninstallNodeTooltipSupport(): void; protected _nodeTooltipText($node: JQuery): string; protected _isTruncatedNodeTooltipEnabled(): boolean; setDisplayStyle(displayStyle: TreeDisplayStyle): void; protected _setDisplayStyle(displayStyle: TreeDisplayStyle): void; protected _updateNodePaddingsLeft($nodesToUpdate?: JQuery): void; setBreadcrumbStyleActive(active: boolean): void; isNodeInBreadcrumbVisible(node: TreeNode): boolean; isBreadcrumbStyleActive(): boolean; setToggleBreadcrumbStyleEnabled(enabled: boolean): void; setBreadcrumbTogglingThreshold(width: number): void; expandNode(node: TreeNode, opts?: TreeNodeExpandOptions): void; collapseNode(node: TreeNode, opts?: TreeNodeExpandOptions): void; collapseAll(): void; setNodeExpanded(node: TreeNode, expanded: boolean, opts?: TreeNodeExpandOptions): void; setNodeExpandedRecursive(nodes: TreeNode[], expanded: boolean, opts?: TreeNodeExpandOptions): void; protected _rebuildParent(node: TreeNode, opts: TreeNodeExpandOptions): void; protected _removeChildrenFromFlatList(parentNode: TreeNode, animatedRemove: boolean): TreeNode[]; protected _removeFromFlatList(node: TreeNode, animatedRemove: boolean): void; protected _addToVisibleFlatList(node: TreeNode, renderingAnimated: boolean): void; protected _addChildrenToFlatList(parentNode: TreeNode, parentIndex: number, animatedRendering: boolean, insertBatch?: InsertBatch, forceFilter?: boolean): number | InsertBatch; /** * Checks if the given node is expanded, and if that's the case determine the insert index of the node and add its children to the flat list. * * @param indexOffset either 0 or 1, offset is added to the insert index */ protected _addChildrenToFlatListIfExpanded(indexOffset: number, node: TreeNode, insertIndex: number, animatedRendering: boolean, insertBatch: InsertBatch, forceFilter: boolean): InsertBatch; protected _showNodes(insertBatch: InsertBatch): boolean; /** * This function tries to find the correct insert position within the flat list for the given node. * The function must consider the order of child nodes in the original tree structure and then check * where in the flat list this position is. */ protected _findInsertPositionInFlatList(node: TreeNode): number; protected _findPositionInFlatList(node: TreeNode): number; /** * Checks whether the given checkNode belongs to the same subtree (or is) the given node. * The function goes up all parentNodes of the checkNode. * * @param node which is used to for the subtree comparison * @param checkNode node which is checked against the given node */ protected _isInSameSubTree(node: TreeNode, checkNode: TreeNode): boolean; /** * Returns true if the given node is a child of one of the selected nodes. * The functions goes up the parent node hierarchy. * * @param node to check */ isChildOfSelectedNodes(node: TreeNode): boolean; /** * Info: the object created here is a bit weird: the array 'insertNodes' is used as function arguments to the Array#splice function at some point. * The signature of that function is: array.splice(index, deleteCount[, element1[, element2 [, ...]]]) * So the first two elements are numbers and all the following elements are TreeNodes or Pages. */ newInsertBatch(insertIndex: number): InsertBatch; checkAndHandleBatchAnimationWrapper(parentNode: TreeNode, animatedRendering: boolean, insertBatch: InsertBatch): void; checkAndHandleBatch(insertBatch: InsertBatch, parentNode: TreeNode, animatedRendering: boolean): InsertBatch; insertBatchInVisibleNodes(insertBatch: InsertBatch, showNodes: boolean, animate: boolean): void; protected _addToVisibleFlatListNoCheck(node: TreeNode, insertIndex: number, animatedRendering: boolean): void; scrollTo(node: TreeNode, options?: ScrollToOptions | ScrollToAlignment): void; revealSelection(): void; ensureExpansionVisible(node: TreeNode): void; deselectAll(): void; /** * @param node the node to be selected. If no node is provided, the selection will be removed. */ selectNode(node: TreeNode, debounceSend?: boolean): void; /** * @param nodes the nodes to be selected. If no nodes are provided, the selection will be removed. */ selectNodes(nodes: TreeNode | TreeNode[], debounceSend?: boolean): void; protected _rememberScrollTopBeforeSelection(): void; protected _updateScrollTopAfterSelection(): void; protected _setSelectedNodes(nodes: TreeNode[], debounceSend?: boolean): void; /** * This method is overridden by subclasses of Tree. The default impl. does nothing. */ protected _nodesSelectedInternal(): void; deselectNode(node: TreeNode): void; /** * @param nodes the nodes to deselect * @param options.collectChildren true to add the selected children to the list of nodes to deselect */ deselectNodes(nodes: TreeNode | TreeNode[], options?: { collectChildren?: boolean; }): void; isNodeSelected(node: TreeNode): boolean; protected _computeNodePaddingLeft(node: TreeNode): number; /** @internal */ _computeNodeControlPaddingLeft(node: TreeNode): number; protected _computeNodePaddingLeftForLevel(node: TreeNode): number; /** * Reads the paddings from CSS and stores them in nodePaddingLeft and nodeControlPaddingLeft */ protected _computeNodePaddings(): void; protected _expandAllParentNodes(node: TreeNode): void; protected _updateChildNodeIndex(nodes: TreeNode[], startIndex?: number): void; /** * Inserts the given node at the end of the existing {@link nodes} resp. at the end of the existing {@link TreeNode.childNodes} if a parentNode is provided. * * @see insertNodes */ insertNode(node: ObjectOrModel, parentNode?: TreeNode, index?: number): void; /** * Inserts the given nodes at the end of the existing {@link nodes} resp. at the end of the existing {@link TreeNode.childNodes} if a parentNode is provided. * * If an index is provided, the new nodes will be inserted at that position. * Alternatively, each node can specify a {@link TreeNode.childNodeIndex}. * If a node provides a {@link TreeNode.childNodeIndex}, it will be inserted at that position. * Other nodes without a {@link TreeNode.childNodeIndex} will still be inserted at the end. * * @param nodes the new nodes to be added. * @param parentNode if provided, the new nodes will be added to that parent (into {@link TreeNode.childNodes}), otherwise they will be added as root nodes (into {@link nodes}). * @param index if provided, the new nodes will be added at that position in {@link TreeNode.childNodes} of the provided parentNode resp. in {@link nodes} if no parent is provided. * If one of the new nodes specifies a {@link TreeNode.childNodeIndex}, it will be ignored and replaced by the calculated one based on the provided index. */ insertNodes(nodes: ObjectOrModel | ObjectOrModel[], parentNode?: TreeNode, index?: number): void; updateNode(node: ObjectOrModel): void; updateNodes(nodes: ObjectOrModel | ObjectOrModel[]): void; /** * Called by _onNodesUpdated for every updated node. The function is expected to apply * all updated properties from the updatedNode to the oldNode. May be overridden by * subclasses so update their specific node properties. * * @param oldNode * The target node to be updated * @param updatedNode * The new node with potentially updated properties. Default values are already applied! * @returns * true if at least one property has changed, false otherwise. This value is used to * determine if the node has to be rendered again. */ protected _applyUpdatedNodeProperties(oldNode: TreeNode, updatedNode: ObjectOrModel): boolean; deleteNode(node: TreeNode, parentNode?: TreeNode): void; deleteAllNodes(): void; /** * @param nodes the nodes to be deleted. If no nodes are provided, nothing will happen. * @param parentNode the parent node that contains the nodes to be deleted. This is completely optional because each node knows its parent. * If provided, an exception will occur if one of the given node has a different parent. */ deleteNodes(nodes: TreeNode | TreeNode[], parentNode?: TreeNode): void; protected _collectNodesIfDescendants(nodes: TreeNode[], nodesToCheck: TreeNode[]): TreeNode[]; deleteAllChildNodes(parentNode?: TreeNode): void; updateNodeOrder(childNodes: TreeNode | TreeNode[], parentNode?: TreeNode): void; /** * @returns all checked nodes */ get checkedNodes(): TreeNode[]; /** * Checks all nodes if no or some nodes are checked. * Unchecks all nodes if all nodes are checked. */ toggleChecked(nodes: TreeNode | TreeNode[]): void; /** * @returns true if the node changed its state, false otherwise. */ checkNode(node: TreeNode, checked?: boolean, options?: TreeNodeCheckOptions): boolean; /** * @returns true if any node changed its state, false otherwise. */ checkNodes(nodes: TreeNode | TreeNode[], options?: TreeNodeCheckOptions): boolean; protected _checkChildrenRecursive(parentNode: TreeNode, opts: TreeNodeCheckOptions): TreeCheckNodesResult; protected _updateChildrenCheckedRecursive(parentNode: TreeNode): TreeCheckNodesResult; /** * Updates `checked` and `checkedChildren` properties on the given node based on its children. * Also updates its parent node if one of these properties have been changed. */ protected _checkParentsRecursive(node: TreeNode): TreeCheckNodesResult; protected _checkNode(node: TreeNode, opts: TreeNodeCheckOptions): TreeCheckNodesResult; protected _uncheckAll(): TreeCheckNodesResult; protected _isNodeEditable(node: TreeNode, checkOnlyEnabled?: boolean): boolean; /** * @returns true if the node changed its state, false otherwise. */ uncheckNode(node: TreeNode, options?: TreeNodeUncheckOptions): void; /** * @param nodes the nodes to uncheck * @returns true if any node changed its state, false otherwise. */ uncheckNodes(nodes: TreeNode[], options?: TreeNodeUncheckOptions): boolean; protected _triggerNodesSelected(debounce?: boolean): void; protected _showContextMenu(event: JQuery.ContextMenuEvent): void; /** @internal */ _onNodeMouseDown(event: JQuery.MouseDownEvent): boolean; /** @internal */ _onNodeMouseUp(event: JQuery.MouseUpEvent): boolean; protected _isCheckboxClicked(event: JQuery.MouseDownEvent): boolean; protected _updateItemPath(selectionChanged: boolean, ultimate?: TreeNode): void; protected _isGroupingEnd(node: TreeNode): boolean; /** * @returns the first selected node or null when no node is selected. */ selectedNode(): TreeNode; $selectedNodes(): JQuery; $nodes(): JQuery; /** * @param filter The filters to add. * @param applyFilter Whether to apply the filters after modifying the filter list or not. Default is true. */ addFilter(filter: FilterOrFunction | FilterOrFunction[], applyFilter?: boolean): void; /** * @param filter The filters to remove. * @param applyFilter Whether to apply the filters after modifying the filter list or not. Default is true. */ removeFilter(filter: FilterOrFunction | FilterOrFunction[], applyFilter?: boolean): void; /** * @param filters The new filters. * @param applyFilter Whether to apply the filters after modifying the filter list or not. Default is true. */ setFilters(filters: FilterOrFunction | FilterOrFunction[], applyFilter?: boolean): void; filter(): void; protected _filter(): TreeFilterResult; updateFilteredElements(result: TreeFilterResult, opts: UpdateFilteredElementsOptions): void; filterVisibleNodes(animated?: boolean): void; protected _nodesFiltered(hiddenNodes: TreeNode[]): void; applyFiltersForNode(node: TreeNode, applyNewHiddenShownNodes?: boolean, animated?: boolean): TreeFilterResult; protected _applyFiltersForNodeRec(node: TreeNode, recursive: boolean, animated?: boolean): TreeFilterResult; /** * @returns true if node state has changed, false if not */ protected _applyFiltersForNode(node: TreeNode): boolean; protected _createFilterSupport(): FilterSupport; setTextFilterEnabled(textFilterEnabled: boolean): void; isTextFilterFieldVisible(): boolean; protected _renderTextFilterEnabled(): void; protected _renderMultiCheck(): void; /** * Just insert node in DOM. NO check if in viewRange */ protected _insertNodesInDOM(nodes: TreeNode[], indexHint?: number): void; protected _installNodes(nodes: TreeNode[]): void; /** * Attaches node to DOM, if it is visible and in view range * */ protected _ensureNodeInDOM(node: TreeNode, useAnimation: boolean, indexHint: number): void; protected _insertNodeInDOMAtPlace(node: TreeNode, index: number): void; protected _updateAriaNodeIndices(): void; showNode(node: TreeNode, useAnimation: boolean, indexHint: number): void; hideNode(node: TreeNode, useAnimation: boolean, suppressDetachHandling?: boolean): void; nodesToIds(nodes: TreeNode[]): string[]; nodesByIds(ids: string[]): TreeNode[]; nodeById(id: string): TreeNode; /** * Checks whether the given node is contained in the tree. Uses the id of the node for the lookup. */ hasNode(node: TreeNode): boolean; protected _onNodeDoubleClick(event: JQuery.DoubleClickEvent): void; doNodeAction(node: TreeNode, expanded: boolean): void; protected _isNodeControl($target: JQuery): boolean; protected _onNodeControlMouseDown(event: JQuery.MouseDownEvent): boolean; protected _onContextMenu(event: JQuery.ContextMenuEvent): void; changeNode(node: TreeNode): void; protected _onDesktopPopupOpen(event: DesktopPopupOpenEvent): void; updateScrollbars(): void; setNodesFocusable(focusable: boolean): void; protected _setNodesFocusable(focusable: boolean): void; protected _renderNodesFocusable(): void; setFocusedNode(node: TreeNode): void; protected _setFocusedNode(node: TreeNode | string): void; protected _removeFocusedNode(): void; protected _renderFocusedNode(): void; protected _updateAriaActiveDescendant(): void; static collectSubtree($rootNode: JQuery, includeRootNodeInResult?: boolean): JQuery; /** * pre-order (top-down) traversal of the tree-nodes provided.
* if func returns true the children of the visited node are not visited. */ static visitNodes(func: (node: TreeNode, parentNode?: TreeNode) => boolean | void, nodes: TreeNode[], parentNode?: TreeNode): void; } export type TreeDisplayStyle = EnumObject; export type TreeCheckableStyle = EnumObject; export type TreeMenuType = EnumObject; export type TreeNodeExpandOptions = { /** * Default is derived from {@link TreeNode.expandedLazy} and {@link TreeNode.lazyExpandingEnabled} if the node is expanded and false otherwise. */ lazy?: boolean; /** * Default is true */ renderAnimated?: boolean; /** * Default is false */ collapseChildNodes?: boolean; /** * Default is true */ renderExpansion?: boolean; }; export type TreeRenderExpansionOptions = { /** * Default is false */ expandLazyChanged?: boolean; /** * Default is false */ expansionChanged?: boolean; }; export type TreeNodeCheckOptions = { /** * Default is true. */ checked?: boolean; /** * Defines if only enabled nodes should be checked. * * Default is true. */ checkOnlyEnabled?: boolean; /** * Default is false. */ checkChildren?: boolean; /** * Specifies if a 'nodesChecked' event should be triggered. * * Default is true. */ triggerNodesChecked?: boolean; }; export type TreeNodeUncheckOptions = TreeNodeCheckOptions & { /** * Default is false. */ checked?: boolean; /** * true to add the checked children to the list of nodes to uncheck. Default is false. */ collectChildren?: boolean; }; export type TreeFilterResult = FilterResult; export type InsertBatch = { /** * second element is always 0 (used as argument for deleteCount in Array#splice) */ insertNodes: (number | TreeNode)[]; $animationWrapper: JQuery; lastBatchInsertIndex(): number; nextBatchInsertIndex(): number; isEmpty(): boolean; length(): number; insertAt(): number; setInsertAt(insertAt: number): any; containsNode(node: TreeNode): boolean; animationCompleteFunc?(): void; }; //# sourceMappingURL=Tree.d.ts.map