@avensio/shared/dist/shared.es.d.ts

A lightweight and dependency-free collection of essential data structures and graph algorithms, written entirely in TypeScript. This library supports CommonJS, ESM, and browser environments, and includes utility functions for practical, everyday tasks in

export declare class AGraph<V extends IVertex, E extends IEdge> implements IGraph<V, E> {
    private vertexType;
    private edgeType;
    uuid: string;
    title: string;
    vertices: Set<V>;
    edges: Set<E>;
    directed: boolean;
    mixed: boolean;
    connected: boolean;
    connectedComponentsCount: number;
    strongConnectedComponentsCount: number;
    cycleCount: number;
    hasCycles: boolean;
    hasNegativeCycles: boolean;
    comparator: Comparator<V>;
    constructor(options: GraphProperties | undefined, _comparator: Comparator<V>, vertexType: new (options?: any) => V, edgeType: new (options?: any) => E);
    infer(): void;
    depthFirstSearch(startVertex: V, L?: IStack<V>): DoublyLinkedList<V>;
    breadthFirstSearch(startVertex: V): DoublyLinkedList<V>;
    /**
     * shortest path (Moore-Bellman-Ford)
     *
     * @param from
     * @param to
     */
    shortestPath(from: V, to: V): DoublyLinkedList<V>;
    /**
     * Yen's k-shortest-paths
     *
     * @param from
     * @param to
     * @param K
     */
    kShortestPaths(from: V, to: V, K: number): DoublyLinkedList<DoublyLinkedList<V>>;
    /**
     * Minimal spanning tree algorithmen (Kruskal and minimum branching) for undirected/directed, connected and weighted graphs
     */
    minimalSpanningTree(): IGraph<V, E>;
    topologicalSorting(): DoublyLinkedList<V>;
    /**
     * With this variant of the topological sorting it's additionally possible
     * to determine which vertices can be processed simulations (see "parallel topological sorting" test)
     */
    parallelTopologicalSorting(): DoublyLinkedList<DoublyLinkedList<V>>;
    checkForCycles(): boolean;
    checkForNegativeCycles(): boolean;
    protected getNeighbours(neighbours: Map<V, Array<V>>, currentVertex: V): V[];
    inferCycles(): Set<Array<V>>;
    connectedComponents(): DoublyLinkedList<IGraph<V, E>>;
    strongConnectedComponents(): Array<IGraph<V, E>>;
    strongConnectedComponentCount(): number;
    density(): number;
    order(): number;
    size(): number;
    isCyclic(): boolean;
    isAcyclic(): boolean;
    isTree(): boolean;
    isForest(): boolean;
    isDirected(): boolean;
    isConnected(): boolean;
    private isConnectedFrom;
    isStronglyConnected(): boolean;
    private isStronglyConnectedFrom;
    isMixed(): boolean;
    isDense(threshold?: number): boolean;
    isSparse(threshold?: number): boolean;
    createEdge(from: V, to: V, title?: string, directed?: boolean, weight?: number): E;
    addEdge(e: E): boolean;
    removeEdge(e: E): boolean;
    createVertex(title?: string, point?: undefined, object?: {}): V;
    addVertex(v: V): boolean;
    removeVertex(v: V): boolean;
    /**
     * Weight function for calculating the weight of an edge.
     *
     * Override, for custom weight function
     *
     * @param from
     * @param to
     */
    c(from: V, to: V): number;
    protected verticesArrayEquals(p1: Array<V>, p2: Array<V>): boolean;
    protected sumUpPathCosts(p: DoublyLinkedList<V>): number;
    protected createSingleEdge(title: string, directed: boolean, weight: number, from: V, to: V): E;
    protected getDeduplicatedEdges(): IEdge[];
    protected constructShortestPath(from: V, to: V, predecessors: Map<V, V>): DoublyLinkedList<V>;
    protected shortestPathMooreBellmanFord(from: V): SPPair<V>;
    protected containsCyclesFrom(v: V): boolean;
    protected checkForNegativeCyclesFrom(s: V): boolean;
}

export declare type Comparator<E> = (e1: E, e2: E) => Ordering;

export declare class CyclicDoublyLinkedList<E> implements ILinkedList<E> {
    first: Node_2<E>;
    last: Node_2<E>;
    size: number;
    comparator: Comparator<E>;
    constructor(elements?: Iterable<E>, reverse?: boolean);
    /**
     * O(1)
     * @param e
     */
    add(e: E): void;
    addAll(c: Iterable<E>): void;
    /**
     * O(1)
     * @param e
     */
    addFirst(e: E): void;
    /**
     * O(1)
     * @param e
     */
    addLast(e: E): void;
    /**
     * O(1)
     */
    clear(): void;
    /**
     * O(size / 2)<br>
     * Ω(1)
     * @param index
     */
    get(index: number): E;
    /**
     * O(size / 2)<br>
     * Ω(1)
     * @param index
     * @param e
     */
    set(index: number, e: E): boolean;
    slice(startIndex: number, endIndex: number): CyclicDoublyLinkedList<E>;
    slice2(startIndex: number, endIndex: number): CyclicDoublyLinkedList<E>;
    splice(startIndex: number, deleteCount: number): CyclicDoublyLinkedList<E>;
    map<V>(fn: (e: E) => V): CyclicDoublyLinkedList<V>;
    reduce<V>(fn: (accumulator: V, element: E) => V, initialValue?: V): V;
    filter(predicate: (e: E) => boolean): CyclicDoublyLinkedList<E>;
    every(predicate: (e: E) => boolean): boolean;
    some(predicate: (e: E) => boolean): boolean;
    /**
     * O(1)
     */
    getFirst(): E;
    /**
     * O(1)
     */
    getLast(): E;
    /**
     * O(1)
     */
    isEmpty(): boolean;
    /**
     * O(size / 2)<br>
     * Ω(1)
     * @param index
     */
    remove(index: number): E;
    /**
     * O(1)
     */
    removeFirst(): E;
    /**
     * O(size / 2)<br>
     * Ω(1)
     */
    removeLast(): E;
    /**
     * O(size / 2)<br>
     * Ω(1)
     * @param index
     */
    getNode(index: number): Node_2<E>;
    /**
     * For this method to work, a comparator must be set
     * @param e
     */
    includes(e: E): boolean;
    /**
     * For this method to work, a comparator must be set
     * @param l
     */
    equals(l: IList<E>): boolean;
    indexOf(e: E): number;
    sort(cmp?: Comparator<E>): void;
    /**
     * In even cases: O(∑ i=1 to &lfloor;size&divide;2&rfloor; (i*2))<br>
     * In odd cases: O((∑ i=1 to &lfloor;size&divide;2&rfloor; (i*2)) + &lceil;size&divide;2&rceil;)<br>
     * Ω(1)
     */
    reverseIterator(): Generator<E, void, unknown>;
    /**
     * O(size)
     */
    [Symbol.iterator](): Iterator<E>;
}

export declare class Dequeue<E> implements IDequeue<E> {
    size: number;
    private _head;
    private tail;
    comparator: Comparator<E>;
    constructor(elements?: Iterable<E>);
    /**
     * O(1)
     * @param e
     */
    enqueue(e: E): void;
    add(e: E): void;
    /**
     * O(1)
     */
    dequeue(): E;
    /**
     * O(1)
     * @param e
     */
    push(e: E): void;
    /**
     * O(1)
     */
    pop(): E;
    /**
     * O(1)
     */
    top(): E;
    /**
     * O(1)
     */
    head(): E;
    /**
     * O(1)
     */
    isEmpty(): boolean;
    /**
     * O(1)
     */
    clear(): void;
    /**
     * For this method to work, a comparator must be set
     * @param e
     */
    contains(e: E): boolean;
    /**
     * O(size)
     */
    [Symbol.iterator](): Iterator<E>;
    /**
     * O(size)
     */
    reverseIterator(): Generator<E, void, unknown>;
    sort(cmp?: Comparator<E>): void;
}

export declare class DoublyLinkedList<E> implements ILinkedList<E> {
    first: Node_2<E>;
    last: Node_2<E>;
    size: number;
    comparator: Comparator<E>;
    constructor(elements?: Iterable<E>, reverse?: boolean);
    /**
     * O(1)
     * @param e
     */
    add(e: E): void;
    addAll(c: Iterable<E>): void;
    /**
     * O(1)
     * @param e
     */
    addFirst(e: E): void;
    /**
     * O(1)
     * @param e
     */
    addLast(e: E): void;
    /**
     * O(1)
     */
    clear(): void;
    /**
     * O(size / 2)<br>
     * Ω(1)
     * @param index
     */
    get(index: number): E;
    /**
     * O(size / 2)<br>
     * Ω(1)
     * @param index
     * @param e
     */
    set(index: number, e: E): boolean;
    slice(startIndex: number, endIndex: number): DoublyLinkedList<E>;
    slice2(startIndex: number, endIndex: number): DoublyLinkedList<E>;
    splice(startIndex: number, deleteCount: number): DoublyLinkedList<E>;
    map<V>(fn: (e: E) => V): DoublyLinkedList<V>;
    reduce<V>(fn: (accumulator: V, element: E) => V, initialValue?: V): V;
    filter(predicate: (e: E) => boolean): DoublyLinkedList<E>;
    every(predicate: (e: E) => boolean): boolean;
    some(predicate: (e: E) => boolean): boolean;
    /**
     * O(1)
     */
    getFirst(): E;
    /**
     * O(1)
     */
    getLast(): E;
    /**
     * O(1)
     */
    isEmpty(): boolean;
    /**
     * O(size / 2)<br>
     * Ω(1)
     * @param index
     */
    remove(index: number): E;
    /**
     * O(1)
     */
    removeFirst(): E;
    /**
     * O(1)
     */
    removeLast(): E;
    /**
     * O(size / 2)<br>
     * Ω(1)
     * @param index
     */
    getNode(index: number): Node_2<E>;
    /**
     * For this method to work, a comparator must be set
     * @param e
     */
    includes(e: E): boolean;
    /**
     * For this method to work, a comparator must be set
     * @param l
     */
    equals(l: IList<E>): boolean;
    indexOf(e: E): number;
    sort(cmp?: Comparator<E>): void;
    /**
     * In even cases: O(∑ i=1 to &lfloor;size&divide;2&rfloor; (i*2))<br>
     * In odd cases: O((∑ i=1 to &lfloor;size&divide;2&rfloor; (i*2)) + &lceil;size&divide;2&rceil;)<br>
     * Ω(1)
     */
    reverseIterator(): Generator<E, void, unknown>;
    /**
     * O(size)
     */
    [Symbol.iterator](): Iterator<E>;
}

export declare class Edge implements IEdge {
    uuid: string;
    title: string;
    from: IVertex;
    to: IVertex;
    directed: boolean;
    weight: number;
    constructor(options?: EdgeProperties);
    isDirected(): boolean;
    /**
     * @returns the reverse edge, if existing
     */
    getReverseEdge(): IEdge;
    /**
     * returns both ends of the edge [from, to]
     */
    getVertices(): VerticesPair<IVertex>;
}

export declare type EdgeProperties = {
    uuid?: string;
    title?: string;
    from: IVertex;
    to: IVertex;
    directed?: boolean;
    weight?: number;
};

export declare class FibonacciHeap<E> implements IFibonacciHeap<E> {
    rootList: HeapNode<E>;
    minNode: HeapNode<E>;
    size: number;
    comparator: Comparator<E>;
    private readonly goldenCut;
    constructor(comparator: Comparator<E>, elements?: Iterable<E>);
    /**
     * O(1)
     * @param e
     */
    insert(e: E): HeapNode<E>;
    add(e: E): HeapNode<E>;
    /**
     * O(log(size)) (amortized)
     *
     * @param e
     */
    delete(e: HeapNode<E>): HeapNode<E>;
    /**
     * Decreases a nodes key. When the newValue is null or undefined, node will get the new minNode
     *
     * O(1) (amortized)
     *
     * @param node
     * @param newValue
     */
    decreaseKey(node: HeapNode<E>, newValue: E): void;
    /**
     * O(1)
     */
    minimum(): HeapNode<E>;
    /**
     * O(log(size)) (amortized)
     */
    extractMin(): HeapNode<E>;
    /**
     * O(1)
     *
     * @param heap to merge in the current one
     */
    union(heap: IFibonacciHeap<E>): void;
    /**
     * O(1)
     */
    isEmpty(): boolean;
    /**
     * O(1)
     */
    clear(): void;
    extractNeighbours(node: HeapNode<E>, includeSelf?: boolean): CyclicDoublyLinkedList<HeapNode<E>>;
    extractChildren(node: HeapNode<E>): CyclicDoublyLinkedList<HeapNode<E>>;
    private cut;
    private cascadingCut;
    private addToChildList;
    private removeFromChildList;
    private mergeWithRootList;
    private removeFromRootList;
    private consolidate;
    private heapLink;
    /**
     * Base conversion
     *
     * @param base
     * @param x value to be converted
     * @return {number}
     */
    private log;
    /**
     * O(log(size)*size + size*3)
     */
    nodeIterator(): Generator<HeapNode<E>, void, unknown>;
    /**
     * O(heap.size*3 + log(heap.size))
     */
    [Symbol.iterator](): Iterator<E>;
    reverseIterator(): Generator<E>;
    /**
     * This sort function changes the comparator, if one is given as parameter!
     *
     * @param cmp
     */
    sort(cmp?: Comparator<E>): void;
}

export declare class Graph extends AGraph<Vertex, Edge> {
    constructor(props?: GraphProperties, comparator?: Comparator<Vertex>);
}

export declare type GraphProperties = {
    uuid?: string;
    title?: string;
    vertices?: Set<IVertex>;
    edges?: Set<IEdge>;
    directed?: boolean;
    mixed?: boolean;
    connected?: boolean;
    connectedComponentsCount?: number;
    strongConnectedComponentsCount?: number;
    cycleCount?: number;
    hasCycles?: boolean;
    hasNegativeCycles?: boolean;
};

export declare type HeapNode<E> = {
    value: E;
    degree: number;
    marked: boolean;
    left: HeapNode<E>;
    right: HeapNode<E>;
    parent?: HeapNode<E>;
    child?: HeapNode<E>;
};

/**
 * Heapsort variant using a fibonacci heap
 *
 * @param A must have a comparator set!
 * @param comparator
 */
export declare function heapSort<V>(A: Iterable<V>, comparator: Comparator<V>): FibonacciHeap<V>;

export declare interface ICollection<E> extends ISortable<E>, Iterable<E>, IReverseIterable<E> {
    add(e: E): void;
    size: number;
    isEmpty(): boolean;
    clear(): void;
}

export declare interface IDequeue<E> extends IQueue<E>, IStack<E> {
}

export declare interface IEdge extends EdgeProperties {
    isDirected(): boolean;
    getReverseEdge(): IEdge;
    getVertices(): VerticesPair<IVertex>;
}

export declare interface IFibonacciHeap<E> extends ICollection<E> {
    rootList: HeapNode<E>;
    minNode: HeapNode<E>;
    insert(element: E): HeapNode<E>;
    delete(node: HeapNode<E>): HeapNode<E>;
    decreaseKey(node: HeapNode<E>, newValue: E): void;
    minimum(): HeapNode<E>;
    extractMin(): HeapNode<E>;
    union(heap: IFibonacciHeap<E>): void;
    extractNeighbours(node: HeapNode<E>, includeSelf?: boolean): CyclicDoublyLinkedList<HeapNode<E>>;
    extractChildren(node: HeapNode<E>): CyclicDoublyLinkedList<HeapNode<E>>;
}

export declare interface IGraph<V extends IVertex, E extends IEdge> extends GraphProperties {
    infer(): void;
    depthFirstSearch(startVertex: V, L?: IStack<V>): DoublyLinkedList<V>;
    breadthFirstSearch(startVertex: V): DoublyLinkedList<V>;
    shortestPath(from: V, to: V): DoublyLinkedList<V>;
    kShortestPaths(from: V, to: V, k: number): DoublyLinkedList<DoublyLinkedList<V>>;
    minimalSpanningTree(): IGraph<V, E>;
    topologicalSorting(): DoublyLinkedList<V>;
    parallelTopologicalSorting(): DoublyLinkedList<DoublyLinkedList<V>>;
    checkForCycles(): boolean;
    checkForNegativeCycles(): boolean;
    inferCycles(): Set<Array<V>> | null;
    connectedComponents(): DoublyLinkedList<IGraph<V, E>>;
    strongConnectedComponents(): Array<IGraph<V, E>>;
    density(): number;
    order(): number;
    size(): number;
    isCyclic(): boolean;
    isAcyclic(): boolean;
    isTree(): boolean;
    isForest(): boolean;
    isDirected(): boolean;
    isConnected(): boolean;
    isStronglyConnected(): boolean;
    isMixed(): boolean;
    isDense(): boolean;
    isSparse(): boolean;
    createEdge(from: V, to: V, title?: string, directed?: boolean, weight?: number): E;
    addEdge(e: E): boolean;
    removeEdge(e: E): boolean;
    createVertex(title?: string, point?: Point, object?: any): V;
    addVertex(v: V): boolean;
    removeVertex(v: V): boolean;
    c(from: V, to: V): number;
}

export declare interface ILinkedList<E> extends IList<E> {
    first: Node_2<E>;
    last: Node_2<E>;
    getNode(index: number): Node_2<E>;
    addFirst(e: E): void;
    addLast(e: E): void;
    getFirst(): E;
    getLast(): E;
    removeFirst(): E;
    removeLast(): E;
}

export declare interface IList<E> extends ICollection<E>, IListFunctions<E> {
    comparator: Comparator<E>;
    addAll(c: Iterable<E>): void;
    get(index: number): E;
    set(index: number, e: E | null): boolean;
    remove(index: number): E;
    equals(l: IList<E>): boolean;
    indexOf(e: E): number;
    includes(e: E): boolean;
    reverseIterator(): Generator<E>;
}

export declare interface IListFunctions<E> {
    map<V>(fn: (e: E) => V): IList<V>;
    reduce<V>(fn: (accumulator: V, element: E) => V, initialValue?: V): V;
    filter(predicate: (e: E) => boolean): IList<E>;
    every(predicate: (e: E) => boolean): boolean;
    some(predicate: (e: E) => boolean): boolean;
    slice(startIndex: number, endIndex: number): IList<E>;
    slice2(startIndex: number, endIndex: number): IList<E>;
    splice(startIndex: number, deleteCount: number): IList<E>;
}

export declare interface IQueue<E> extends ICollection<E> {
    enqueue(e: E): void;
    dequeue(): E;
    head(): E;
}

export declare interface IReverseIterable<E> {
    reverseIterator(): Generator<E>;
}

export declare interface ISortable<V> {
    sort(cmp?: Comparator<V>): void;
}

export declare interface IStack<E> extends ICollection<E> {
    comparator: Comparator<E>;
    push(e: E): void;
    pop(): E;
    top(): E;
    contains(e: E): boolean;
}

export declare interface IVertex extends VertexProperties {
    hasPosition(): boolean;
    getAllEdges(): Set<IEdge>;
    getNeighbours(): Set<IVertex>;
    getReachableNeighbours(): Set<IVertex>;
    getEdgeTo(to: IVertex): IEdge | undefined;
    addIncomingEdge(incoming: IEdge): boolean;
    removeIncomingEdge(e: IEdge): boolean;
    addOutgoingEdge(outgoing: IEdge): boolean;
    removeOutgoingEdge(e: IEdge): boolean;
    deg(): number;
    indeg(): number;
    outdeg(): number;
}

export declare class LinkedList<E> implements ILinkedList<E> {
    first: Node_2<E>;
    last: Node_2<E>;
    size: number;
    comparator: Comparator<E>;
    constructor(elements?: Iterable<E>, reverse?: boolean);
    /**
     * O(1)
     * @param e
     */
    add(e: E): void;
    addAll(c: Iterable<E>): void;
    /**
     * O(1)
     * @param e
     */
    addFirst(e: E): void;
    /**
     * O(1)
     * @param e
     */
    addLast(e: E): void;
    /**
     * O(1)
     */
    clear(): void;
    /**
     * O(size)<br>
     * Ω(1)
     */
    get(index: number): E;
    /**
     * O(size)<br>
     * Ω(1)
     */
    set(index: number, e: E): boolean;
    slice(startIndex: number, endIndex: number): LinkedList<E>;
    slice2(startIndex: number, endIndex: number): LinkedList<E>;
    splice(startIndex: number, deleteCount: number): LinkedList<E>;
    map<V>(fn: (e: E) => V): LinkedList<V>;
    reduce<V>(fn: (accumulator: V, element: E) => V, initialValue?: V): V;
    filter(predicate: (e: E) => boolean): LinkedList<E>;
    every(predicate: (e: E) => boolean): boolean;
    some(predicate: (e: E) => boolean): boolean;
    /**
     * O(1)
     */
    getFirst(): E;
    /**
     * O(1)
     */
    getLast(): E;
    /**
     * O(1)
     */
    isEmpty(): boolean;
    /**
     * O(size)<br>
     * Ω(1)
     * @param index
     */
    remove(index: number): E;
    /**
     * O(1)
     */
    removeFirst(): E;
    /**
     * O(size)<br>
     * Ω(1)
     */
    removeLast(): E;
    /**
     * O(index + 1)<br>
     * Ω(1)
     * @param index
     */
    getNode(index: number): Node_2<E>;
    /**
     * For this method to work, a comparator must be set
     * @param e
     */
    includes(e: E): boolean;
    /**
     * For this method to work, a comparator must be set
     * @param l
     */
    equals(l: IList<E>): boolean;
    indexOf(e: E): number;
    sort(cmp?: Comparator<E>): void;
    /**
     * O(∑ i=1 to size (i))
     * Ω(1)
     */
    reverseIterator(): Generator<E, void, unknown>;
    /**
     * O(size)
     */
    [Symbol.iterator](): Iterator<E>;
}

export declare class LinkedQueue<E> implements IQueue<E> {
    private _head;
    private tail;
    size: number;
    comparator: Comparator<E>;
    constructor(elements?: Iterable<E>, comparator?: Comparator<E>);
    /**
     * O(1)
     * @param e
     */
    enqueue(e: E): void;
    add(e: E): void;
    /**
     * O(1)
     */
    dequeue(): E;
    /**
     * O(1)
     */
    isEmpty(): boolean;
    /**
     * O(1)
     */
    head(): E;
    /**
     * O(1)
     */
    clear(): void;
    /**
     * O(size)
     */
    [Symbol.iterator](): Iterator<E>;
    reverseIterator(): Generator<E>;
    sort(cmp?: Comparator<E>): void;
}

export declare class LinkedStack<E> implements IStack<E> {
    private _top;
    size: number;
    comparator: Comparator<E>;
    constructor(elements?: Iterable<E>);
    /**
     * O(1)
     * @param e
     */
    push(e: E): void;
    /**
     * O(1)
     */
    pop(): E;
    /**
     * O(1)
     */
    isEmpty(): boolean;
    /**
     * O(1)
     */
    top(): E;
    /**
     * O(1)
     */
    clear(): void;
    /**
     * To use this method, a comparator must be set
     * @param e
     */
    contains(e: E): boolean;
    /**
     * O(size)
     */
    [Symbol.iterator](): Iterator<E>;
    add(e: E): void;
    reverseIterator(): Generator<E>;
    sort(cmp?: Comparator<E>): void;
}

export declare class List<E> implements IList<E> {
    private arr;
    size: number;
    comparator: Comparator<E>;
    constructor(elements?: Iterable<E>);
    add(e: E): void;
    addAll(c: Iterable<E>): void;
    get(index: number): E;
    set(index: number, e: E): boolean;
    /**
     * A positive end index will result in slicing to the right, a negative end index in slicing to the left
     * @param startIndex
     * @param endIndex
     */
    slice(startIndex: number, endIndex: number): List<E>;
    /**
     * <p>With this variant of slice, the end index can be used as a direction value.</p>
     * <p>When the end index is negative, then it will be sliced to the left.</p>
     *
     * @param startIndex
     * @param endIndex
     */
    slice2(startIndex: number, endIndex: number): List<E>;
    /**
     * <p>A negative delete count will result in slicing to the left</p>
     * <p>A negative start count will be mapped to <code>this.size - startIndex</code></p>
     * <p>f.e. (size = 6) -1 -> 5, -2 -> 4, ...</p>
     * @param startIndex
     * @param deleteCount
     */
    splice(startIndex: number, deleteCount: number): List<E>;
    map<V>(fn: (e: E) => V): List<V>;
    reduce<V>(fn: (accumulator: V, element: E) => V, initialValue?: V): V;
    filter(predicate: (e: E) => boolean): List<E>;
    every(predicate: (e: E) => boolean): boolean;
    some(predicate: (e: E) => boolean): boolean;
    isEmpty(): boolean;
    clear(): void;
    remove(index: number): E;
    /**
     * For this method to work, a comparator must be set
     * @param e
     */
    includes(e: E): boolean;
    /**
     * For this method to work, a comparator must be set
     * @param l
     */
    equals(l: IList<E>): boolean;
    /**
     * Finds the first index of the element
     * @param e
     */
    indexOf(e: E): number;
    sort(cmp?: Comparator<E>): void;
    reverseIterator(): Generator<E, void, unknown>;
    [Symbol.iterator](): Iterator<E>;
}

declare type Node_2<E> = undefined | {
    value: E;
    prev?: Node_2<E>;
    next?: Node_2<E>;
};
export { Node_2 as Node }

export declare function numberComparatorASC(n1: number, n2: number): Ordering;

export declare function numberComparatorDESC(n1: number, n2: number): Ordering;

export declare enum Ordering {
    LT = -1,
    EQ = 0,
    GT = 1
}

export declare class Point {
    x: number;
    y: number;
    z: number;
    constructor(x?: number, y?: number, z?: number);
}

export declare class PriorityQueue<E> implements IQueue<E> {
    size: number;
    comparator: Comparator<E>;
    heap: FibonacciHeap<E>;
    constructor(comparator: Comparator<E>, elements?: Iterable<E>);
    enqueue(e: E): void;
    dequeue(): E;
    head(): E;
    add(e: E): void;
    isEmpty(): boolean;
    clear(): void;
    [Symbol.iterator](): Iterator<E>;
    reverseIterator(): Generator<E>;
    sort(cmp?: Comparator<E>): void;
}

export declare class Queue<E> implements IQueue<E> {
    private arr;
    size: number;
    comparator: Comparator<E>;
    constructor(elements?: Iterable<E>, comparator?: Comparator<E>);
    clear(): void;
    dequeue(): E;
    enqueue(e: E): void;
    add(e: E): void;
    isEmpty(): boolean;
    head(): E;
    [Symbol.iterator](): Iterator<E>;
    reverseIterator(): Generator<E>;
    sort(cmp?: Comparator<E>): void;
}

export declare function quicksort<V>(collection: ICollection<V>, comparator: Comparator<V>, factory: () => ICollection<V>): ICollection<V>;

export declare type SPPair<V extends IVertex> = {
    /**
     * Map of all Predecessors
     */
    p: Map<V, V>;
    /**
     * Map of path costs to Vertex
     */
    k: Map<V, number>;
};

export declare class Stack<E> implements IStack<E> {
    private arr;
    size: number;
    comparator: Comparator<E>;
    constructor(elements?: Iterable<E>);
    clear(): void;
    isEmpty(): boolean;
    top(): E;
    pop(): E;
    push(e: E): void;
    /**
     * To use this method, a comparator must be set
     * @param e
     */
    contains(e: E): boolean;
    [Symbol.iterator](): Iterator<E>;
    add(e: E): void;
    reverseIterator(): Generator<E>;
    sort(cmp?: Comparator<E>): void;
}

export declare function stringComparator(s1: string, s2: string): Ordering;

export declare class Vertex implements IVertex {
    title: string;
    uuid: string;
    outgoingEdges: Set<IEdge>;
    incomingEdges: Set<IEdge>;
    point: Point;
    object: object;
    constructor(options?: VertexProperties);
    hasPosition(): boolean;
    getAllEdges(): Set<IEdge>;
    getNeighbours(): Set<IVertex>;
    getReachableNeighbours(): Set<IVertex>;
    getEdgeTo(to: IVertex): IEdge | undefined;
    addIncomingEdge(incoming: IEdge): boolean;
    removeIncomingEdge(e: IEdge): boolean;
    addOutgoingEdge(outgoing: IEdge): boolean;
    removeOutgoingEdge(e: IEdge): boolean;
    deg(): number;
    indeg(): number;
    outdeg(): number;
}

export declare type VertexProperties = {
    uuid?: string;
    title?: string;
    outgoingEdges?: Set<IEdge>;
    incomingEdges?: Set<IEdge>;
    point?: Point;
    object?: any;
};

export declare type VerticesPair<V extends IVertex> = [from: V, to: V];

export { }