/** @import {ParametersNNDescent} from "./index.js" */
/**
 *
 * @template {number[] | Float64Array} T
 * @typedef {Object} NNDescentElement
 * @property {T} value
 * @property {number} index
 * @property {boolean} flag
 */
/**
 * @template {number[] | Float64Array} T
 * @typedef {Object} NNDescentNeighbor
 * @property {T} value
 * @property {number} index
 * @property {number} distance
 * @property {boolean} [flag]
 */
/**
 * NN-Descent
 *
 * An efficient graph-based approximate nearest neighbor search algorithm.
 * It works by iteratively improving a neighbor graph using the fact that
 * "neighbors of neighbors are likely to be neighbors".
 *
 * @class
 * @category KNN
 * @template {number[] | Float64Array} T
 * @extends KNN<T, ParametersNNDescent>
 * @see {@link http://www.cs.princeton.edu/cass/papers/www11.pdf|NN-Descent Paper}
 */
export class NNDescent<T extends number[] | Float64Array> extends KNN<T, ParametersNNDescent> {
  /**
   * @param {T[]} elements - Called V in paper.
   * @param {Partial<ParametersNNDescent>} parameters
   * @see {@link http://www.cs.princeton.edu/cass/papers/www11.pdf}
   */
  constructor(elements: T[], parameters?: Partial<ParametersNNDescent>);
  /**
   * @private
   * @type {KNNHeap<T>[]}
   */
  private _B;
  /**
   * @private
   * @type {NNDescentNeighbor<T>[][]}
   */
  private nn;
  _N: number;
  _randomizer: Randomizer;
  _sample_size: number;
  _nndescent_elements: {
    value: T;
    index: number;
    flag: boolean;
  }[];
  /**
   * Samples Array A with sample size.
   *
   * @private
   * @template U
   * @param {U[]} A
   * @returns {U[]}
   */
  private _sample;
  /**
   * @private
   * @param {KNNHeap<T>} B
   * @param {NNDescentNeighbor<T>} u
   * @returns {number}
   */
  private _update;
  /**
   * @private
   * @param {(KNNHeap<T> | null)[]} B
   * @returns {NNDescentNeighbor<T>[][]}
   */
  private _reverse;
  /**
   * @param {T[]} elements
   * @returns {this}
   */
  add(elements: T[]): this;
  /**
   * @param {T} x
   * @param {number} [k=5] Default is `5`
   * @returns {{ element: T, index: number; distance: number }[]}
   */
  search(
    x: T,
    k?: number,
  ): {
    element: T;
    index: number;
    distance: number;
  }[];
  /**
   * @param {number} i
   * @param {number} [k=5] Default is `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 NNDescentElement<T extends number[] | Float64Array> = {
  value: T;
  index: number;
  flag: boolean;
};
export type NNDescentNeighbor<T extends number[] | Float64Array> = {
  value: T;
  index: number;
  distance: number;
  flag?: boolean | undefined;
};
export type HeapEntry<U extends number[] | Float64Array> = {
  element: NNDescentNeighbor<U>;
  value: number;
};
import type { ParametersNNDescent } from "./index.js";
import { KNN } from "./KNN.js";
import { Randomizer } from "../util/index.js";
//# sourceMappingURL=NNDescent.d.ts.map