@limble/limble-tree 6.1.1 → 7.0.0

package/index.d.ts

@@ -1,5 +1,825 @@
+import * as i0 from '@angular/core';
+import { Type, EventEmitter, ComponentRef, ViewContainerRef, AfterViewInit, OnDestroy, QueryList, ApplicationRef, OnInit, NgZone, ElementRef, ViewRef, OnChanges, Renderer2 } from '@angular/core';
+import { Observable } from 'rxjs';
+
 /**
- * Generated bundle index. Do not edit.
+ * An object that references the component to be rendered and its bindings
+ * @deprecated
  */
-/// <amd-module name="@limble/limble-tree" />
-export * from './public-api';
+interface ComponentObj {
+    /** The component class */
+    class: Type<unknown>;
+    /** The bindings (inputs and outputs) of the class */
+    bindings?: {
+        [index: string]: unknown;
+    };
+}
+
+/**
+ * An object describing a node of the tree
+ * @deprecated
+ */
+interface LimbleTreeNode {
+    /** A list of nodes to be rendered "under" this one, one level deeper in the tree. */
+    nodes?: LimbleTreeData;
+    /** An object that describes the component which will represent this node in the visual tree */
+    component?: ComponentObj;
+    collapsed?: boolean;
+    [index: string]: unknown;
+}
+/**
+ * An object that the limble-tree-root component uses to build the tree
+ * @deprecated
+ */
+type LimbleTreeData = Array<LimbleTreeNode>;
+
+interface HostComponent<UserlandComponent> {
+    contentCreated: EventEmitter<UserlandComponent>;
+    contentToHost?: Type<UserlandComponent>;
+    getHostedContent: () => ComponentRef<UserlandComponent> | undefined;
+}
+
+interface NodeComponent {
+    branchesContainer: ViewContainerRef | undefined;
+    showInnerDropzone: boolean;
+}
+
+declare class DropzoneComponent {
+    placement?: "inner" | "lateral";
+    readonly dropped: EventEmitter<DragEvent>;
+    protected active: boolean;
+    dragenterHandler(): void;
+    dragleaveHandler(): void;
+    dragoverHandler(event: DragEvent): void;
+    dropHandler(event: DragEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DropzoneComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DropzoneComponent, "dropzone", never, { "placement": { "alias": "placement"; "required": false; }; }, { "dropped": "dropped"; }, never, never, true, never>;
+}
+
+declare class BranchComponent<T> implements NodeComponent, HostComponent<T>, AfterViewInit, OnDestroy {
+    private readonly appRef;
+    branchesContainer: ViewContainerRef | undefined;
+    contentContainer: ViewContainerRef | undefined;
+    dropzones: QueryList<DropzoneComponent> | undefined;
+    contentToHost?: Type<T>;
+    readonly contentCreated: EventEmitter<T>;
+    readonly showDropzones: EventEmitter<"upper" | "lower">;
+    readonly dropped: EventEmitter<"inner" | "lateral">;
+    showInnerDropzone: boolean;
+    showLateralDropzone: boolean;
+    private hostedContent?;
+    constructor(appRef: ApplicationRef);
+    ngAfterViewInit(): void;
+    getHostedContent(): ComponentRef<T> | undefined;
+    triggerChangeDetection(): void;
+    protected dragoverHandler(event: DragEvent): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BranchComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BranchComponent<any>, "branch", never, { "contentToHost": { "alias": "contentToHost"; "required": false; }; }, { "contentCreated": "contentCreated"; "showDropzones": "showDropzones"; "dropped": "dropped"; }, never, never, true, never>;
+}
+
+declare class RootComponent implements NodeComponent, AfterViewInit {
+    branchesContainer: ViewContainerRef | undefined;
+    dropzone: DropzoneComponent | undefined;
+    readonly afterViewInit: EventEmitter<void>;
+    readonly dropped: EventEmitter<void>;
+    showInnerDropzone: boolean;
+    ngAfterViewInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RootComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RootComponent, "root", never, {}, { "afterViewInit": "afterViewInit"; "dropped": "dropped"; }, never, never, true, never>;
+}
+
+/**
+ * Works just like Angular's built-in `(dragover)` event binding, but is much
+ * more performant. It throttles the event to a configurable rate (default once
+ * every 25ms) and runs outside of Angular's change detection.
+ */
+declare class DragoverNoChangeDetectDirective implements OnInit, OnDestroy {
+    private readonly ngZone;
+    private readonly el;
+    readonly dragoverNoChangeDetect: EventEmitter<DragEvent>;
+    private eventSubscription;
+    constructor(ngZone: NgZone, el: ElementRef<Element>);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DragoverNoChangeDetectDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DragoverNoChangeDetectDirective, "[dragoverNoChangeDetect]", never, {}, { "dragoverNoChangeDetect": "dragoverNoChangeDetect"; }, never, never, true, never>;
+}
+
+interface ComponentContainer<Component> {
+    detectChanges: () => void;
+    getBranchesContainer: () => ViewContainerRef | undefined;
+    getComponentInstance: () => Component;
+    getHostView: () => ViewRef;
+    getNativeElement: () => HTMLElement;
+}
+
+type TreePlot = Map<number, TreePlot>;
+
+interface BranchOptions<Component> {
+    inputBindings?: {
+        [K in keyof Component]?: Component[K];
+    };
+    outputBindings?: {
+        [K in keyof Component]?: Component[K] extends EventEmitter<infer T> ? (value: T) => void : never;
+    };
+    defaultCollapsed?: boolean;
+    meta?: Record<string, any>;
+}
+interface FullBranchOptions<Component> extends BranchOptions<Component> {
+    component: Type<Component>;
+}
+
+interface Branchable<UserlandComponent> {
+    branches: () => Array<TreeBranch<UserlandComponent>>;
+    getBranch: (index: number) => TreeBranch<UserlandComponent> | undefined;
+    grow: (component: Type<UserlandComponent>, options?: BranchOptions<UserlandComponent>) => TreeBranch<UserlandComponent>;
+}
+
+/** Emitted when a drag-and-drop operation has completed */
+declare class DragEndEvent<T> implements TreeEvent<T> {
+    private readonly _source;
+    private readonly _newParent;
+    private readonly _newIndex;
+    private readonly _oldParent;
+    private readonly _oldIndex;
+    constructor(source: TreeNode<T>, endpoints: {
+        oldParent: TreeNode<T>;
+        oldIndex: number;
+        newParent: TreeNode<T>;
+        newIndex: number;
+    });
+    /** @returns The new index of the dropped branch */
+    newIndex(): number;
+    /** @returns The new parent of the dropped branch */
+    newParent(): TreeNode<T>;
+    /** @returns The index of the dropped branch before it was dragged */
+    oldIndex(): number;
+    /** @returns The parent of the dropped branch before it was dragged */
+    oldParent(): TreeNode<T>;
+    source(): TreeNode<T>;
+}
+
+/** Emitted when a TreeBranch begins being dragged */
+declare class DragStartEvent<T> implements TreeEvent<T> {
+    private readonly _source;
+    constructor(source: TreeNode<T>);
+    source(): TreeNode<T>;
+}
+
+/** Emitted when a TreeBranch is dropped into a valid Dropzone */
+declare class DropEvent<T> implements TreeEvent<T> {
+    private readonly _source;
+    private readonly _parent;
+    private readonly _index;
+    constructor(source: TreeNode<T>, parent: TreeNode<T>, index: number);
+    source(): TreeNode<T>;
+    index(): number;
+    parent(): TreeNode<T>;
+}
+
+/** Emitted when a node is destroyed */
+declare class DestructionEvent<T> implements TreeEvent<T> {
+    private readonly _source;
+    constructor(source: TreeNode<T>);
+    source(): TreeNode<T>;
+}
+
+/** An event emitted by a node in the tree */
+interface TreeEvent<UserlandComponent> {
+    source: () => TreeNode<UserlandComponent>;
+}
+
+/** A TreeEvent which involves a parent/child relationship */
+interface RelationalTreeEvent<UserlandComponent> extends TreeEvent<UserlandComponent> {
+    /** @returns The parent branch of the relationship */
+    parent: () => TreeNode<UserlandComponent>;
+    /** @returns The child branch of the relationship */
+    child: () => TreeBranch<UserlandComponent>;
+    /** @returns The index location of the child */
+    index: () => number;
+}
+
+interface TreeRelationship<UserlandComponent> {
+    parent: TreeNode<UserlandComponent>;
+    child: TreeBranch<UserlandComponent>;
+    index: number;
+}
+
+/** Emits when a branch is grafted to another tree node */
+declare class GraftEvent<UserlandComponent> implements RelationalTreeEvent<UserlandComponent> {
+    private readonly _source;
+    private readonly _parent;
+    private readonly _child;
+    private readonly _index;
+    constructor(source: TreeBranch<UserlandComponent>, relationship: TreeRelationship<UserlandComponent>);
+    child(): TreeBranch<UserlandComponent>;
+    index(): number;
+    parent(): TreeNode<UserlandComponent>;
+    source(): TreeBranch<UserlandComponent>;
+}
+
+/** Emitted when a branch is pruned from its parent branch */
+declare class PruneEvent<UserlandComponent> implements RelationalTreeEvent<UserlandComponent> {
+    private readonly _source;
+    private readonly _parent;
+    private readonly _child;
+    private readonly _index;
+    constructor(source: TreeBranch<UserlandComponent>, relationship: TreeRelationship<UserlandComponent>);
+    child(): TreeBranch<UserlandComponent>;
+    index(): number;
+    parent(): TreeNode<UserlandComponent>;
+    source(): TreeBranch<UserlandComponent>;
+}
+
+interface TreeNode<UserlandComponent> extends Branchable<UserlandComponent>, ComponentContainer<NodeComponent> {
+    destroy: () => void;
+    dispatch: (event: TreeEvent<UserlandComponent>) => void;
+    events: () => Observable<TreeEvent<UserlandComponent>>;
+    isDestroyed: () => boolean;
+    plot: () => TreePlot;
+    root: () => TreeRoot<any> | undefined;
+    traverse: (callback: (node: TreeNode<UserlandComponent>) => void) => void;
+}
+
+interface Graftable<UserlandComponent> {
+    graftTo: (newParent: TreeNode<UserlandComponent>, index?: number) => number;
+    index: () => number | undefined;
+    parent: () => TreeNode<UserlandComponent> | undefined;
+    prune: () => void;
+}
+
+/** Represents a standard node in a tree. Renders a BranchComponent.
+ *
+ * @remarks
+ * This class renders a branch component, which does the following:
+ * 1. Renders a component provided by the user
+ * 2. Provides a container in which child branches may be rendered
+ * 3. Contains two Dropzones: one for dropping branches below this branch (as a
+ * sibling), and one for dropping branches as a first child of this branch.
+ */
+declare class TreeBranch<UserlandComponent> implements TreeNode<UserlandComponent>, Graftable<UserlandComponent> {
+    readonly branchOptions: FullBranchOptions<UserlandComponent>;
+    private readonly branchController;
+    private detachedView;
+    private _parent;
+    private readonly treeNodeBase;
+    constructor(parent: TreeNode<UserlandComponent>, branchOptions: FullBranchOptions<UserlandComponent>);
+    /** @returns All child branches as an array of TreeBranch instances, in order. */
+    branches(): Array<TreeBranch<UserlandComponent>>;
+    /**
+     * Recursively destroys all descendant branches, as well as itself. This
+     * releases all resources held or consumed by this branch and its descendants.
+     *
+     * @remarks
+     * It is important to call this method when a branch is discarded, otherwise
+     * the branch will remain in memory and continue to consume resources.
+     */
+    destroy(): void;
+    /** Run Angular change detection on this branch */
+    detectChanges(): void;
+    /**
+     * Emits the specified TreeEvent.
+     *
+     * @remarks
+     * Caution: It is not recommended to manually emit TreeEvents that are already
+     * provided by the library. For example, it is not recommended to emit a
+     * `GraftEvent`, `DestructionEvent`, etc. These events may be used by the tree,
+     * and emitting them manually may cause unexpected behavior. Instead, we
+     * recommend implementing the TreeEvent interface with your own custom events
+     * and dispatching those.
+     *
+     * @param event - The TreeEvent that will be emitted.
+     */
+    dispatch(event: TreeEvent<UserlandComponent>): void;
+    /**
+     * @returns
+     * An observable that emits TreeEvents whenever an event is dispatched
+     * in this branch or any of its descendant branches.
+     */
+    events(): Observable<TreeEvent<UserlandComponent>>;
+    /**
+     * @param index - The index of the child branch to retrieve.
+     *
+     * @returns
+     * The child branch at the specified index, or undefined if there is
+     * no child branch at the specified index.
+     */
+    getBranch(index: number): TreeBranch<UserlandComponent> | undefined;
+    /** @returns The ViewContainerRef in which child branches are rendered */
+    getBranchesContainer(): ViewContainerRef | undefined;
+    /** @returns The instance of BranchComponent that is rendered by this class. */
+    getComponentInstance(): BranchComponent<UserlandComponent>;
+    /** @returns The Host View in which the BranchComponent is rendered */
+    getHostView(): ViewRef;
+    /** @returns The BranchComponent as a native HTML Element */
+    getNativeElement(): HTMLElement;
+    /**
+     * @returns
+     * A ComponentRef containing the instance of the user-provided
+     * component which is rendered by this branch.
+     */
+    getUserlandComponentRef(): ComponentRef<UserlandComponent> | undefined;
+    /**
+     * Attaches a branch to a new parent node.
+     *
+     * @remarks
+     * If not already pruned, this method prunes (removes) this branch from its
+     * current position in the tree; then grafts (reattaches) it as a child of the
+     * specified parent branch at the specified index. If no index is specified,
+     * the branch is appended as the last child of the parent. This causes this
+     * branch's associated BranchComponent to be re-rendered in the DOM at the
+     * new location.
+     *
+     * @param newParent - The new parent branch unto which this branch will be grafted.
+     * @param index - The index at which this branch will be grafted. If not specified,
+     * this branch will be appended as the last child of the new parent.
+     *
+     * @returns The index at which this branch was grafted.
+     */
+    graftTo(newParent: TreeNode<UserlandComponent>, index?: number): number;
+    /**
+     * Appends a new child branch to this branch. The child branch will render
+     * the specified component according to the (optional) configuration parameter.
+     *
+     * @param component - The component to render in the new child branch.
+     * @param options - Configuration options for the new child branch.
+     *
+     * @returns
+     * The newly-created child branch.
+     */
+    grow(component: Type<UserlandComponent>, options?: BranchOptions<UserlandComponent>): TreeBranch<UserlandComponent>;
+    /**
+     * Determines this branch's index in relation to its sibling branches.
+     *
+     * @remarks
+     * For example, if it is the first child of its parent, this method will return
+     * 0. If it is the second child of its parent, this method will return 1.
+     *
+     * If this branch has no parent, (eg, if this branch has been pruned) this
+     * method will return undefined.
+     *
+     * @returns
+     * The index of this branch in relation to its sibling branches, or undefined.
+     */
+    index(): number | undefined;
+    /** @returns `true` if the branch is destroyed, `false` otherwise */
+    isDestroyed(): boolean;
+    /**
+     * @returns
+     * The data that was passed into the `branchOptions`' `meta` property
+     * at construction.
+     */
+    meta(): Record<string, any>;
+    /**
+     * @returns
+     * This branch's parent node (which may be a TreeBranch or TreeRoot).
+     * If this branch has no parent, (eg, if this branch has been pruned) this
+     * method will return undefined.
+     */
+    parent(): TreeNode<UserlandComponent> | undefined;
+    /**
+     * Provides a model describing this branch's descendants.
+     *
+     * @returns
+     * A multi-dimensional Map which describes the shape of this branch's
+     * descendants.
+     *
+     * @example
+     * A branch with no children will return an empty Map. A branch with
+     * a single child will return a Map with a single entry, where the key is the index
+     * of the branch (zero) and the value is an empty Map. A Tree like this:
+     *
+     * ```
+     *         ---Branch-------Branch
+     *        /
+     * Branch-------Branch
+     *        \
+     *         ---Branch
+     * ```
+     * Will return a Map of matching shape:
+     * ```
+     * Map {
+     *    0: Map { 0: Map {}},
+     *    1: Map {},
+     *    2: Map {}
+     * }
+     * ```
+     */
+    plot(): TreePlot;
+    /**
+     * Calculates the branch's position in the tree relative to the Root.
+     *
+     * @remarks
+     * The position is described as an array of numbers, where each number
+     * represents the index of the branch at that level of the tree.
+     *
+     * For example, if this branch is the first child of the Root, this method
+     * will return [0]. If this branch is the second child of the first child
+     * of the Root, this method will return [0, 1].
+     *
+     * If the branch is not related to a TreeRoot, (such as when it has been
+     * pruned,) this method will throw an error.
+     *
+     * @returns
+     * An array of numbers which describe the branch's position in the tree
+     * relative to the Root.
+     */
+    position(): Array<number>;
+    /**
+     * Removes a branch from its tree without destroying it.
+     *
+     * @remarks
+     * Removes this branch from its parent and detaches its associated
+     * BranchComponent from the DOM. This puts the branch in a "pruned" state,
+     * which may affect the behavior of other methods.
+     *
+     * A pruned branch can be reattached to any other node using the `graftTo` method.
+     *
+     * @returns
+     * Itself, or undefined if it is already in a pruned state.
+     */
+    prune(): this | undefined;
+    /**
+     * Get the root of the tree to which this Branch is attached.
+     *
+     * @returns
+     * The TreeRoot of the tree this branch is in. If this branch is
+     * does not have a root (such as when it has been pruned) this method will
+     * return undefined.
+     */
+    root(): TreeRoot<UserlandComponent> | undefined;
+    /**
+     * Traverses this branch's descendants in depth-first pre-order, executing
+     * the provided callback function on each node. Traversal includes this branch.
+     *
+     * @param callback - A function to execute on each node.
+     */
+    traverse(callback: (node: TreeBranch<UserlandComponent>) => void): void;
+    private checkGraftLocationValidity;
+    private handleUserlandError;
+    private indexIsOutOfRange;
+    private furthestAncestor;
+    private reattachView;
+    private setIndentation;
+}
+
+/**
+ * Represents the base of the tree. It renders a very simple container for child
+ * branches. It has methods for creating and accessing those branches. It emits
+ * events when things happen in the tree.
+ */
+declare class TreeRoot<UserlandComponent> implements TreeNode<UserlandComponent> {
+    private readonly viewContainerRef;
+    private readonly rootController;
+    private readonly treeNodeBase;
+    constructor(viewContainerRef: ViewContainerRef);
+    /** @returns All child branches as an array of TreeBranch instances */
+    branches(): Array<TreeBranch<UserlandComponent>>;
+    /**
+     * Recursively destroys all branches of the tree, as well as itself.
+     *
+     * @remarks
+     * This releases all resources held or consumed by the tree.
+     *
+     * It is important to call this method when a tree is discarded, otherwise
+     * the tree will remain in memory and continue to consume resources.
+     */
+    destroy(): void;
+    /** Run Angular change detection on the root of the tree */
+    detectChanges(): void;
+    /**
+     * Emits the specified TreeEvent.
+     *
+     * @remarks
+     * Caution: It is not recommended to manually emit TreeEvents that are already
+     * provided by the library. For example, it is not recommended to emit a
+     * `GraftEvent`, `DestructionEvent`, etc. These events may be used by the tree,
+     * and emitting them manually may cause unexpected behavior. Instead, we
+     * recommend implementing the TreeEvent interface with your own custom events
+     * and dispatching those.
+     *
+     * @param event - The TreeEvent that will be emitted.
+     */
+    dispatch(event: TreeEvent<UserlandComponent>): void;
+    /**
+     * @returns
+     * An observable that emits TreeEvents whenever an event is dispatched
+     * in the root or any of its descendant branches.
+     */
+    events(): Observable<TreeEvent<UserlandComponent>>;
+    /**
+     * @returns
+     * The child branch at the specified index, or undefined if there is
+     * no child branch at the specified index.
+     */
+    getBranch(index: number): TreeBranch<UserlandComponent> | undefined;
+    /** @returns The ViewContainerRef in which child branches are rendered */
+    getBranchesContainer(): ViewContainerRef | undefined;
+    /**
+     * Retrieves the RootComponent.
+     *
+     * @remarks
+     * The RootComponent holds the BranchesContainer, as well as a single Dropzone
+     * for drag-and-drop operations.
+     *
+     * @returns The instance of RootComponent that is rendered by this class.
+     */
+    getComponentInstance(): RootComponent;
+    /** @returns The Host View in which the RootComponent is rendered */
+    getHostView(): ViewRef;
+    /** @returns The RootComponent as a native HTML Element */
+    getNativeElement(): HTMLElement;
+    /**
+     * Appends a new child branch to this branch. The child branch will render
+     * the specified component according to the (optional) configuration parameter.
+     *
+     * @param component - The component to render in the new child branch.
+     * @param options - Configuration options for the new child branch.
+     *
+     * @returns
+     * The newly-created child branch.
+     */
+    grow(component: Type<UserlandComponent>, options?: BranchOptions<UserlandComponent>): TreeBranch<UserlandComponent>;
+    /** @returns `true` if the tree is destroyed, `false` otherwise */
+    isDestroyed(): boolean;
+    /**
+     * Provides a model describing the shape of the tree.
+     *
+     * @returns A multi-dimensional Map which describes the shape of the tree.
+     *
+     * @example
+     * For example, an empty tree will return an empty Map. A tree with a single
+     * branch will return a Map with a single entry, where the key is the index
+     * of the branch (zero) and the value is an empty Map. A Tree like this:
+     *
+     * ```
+     *         ---Branch-------Branch
+     *        /
+     * Root-------Branch
+     *        \
+     *         ---Branch
+     * ```
+     * Will return a Map of matching shape:
+     * ```
+     * Map {
+     *    0: Map { 0: Map {}},
+     *    1: Map {},
+     *    2: Map {}
+     * }
+     * ```
+     */
+    plot(): TreePlot;
+    /** @returns Itself */
+    root(): this;
+    /**
+     * Traverses the tree in depth-first pre-order, executing the provided
+     * callback function on each node. Traversal includes the Root.
+     *
+     * @param callback - A function to execute on each node.
+     */
+    traverse(callback: (node: TreeNode<UserlandComponent>) => void): void;
+    private handleUserlandError;
+}
+
+/** The configuration options for a tree, as identified by a TreeRoot */
+interface TreeOptions {
+    dragAndDrop?: {
+        /**
+         * A function that determines whether to allow a node to be dragged.
+         *
+         * @remarks
+         * Runs when a drag begins, but before the branch is pruned from the tree.
+         *
+         * @param treeBranch - The node of the tree that is about to be dragged.
+         *
+         * @defaultValue A function that always returns true.
+         *
+         * @returns `true` if the node can be dragged; `false` if it cannot.
+         */
+        allowDragging?: <T>(treeBranch: TreeBranch<T>) => boolean;
+        /**
+         * A function to determine whether a sourceNode can be dropped at a
+         * particular location.
+         *
+         * @remarks
+         * This function runs just before displaying a family of dropzones.
+         *
+         * @param sourceBranch - The branch that is being dragged.
+         * @param proposedParent - The proposed new parent of the sourceBranch.
+         * @param proposedIndex - The proposed new index of the sourceBranch.
+         *
+         * @defaultValue A function that always returns true.
+         */
+        allowDrop?: <T>(sourceBranch: TreeBranch<T>, proposedParent: TreeBranch<T> | TreeRoot<T>, proposedIndex: number) => boolean;
+        /**
+         * A function to indicate whether to allow "nesting" (placing a branch as
+         * a child) of a particular branch.
+         *
+         * @remarks
+         * This function runs just before displaying a family of dropzones.
+         *
+         * @param treeBranch - The node of the tree whose nesting capability is being
+         * checked.
+         *
+         * @defaultValue A function that always returns true.
+         */
+        allowNesting?: <T>(treeBranch: TreeBranch<T>) => boolean;
+    };
+    /**
+     * The number of pixels each level of the tree will be indented relative to
+     * its parent.
+     *
+     * @defaultValue 16
+     */
+    indentation?: number;
+}
+
+/** Responsible for the creation of new trees. */
+declare class TreeService {
+    /**
+     * Creates a new, empty tree structure inside the provided container.
+     *
+     * @returns A `TreeRoot` representing the base of the new tree.
+     */
+    createEmptyTree<Component>(container: ViewContainerRef, options?: TreeOptions): TreeRoot<Component>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TreeService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TreeService>;
+}
+
+declare class TreeError extends Error {
+}
+
+/**
+ * A group of settings for changing the functionality of the tree
+ * @deprecated
+ */
+interface LimbleTreeOptions {
+    /** The component object to use if one is not specified for a particular node */
+    defaultComponent?: ComponentObj;
+    /** The number of pixels to indent each level of the tree. Defaults to 45 */
+    indent?: number;
+    /**
+     * Whether to allow "nesting" (placing a node one level deeper than currently exists on the branch).
+     * When this is a boolean, it applies to all nodes. When this is a function, the node in question
+     * is passed in. Defaults to true.
+     */
+    allowNesting?: boolean | (<T>(treeBranch: TreeBranch<T>) => boolean);
+    /**
+     * Whether to allow a node to be dragged. When this is a boolean, it applies to all nodes. When this
+     * is a function, the node in question is passed in. Defaults to true.
+     */
+    allowDragging?: boolean | (<T>(treeBranch: TreeBranch<T>) => boolean);
+    /** A callback to determine whether a sourceNode can be dropped at a particular location. */
+    allowDrop?: <T>(sourceNode: TreeBranch<T>, proposedParent: TreeBranch<T> | TreeRoot<T>, proposedIndex: number) => boolean;
+    /**
+     * When set to true, list mode will enforce a flat tree structure, meaning there
+     * can only be one level of the tree. `allowNesting` is automatically set to `false`.
+     *
+     * This mode can be used when the same dynamic drag and drop functionality of
+     * the tree is desired, but the tree structure itself is not necessary. This
+     * also opens up the pagination API on the limble-tree-root component.
+     */
+    listMode?: boolean;
+}
+
+/** @deprecated */
+declare class LimbleTreeRootComponent implements AfterViewInit, OnChanges, OnDestroy {
+    data?: LimbleTreeData;
+    options?: LimbleTreeOptions | undefined;
+    itemsPerPage: number;
+    page: number;
+    host?: ViewContainerRef;
+    readonly treeChange: EventEmitter<TreeRoot<any>>;
+    readonly treeDrop: EventEmitter<DragEndEvent<any>>;
+    private dropSubscription?;
+    private readonly legacyTree;
+    private root?;
+    constructor();
+    ngOnChanges(): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    getRoot(): TreeRoot<any> | undefined;
+    update(): void;
+    private paginatedData;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LimbleTreeRootComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<LimbleTreeRootComponent, "limble-tree-root", never, { "data": { "alias": "data"; "required": false; }; "options": { "alias": "options"; "required": false; }; "itemsPerPage": { "alias": "itemsPerPage"; "required": false; }; "page": { "alias": "page"; "required": false; }; }, { "treeChange": "treeChange"; "treeDrop": "treeDrop"; }, never, never, true, never>;
+}
+
+/** @deprecated */
+declare class LimbleTreeLegacyModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<LimbleTreeLegacyModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<LimbleTreeLegacyModule, never, [typeof LimbleTreeRootComponent], [typeof LimbleTreeRootComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<LimbleTreeLegacyModule>;
+}
+
+/** A module containing the entities which provide collapse functionality */
+declare class TreeCollapseModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<TreeCollapseModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<TreeCollapseModule, never, never, never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<TreeCollapseModule>;
+}
+
+/** Makes an TreeBranch draggable when the host element is dragged */
+declare class DraggableDirective {
+    limbleTreeDraggable?: TreeBranch<any> | undefined;
+    constructor(renderer: Renderer2, hostElement: ElementRef<HTMLElement>);
+    onDragstart(event: DragEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DraggableDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DraggableDirective, "[limbleTreeDraggable]", never, { "limbleTreeDraggable": { "alias": "limbleTreeDraggable"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * An Angular module containing all of the entities which provide Drag-And-Drop
+ * functionality.
+ */
+declare class TreeDragAndDropModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<TreeDragAndDropModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<TreeDragAndDropModule, never, [typeof DraggableDirective], [typeof DraggableDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<TreeDragAndDropModule>;
+}
+
+/**
+ * Import this Angular module into your application to gain access to the
+ * components, directives, and services provided by Limble Tree.
+ */
+declare class LimbleTreeModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<LimbleTreeModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<LimbleTreeModule, never, [typeof LimbleTreeLegacyModule, typeof TreeCollapseModule, typeof TreeDragAndDropModule], [typeof LimbleTreeLegacyModule, typeof TreeCollapseModule, typeof TreeDragAndDropModule]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<LimbleTreeModule>;
+}
+
+/** A service that collapses and expands tree branches */
+declare class TreeCollapseService {
+    /**
+     * Causes a TreeBranch to collapse, temporarily pruning all of its children
+     * from the tree.
+     *
+     * @param treeBranch - The branch to collapse.
+     */
+    collapse<T>(treeBranch: TreeBranch<T>): void;
+    /**
+     * Causes a TreeBranch to expand, restoring all of its children which were
+     * previously pruned by a call to `collapse()`.
+     *
+     * @param treeBranch - The branch to expand.
+     */
+    expand<T>(treeBranch: TreeBranch<T>): void;
+    /**
+     * Determines whether a TreeBranch currently has any children which are
+     * pruned from the tree due to a call to  the `collapse()` method.
+     *
+     * @remarks
+     * Child branches which are pruned manually from the tree, rather than
+     * through the `collapse()` method, will not be considered.
+     *
+     * @param treeBranch - The branch to check.
+     *
+     * @returns `true` if the branch is currently collapsed; `false` if it is not.
+     */
+    isCollapsed<T>(treeBranch: TreeBranch<T>): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TreeCollapseService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TreeCollapseService>;
+}
+
+declare enum DragStates {
+    Idle = 0,
+    Starting = 1,
+    Dragging = 2,
+    Dropped = 3
+}
+
+declare class TreeDragAndDropService {
+    /** Hides all Dropzones */
+    clearDropzones(): void;
+    /**
+     * @returns An object that indicates which dropzones are currently being displayed.
+     * If no dropzones are being displayed, then null is returned.
+     */
+    getCurrentlyDisplayedDropzoneFamily(): {
+        treeBranch: TreeNode<any>;
+        direction: "upper" | "lower";
+    } | null;
+    /**
+     * Causes the dropzone of the TreeRoot to be displayed.
+     *
+     * @remarks
+     * This is a useful function when you want to show the dropzone of a TreeRoot
+     * that has no child branches.
+     *
+     * @param root - The TreeRoot whose dropzone you want to show.
+     */
+    showRootDropzone<T>(root: TreeRoot<T>): void;
+    /**
+     * @returns An observable that emits a number whenever the drag state changes.
+     *
+     * @remarks
+     * See the `DragStates` enum for a list of possible states.
+     */
+    state(): Observable<DragStates>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TreeDragAndDropService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TreeDragAndDropService>;
+}
+
+export { BranchComponent, DestructionEvent, DragEndEvent, DragStartEvent, DraggableDirective, DragoverNoChangeDetectDirective, DropEvent, GraftEvent, LimbleTreeLegacyModule, LimbleTreeModule, LimbleTreeRootComponent, PruneEvent, RootComponent, TreeBranch, TreeCollapseModule, TreeCollapseService, TreeDragAndDropModule, TreeDragAndDropService, TreeError, TreeRoot, TreeService };
+export type { ComponentObj, HostComponent, LimbleTreeData, LimbleTreeNode, LimbleTreeOptions, NodeComponent, TreeEvent, TreeNode, TreeOptions, TreePlot };