/**
 * Numbered levels of a Merkle tree.
 */
type MerkleLevels<TNode> = Record<number, Record<string, TNode>>;
/**
 * A function type used to merge two nodes of a Merkle tree.
 *
 * @param left The left node to be merged.
 * @param right The right node to be merged.
 *
 * @returns The merged node.
 */
export type MergeFn<TNode> = (left: TNode, right: TNode) => TNode;
/**
 * Represents a read-only Merkle tree.
 */
export interface IMerkleTree<TNode> {
    get(index: bigint | number): TNode | undefined;
    readonly root: TNode;
    readonly height: number;
    witness(index: number | bigint): MerkleTreeWitness<TNode>;
}
/**
 * Represents an element of a Merkle tree witness.
 */
export type WitnessElement<TNode> = {
    isLeft: boolean;
    sibling: TNode;
};
/**
 * Represents a Merkle Tree witness.
 * Witness is an array of witness elements.
 * @see {WitnessElement}
 */
export type MerkleTreeWitness<TNode> = ReadonlyArray<WitnessElement<TNode>>;
/**
 * Represents a mutable Merkle tree data structure.
 */
export declare class MerkleTree<TNode> implements IMerkleTree<TNode> {
    readonly height: number;
    private readonly zeroes;
    private readonly mergeFn;
    private readonly nodes;
    constructor(height: number, zeroes: Zeroes<TNode>, mergeFn: MergeFn<TNode>, nodes?: MerkleLevels<TNode>);
    /**
     * Retrieves a leaf node at `index`.
     */
    get(index: number | bigint): TNode | undefined;
    /**
     * Retrieves the root node of the Merkle tree.
     */
    get root(): TNode;
    /**
     * Sets the value of a leaf node at a given index to a given value.
     * @param index Position of the leaf node.
     * @param  leaf New value.
     * @throws {RangeError} If the index is out of range for the maximum number of leaves.
     */
    set(index: bigint | number, leaf: TNode): this;
    /**
     * Generate a Merkle witness for a given leaf index.
     *
     * @param index The index of the leaf node in the Merkle tree.
     * @returns The witness for the given index.
     * @throws {RangeError} If the index is out of range for the number of leaves.
     */
    witness(index: number | bigint): MerkleTreeWitness<TNode>;
    /**
     * Set the value of a node at the specified level and index.
     *
     * @param level - The level of the node.
     * @param index - The index of the node.
     * @param value - The value to set for the node.
     * @internal
     */
    setNode(level: number, index: bigint | number, value: TNode): void;
    /**
     * Get the node at the specified level and index.
     *
     * @param level - The level of the node.
     * @param index - The index of the node.
     */
    getNode(level: number, index: bigint | number): TNode;
    /**
     * The maximum number of leafs available, calculated based on the height
     */
    get size(): bigint;
    /**
     * Validates whether the given index is within range.
     * @param index - The index to be validated.
     * @throws {RangeError} If the index is out of range.
     */
    private validateIndexRange;
}
/**
 * Represents a class that caches zero values at different levels of a Merkle tree.
 * @internal
 */
export declare class Zeroes<TNode> {
    private readonly mergeFn;
    private readonly zeroes;
    /**
     * @param zero - The initial value of "zero" in a Merkle tree.
     * @param mergeFn - The function responsible for merging two values of type TNode.
     */
    constructor(zero: TNode, mergeFn: MergeFn<TNode>);
    /**
     * Retrieves a zero hash (=hash^level) at the specified level.
     *
     * @param level - The level at which to retrieve the node.
     * @return - zero hash at the level.
     */
    at(level: number): TNode;
}
/**
 * A factory class for creating Merkle Trees.
 */
export declare class MerkleTreeFactory<TNode> {
    private readonly zeroes;
    private readonly mergeFn;
    /**
     * Constructor for creating an instance of the class.
     *
     * @param zero - The zero value for the instance.
     * @param mergeFn - The merge function for the instance.
     */
    constructor(zero: TNode, mergeFn: MergeFn<TNode>);
    /**
     * Builds a Merkle tree from the given array of leaves.
     *
     * @param leaves - The array of leaves to build the tree from.
     * @returns The resulting Merkle tree.
     */
    build(leaves: ReadonlyArray<TNode>): IMerkleTree<TNode>;
    /**
     * Calculates the height of a Merkle tree based on the number of leaves.
     *
     * @param leavesCount - The total count of leaves in the binary tree.
     * @return The height of the binary tree.
     */
    height(leavesCount: number): number;
}
export {};