semantic-typescript 0.5.3 → 0.6.0

package/dist/node.d.ts

@@ -1,182 +0,0 @@
-import { Optional } from "./optional";
-import { type Comparator } from "./utility";
-export interface Node<E, N extends Node<E, N>> extends Iterable<N> {
-    ancestors(): Iterable<N>;
-    children(): Iterable<N>;
-    descendants(): Iterable<N>;
-    siblings(): Iterable<N>;
-    parent(): Optional<N>;
-    root(): N;
-    previousSibling(): Optional<N>;
-    nextSibling(): Optional<N>;
-    preorder(): Generator<N>;
-    inorder(): Generator<N>;
-    postorder(): Generator<N>;
-    breadthfirst(): Generator<N>;
-    depth(): bigint;
-    height(): bigint;
-    width(): bigint;
-    level(): bigint;
-    isLeaf(): boolean;
-    isRoot(): boolean;
-    [Symbol.iterator](): Iterator<N>;
-}
-export declare abstract class AbstractNode<E, N extends Node<E, N>> implements Node<E, N> {
-    protected readonly Node: symbol;
-    constructor();
-    ancestors(): Iterable<N>;
-    abstract children(): Iterable<N>;
-    descendants(): Iterable<N>;
-    root(): N;
-    siblings(): Iterable<N>;
-    abstract parent(): Optional<N>;
-    previousSibling(): Optional<N>;
-    nextSibling(): Optional<N>;
-    preorder(): Generator<N>;
-    inorder(): Generator<N>;
-    postorder(): Generator<N>;
-    breadthfirst(): Generator<N>;
-    [Symbol.iterator](): Iterator<N>;
-    depth(): bigint;
-    height(): bigint;
-    width(): bigint;
-    level(): bigint;
-    isLeaf(): boolean;
-    isRoot(): boolean;
-}
-export declare class LinearNode<E> extends AbstractNode<E, LinearNode<E>> {
-    protected previous: Optional<LinearNode<E>>;
-    protected next: Optional<LinearNode<E>>;
-    protected element: Optional<E>;
-    protected readonly LinearNode: symbol;
-    constructor(element: E);
-    constructor(element: E, previous: Optional<LinearNode<E>>, next: Optional<LinearNode<E>>);
-    ancestors(): Iterable<LinearNode<E>>;
-    descendants(): Iterable<LinearNode<E>>;
-    root(): LinearNode<E>;
-    siblings(): Iterable<LinearNode<E>>;
-    children(): Iterable<LinearNode<E>>;
-    parent(): Optional<LinearNode<E>>;
-    [Symbol.iterator](): Iterator<LinearNode<E>>;
-    getElement(): Optional<E>;
-    setElement(element: E): void;
-    getPrevious(): Optional<LinearNode<E>>;
-    setPrevious(previous: LinearNode<E>): void;
-    setPrevious(previous: Optional<LinearNode<E>>): void;
-    getNext(): Optional<LinearNode<E>>;
-    setNext(next: LinearNode<E>): void;
-    setNext(next: Optional<LinearNode<E>>): void;
-    linkPrevious(previous: LinearNode<E>): void;
-    unlinkPrevious(): void;
-    linkNext(next: LinearNode<E>): void;
-    unlinkNext(): void;
-}
-export declare abstract class BinaryNode<E, N extends BinaryNode<E, N>> extends AbstractNode<E, N> {
-    BinaryNode: symbol;
-    protected ancestor: Optional<N>;
-    protected left: Optional<N>;
-    protected right: Optional<N>;
-    protected element: Optional<E>;
-    constructor(element: E);
-    constructor(element: E, ancestor: Optional<N>, left: Optional<N>, right: Optional<N>);
-    ancestors(): Iterable<N>;
-    compare(other: N): bigint;
-    compare(other: N, comparator: Comparator<E>): bigint;
-    descendants(): Iterable<N>;
-    abstract identity(): N;
-    root(): N;
-    siblings(): Iterable<N>;
-    children(): Iterable<N>;
-    parent(): Optional<N>;
-    [Symbol.iterator](): Iterator<N>;
-    preorder(): Generator<N>;
-    inorder(): Generator<N>;
-    postorder(): Generator<N>;
-    breadthfirst(): Generator<N>;
-    getElement(): Optional<E>;
-    setElement(element: E): void;
-    getLeft(): Optional<N>;
-    setLeft(left: N): void;
-    setLeft(left: Optional<N>): void;
-    getRight(): Optional<N>;
-    setRight(right: N): void;
-    setRight(right: Optional<N>): void;
-    getAncestor(): Optional<N>;
-    setAncestor(ancestor: N): void;
-    setAncestor(ancestor: Optional<N>): void;
-    linkLeft(left: N): void;
-    unlinkLeft(): Optional<N>;
-    linkRight(right: N): void;
-    unlinkRight(): Optional<N>;
-    isLeftChild(): boolean;
-    isRightChild(): boolean;
-    detach(): void;
-    isBanlanced(): boolean;
-    isFull(): boolean;
-    isComplete(): boolean;
-    isPerfect(): boolean;
-    invert(): void;
-    invert(deep: boolean): void;
-}
-type Color = "RED" | "BLACK";
-export declare class RedBlackNode<E> extends BinaryNode<E, RedBlackNode<E>> {
-    protected readonly RedBlackNode: symbol;
-    protected color: Color;
-    constructor(element: E);
-    constructor(element: E, color: Color);
-    constructor(element: E, color: Color, ancestor: Optional<RedBlackNode<E>>, left: Optional<RedBlackNode<E>>, right: Optional<RedBlackNode<E>>);
-    identity(): RedBlackNode<E>;
-    getElement(): Optional<E>;
-    setElement(element: E): void;
-    getLeft(): Optional<RedBlackNode<E>>;
-    getRight(): Optional<RedBlackNode<E>>;
-    getColor(): Color;
-    setColor(color: Color): void;
-    isRed(): boolean;
-    isBlack(): boolean;
-    turnRed(): void;
-    turnBlack(): void;
-    toggle(): void;
-    compareAndLink(other: RedBlackNode<E>): void;
-    compareAndLink(other: RedBlackNode<E>, comparator: Comparator<E>): void;
-    rotate(): void;
-    rotateLeft(): RedBlackNode<E>;
-    rotateRight(): RedBlackNode<E>;
-    fix(): void;
-    uncle(): Optional<RedBlackNode<E>>;
-    findMinimum(): RedBlackNode<E>;
-    findMaximum(): RedBlackNode<E>;
-}
-export declare class AverageLevelNode<E> extends BinaryNode<E, AverageLevelNode<E>> {
-    constructor(element: E);
-    constructor(element: E, ancestor: Optional<AverageLevelNode<E>>, left: Optional<AverageLevelNode<E>>, right: Optional<AverageLevelNode<E>>);
-    [Symbol.iterator](): Iterator<AverageLevelNode<E>>;
-    identity(): AverageLevelNode<E>;
-    getElement(): Optional<E>;
-    setElement(element: E): void;
-    getLeft(): Optional<AverageLevelNode<E>>;
-    getRight(): Optional<AverageLevelNode<E>>;
-}
-export declare class BinarySearchNode<E> extends AbstractNode<E, BinarySearchNode<E>> {
-    protected left: Optional<BinarySearchNode<E>>;
-    protected right: Optional<BinarySearchNode<E>>;
-    protected element: Optional<E>;
-    constructor(element: E);
-    constructor(element: E, left: Optional<BinarySearchNode<E>>, right: Optional<BinarySearchNode<E>>);
-    ancestors(): Iterable<BinarySearchNode<E>>;
-    descendants(): Iterable<BinarySearchNode<E>>;
-    root(): BinarySearchNode<E>;
-    siblings(): Iterable<BinarySearchNode<E>>;
-    children(): Iterable<BinarySearchNode<E>>;
-    parent(): Optional<BinarySearchNode<E>>;
-    [Symbol.iterator](): Iterator<BinarySearchNode<E>>;
-    inorder(): Generator<BinarySearchNode<E>>;
-    preorder(): Generator<BinarySearchNode<E>>;
-    postorder(): Generator<BinarySearchNode<E>>;
-    breadthfirst(): Generator<BinarySearchNode<E>>;
-    getElement(): Optional<E>;
-    setElement(element: E): void;
-    getLeft(): Optional<BinarySearchNode<E>>;
-    getRight(): Optional<BinarySearchNode<E>>;
-}
-export {};