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 { }