/**
 * Search worker entry point for parallel query processing.
 * Each worker maintains independent search state (visited array, heaps)
 * and operates on shared read-only vector data (SharedArrayBuffer when available).
 * Graph structure is shared via SAB when available, eliminating per-worker duplication.
 */
export interface WorkerInitData {
    flatVectors: Float32Array;
    flatInt8Vectors: Int8Array | null;
    dimension: number;
    nodeCount: number;
    metric: 'cosine' | 'euclidean' | 'dot_product';
    entryPointId: number;
    maxLevel: number;
    M: number;
    M0: number;
    nodeLevels: Uint8Array;
    quantizationEnabled: boolean;
    quantizationParams: {
        min: Float32Array;
        max: Float32Array;
        scale: Float32Array;
        offset: Float32Array;
    } | null;
    graphData?: ArrayBuffer;
    graphNeighborData?: Uint32Array;
    graphIndex?: Uint32Array;
    maxLayerSlots?: number;
    sharedMetadata?: Uint32Array;
    /** Generation for copied graph payloads without shared metadata. */
    graphGeneration?: number;
}
/**
 * Independent search state for a single worker.
 * Mirrors the essential search logic from HNSWIndex without mutation.
 * Uses batch distance calculation for improved cache locality.
 *
 * Graph structure is stored in flat typed arrays (graphIndex + graphNeighborData)
 * for fast indexed access. When backed by SharedArrayBuffer, all workers share
 * the same graph memory with zero copying; savings depend on graph size and
 * worker count and are measured by the benchmark harness.
 */
export declare class WorkerSearchState {
    private flatVectors;
    private flatInt8Vectors;
    private dimension;
    private nodeCount;
    private metric;
    private entryPointId;
    private maxLevel;
    private M;
    private M0;
    private graphNeighborData;
    private graphIndex;
    private maxLayerSlots;
    private sharedMetadata;
    private graphGeneration;
    private visitedArray;
    private visitedGeneration;
    private candidatesHeap;
    private resultsHeap;
    private queryNormBuffer;
    private vectorsAreNormalized;
    private batchNeighborIds;
    private batchDistances;
    private quantizationEnabled;
    private quantizationScale;
    private quantizationOffset;
    private queryInt8Buffer;
    private distanceFn;
    private isBetterResult;
    constructor(init: WorkerInitData);
    getDimension(): number;
    private readSharedMetadata;
    private currentGraphGeneration;
    private assertGraphGeneration;
    private validateQueryVector;
    private validateSearchParams;
    private validateCandidateMultiplier;
    /**
     * Deserialize legacy graph ArrayBuffer into flat typed arrays.
     * Produces the same layout as the shared SAB graph format.
     */
    private deserializeGraphToFlat;
    private getVector;
    private clearVisited;
    private isVisited;
    private markVisited;
    /**
     * Get neighbor count for a node at a given layer.
     * Uses flat graphIndex for O(1) lookup.
     */
    private getNeighborCount;
    /**
     * Get neighbor data offset for a node at a given layer.
     */
    private getNeighborOffset;
    /**
     * Batch distance calculation with inlined 8-wide unrolled loop.
     * Uses pre-allocated Uint32Array/Float64Array buffers.
     */
    private calculateDistancesBatch;
    /**
     * Batch int8 distance calculation with inlined 8-wide unrolled loop.
     */
    private calculateDistancesBatchInt8;
    /**
     * Quantize a query vector to int8 using stored params.
     */
    private quantizeQuery;
    searchKNN(query: Float32Array, k: number, efSearch?: number): Array<{
        id: number;
        distance: number;
    }>;
    /**
     * Quantized search: int8 candidate scan -> float32 rescore.
     */
    searchKNNQuantized(query: Float32Array, k: number, candidateMultiplier?: number, efSearch?: number): Array<{
        id: number;
        distance: number;
    }>;
    /**
     * Layer 0 float32 search with batch distance calculation.
     * Uses flat graphIndex for O(1) neighbor lookup (no JS object dereference chain).
     */
    private searchLayer0;
    /**
     * Layer 0 int8 search with batch distance calculation.
     */
    private searchLayer0Int8;
    /**
     * Apply incremental graph updates from the main thread.
     * When using shared graph SABs, this is a no-op since workers
     * read neighbor data directly from shared memory.
     */
    applyGraphUpdate(newNodes: Array<{
        id: number;
        neighbors: number[][];
    }>, graphGeneration?: number): void;
    /**
     * Update entry point, max level, and optionally node count.
     */
    updateEntryPoint(entryPointId: number, maxLevel: number, nodeCount?: number, graphGeneration?: number): void;
}
//# sourceMappingURL=SearchWorker.d.ts.map