@figtreejs/core 0.0.1-alpha.1 → 0.0.1-beta.1

package/dist/index.d.ts

@@ -1,6 +1,5 @@
 import { immerable } from 'immer';
 import { JSX as JSX_2 } from 'react/jsx-runtime';
-import { Maybe } from '@figtreejs/maybe/maybe';
 import { ScaleContinuousNumeric } from 'd3-scale';
 
 /** A single, generic annotation, discriminated by `type`. */
@@ -10,6 +9,9 @@ export declare type AbstractAnnotation<T extends BaseAnnotationType> = {
     value: ValueOf<T>;
 };
 
+/**
+ * The type of summary information that can be provided by a tree.
+ */
 export declare interface AbstractAnnotationSummary<T extends BaseAnnotationType> {
     id: string;
     type: T;
@@ -20,6 +22,9 @@ export declare type Annotation = {
     [K in BaseAnnotationType]: AbstractAnnotation<K>;
 }[BaseAnnotationType];
 
+/**
+ * unions across all types of annotations.
+ */
 export declare type AnnotationDomain = {
     [K in BaseAnnotationType]: DomainOf<K>;
 }[BaseAnnotationType];
@@ -32,35 +37,6 @@ export declare type AnnotationValue = {
     [K in BaseAnnotationType]: ValueOf<K>;
 }[BaseAnnotationType];
 
-export declare interface ArbitraryVertex {
-    hidden: boolean;
-    labelHidden: boolean;
-    number: number;
-    x: number;
-    y: number;
-    level: number;
-    theta?: number;
-    pathPoints: {
-        x: number;
-        y: number;
-    }[];
-    nodeLabel: {
-        dx: number;
-        dy: number;
-        alignmentBaseline: string;
-        textAnchor: string;
-        rotation?: number;
-    };
-}
-
-export declare interface ArbitraryVertices {
-    vertices: ArbitraryVertex[];
-    extent: {
-        x: [number, number];
-        y: [number, number];
-    };
-}
-
 /** Attribute as they are passed internally to possibly animated svg elements */
 declare type Attrs = Record<string, number | string>;
 
@@ -108,6 +84,10 @@ declare type AxisTicksOptions = {
     values?: number[];
 };
 
+/**
+ * Types of annotations that can exist on nodes in a tree.
+ * Each type corresponds to a value type.
+ */
 export declare enum BaseAnnotationType {
     DISCRETE = "DISCRETE",// string  could also be stringy numbers
     BOOLEAN = "BOOLEAN",// true false
@@ -176,11 +156,6 @@ declare type CartoonAttrs = ExposedAttrs<PathAttrs>;
 
 export declare function CartoonClades(options: CartoonOptions): InternalCladeOptions;
 
-export declare interface CartoonData {
-    cartooned: boolean;
-    collapseFactor: number;
-}
-
 export declare type CartoonOptions = BaseBaubleOptions<CartoonAttrs>;
 
 declare type CircleAttrs = Omit<BaseCircleDOMProps, "cx" | "cy"> & {
@@ -234,6 +209,10 @@ export declare const defaultInternalLayoutOptions: {
     minRadius: number;
 };
 
+/**
+ *  A helper type function that returns the domain of an annotation based on the
+ * type of an annotation.
+ */
 export declare type DomainOf<T extends BaseAnnotationType> = T extends BaseAnnotationType.DISCRETE ? string[] : T extends BaseAnnotationType.BOOLEAN ? [boolean, boolean] : T extends BaseAnnotationType.NUMERICAL ? [number, number] : T extends BaseAnnotationType.NUMERICAL_SET ? [number, number] : T extends BaseAnnotationType.DISCRETE_SET ? string[] | number[] : T extends BaseAnnotationType.MARKOV_JUMPS ? string[] : T extends BaseAnnotationType.DENSITIES ? string[] : never;
 
 declare type ExposedAttrs<A> = {
@@ -427,11 +406,6 @@ export declare type InternalLabelOptions = LabelOptions & ({
     target: BaubleTarget.BranchLabel;
 });
 
-export declare interface internalLayoutOptions extends layoutOptions {
-    width?: number;
-    height?: number;
-}
-
 export declare type InternalNodeOptions = ((CircleNodeOptions & {
     shape: NodeShapes.Circle;
 }) | (RectangleNodeOptions & {
@@ -440,18 +414,6 @@ export declare type InternalNodeOptions = ((CircleNodeOptions & {
     target: BaubleTarget.Node;
 };
 
-export declare interface Label {
-    x: number;
-    y: number;
-    alignmentBaseline: string;
-    textAnchor: string;
-    rotation: number;
-    alignedPos?: {
-        x: number;
-        y: number;
-    };
-}
-
 declare type LabelAttrs = ExposedAttrs<LabelSpecificTextAttrs>;
 
 declare type LabelOptions = BaseBaubleOptions<LabelAttrs> & ExposedAttrs<{
@@ -501,8 +463,23 @@ export declare type MarkovJumpValue = {
     time?: number;
 };
 
+declare type Maybe<T> = Some<T> | Nothing;
+
 export declare type maybeNodeIndex = Maybe<nodeIndex>;
 
+declare enum MaybeType {
+    Some = "some",
+    Nothing = "nothing"
+}
+
+/**
+ * A object for the parsing options available for importing a newick string.
+ * dateFormat : string if provided with date prefix the data will be parsed from the taxon label and stored in an annotation called 'date'
+ * datePrefix : string The character immediately preceding the date assuming the date is at the end of the taxon label
+ * labelName : If there are node labels they will be parsed as annotations and stored with this annotation name
+ * tipNameMap : If taxon are present as number or some other encoding this map will be used to insert the full taxon name.
+ * taxonSet : If provided this taxon set will be used to link taxa across trees.
+ */
 export declare interface newickParsingOptions {
     dateFormat?: string;
     datePrefix?: string;
@@ -512,6 +489,10 @@ export declare interface newickParsingOptions {
     taxonSet?: TaxonSet;
 }
 
+/**
+ * A nexus importing class that parses a stream and into an asynchronous
+ * iterator over trees.
+ */
 export declare class NexusImporter {
     reader: ReadableStreamDefaultReader<string>;
     taxonSet: TaxonSet;
@@ -524,6 +505,10 @@ export declare class NexusImporter {
     constructor(stream: ReadableStream<BufferSource>, options?: {
         labelName?: string;
     });
+    /**
+     * The main public api.
+     * an asynchronous iterator over the trees provided by the stream
+     */
     getTrees(): AsyncIterableIterator<ImmutableTree>;
     private parseNextBlock;
     private nextToken;
@@ -568,6 +553,10 @@ declare type nodeOption = {
     nodes: NodeRef[];
 };
 
+/**
+ * The base interface for a node.
+ * Information about the node will be provided by the tree.
+ */
 export declare interface NodeRef {
     number: number;
     _id: string;
@@ -578,9 +567,11 @@ declare enum NodeShapes {
     Rectangle = 1
 }
 
-export declare function notNull<T>(x: T, message: string): asserts x is NonNullable<T>;
+declare type Nothing = {
+    type: typeof MaybeType.Nothing;
+};
 
-export declare function panic(message: string): never;
+declare const Nothing: () => Nothing;
 
 declare type PathAttrs = Omit<BasePathDOMProps, "d">;
 
@@ -597,6 +588,10 @@ export declare function postOrderIterator(tree: Tree, node?: NodeRef | undefined
 
 export declare function preOrderIterator(tree: Tree, node?: NodeRef | undefined): Generator<NodeRef>;
 
+/**
+ * A class for a cached pre-order traversal.
+ * This needs to be revisited before it can be used.
+ */
 export declare class PreOrderTraversalCache implements TreeTraversal {
     _forwardCache: Map<NodeRef, NodeRef>;
     _reverseCache: Map<NodeRef, NodeRef>;
@@ -610,182 +605,415 @@ export declare function psuedoRootPostOrderIterator(tree: Tree, node?: NodeRef |
 
 export declare function psuedoRootPreOrderIterator(tree: Tree, node?: NodeRef | undefined, sort?: (a: NodeRef, b: NodeRef) => number): Generator<NodeRef>;
 
-export declare function radialLayout(tree: ImmutableTree, options?: {
-    spread?: number;
-}): (node: NodeRef) => FunctionalVertex;
-
-export declare type RawAnnotationValue = {
-    [K in BaseAnnotationType]: RawValueOf<K>;
-}[BaseAnnotationType];
-
-export declare type RawValueOf<T extends BaseAnnotationType> = T extends BaseAnnotationType.DISCRETE ? string : T extends BaseAnnotationType.BOOLEAN ? boolean : T extends BaseAnnotationType.NUMERICAL ? number : T extends BaseAnnotationType.NUMERICAL_SET ? number[] : T extends BaseAnnotationType.DISCRETE_SET ? string[] : T extends BaseAnnotationType.MARKOV_JUMPS ? [number, string, string][] | [string, string, string][] : T extends BaseAnnotationType.DENSITIES ? Record<string, number> : never;
-
-declare type RectangleNodeAttrs = ExposedAttrs<RectAttrs>;
-
-export declare type RectangleNodeOptions = BaseBaubleOptions<RectangleNodeAttrs>;
-
-export declare function RectangleNodes(options: RectangleNodeOptions): InternalNodeOptions;
-
-export declare const rectangularLayout: (tree: ImmutableTree) => (node: NodeRef) => FunctionalVertex;
-
-declare type RectAttrs = BaseRectangleDOMProps & {
-    width: number;
-    height: number;
-};
-
-export declare interface simplePolarVertex extends simpleVertex {
-    theta: number;
-    r: number;
-}
-
-export declare interface simpleVertex {
-    x: number;
-    y: number;
-}
-
-export declare interface Taxon {
-    name: string;
-    number: number;
-    annotations: {
-        [annotation: string]: string | string[] | number | number[];
-    };
-}
-
-export declare class TaxonSet implements TaxonSetInterface {
-    _data: TaxonSetData;
-    constructor(taxonSetData?: TaxonSetData);
-    lockTaxa(): TaxonSetInterface;
-    addTaxon(taxonOrName: string | Taxon): this;
-    getTaxon(id: number): Taxon;
-    getTaxonByName(name: string): Taxon;
-    hasTaxon(id: string): boolean;
-    getTaxonCount(): number;
-    get isFinalized(): boolean;
-}
-
-export declare interface TaxonSetData {
-    allNames: string[];
-    byName: {
-        [taxon: string]: Taxon;
-    };
-    finalized: boolean;
-}
-
-export declare interface TaxonSetInterface {
-    addTaxon(name: string): TaxonSetInterface;
-    getTaxon(id: number): Taxon | undefined;
-    getTaxonByName(name: string): Taxon;
-    getTaxonCount(): number;
-    lockTaxa(): TaxonSetInterface;
-}
-
-declare type TextAttrs = BaseTextDOMProps & {
-    text: string;
-};
-
-export declare function tipIterator(tree: Tree, node?: NodeRef): Generator<NodeRef>;
-
-export declare interface Tree {
-    getRoot(): NodeRef;
-    isRooted(): boolean;
-    getNodeCount(): number;
-    getInternalNodeCount(): number;
-    getExternalNodeCount(): number;
-    getNode(i: string | Taxon | number): NodeRef;
-    getInternalNodes(): NodeRef[];
-    getExternalNodes(): NodeRef[];
-    getNodes(): NodeRef[];
-    getTaxon(id: number | NodeRef): Taxon;
-    isExternal(node: NodeRef): boolean;
-    isInternal(node: NodeRef): boolean;
-    isRoot(node: NodeRef): boolean;
-    getChildCount(node: NodeRef): number;
-    getChild(node: NodeRef, i: number): NodeRef;
-    getNodeByTaxon(taxon: Taxon): NodeRef;
-    getNodeByLabel(label: string): NodeRef;
-    getDivergence(node: NodeRef): number;
-    getHeight(node: NodeRef): number;
-    getLength(node: NodeRef): number;
-    getParent(node: NodeRef): NodeRef;
-    getChildren(node: NodeRef): NodeRef[];
-    getAnnotation(node: NodeRef, name: string, d?: AnnotationValue): AnnotationValue;
-    annotateNode(node: NodeRef, name: string, value: RawAnnotationValue): Tree;
-    annotateNode(node: NodeRef, annotation: Record<string, RawAnnotationValue>): Tree;
-    getLabel(node: NodeRef): string;
-    hasLabel(node: NodeRef): boolean;
-    getAnnotationKeys(): string[];
-    getAnnotationType(name: string): BaseAnnotationType;
-    getAnnotations(): AnnotationSummary[];
-    getAnnotationSummary(name: string): AnnotationSummary;
-    addNodes(n?: number): {
-        tree: Tree;
-        nodes: NodeRef[];
-    };
-    deleteNode(n: NodeRef): Tree;
-    removeChild(parent: NodeRef, child: NodeRef): Tree;
-    deleteClade(n: NodeRef): Tree;
-    getNextSibling(node: NodeRef): NodeRef;
-    hasRightSibling(node: NodeRef): boolean;
-    getRightSibling(node: NodeRef): NodeRef;
-    hasLeftSibling(node: NodeRef): boolean;
-    getLeftSibling(node: NodeRef): NodeRef;
-    setHeight(node: NodeRef, height: number): Tree;
-    setDivergence(node: NodeRef, divergence: number): Tree;
-    setLength(node: NodeRef, length: number): Tree;
-    setTaxon(node: NodeRef, taxon: Taxon): Tree;
-    setLabel(node: NodeRef, label: string): Tree;
-    addChild(parent: NodeRef, child: NodeRef): Tree;
-    unroot(node: NodeRef): Tree;
-    toNewick(node?: NodeRef, options?: {
-        includeAnnotations: boolean;
-    }): string;
-    orderNodesByDensity(down: boolean): Tree;
-    sortChildren(node: NodeRef, compare: (a: NodeRef, b: NodeRef) => number): Tree;
-    isRoot(node: NodeRef): boolean;
-    getMRCA(node1: NodeRef, node2: NodeRef): NodeRef;
-    getMRCA(nodes: NodeRef[]): NodeRef;
-    rotate(node: NodeRef, recursive: boolean): Tree;
-    reroot(node: NodeRef, proportion: number): Tree;
-}
-
-export declare type TreeListener = (tree: Tree, node: NodeRef) => void;
-
-declare interface TreeTraversal {
-    getNext(tree: Tree, node: NodeRef): NodeRef | undefined;
-    getPrevious(tree: Tree, node: NodeRef): NodeRef | undefined;
-}
-
-export declare function u<T>(x: T | undefined): NonNullable<T>;
-
-export declare function unNullify<T>(x: T, message: string): NonNullable<T>;
-
-export declare type ValueOf<T extends BaseAnnotationType> = T extends BaseAnnotationType.DISCRETE ? string : T extends BaseAnnotationType.BOOLEAN ? boolean : T extends BaseAnnotationType.NUMERICAL ? number : T extends BaseAnnotationType.NUMERICAL_SET ? number[] : T extends BaseAnnotationType.DISCRETE_SET ? string[] : T extends BaseAnnotationType.MARKOV_JUMPS ? MarkovJumpValue[] : T extends BaseAnnotationType.DENSITIES ? Record<string, number> : never;
-
-export declare interface Vertex {
-    number: number;
-    x: number;
-    y: number;
-    hidden: boolean | undefined;
-    labelHidden: boolean | undefined;
-    level: number;
-    branch?: {
-        d: string;
-        label: Label;
-    };
-    theta?: number;
-    r?: number;
-    nodeLabel: Label;
-}
-
-export declare interface Vertices {
-    type: "Rectangular" | "Polar" | "Radial";
-    vertices: Vertex[];
-    origin?: {
-        x: number;
-        y: number;
-    };
-    theta?: [number, number];
-    axisLength?: number;
-}
-
-export { }
+/**
+ * The radial (unrooted) layout
+ * @param tree
+ * @param options  {spread: number} - increases this increases the space between tips
+     * @returns (node)=>FunctionalVertex
+     */
+ export declare function radialLayout(tree: ImmutableTree, options?: {
+     spread?: number;
+ }): (node: NodeRef) => FunctionalVertex;
+
+ export declare type RawAnnotationValue = {
+     [K in BaseAnnotationType]: RawValueOf<K>;
+ }[BaseAnnotationType];
+
+ export declare type RawValueOf<T extends BaseAnnotationType> = T extends BaseAnnotationType.DISCRETE ? string : T extends BaseAnnotationType.BOOLEAN ? boolean : T extends BaseAnnotationType.NUMERICAL ? number : T extends BaseAnnotationType.NUMERICAL_SET ? number[] : T extends BaseAnnotationType.DISCRETE_SET ? string[] : T extends BaseAnnotationType.MARKOV_JUMPS ? [number, string, string][] | [string, string, string][] : T extends BaseAnnotationType.DENSITIES ? Record<string, number> : never;
+
+ declare type RectangleNodeAttrs = ExposedAttrs<RectAttrs>;
+
+ export declare type RectangleNodeOptions = BaseBaubleOptions<RectangleNodeAttrs>;
+
+ export declare function RectangleNodes(options: RectangleNodeOptions): InternalNodeOptions;
+
+ export declare const rectangularLayout: (tree: ImmutableTree) => (node: NodeRef) => FunctionalVertex;
+
+ declare type RectAttrs = BaseRectangleDOMProps & {
+     width: number;
+     height: number;
+ };
+
+ export declare interface simplePolarVertex extends simpleVertex {
+     theta: number;
+     r: number;
+ }
+
+ export declare interface simpleVertex {
+     x: number;
+     y: number;
+ }
+
+ declare type Some<T> = {
+     type: typeof MaybeType.Some;
+     value: T;
+ };
+
+ declare const Some: <T>(value: T) => Some<T>;
+
+ /**
+  * A interface for taxon.
+  * There should only be one taxon per individual sampled.
+  * The taxon is meant to be synonymous with the individual and may be shared across multiple trees.
+  */
+ export declare interface Taxon {
+     name: string;
+     number: number;
+     annotations: {
+         [annotation: string]: string | string[] | number | number[];
+     };
+ }
+
+ /**
+  * A concrete implementation of the taxonset interface
+  */
+ export declare class TaxonSet implements TaxonSetInterface {
+     _data: TaxonSetData;
+     constructor(taxonSetData?: TaxonSetData);
+     lockTaxa(): TaxonSetInterface;
+     addTaxon(taxonOrName: string | Taxon): this;
+     getTaxon(id: number): Taxon;
+     getTaxonByName(name: string): Taxon;
+     hasTaxon(id: string): boolean;
+     getTaxonCount(): number;
+     get isFinalized(): boolean;
+ }
+
+ /**
+  * The interface for a taxon set internal data structure.
+  */
+ export declare interface TaxonSetData {
+     allNames: string[];
+     byName: {
+         [taxon: string]: Taxon;
+     };
+     finalized: boolean;
+ }
+
+ /**
+  * An interface for a taxon set - a group of taxa in a tree.
+  */
+ export declare interface TaxonSetInterface {
+     /**
+      * Add a taxon the the set
+      * @param name - Add a new taxon with this name
+      */
+     addTaxon(name: string): TaxonSetInterface;
+     /**
+      * Get a taxon by it's number
+      * @param id -taxon number
+      */
+     getTaxon(id: number): Taxon | undefined;
+     /**
+      * Get a taxon object by it's name.
+      * @param name -the taxon name
+      */
+     getTaxonByName(name: string): Taxon;
+     /**
+      * Return the number of taxa in the set.
+      */
+     getTaxonCount(): number;
+     /**
+      * Lock the taxa set. No taxa can be added or removed at this point. The population is fixed.
+      */
+     lockTaxa(): TaxonSetInterface;
+ }
+
+ declare type TextAttrs = BaseTextDOMProps & {
+     text: string;
+ };
+
+ export declare function tipIterator(tree: Tree, node?: NodeRef): Generator<NodeRef>;
+
+ /**
+  * A representation of a phylogenetic tree.
+  * Trees may represent unrooted tree, but all trees nominally have a root node.
+  * Functions do not return 'undefined' or 'null'.
+  * If a value that does not exist is accessed the tree will throw an error.
+  * Helper functions are provided to check if a value exists.
+  */
+ export declare interface Tree {
+     /**
+      * Return the root of the tree.
+      */
+     getRoot(): NodeRef;
+     /**
+      * Return the number of nodes in the tree.
+      */
+     getNodeCount(): number;
+     /**
+      * Return the number of internal nodes.
+      */
+     getInternalNodeCount(): number;
+     /**
+      * Return the number of tips / external nodes
+      */
+     getExternalNodeCount(): number;
+     /**
+      * Get Node by name/label, taxon, or index (in full node list)
+      * @param i: string | Taxon | number
+      */
+     getNode(i: string | Taxon | number): NodeRef;
+     /**
+      * Get an array of internal nodes
+      */
+     getInternalNodes(): NodeRef[];
+     /**
+      * Get an array of external nodes
+      */
+     getExternalNodes(): NodeRef[];
+     /**
+      * Get an array of all nodes.
+      */
+     getNodes(): NodeRef[];
+     /**
+      * Get the taxon affiliated with a node or by it's index
+      * @param id: number | NodeRef
+      */
+     getTaxon(id: number | NodeRef): Taxon;
+     /**
+      * Helper to function to determine if a node in an external node
+      * @param node
+      */
+     isExternal(node: NodeRef): boolean;
+     /**
+      * A helper function to determine if an node is an internal node
+      * @param node
+      */
+     isInternal(node: NodeRef): boolean;
+     /**
+      * A helper function to determine if a node is the root node.
+      * @param node
+      */
+     isRoot(node: NodeRef): boolean;
+     /**
+      * Return the number of children an given node has.
+      * @param node
+      */
+     getChildCount(node: NodeRef): number;
+     /**
+      * Access the ith child of a node
+      * @param node - NodeRef
+      * @param i - index of the child
+      */
+     getChild(node: NodeRef, i: number): NodeRef;
+     /**
+      * An explicit function to get a node by it's Taxon
+      * @param taxon
+      */
+     getNodeByTaxon(taxon: Taxon): NodeRef;
+     /**
+      * An explicit function to access a node by it's label
+      * @param label - string
+      */
+     getNodeByLabel(label: string): NodeRef;
+     /**
+      * Return the distance from this node to the root.
+      * @param node -NodeRef
+      */
+     getDivergence(node: NodeRef): number;
+     /**
+      * Return the distance between a node and the node furthest from the root
+      * @param node -NodeRef
+      */
+     getHeight(node: NodeRef): number;
+     /**
+      * Return the length of the branch subtending a node
+      * @param node -NodeRef
+      */
+     getLength(node: NodeRef): number;
+     /**
+      * Return a node's parent
+      * @param node -NodeRef
+      */
+     getParent(node: NodeRef): NodeRef;
+     /**
+      * Get an array of the node's children
+      * @param node -NodeRef
+      */
+     getChildren(node: NodeRef): NodeRef[];
+     /**
+      * Get the annotation value for a node.
+      * If the default value is not provided, and the node is not annotated, the function will throw an error.
+      * @param node - NodeRef
+      * @param name - string the name of the annotation
+      * @param d - AnnotationValue - The default value to return if the node does not have the provided annotation.
+      */
+     getAnnotation(node: NodeRef, name: string, d?: AnnotationValue): AnnotationValue;
+     /**
+      * Annotate a node with a value.
+      * @param node - NodeRef
+      * @param name -string - Name of the annotation
+      * @param value - the annotation value for a node.
+      */
+     annotateNode(node: NodeRef, name: string, value: RawAnnotationValue): Tree;
+     annotateNode(node: NodeRef, annotation: Record<string, RawAnnotationValue>): Tree;
+     /**
+      * Get the label for a given node
+      * @param node
+      */
+     getLabel(node: NodeRef): string;
+     /**
+      * Check if a node has a label
+      * @param node
+      */
+     hasLabel(node: NodeRef): boolean;
+     /**
+      * Get all the names of annotations in the tree
+      */
+     getAnnotationKeys(): string[];
+     /**
+      * Get the type of an annotation found in the tree.
+      * @param name string - Name of the annotation
+      */
+     getAnnotationType(name: string): BaseAnnotationType;
+     /**
+      * Return an array of summary data for all annotations in the tree.
+      */
+     getAnnotations(): AnnotationSummary[];
+     /**
+      * Return a summary of an annotation in the tree
+      * @param name - name of the annotation
+      */
+     getAnnotationSummary(name: string): AnnotationSummary;
+     /**
+      * Add nodes to a tree.
+      * The nodes can be accessed by their indices, but have no relationships with other nodes in the tree.
+      * Returns an object with {tree: the new tree with nodes,node: An array of the new nodes}
+      * @param n - number of nodes to add default 1
+      */
+     addNodes(n?: number): {
+         tree: Tree;
+         nodes: NodeRef[];
+     };
+     /**
+      * Delete a node from a tree.
+      * It is not possible to delete the root node.
+      * @param n - NodeRef
+      */
+     deleteNode(n: NodeRef): Tree;
+     /**
+      * Remove a child node from a parent node's descendants
+      * @param parent - The node whose child will be removed
+      * @param child - The child that is removed from the parent.
+      */
+     removeChild(parent: NodeRef, child: NodeRef): Tree;
+     /**
+      * Get the next sibling.
+      * This will wrap back to the first sibling if the provided node is the last sibling.
+      * @param node - NodeRef
+      */
+     getNextSibling(node: NodeRef): NodeRef;
+     /**
+      * A checker function to determine if a node has a right sibling
+      * @param node - NodeRef
+      */
+     hasRightSibling(node: NodeRef): boolean;
+     /**
+      * Return a node's right sibling (if it has one) or error.
+      * @param node
+      */
+     getRightSibling(node: NodeRef): NodeRef;
+     /**
+      * Check if a node has a left sibling
+      * @param node
+      */
+     hasLeftSibling(node: NodeRef): boolean;
+     /**
+      * Return a node's left sibling (if it has one) or throw an error.
+      * @param node
+      */
+     getLeftSibling(node: NodeRef): NodeRef;
+     /**
+      * Set the distance between a node and the node furthest from the root.
+      * @param node
+      * @param height number - the new node height
+      */
+     setHeight(node: NodeRef, height: number): Tree;
+     /**
+      * Set the distance between a node and the root node.
+      * @param node
+      * @param divergence number - new divergence
+      */
+     setDivergence(node: NodeRef, divergence: number): Tree;
+     /**
+      * Set the length of the branch subtending a node
+      * @param node NodeRef
+      * @param length - number - the new length
+      */
+     setLength(node: NodeRef, length: number): Tree;
+     /**
+      * Assign a taxon to a node.
+      * @param node NodRef
+      * @param taxon Taxon
+      */
+     setTaxon(node: NodeRef, taxon: Taxon): Tree;
+     /**
+      * Set the label on a node.
+      * @param node Noderf
+      * @param label string
+      */
+     setLabel(node: NodeRef, label: string): Tree;
+     /**
+      * Add a child to a node.
+      * @param parent the parent that gets a new child
+      * @param child The child added to a parent
+      */
+     addChild(parent: NodeRef, child: NodeRef): Tree;
+     /**
+      *
+      * @param node - An optional node start writing from. If not provided the whole tree will be written.
+      * @param options { includeAnnotations: boolean } - include annotations in newick string
+          */
+      toNewick(node?: NodeRef, options?: {
+          includeAnnotations: boolean;
+      }): string;
+      /**
+       * Sort children arrays by the number of offspring.
+       * @param down Boolean to sort down or up.
+       */
+      orderNodesByDensity(down: boolean): Tree;
+      /**
+       *
+       * @param node Node whose children will be sorted
+       * @param compare - A function which compares two nodes. Will be used as in an array sort
+       */
+      sortChildren(node: NodeRef, compare: (a: NodeRef, b: NodeRef) => number): Tree;
+      /**
+       * Get the most recent common ancestor of two nodes
+       * @param node1
+       * @param node2
+       */
+      getMRCA(node1: NodeRef, node2: NodeRef): NodeRef;
+      /**
+       * Get the most recent common ancestor of an array of nodes
+       * @param nodes
+       */
+      getMRCA(nodes: NodeRef[]): NodeRef;
+      /**
+       * Rotate a node's children
+       * @param node
+       * @param recursive - rotate the children as well down the tree
+       */
+      rotate(node: NodeRef, recursive: boolean): Tree;
+      /**
+       * Reroot a tree along a branch subtending a new node.
+       * @param node The root will be inserted along the branch subtending this node
+       * @param proportion - proportion along the branch to place the root.
+       */
+      reroot(node: NodeRef, proportion: number): Tree;
+     }
+
+     export declare type TreeListener = (tree: Tree, node: NodeRef) => void;
+
+     /**
+      * An interface for tree traversals
+      */
+     declare interface TreeTraversal {
+         getNext(tree: Tree, node: NodeRef): NodeRef | undefined;
+         getPrevious(tree: Tree, node: NodeRef): NodeRef | undefined;
+     }
+
+     export declare type ValueOf<T extends BaseAnnotationType> = T extends BaseAnnotationType.DISCRETE ? string : T extends BaseAnnotationType.BOOLEAN ? boolean : T extends BaseAnnotationType.NUMERICAL ? number : T extends BaseAnnotationType.NUMERICAL_SET ? number[] : T extends BaseAnnotationType.DISCRETE_SET ? string[] : T extends BaseAnnotationType.MARKOV_JUMPS ? MarkovJumpValue[] : T extends BaseAnnotationType.DENSITIES ? Record<string, number> : never;
+
+     export { }