/**
 * Returned by {@link Uint32Map#get} when the key is absent. Chosen so that any uint32 (0 .. UINT32_MAX) is
 * unambiguously a valid value. As a JS Number this is a Smi on all V8 builds, so the return doesn't allocate.
 * @type {number}
 */
export const UINT32_MAP_ABSENT: number;
/**
 * Non-allocating Map&lt;uint32, uint32&gt; backed by a single Uint32Array.
 *
 * Layout: one slot occupies two consecutive words — `data[2*slot] = key + 1`, `data[2*slot + 1] = value`.
 * Keys are stored offset by +1 so that 0 is unambiguously "empty slot"; this also keeps every stored value
 * inside the V8 Smi range (under pointer compression, Smi is 31-bit signed = max 2^30 − 1), which means
 * reading any non-empty slot does not allocate a HeapNumber. Without the shift, a sentinel of 0xFFFFFFFF
 * would box on every read of an empty slot — the exact opposite of what we want.
 *
 * Collision resolution: Robin Hood linear probing with backward-shift deletion (Knuth Algorithm R). Hash
 * is Fibonacci multiplicative (see Skarupke 2018, "Fibonacci Hashing"), indexing from the high bits of
 * the product. Table capacity is always a power of two; index is computed by right-shift, not by mask of
 * the low bits — the high bits of a multiplicative hash have more entropy.
 *
 * Allowed key range: 0 .. UINT32_MAX - 1 (because we store key + 1). Allowed value range: full uint32.
 * Values are returned via {@link UINT32_MAP_ABSENT} when not found — callers check `=== -1` rather than
 * `=== undefined`, which is the Map API but is allocation-incompatible with typed-array storage.
 */
export class Uint32Map {
    /**
     *
     * @param {number} [initial_capacity] minimum number of slots to reserve. Rounded up to next power of two.
     */
    constructor(initial_capacity?: number);
    /**
     * @type {number}
     * @private
     */
    private __capacity;
    /**
     * @type {number}
     * @private
     */
    private __mask;
    /**
     * Right-shift amount that extracts log2(cap) high bits from a 32-bit hash.
     * @type {number}
     * @private
     */
    private __shift;
    /**
     * @type {number}
     * @private
     */
    private __grow_threshold;
    /**
     * @type {number}
     * @private
     */
    private __size;
    /**
     * Packed (key+1, value) pairs. Length is 2 * capacity. Zero-initialized so every slot starts empty.
     * @type {Uint32Array}
     * @private
     */
    private __data;
    /**
     *
     * @returns {number}
     */
    get size(): number;
    /**
     *
     * @returns {number}
     */
    get capacity(): number;
    /**
     *
     * @param {number} id
     * @returns {number} value associated with `id`, or {@link UINT32_MAP_ABSENT} (-1) if not present.
     */
    get(id: number): number;
    /**
     *
     * @param {number} id
     * @returns {boolean}
     */
    has(id: number): boolean;
    /**
     *
     * @param {number} id
     * @param {number} value
     */
    set(id: number, value: number): void;
    /**
     * Insert a (already key+1 shifted) entry assuming there is at least one empty slot. Performs Robin Hood
     * swapping: when the new entry has been displaced further than the current occupant, swap them and
     * continue placing the displaced occupant.
     *
     * @private
     * @param {number} key_shifted
     * @param {number} value
     */
    private __insert_no_grow;
    /**
     *
     * @param {number} id
     * @returns {boolean} true if the entry existed and was removed.
     */
    delete(id: number): boolean;
    /**
     * Remove all entries. Capacity is unchanged.
     */
    clear(): void;
    /**
     * Grow the table and rehash every entry.
     *
     * @private
     * @param {number} new_capacity power of two
     */
    private __resize;
}
//# sourceMappingURL=Uint32Map.d.ts.map