import { EventEmitter } from '@angular/core';
import { NestedTreeControl } from '@angular/cdk/tree';
import { Filter } from '../../../filter/models/filter';
import { CaseTreeService } from './case-tree.service';
import { CaseTreeNode } from './model/case-tree-node';
import { MatTreeNestedDataSource } from '@angular/material/tree';
import { CaseTreePath } from './model/case-tree-path';
import * as i0 from "@angular/core";
export declare abstract class AbstractTreeComponent {
    protected _treeService: CaseTreeService;
    /**
     * `true` is emitted whenever the tree's root node is in it's loading state.
     *
     * `false` is emitted when the root node is no longer in the loading state.
     *
     * The first value emitted from this Output is `false`, when the tree finishes initializing.
     *
     * The root node enters it's loading state when it's children are being loaded.
     */
    treeRootLoading: EventEmitter<boolean>;
    /**
     * `true` is emitted whenever the tree's root node is adding a new child node.
     *
     * `false` is emitted when the root node is no longer adding a new child node.
     *
     * The first value emitted from this Output is `false`, when the tree finishes initializing.
     *
     * No further calls to add a child node should be made, while a child is being added.
     */
    treeRootAddingChild: EventEmitter<boolean>;
    protected constructor(_treeService: CaseTreeService);
    /**
     * The {@link Filter} that determines the root node of the tree.
     *
     * The tree can only have one root. If more than one case is returned by the Filter.
     * The first result will be used as the tree root.
     *
     * If you want to have multiple nodes in the first level checkout the [showTreeRoot]{@link AbstractTreeComponent#showTreeRoot} property.
     * @param filter Case Filter that determines the tree root
     */
    set filter(filter: Filter);
    /**
     * Whether the tree root should be displayed as a node or not.
     *
     * `true` displays the root as the only node in the first level.
     *
     * `false` displays the root's child nodes in the first level.
     *
     * If you want to add more children while the root is hidden use the [addRootChildNode]
     * {@link AbstractTreeComponent#addRootChildNode} method.
     * @param showTreeRoot whether the root node should be displayed in the tree or not
     */
    set showTreeRoot(showTreeRoot: boolean);
    /**
     * Weather the tree is eager loaded or not.
     *
     * Defaults to `false`.
     *
     * It is not recommended to eager load large trees as each node sends a separate backend request to load its data.
     *
     * @param eager the new setting for eager loading
     */
    set eagerLoaded(eager: boolean);
    /**
     * @ignore
     */
    get dataSource(): MatTreeNestedDataSource<CaseTreeNode>;
    /**
     * @ignore
     */
    get treeControl(): NestedTreeControl<CaseTreeNode>;
    /**
     * @ignore
     */
    hasChild: (_: number, node: CaseTreeNode) => boolean;
    /**
     * @ignore
     */
    caseNodeClicked(node: CaseTreeNode): void;
    /**
     * @ignore
     */
    toggleCaseNode(event: Event, node: CaseTreeNode): void;
    /**
     * @ignore
     */
    selectedCaseNode(node: CaseTreeNode): boolean;
    /**
     * Adds a child to the root node.
     *
     * Useful if you set the [showTreeRoot]{@link AbstractTreeComponent#showTreeRoot} property to `false`.
     */
    addRootChildNode(): void;
    /**
     * Expands all nodes in the tree dictated by the argument.
     *
     * @param path nodes that should be expanded along with their path from the root node
     */
    expandPath(path: CaseTreePath): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<AbstractTreeComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<AbstractTreeComponent, "ncc-abstract-tree", never, { "filter": "filter"; "showTreeRoot": "showTreeRoot"; "eagerLoaded": "eagerLoaded"; }, { "treeRootLoading": "treeRootLoading"; "treeRootAddingChild": "treeRootAddingChild"; }, never, never>;
}