/** @import { Metric } from "../metrics/index.js" */
/** @import { ParametersAnnoy } from "./index.js" */
/**
 * @template {number[] | Float64Array} T
 * @typedef {Object} AnnoyNode
 * @property {boolean} isLeaf - Whether this is a leaf node
 * @property {number[]} indices - Indices of points in this node (leaf) or children (internal)
 * @property {number[]} normal - Hyperplane normal vector (internal nodes only)
 * @property {number} offset - Hyperplane offset (internal nodes only)
 * @property {AnnoyNode<T> | null} left - Left child (internal nodes only)
 * @property {AnnoyNode<T> | null} right - Right child (internal nodes only)
 */
/**
 * Annoy-style (Approximate Nearest Neighbors Oh Yeah) implementation using Random Projection Trees.
 *
 * This implementation builds multiple random projection trees where each tree randomly selects
 * two points and splits the space based on a hyperplane equidistant between them.
 *
 * Key features:
 * - Multiple random projection trees for better recall
 * - Each tree uses random hyperplanes for splitting
 * - Priority queue search for better recall
 * - Combines results from all trees
 *
 * Best suited for:
 * - High-dimensional data
 * - Approximate nearest neighbor search
 * - Large datasets
 * - When high recall is needed with approximate methods
 *
 * @class
 * @category KNN
 * @template {number[] | Float64Array} T
 * @extends KNN<T, ParametersAnnoy>
 * @see {@link https://github.com/spotify/annoy}
 * @see {@link https://erikbern.com/2015/09/24/nearest-neighbors-and-vector-models-epilogue-curse-of-dimensionality.html}
 */
export class Annoy<T extends number[] | Float64Array> extends KNN<T, ParametersAnnoy> {
  /**
   * Creates a new Annoy-style index with random projection trees.
   *
   * @param {T[]} elements - Elements to index
   * @param {ParametersAnnoy} [parameters={}] - Configuration parameters
   */
  constructor(elements: T[], parameters?: ParametersAnnoy);
  _metric: Metric;
  _numTrees: number;
  _maxPointsPerLeaf: number;
  _seed: number;
  _randomizer: Randomizer;
  /**
   * @private
   * @type {AnnoyNode<T>[]}
   */
  private _trees;
  /**
   * Get the number of trees in the index.
   * @returns {number}
   */
  get num_trees(): number;
  /**
   * Get the total number of nodes in all trees.
   * @returns {number}
   */
  get num_nodes(): number;
  /**
   * @private
   * @param {any} node
   * @returns {number}
   */
  private _countNodes;
  /**
   * Add elements to the Annoy index.
   * @param {T[]} elements
   * @returns {this}
   */
  add(elements: T[]): this;
  /**
   * Build all random projection trees.
   * @private
   */
  private _buildTrees;
  /**
   * Recursively build a random projection tree.
   * @private
   * @param {number[]} indices - Indices of elements to include
   * @returns {AnnoyNode<T>}
   */
  private _buildTreeRecursive;
  /**
   * Compute distance from point to hyperplane.
   * @private
   * @param {T} point
   * @param {number[]} normal
   * @param {number} offset
   * @returns {number} Signed distance (positive = right side, negative = left side)
   */
  private _distanceToHyperplane;
  /**
   * Search for k approximate nearest neighbors.
   * @param {T} query
   * @param {number} [k=5]
   * @returns {{ element: T; index: number; distance: number }[]}
   */
  search(
    query: T,
    k?: number,
  ): {
    element: T;
    index: number;
    distance: number;
  }[];
  /**
   * Search tree using priority queue for better recall.
   * Explores nodes in order of distance to hyperplane.
   * @private
   * @param {AnnoyNode<T>} node
   * @param {T} query
   * @param {Set<number>} candidates
   * @param {number} maxCandidates
   */
  private _searchTreePriority;
  /**
   * @param {number} i
   * @param {number} [k=5]
   * @returns {{ element: T; index: number; distance: number }[]}
   */
  search_by_index(
    i: number,
    k?: number,
  ): {
    element: T;
    index: number;
    distance: number;
  }[];
  /**
   * Alias for search_by_index for backward compatibility.
   *
   * @param {number} i - Index of the query element
   * @param {number} [k=5] - Number of nearest neighbors to return
   * @returns {{ element: T; index: number; distance: number }[]}
   */
  search_index(
    i: number,
    k?: number,
  ): {
    element: T;
    index: number;
    distance: number;
  }[];
}
export type AnnoyNode<T extends number[] | Float64Array> = {
  /**
   * - Whether this is a leaf node
   */
  isLeaf: boolean;
  /**
   * - Indices of points in this node (leaf) or children (internal)
   */
  indices: number[];
  /**
   * - Hyperplane normal vector (internal nodes only)
   */
  normal: number[];
  /**
   * - Hyperplane offset (internal nodes only)
   */
  offset: number;
  /**
   * - Left child (internal nodes only)
   */
  left: AnnoyNode<T> | null;
  /**
   * - Right child (internal nodes only)
   */
  right: AnnoyNode<T> | null;
};
import type { ParametersAnnoy } from "./index.js";
import { KNN } from "./KNN.js";
import type { Metric } from "../metrics/index.js";
import { Randomizer } from "../util/index.js";
//# sourceMappingURL=Annoy.d.ts.map