/**
 * Binary Indexed Tree (Fenwick Tree).
 *
 * Efficient prefix sums and point updates in O(log n).
 * Standard array-based implementation per C++ competitive programming conventions.
 *
 * All indices are 0-based externally; internally converted to 1-based for BIT arithmetic.
 *
 * @example
 * ```ts
 * const bit = new BinaryIndexedTree(6);
 * bit.update(0, 3);   // index 0 += 3
 * bit.update(1, 2);   // index 1 += 2
 * bit.update(2, 7);   // index 2 += 7
 *
 * bit.query(2);       // prefix sum [0..2] = 12
 * bit.queryRange(1, 2); // range sum [1..2] = 9
 * bit.get(1);         // point value at index 1 = 2
 * ```
 */
export declare class BinaryIndexedTree implements Iterable<number> {
    protected readonly _size: number;
    protected _tree: number[];
    /**
     * Construct a BIT of given size (all zeros), or from an initial values array.
     * @param sizeOrElements - number of elements, or an array of initial values
     */
    constructor(sizeOrElements: number | number[]);
    /**
     * Point update: add delta to the value at index (0-based).
     * Time: O(log n)
    
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
      * @example
   * // Add delta at index
   *  const bit = new BinaryIndexedTree([1, 2, 3, 4, 5]);
   *     bit.update(2, 7);
   *     console.log(bit.get(2)); // 10;
     */
    update(index: number, delta: number): void;
    /**
     * Point set: set the value at index to an absolute value (0-based).
     * Time: O(log n)
     
    
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
      * @example
   * // Set value at index
   *  const bit = new BinaryIndexedTree([1, 2, 3]);
   *     bit.set(1, 10);
   *     console.log(bit.get(1)); // 10;
     */
    set(index: number, value: number): void;
    /**
     * Get the point value at index (0-based).
     * Time: O(log n)
    
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
      * @example
   * // Get value at index
   *  const bit = new BinaryIndexedTree([1, 2, 3]);
   *     console.log(bit.get(0)); // 1;
   *     console.log(bit.get(2)); // 3;
     */
    get(index: number): number;
    /**
     * Prefix sum query: returns sum of elements [0..index] (inclusive, 0-based).
     * Time: O(log n)
     
    
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
      * @example
   * // Prefix sum
   *  const bit = new BinaryIndexedTree([1, 2, 3, 4]);
   *     console.log(bit.query(2)); // 6;
     */
    query(index: number): number;
    /**
     * Range sum query: returns sum of elements [start..end] (inclusive, 0-based).
     * Time: O(log n)
    
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
      * @example
   * // Range sum
   *  const bit = new BinaryIndexedTree([1, 2, 3, 4]);
   *     console.log(bit.queryRange(1, 2)); // 5;
     */
    queryRange(start: number, end: number): number;
    /**
     * Find the smallest index i such that prefix sum [0..i] >= sum.
     * Requires all values to be non-negative (behavior undefined otherwise).
     * Returns size if no such index exists.
     * Time: O(log n)
     
    
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
      * @example
   * // Find index with prefix sum ≥ target
   *  const bit = new BinaryIndexedTree([1, 2, 3, 4]);
   *     const idx = bit.lowerBound(4);
   *     console.log(idx); // >= 0;
     */
    lowerBound(sum: number): number;
    /**
     * Find the smallest index i such that prefix sum [0..i] > sum.
     * Requires all values to be non-negative (behavior undefined otherwise).
     * Returns size if no such index exists.
     * Time: O(log n)
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
      * @example
   * // Find index with prefix sum > target
   *  const bit = new BinaryIndexedTree([1, 2, 3, 4]);
   *     const idx = bit.upperBound(4);
   *     console.log(idx); // >= 0;
     */
    upperBound(sum: number): number;
    get size(): number;
    isEmpty(): boolean;
    clear(): void;
    clone(): BinaryIndexedTree;
    /**
     * Returns the point values as a plain array.
     * Time: O(n log n)
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
      * @example
   * // Convert to array
   *  const bit = new BinaryIndexedTree([1, 2, 3]);
   *     console.log(bit.toArray()); // [1, 2, 3];
     */
    toArray(): number[];
    /**
     * Iterate over point values in index order.
     */
    [Symbol.iterator](): IterableIterator<number>;
    forEach(callback: (value: number, index: number) => void): void;
    print(): void;
    /** 1-based prefix sum up to pos (inclusive). */
    protected _prefixSum(pos: number): number;
    /** 1-based point update: add delta to position pos. */
    protected _pointUpdate(pos: number, delta: number): void;
    /** 1-based point query: get exact value at pos. */
    protected _pointQuery(pos: number): number;
    protected _checkIndex(index: number): void;
    /** Returns highest power of 2 <= n. */
    protected _highBit(n: number): number;
}