primenglab 22.0.0-beta.1

package/types/primenglab-tree.d.ts

@@ -0,0 +1,571 @@
+import { TreePassThrough, TreeSelectionMode, TreeLoadingMode, TreeNodeSelectEvent, TreeNodeUnSelectEvent, TreeNodeExpandEvent, TreeNodeCollapseEvent, TreeNodeContextMenuSelectEvent, TreeNodeDoubleClickEvent, TreeNodeDropEvent, TreeLazyLoadEvent, TreeScrollEvent, TreeScrollIndexChangeEvent, TreeFilterEvent, TreeFilterTemplateContext, TreeLoaderTemplateContext, TreeTogglerIconTemplateContext, TreeCheckboxIconTemplateContext } from 'primenglab/types/tree';
+export * from 'primenglab/types/tree';
+import * as _angular_core from '@angular/core';
+import { TemplateRef, ElementRef } from '@angular/core';
+import { BlockableUI, TreeNode, ScrollerOptions, TreeDragDropService } from 'primenglab/api';
+import { BaseComponent } from 'primenglab/basecomponent';
+import * as i1 from 'primenglab/bind';
+import { Bind } from 'primenglab/bind';
+import { Scroller } from 'primenglab/scroller';
+import * as _primeuix_styled from '@primeuix/styled';
+import { BaseStyle } from 'primenglab/base';
+
+/**
+ *
+ * Tree is used to display hierarchical data.
+ *
+ * [Live Demo](https://www.primeng.org/tree/)
+ *
+ * @module treestyle
+ *
+ */
+declare enum TreeClasses {
+    /**
+     * Class name of the root element
+     */
+    root = "p-tree",
+    /**
+     * Class name of the mask element
+     */
+    mask = "p-tree-mask",
+    /**
+     * Class name of the loading icon element
+     */
+    loadingIcon = "p-tree-loading-icon",
+    /**
+     * Class name of the filter input element
+     */
+    pcFilterInput = "p-tree-filter-input",
+    /**
+     * Class name of the wrapper element
+     */
+    wrapper = "p-tree-root",
+    /**
+     * Class name of the root children element
+     */
+    rootChildren = "p-tree-root-children",
+    /**
+     * Class name of the node element
+     */
+    node = "p-tree-node",
+    /**
+     * Class name of the node content element
+     */
+    nodeContent = "p-tree-node-content",
+    /**
+     * Class name of the node toggle button element
+     */
+    nodeToggleButton = "p-tree-node-toggle-button",
+    /**
+     * Class name of the node toggle icon element
+     */
+    nodeToggleIcon = "p-tree-node-toggle-icon",
+    /**
+     * Class name of the node checkbox element
+     */
+    nodeCheckbox = "p-tree-node-checkbox",
+    /**
+     * Class name of the node icon element
+     */
+    nodeIcon = "p-tree-node-icon",
+    /**
+     * Class name of the node label element
+     */
+    nodeLabel = "p-tree-node-label",
+    /**
+     * Class name of the node children element
+     */
+    nodeChildren = "p-tree-node-children",
+    /**
+     * Class name of the empty message element
+     */
+    emptyMessage = "p-tree-empty-message",
+    /**
+     * Class name of the drop point element
+     */
+    dropPoint = "p-tree-node-droppoint"
+}
+declare class TreeStyle extends BaseStyle {
+    name: string;
+    style: _primeuix_styled.StyleType;
+    classes: {
+        root: ({ instance }: {
+            instance: any;
+        }) => (string | {
+            'p-tree-selectable': boolean;
+            'p-tree-loading': any;
+            'p-tree-flex-scrollable': boolean;
+            'p-tree-node-dragover': any;
+        })[];
+        mask: string;
+        loadingIcon: string;
+        pcFilterInput: string;
+        wrapper: string;
+        rootChildren: string;
+        node: ({ instance }: {
+            instance: any;
+        }) => {
+            'p-tree-node': boolean;
+            'p-tree-node-leaf': any;
+        };
+        nodeContent: ({ instance }: {
+            instance: any;
+        }) => {
+            'p-tree-node-content': boolean;
+            'p-tree-node-selectable': any;
+            'p-tree-node-dragover': any;
+            'p-tree-node-selected': any;
+            'p-tree-node-contextmenu-selected': any;
+        };
+        nodeToggleButton: string;
+        nodeToggleIcon: string;
+        nodeCheckbox: string;
+        nodeIcon: string;
+        nodeLabel: string;
+        nodeChildren: string;
+        emptyMessage: string;
+        dropPoint: string;
+    };
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TreeStyle, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<TreeStyle>;
+}
+interface TreeStyle extends BaseStyle {
+}
+
+/**
+ * Tree is used to display hierarchical data.
+ * @group Components
+ */
+declare class Tree extends BaseComponent<TreePassThrough> implements BlockableUI {
+    componentName: string;
+    private _destroyed;
+    bindDirectiveInstance: Bind;
+    $pcTree: Tree | undefined;
+    onDestroy(): void;
+    onAfterViewChecked(): void;
+    /**
+     * An array of treenodes.
+     * @group Props
+     */
+    value: _angular_core.InputSignal<any>;
+    /**
+     * Defines the selection mode.
+     * @group Props
+     */
+    selectionMode: _angular_core.InputSignal<TreeSelectionMode>;
+    /**
+     * Loading mode display.
+     * @group Props
+     */
+    loadingMode: _angular_core.InputSignal<TreeLoadingMode>;
+    /**
+     * A single treenode instance or an array to refer to the selections.
+     * @deprecated since v22, use `selectionKeys` instead for key-based selection state.
+     * @group Props
+     */
+    selection: _angular_core.ModelSignal<TreeNode<any> | TreeNode<any>[] | null | undefined>;
+    /**
+     * A map of node keys (by `TreeNode.key`) whose value is `true` for collapsed nodes. Two-way bindable.
+     * When provided it controls expansion (a node is expanded unless its key maps to `true`); leave it
+     * unset to keep driving expansion from each node's `expanded` flag (default, non-breaking).
+     * @group Props
+     */
+    collapsedKeys: _angular_core.ModelSignal<{
+        [key: string]: boolean;
+    } | null>;
+    /**
+     * A map of node keys (by `TreeNode.key`) describing the selection state. Two-way bindable.
+     * For single/multiple selection a key maps to `true`; for checkbox selection it maps to
+     * `{ checked, partialChecked }`. When provided it is kept in sync with `selection`; leave it unset
+     * to keep using the node-reference based `selection` model (default, non-breaking).
+     * @group Props
+     */
+    selectionKeys: _angular_core.ModelSignal<{
+        [key: string]: any;
+    } | null>;
+    /**
+     * Context menu instance.
+     * @group Props
+     */
+    contextMenu: _angular_core.InputSignal<any>;
+    /**
+     * Selected node with a context menu.
+     * @group Props
+     */
+    contextMenuSelection: _angular_core.ModelSignal<TreeNode<any> | null>;
+    /**
+     * Scope of the draggable nodes to match a droppableScope.
+     * @group Props
+     */
+    draggableScope: _angular_core.InputSignal<any>;
+    /**
+     * Scope of the droppable nodes to match a draggableScope.
+     * @group Props
+     */
+    droppableScope: _angular_core.InputSignal<any>;
+    /**
+     * Whether the nodes are draggable.
+     * @group Props
+     */
+    draggableNodes: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Whether the nodes are droppable.
+     * @group Props
+     */
+    droppableNodes: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Defines how multiple items can be selected, when true metaKey needs to be pressed to select or unselect an item and when set to false selection of each item can be toggled individually. On touch enabled devices, metaKeySelection is turned off automatically.
+     * @group Props
+     */
+    metaKeySelection: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Whether checkbox selections propagate to ancestor nodes.
+     * @group Props
+     */
+    propagateSelectionUp: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Whether checkbox selections propagate to descendant nodes.
+     * @group Props
+     */
+    propagateSelectionDown: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Displays a loader to indicate data load is in progress.
+     * @group Props
+     */
+    loading: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * The icon to show while indicating data load is in progress.
+     * @group Props
+     */
+    loadingIcon: _angular_core.InputSignal<string | undefined>;
+    /**
+     * Text to display when there is no data.
+     * @group Props
+     */
+    emptyMessage: _angular_core.InputSignal<string>;
+    /**
+     * Used to define a string that labels the tree.
+     * @group Props
+     */
+    ariaLabel: _angular_core.InputSignal<string | undefined>;
+    /**
+     * Defines a string that labels the toggler icon for accessibility.
+     * @group Props
+     */
+    togglerAriaLabel: _angular_core.InputSignal<string | undefined>;
+    /**
+     * Establishes relationships between the component and label(s) where its value should be one or more element IDs.
+     * @group Props
+     */
+    ariaLabelledBy: _angular_core.InputSignal<string | undefined>;
+    /**
+     * When enabled, drop can be accepted or rejected based on condition defined at onNodeDrop.
+     * @group Props
+     */
+    validateDrop: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * When specified, displays an input field to filter the items.
+     * @group Props
+     */
+    filter: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Determines whether the filter input should be automatically focused when the component is rendered.
+     * @group Props
+     */
+    filterInputAutoFocus: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * When filtering is enabled, filterBy decides which field or fields (comma separated) to search against.
+     * @group Props
+     */
+    filterBy: _angular_core.InputSignal<string>;
+    /**
+     * Mode for filtering valid values are "lenient" and "strict". Default is lenient.
+     * @group Props
+     */
+    filterMode: _angular_core.InputSignal<string>;
+    /**
+     * Mode for filtering valid values are "lenient" and "strict". Default is lenient.
+     * @group Props
+     */
+    filterOptions: any;
+    /**
+     * Placeholder text to show when filter input is empty.
+     * @group Props
+     */
+    filterPlaceholder: _angular_core.InputSignal<string | undefined>;
+    /**
+     * Values after the tree nodes are filtered.
+     * @group Props
+     */
+    filteredNodes: TreeNode<any>[] | undefined | null;
+    /**
+     * Locale to use in filtering. The default locale is the host environment's current locale.
+     * @group Props
+     */
+    filterLocale: _angular_core.InputSignal<string | undefined>;
+    /**
+     * Height of the scrollable viewport.
+     * @group Props
+     */
+    scrollHeight: _angular_core.InputSignal<string | undefined>;
+    /**
+     * Defines if data is loaded and interacted with in lazy manner.
+     * @group Props
+     */
+    lazy: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Whether the data should be loaded on demand during scroll.
+     * @group Props
+     */
+    virtualScroll: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Height of an item in the list for VirtualScrolling.
+     * @group Props
+     */
+    virtualScrollItemSize: _angular_core.InputSignal<number | undefined>;
+    /**
+     * Whether to use the scroller feature. The properties of scroller component can be used like an object in it.
+     * @group Props
+     */
+    virtualScrollOptions: _angular_core.InputSignal<ScrollerOptions | undefined>;
+    /**
+     * Indentation factor for spacing of the nested node when virtual scrolling is enabled.
+     * @group Props
+     */
+    indentation: _angular_core.InputSignalWithTransform<number, unknown>;
+    /**
+     * Function to optimize the node list rendering, default algorithm checks for object identity.
+     * @group Props
+     */
+    trackBy: _angular_core.InputSignal<Function>;
+    /**
+     * Highlights the node on select.
+     * @group Props
+     */
+    highlightOnSelect: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Callback to invoke when a node is selected.
+     * @param {TreeNodeSelectEvent} event - Node select event.
+     * @group Emits
+     */
+    onNodeSelect: _angular_core.OutputEmitterRef<TreeNodeSelectEvent>;
+    /**
+     * Callback to invoke when a node is unselected.
+     * @param {TreeNodeUnSelectEvent} event - Node unselect event.
+     * @group Emits
+     */
+    onNodeUnselect: _angular_core.OutputEmitterRef<TreeNodeUnSelectEvent>;
+    /**
+     * Callback to invoke when a node is expanded.
+     * @param {TreeNodeExpandEvent} event - Node expand event.
+     * @group Emits
+     */
+    onNodeExpand: _angular_core.OutputEmitterRef<TreeNodeExpandEvent>;
+    /**
+     * Callback to invoke when a node is collapsed.
+     * @param {TreeNodeCollapseEvent} event - Node collapse event.
+     * @group Emits
+     */
+    onNodeCollapse: _angular_core.OutputEmitterRef<TreeNodeCollapseEvent>;
+    /**
+     * Callback to invoke when a node is selected with right click.
+     * @param {onNodeContextMenuSelect} event - Node context menu select event.
+     * @group Emits
+     */
+    onNodeContextMenuSelect: _angular_core.OutputEmitterRef<TreeNodeContextMenuSelectEvent>;
+    /**
+     * Callback to invoke when a node is double clicked.
+     * @param {TreeNodeDoubleClickEvent} event - Node double click event.
+     * @group Emits
+     */
+    onNodeDoubleClick: _angular_core.OutputEmitterRef<TreeNodeDoubleClickEvent>;
+    /**
+     * Callback to invoke when a node is dropped.
+     * @param {TreeNodeDropEvent} event - Node drop event.
+     * @group Emits
+     */
+    onNodeDrop: _angular_core.OutputEmitterRef<TreeNodeDropEvent>;
+    /**
+     * Callback to invoke in lazy mode to load new data.
+     * @param {TreeLazyLoadEvent} event - Custom lazy load event.
+     * @group Emits
+     */
+    onLazyLoad: _angular_core.OutputEmitterRef<TreeLazyLoadEvent>;
+    /**
+     * Callback to invoke in virtual scroll mode when scroll position changes.
+     * @param {TreeScrollEvent} event - Custom scroll event.
+     * @group Emits
+     */
+    onScroll: _angular_core.OutputEmitterRef<TreeScrollEvent>;
+    /**
+     * Callback to invoke in virtual scroll mode when scroll position and item's range in view changes.
+     * @param {TreeScrollIndexChangeEvent} event - Scroll index change event.
+     * @group Emits
+     */
+    onScrollIndexChange: _angular_core.OutputEmitterRef<TreeScrollIndexChangeEvent>;
+    /**
+     * Callback to invoke when data is filtered.
+     * @param {TreeFilterEvent} event - Custom filter event.
+     * @group Emits
+     */
+    onFilter: _angular_core.OutputEmitterRef<TreeFilterEvent>;
+    /**
+     * Custom filter template.
+     * @param {TreeFilterTemplateContext} context - filter context.
+     * @see {@link TreeFilterTemplateContext}
+     * @group Templates
+     */
+    filterTemplate: _angular_core.Signal<TemplateRef<TreeFilterTemplateContext> | undefined>;
+    /**
+     * Custom node template.
+     * @group Templates
+     */
+    nodeTemplate: _angular_core.Signal<TemplateRef<any> | undefined>;
+    /**
+     * Custom header template.
+     * @group Templates
+     */
+    headerTemplate: _angular_core.Signal<TemplateRef<void> | undefined>;
+    /**
+     * Custom footer template.
+     * @group Templates
+     */
+    footerTemplate: _angular_core.Signal<TemplateRef<void> | undefined>;
+    /**
+     * Custom loader template.
+     * @param {TreeLoaderTemplateContext} context - loader context.
+     * @see {@link TreeLoaderTemplateContext}
+     * @group Templates
+     */
+    loaderTemplate: _angular_core.Signal<TemplateRef<TreeLoaderTemplateContext> | undefined>;
+    /**
+     * Custom empty message template.
+     * @group Templates
+     */
+    emptyTemplate: _angular_core.Signal<TemplateRef<void> | undefined>;
+    /**
+     * Custom toggler icon template.
+     * @param {TreeTogglerIconTemplateContext} context - toggler icon context.
+     * @see {@link TreeTogglerIconTemplateContext}
+     * @group Templates
+     */
+    togglerIconTemplate: _angular_core.Signal<TemplateRef<TreeTogglerIconTemplateContext> | undefined>;
+    /**
+     * Custom checkbox icon template.
+     * @param {TreeCheckboxIconTemplateContext} context - checkbox icon context.
+     * @see {@link TreeCheckboxIconTemplateContext}
+     * @group Templates
+     */
+    checkboxIconTemplate: _angular_core.Signal<TemplateRef<TreeCheckboxIconTemplateContext> | undefined>;
+    /**
+     * Custom loading icon template.
+     * @group Templates
+     */
+    loadingIconTemplate: _angular_core.Signal<TemplateRef<void> | undefined>;
+    /**
+     * Custom filter icon template.
+     * @group Templates
+     */
+    filterIconTemplate: _angular_core.Signal<TemplateRef<void> | undefined>;
+    filterViewChild: _angular_core.Signal<ElementRef<any> | undefined>;
+    scroller: _angular_core.Signal<Scroller | undefined>;
+    wrapperViewChild: _angular_core.Signal<ElementRef<any> | undefined>;
+    contentViewChild: _angular_core.Signal<ElementRef<any> | undefined>;
+    serializedValue: TreeNode<any>[] | null | undefined;
+    nodeTouched: boolean | undefined | null;
+    dragNodeTree: Tree | undefined | null;
+    dragNode: TreeNode<any> | undefined | null;
+    dragNodeSubNodes: TreeNode<any>[] | undefined | null;
+    dragNodeIndex: number | undefined | null;
+    dragNodeScope: any;
+    dragHover: boolean | undefined | null;
+    _componentStyle: TreeStyle;
+    dragDropService: TreeDragDropService | null;
+    private destroyRef;
+    constructor();
+    onInit(): void;
+    showLoadingMask: _angular_core.Signal<boolean>;
+    get showEmptyMessage(): boolean;
+    scrollerStyleHeight: _angular_core.Signal<string | undefined>;
+    scrollerScrollHeight: _angular_core.Signal<"100%" | undefined>;
+    get emptyMessageLabel(): string;
+    updateSerializedValue(): void;
+    /**
+     * Projects the current `collapsedKeys` map onto each node's `expanded` flag (a node is expanded
+     * unless its key maps to `true`).
+     */
+    private applyCollapsedKeys;
+    /**
+     * Reflects a node's expansion change back into the two-way `collapsedKeys` map when it is in use.
+     */
+    setNodeCollapsed(node: TreeNode<any>, collapsed: boolean): void;
+    /** Builds a `key -> node` lookup over the whole tree (for `selectionKeys` projection). */
+    private collectNodesByKey;
+    /** Derives the `selectionKeys` map from the current `selection` (and `partialSelected` for checkbox). */
+    private deriveSelectionKeys;
+    /** Applies the current `selectionKeys` map onto the `selection` model (and `partialSelected` for checkbox). */
+    private applySelectionKeys;
+    /** Value-based equality for two `selectionKeys` maps (handles both boolean and `{checked,partialChecked}` values). */
+    private isSameSelectionKeys;
+    serializeNodes(parent: TreeNode<any> | null, nodes: TreeNode<any>[] | any, level: number, visible: boolean): void;
+    onNodeClick(event: Event, node: TreeNode): void;
+    onNodeTouchEnd(): void;
+    onNodeRightClick(event: MouseEvent, node: TreeNode<any>): void;
+    onNodeDblClick(event: MouseEvent, node: TreeNode<any>): void;
+    findIndexInSelection(node: TreeNode): number;
+    syncNodeOption(node: TreeNode, parentNodes: TreeNode<any>[], option: any, value?: any): void;
+    hasFilteredNodes(): number | false | null | undefined;
+    hasFilterActive(): boolean;
+    getNodeWithKey(key: string, nodes: TreeNode<any>[]): TreeNode<any> | undefined;
+    propagateUp(node: TreeNode, select: boolean): void;
+    propagateDown(node: TreeNode, select: boolean): void;
+    isSelected(node: TreeNode): boolean;
+    isSingleSelectionMode(): boolean | null | undefined;
+    isMultipleSelectionMode(): boolean | null | undefined;
+    isCheckboxSelectionMode(): boolean | null | undefined;
+    isNodeLeaf(node: TreeNode): boolean;
+    getRootNode(): any;
+    getTemplateForNode(node: TreeNode): TemplateRef<any> | null;
+    onDragOver(event: DragEvent): void;
+    onDrop(event: DragEvent): void;
+    processTreeDrop(dragNode: TreeNode, dragNodeIndex: number): void;
+    onDragEnter(): void;
+    onDragLeave(event: DragEvent): void;
+    allowDrop(dragNode: TreeNode, dropNode: TreeNode<any> | null, dragNodeScope: any): boolean;
+    hasCommonScope(dragScope: any, dropScope: any): boolean;
+    isSameTreeScope(dragScope: any): boolean;
+    isValidDragScope(dragScope: any): boolean;
+    _filter(value: string): void;
+    /**
+     * Resets filter.
+     * @group Method
+     */
+    resetFilter(): void;
+    /**
+     * Scrolls to virtual index.
+     * @param {number} number - Index to be scrolled.
+     * @group Method
+     */
+    scrollToVirtualIndex(index: number): void;
+    /**
+     * Scrolls to virtual index.
+     * @param {ScrollToOptions} options - Scroll options.
+     * @group Method
+     */
+    scrollTo(options: any): void;
+    findFilteredNodes(node: TreeNode, paramsWithoutNode: any): true | undefined;
+    isFilterMatched(node: TreeNode, params: any): boolean;
+    getIndex(options: any, index: number): any;
+    getBlockableElement(): HTMLElement;
+    get containerDataP(): string | undefined;
+    get wrapperDataP(): string | undefined;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Tree, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Tree, "p-tree", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "selectionMode": { "alias": "selectionMode"; "required": false; "isSignal": true; }; "loadingMode": { "alias": "loadingMode"; "required": false; "isSignal": true; }; "selection": { "alias": "selection"; "required": false; "isSignal": true; }; "collapsedKeys": { "alias": "collapsedKeys"; "required": false; "isSignal": true; }; "selectionKeys": { "alias": "selectionKeys"; "required": false; "isSignal": true; }; "contextMenu": { "alias": "contextMenu"; "required": false; "isSignal": true; }; "contextMenuSelection": { "alias": "contextMenuSelection"; "required": false; "isSignal": true; }; "draggableScope": { "alias": "draggableScope"; "required": false; "isSignal": true; }; "droppableScope": { "alias": "droppableScope"; "required": false; "isSignal": true; }; "draggableNodes": { "alias": "draggableNodes"; "required": false; "isSignal": true; }; "droppableNodes": { "alias": "droppableNodes"; "required": false; "isSignal": true; }; "metaKeySelection": { "alias": "metaKeySelection"; "required": false; "isSignal": true; }; "propagateSelectionUp": { "alias": "propagateSelectionUp"; "required": false; "isSignal": true; }; "propagateSelectionDown": { "alias": "propagateSelectionDown"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "loadingIcon": { "alias": "loadingIcon"; "required": false; "isSignal": true; }; "emptyMessage": { "alias": "emptyMessage"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "togglerAriaLabel": { "alias": "togglerAriaLabel"; "required": false; "isSignal": true; }; "ariaLabelledBy": { "alias": "ariaLabelledBy"; "required": false; "isSignal": true; }; "validateDrop": { "alias": "validateDrop"; "required": false; "isSignal": true; }; "filter": { "alias": "filter"; "required": false; "isSignal": true; }; "filterInputAutoFocus": { "alias": "filterInputAutoFocus"; "required": false; "isSignal": true; }; "filterBy": { "alias": "filterBy"; "required": false; "isSignal": true; }; "filterMode": { "alias": "filterMode"; "required": false; "isSignal": true; }; "filterPlaceholder": { "alias": "filterPlaceholder"; "required": false; "isSignal": true; }; "filterLocale": { "alias": "filterLocale"; "required": false; "isSignal": true; }; "scrollHeight": { "alias": "scrollHeight"; "required": false; "isSignal": true; }; "lazy": { "alias": "lazy"; "required": false; "isSignal": true; }; "virtualScroll": { "alias": "virtualScroll"; "required": false; "isSignal": true; }; "virtualScrollItemSize": { "alias": "virtualScrollItemSize"; "required": false; "isSignal": true; }; "virtualScrollOptions": { "alias": "virtualScrollOptions"; "required": false; "isSignal": true; }; "indentation": { "alias": "indentation"; "required": false; "isSignal": true; }; "trackBy": { "alias": "trackBy"; "required": false; "isSignal": true; }; "highlightOnSelect": { "alias": "highlightOnSelect"; "required": false; "isSignal": true; }; }, { "selection": "selectionChange"; "collapsedKeys": "collapsedKeysChange"; "selectionKeys": "selectionKeysChange"; "contextMenuSelection": "contextMenuSelectionChange"; "onNodeSelect": "onNodeSelect"; "onNodeUnselect": "onNodeUnselect"; "onNodeExpand": "onNodeExpand"; "onNodeCollapse": "onNodeCollapse"; "onNodeContextMenuSelect": "onNodeContextMenuSelect"; "onNodeDoubleClick": "onNodeDoubleClick"; "onNodeDrop": "onNodeDrop"; "onLazyLoad": "onLazyLoad"; "onScroll": "onScroll"; "onScrollIndexChange": "onScrollIndexChange"; "onFilter": "onFilter"; }, ["filterTemplate", "nodeTemplate", "headerTemplate", "footerTemplate", "loaderTemplate", "emptyTemplate", "togglerIconTemplate", "checkboxIconTemplate", "loadingIconTemplate", "filterIconTemplate"], never, true, [{ directive: typeof i1.Bind; inputs: {}; outputs: {}; }]>;
+}
+declare class TreeModule {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TreeModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<TreeModule, never, [typeof Tree], [typeof Tree]>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<TreeModule>;
+}
+
+export { Tree, TreeClasses, TreeModule, TreeStyle };