angular-tree-component

node: TreeNode;

template: TemplateRef<any>;

constructor(
    renderer: Renderer2,
    templateRef: TemplateRef<any>,
    viewContainerRef: ViewContainerRef
);

animateAcceleration: number;

animateSpeed: number;

isEnabled: boolean;

isOpen: boolean;

constructor(treeModel: TreeModel, treeDraggedElement: TreeDraggedElement);

activate: any;

blur: any;

changeFilter: any;

copyNode: any;

deactivate: any;

deselect: any;

event: any;

focus: any;

focused: boolean;

initialized: any;

loadingTemplate: TemplateRef<any>;

loadNodeChildren: any;

moveNode: any;

nodeActivate: any;

nodeDeactivate: any;

nodes: any[];

options: TreeOptions;

select: any;

state: any;

stateChange: any;

toggleExpanded: any;

treeDraggedElement: TreeDraggedElement;

treeModel: TreeModel;

treeNodeFullTemplate: TemplateRef<any>;

treeNodeTemplate: TemplateRef<any>;

treeNodeWrapperTemplate: TemplateRef<any>;

updateData: any;

viewportComponent: TreeViewportComponent;

ngOnChanges: (changes: any) => void;

onKeydown: ($event: any) => void;

onMousedown: ($event: any) => void;

sizeChanged: () => void;

constructor(
    el: ElementRef,
    renderer: Renderer2,
    treeDraggedElement: TreeDraggedElement,
    ngZone: NgZone
);

draggedElement: any;

treeDragEnabled: any;

ngAfterViewInit: () => void;

ngDoCheck: () => void;

ngOnDestroy: () => void;

onDrag: (ev: any) => void;

onDragEnd: () => void;

onDragStart: (ev: any) => void;

get: () => any;

isDragging: () => boolean;

set: (draggedElement: any) => void;

constructor(
    el: ElementRef,
    renderer: Renderer2,
    treeDraggedElement: TreeDraggedElement,
    ngZone: NgZone
);

allowDragoverStyling: boolean;

onDragEnterCallback: EventEmitter<any>;

onDragLeaveCallback: EventEmitter<any>;

onDragOverCallback: EventEmitter<any>;

onDropCallback: EventEmitter<any>;

treeAllowDrop: any;

allowDrop: ($event: any) => boolean;

ngAfterViewInit: () => void;

ngOnDestroy: () => void;

onDragEnter: ($event: any) => void;

onDragLeave: ($event: any) => void;

onDragOver: ($event: any) => void;

onDrop: ($event: any) => void;

activeNodeIds: IDTypeDictionary;

readonly activeNodes: any[];

eventNames: string[];

expandedNodeIds: IDTypeDictionary;

readonly expandedNodes: any[];

readonly focusedNode: any;

focusedNodeId: IDType;

static focusedTree: any;

hiddenNodeIds: IDTypeDictionary;

readonly hiddenNodes: any[];

readonly isFocused: boolean;

nodes: any[];

options: TreeOptions;

roots: TreeNode[];

selectedLeafNodeIds: IDTypeDictionary;

readonly selectedLeafNodes: any[];

virtualRoot: TreeNode;

virtualScroll: TreeVirtualScroll;

calculateExpandedNodes: () => void;

canMoveNode: (node: any, to: any, fromIndex?: any) => boolean;

clearFilter: () => void;

collapseAll: () => void;

copyNode: (node: any, to: any) => void;

dispose: () => void;

doForAll: (fn: any) => void;

expandAll: () => void;

filterNodes: (filter: any, autoShow?: boolean) => void;

fireEvent: (event: any) => void;

focusDrillDown: () => void;

focusDrillUp: () => void;

focusNextNode: () => void;

focusPreviousNode: () => void;

getActiveNode: () => TreeNode;

getActiveNodes: () => TreeNode[];

getFirstRoot: (skipHidden?: boolean) => TreeNode;

getFocusedNode: () => TreeNode;

getLastRoot: (skipHidden?: boolean) => TreeNode;

getNodeBy: (predicate: any, startNode?: any) => any;

getNodeById: (id: any) => any;

getNodeByPath: (path: any[], startNode?: any) => TreeNode;

getState: () => {
    expandedNodeIds: IDTypeDictionary;
    selectedLeafNodeIds: IDTypeDictionary;
    activeNodeIds: IDTypeDictionary;
    hiddenNodeIds: IDTypeDictionary;
    focusedNodeId: IDType;
};

getVisibleRoots: () => TreeNode[];

isActive: (node: any) => boolean;

isEmptyTree: () => boolean;

isExpanded: (node: any) => boolean;

isHidden: (node: any) => boolean;

isNodeFocused: (node: any) => boolean;

isSelected: (node: any) => boolean;

moveNode: (node: any, to: any) => void;

ngOnDestroy: () => void;

performKeyAction: (node: any, $event: any) => boolean;

setActiveNode: (node: any, value: any, multi?: boolean) => void;

setData: ({
    nodes,
    options,
    events,
}: {
    nodes: any;
    options: any;
    events: any;
}) => void;

setExpandedNode: (node: any, value: any) => void;

setFocus: (value: any) => void;

setFocusedNode: (node: any) => void;

setHiddenNodeIds: (nodeIds: any) => void;

setIsHidden: (node: any, value: any) => void;

setSelectedNode: (node: any, value: any) => void;

setState: (state: any) => void;

subscribe: (eventName: any, fn: any) => void;

subscribeToState: (fn: any) => void;

unsubscribeAll: () => void;

update: () => void;

static forRoot: () => ModuleWithProviders;

constructor(data: any, parent: TreeNode, treeModel: TreeModel, index: number);

allowDragoverStyling: () => boolean;

allowDrop: (element: any, $event?: any) => boolean;

children: TreeNode[];

data: any;

readonly displayField: any;

readonly elementRef: any;

readonly hasChildren: boolean;

height: number;

id: any;

index: number;

readonly isActive: boolean;

readonly isAllSelected: boolean;

readonly isCollapsed: boolean;

readonly isExpanded: boolean;

readonly isFocused: boolean;

readonly isHidden: boolean;

readonly isLeaf: boolean;

readonly isPartiallySelected: boolean;

readonly isRoot: boolean;

readonly isSelected: boolean;

readonly level: number;

readonly options: TreeOptions;

readonly originalNode: any;

parent: TreeNode;

readonly path: string[];

position: number;

readonly realParent: TreeNode;

treeModel: TreeModel;

readonly visibleChildren: TreeNode[];

allowDrag: () => boolean;

autoLoadChildren: () => void;

blur: () => this;

collapse: () => this;

collapseAll: () => void;

dispose: () => void;

doForAll: (fn: (node: ITreeNode) => any) => void;

ensureVisible: () => this;

expand: () => this;

expandAll: () => void;

findNextNode: (goInside?: boolean, skipHidden?: boolean) => any;

findNextSibling: (skipHidden?: boolean) => any;

findPreviousNode: (skipHidden?: boolean) => any;

findPreviousSibling: (skipHidden?: boolean) => any;

fireEvent: (event: any) => void;

focus: (scroll?: boolean) => this;

getClass: () => string;

getField: (key: any) => any;

getFirstChild: (skipHidden?: boolean) => TreeNode;

getLastChild: (skipHidden?: boolean) => TreeNode;

getNodePadding: () => string;

getSelfHeight: () => number;

getVisibleChildren: () => TreeNode[];

hide: () => void;

isDescendantOf: (node: TreeNode) => any;

isSelectable: () => boolean;

loadNodeChildren: () => Promise<void>;

mouseAction: (actionName: string, $event: any, data?: any) => void;

onDrop: ($event: any) => void;

scrollIntoView: (force?: boolean) => void;

setActiveAndVisible: (multi?: boolean) => this;

setField: (key: any, value: any) => void;

setIsActive: (value: any, multi?: boolean) => this;

setIsExpanded: (value: any) => this;

setIsHidden: (value: any) => void;

setIsSelected: (value: any) => this;

show: () => void;

toggleActivated: (multi?: boolean) => this;

toggleExpanded: () => this;

toggleSelected: () => this;

node: TreeNode;

node: TreeNode;

templates: any;

readonly marginTop: string;

nodes: any;

templates: any;

treeModel: TreeModel;

viewportNodes: TreeNode[];

ngOnDestroy: () => void;

ngOnInit: () => void;

setNodes: (nodes: any) => void;

trackNode: (index: any, node: any) => any;

index: number;

node: TreeNode;

templates: any;

index: number;

node: TreeNode;

template: TemplateRef<any>;

dropIndex: number;

node: TreeNode;

allowDrop: (element: any, $event: any) => boolean;

onDrop: ($event: any) => void;

node: TreeNode;

constructor();

index: number;

node: TreeNode;

templates: any;

constructor(
    elementRef: ElementRef,
    ngZone: NgZone,
    virtualScroll: TreeVirtualScroll
);

setViewport: any;

virtualScroll: TreeVirtualScroll;

getTotalHeight: () => string;

ngAfterViewInit: () => void;

ngOnDestroy: () => void;

ngOnInit: () => void;

constructor(treeModel: TreeModel);

readonly totalHeight: number;

viewport: any;

viewportHeight: any;

x: number;

readonly y: number;

yBlocks: number;

clear: () => void;

fireEvent: (event: any) => void;

fixScroll: () => void;

getViewportNodes: (nodes: any) => any;

init: () => void;

isEnabled: () => boolean;

recalcPositions: () => void;

scrollIntoView: (node: any, force: any, scrollToMiddle?: boolean) => void;

setViewport: (viewport: any) => void;

(tree: TreeModel, node: TreeNode, $event: any, ...rest: any[]): any;

keys?: {
    [key: number]: IActionHandler;
};

mouse?: {
    click?: IActionHandler;
    dblClick?: IActionHandler;
    contextMenu?: IActionHandler;
    expanderClick?: IActionHandler;
    checkboxClick?: IActionHandler;
    dragStart?: IActionHandler;
    drag?: IActionHandler;
    dragEnd?: IActionHandler;
    dragOver?: IActionHandler;
    dragLeave?: IActionHandler;
    dragEnter?: IActionHandler;
    drop?: IActionHandler;
    mouseOver?: IActionHandler;
    mouseOut?: IActionHandler;
};

(node: TreeNode): boolean;

(
    element: any,
    to: {
        parent: TreeNode;
        index: number;
    },
    $event?: any
): boolean;

actionMapping?: any;

allowDrag?: boolean | IAllowDragFn;