/**
 * Length of a blake3 route key in bytes.
 *
 * blake3's default output is 32 bytes (256 bits). This is the only
 * length this module supports.
 */
export declare const ROUTE_KEY_BYTES = 32;
/**
 * Total bits available for nibble extraction from a route key.
 */
export declare const ROUTE_KEY_BITS: number;
/**
 * Supported nibble widths in bits.
 *
 * The trie geometry parameterizes branching factor via nibble width.
 * 4 bits gives 16-way branching, 6 bits gives 64-way branching, and
 * 8 bits gives 256-way branching. Non-byte-aligned widths may
 * straddle byte boundaries; extraction reads individual bits
 * MSB-first so every supported width has the same semantics.
 */
export type NibbleBits = 1 | 2 | 4 | 6 | 8;
/**
 * Binary route key derived from an element ID via blake3.
 *
 * A route key is a deterministic 32-byte hash of an element identifier
 * (e.g., a node ID or edge key). Nibbles extracted from the key at
 * increasing depth provide a uniformly distributed path for trie
 * navigation, regardless of the original ID's distribution.
 *
 * Route keys are frozen at construction. Their bytes must not be
 * mutated by callers.
 */
export default class RouteKey {
    readonly bytes: Uint8Array;
    /**
     * Wrap an existing 32-byte array as a RouteKey.
     *
     * The byte array is cloned to prevent external mutation. If the
     * array length does not match ROUTE_KEY_BYTES, throws RouteKeyError.
     */
    constructor(bytes: Uint8Array);
    /**
     * Derive a route key from a non-empty element ID.
     *
     * The element ID is UTF-8 encoded and hashed with blake3. Different
     * elements produce near-uniformly distributed route keys, so trie
     * paths based on these keys are balanced in expectation regardless
     * of element ID distribution.
     */
    static fromElement(element: string): RouteKey;
    /**
     * Extract the nibble at the given zero-based depth.
     *
     * A nibble is the next `nibbleBits`-bit slice of the route key, read
     * from the most-significant bit at depth 0. The extracted value is
     * a non-negative integer in the range [0, 2^nibbleBits).
     *
     * Depth must be within the bounds determined by `nibbleBits`:
     *   0 <= depth < ROUTE_KEY_BITS / nibbleBits
     *
     * Out-of-range depth or unsupported nibbleBits throws RouteKeyError.
     */
    nibbleAt(depth: number, nibbleBits: NibbleBits): number;
    /**
     * Return the route key as a lowercase hex string.
     *
     * Useful for logging and test assertions. Not for storage — storage
     * uses the raw bytes.
     */
    toHex(): string;
}
