import { Equals } from "@tsplus/stdlib/structure/Equals";
import { Ord } from "@tsplus/stdlib/prelude/Ord/definition";
import { Collection } from "@tsplus/stdlib/collections/Collection/definition";
import { Maybe } from "@tsplus/stdlib/data/Maybe/definition";
import type { Node } from "@tsplus/stdlib/collections/RedBlackTree/node";
export declare const RedBlackTreeSym: unique symbol;
export type RedBlackTreeSym = typeof RedBlackTreeSym;
export declare const _K: unique symbol;
export type _K = typeof _K;
export declare const _V: unique symbol;
export type _V = typeof _V;
export type Direction = "Forward" | "Backward";
/**
 * A Red-Black Tree.
 *
 * @tsplus type RedBlackTree
 */
export interface RedBlackTree<K, V> extends RedBlackTreeIterable<K, V>, Equals {
    readonly [RedBlackTreeSym]: RedBlackTreeSym;
    readonly [_K]: () => K;
    readonly [_V]: () => V;
    readonly ord: Ord<K>;
    readonly root: Node<K, V> | undefined;
    [Symbol.iterator](): RedBlackTreeIterator<K, V>;
}
/**
 * @tsplus type RedBlackTree.Ops
 */
export interface RedBlackTreeOps {
    $: RedBlackTreeAspects;
}
export declare const RedBlackTree: RedBlackTreeOps;
/**
 * @tsplus type RedBlackTree.Aspects
 */
export interface RedBlackTreeAspects {
}
export interface RedBlackTreeIterable<K, V> extends Collection<readonly [K, V]> {
    readonly ord: Ord<K>;
    [Symbol.iterator](): RedBlackTreeIterator<K, V>;
}
export declare class RedBlackTreeIterator<K, V> implements Iterator<readonly [K, V]> {
    readonly self: RedBlackTree<K, V>;
    readonly stack: Node<K, V>[];
    readonly direction: Direction;
    private count;
    constructor(self: RedBlackTree<K, V>, stack: Node<K, V>[], direction: Direction);
    /**
     * Clones the iterator
     */
    clone(): RedBlackTreeIterator<K, V>;
    /**
     * Reverse the traversal direction
     */
    reversed(): RedBlackTreeIterator<K, V>;
    /**
     * Iterator next
     */
    next(): IteratorResult<readonly [K, V]>;
    /**
     * Returns the key
     */
    get key(): Maybe<K>;
    /**
     * Returns the value
     */
    get value(): Maybe<V>;
    /**
     * Returns the key
     */
    get entry(): Maybe<readonly [K, V]>;
    /**
     * Returns the position of this iterator in the sorted list
     */
    get index(): number;
    /**
     * Advances iterator to next element in list
     */
    moveNext(): void;
    /**
     * Checks if there is a next element
     */
    get hasNext(): boolean;
    /**
     * Advances iterator to previous element in list
     */
    movePrev(): void;
    /**
     * Checks if there is a previous element
     */
    get hasPrev(): boolean;
}
//# sourceMappingURL=definition.d.ts.map