import type { LoggerInterface } from '@qvac/logging';
import type { Corestore, Hypercore, HyperDBInstance, HyperDBReader, HyperDBTransaction } from './db-types.js';
import { type LRUCache } from '../../utils/helper.js';
import type { EmbeddedDoc, HyperDBAdapterConfig, SaveEmbeddingsOpts, SaveEmbeddingsResult } from '../../types.js';
export declare const UPSERT_MUTATION_OPERATION = "upsert";
export declare const DELETE_MUTATION_OPERATION = "delete";
export type WorkspaceMutationOperation = typeof UPSERT_MUTATION_OPERATION | typeof DELETE_MUTATION_OPERATION;
export interface HyperDBStorageInput {
    store?: object;
    db?: HyperDBInstance;
    dbName?: string;
    BATCH_SIZE?: number;
    PROGRESS_INTERVAL?: number;
    CACHE_SIZE?: number;
    documentsTable?: string;
    vectorsTable?: string;
    configTable?: string;
    workspaceStateTable?: string;
    mutationsTable?: string;
    logger?: LoggerInterface;
}
export type StoredAdapterConfig = Pick<HyperDBAdapterConfig, 'NUM_CENTROIDS' | 'BUCKET_SIZE' | 'BATCH_SIZE'>;
export interface PreparedDocument {
    id: string;
    vector: number[];
    content: string;
    contentHash: string;
    metadata: Record<string, any>;
    embeddingModelId: string;
    dimension: number;
}
export interface VectorRecord {
    docId: string;
    vector: number[];
}
export interface DocumentRecord {
    id: string;
    content: string;
}
export interface WorkspaceStateRecord {
    key: string;
    revision: number;
    updatedAt: Date;
}
export interface MutationRecord {
    revision: number;
    operation: WorkspaceMutationOperation;
    documentIds: string[];
    createdAt: Date;
}
export interface SavePipelineHooks<TDoc extends PreparedDocument, TWrite> {
    prepare?(doc: EmbeddedDoc, contentHash: string): TDoc;
    write(tx: HyperDBTransaction, docs: TDoc[], now: Date): Promise<TWrite>;
    beforeFlush?(): void | Promise<void>;
    committed?(docs: TDoc[], writeResult: TWrite, revision: number): void | Promise<void>;
}
export interface DeletePipelineHooks<TWrite> {
    write?(tx: HyperDBTransaction, ids: string[], now: Date): Promise<TWrite>;
    beforeFlush?(): void | Promise<void>;
    committed?(ids: string[], writeResult: TWrite, revision: number): void | Promise<void>;
}
export declare class HyperDBStorage {
    store: Corestore | null;
    db: HyperDBInstance | null;
    readonly dbName: string;
    readonly BATCH_SIZE: number;
    readonly PROGRESS_INTERVAL: number;
    readonly CACHE_SIZE: number;
    readonly documentsTable: string;
    readonly vectorsTable: string;
    readonly configTable: string;
    readonly workspaceStateTable: string;
    readonly mutationsTable: string;
    readonly logger: LoggerInterface;
    readonly documentCache: LRUCache<string, string>;
    readonly vectorCache: LRUCache<string, number[]>;
    hypercore: Hypercore | null;
    private workspaceKey;
    constructor(config?: HyperDBStorageInput);
    open(): Promise<void>;
    close(): Promise<void>;
    withSnapshot<T>(operation: (snapshot: HyperDBReader) => Promise<T>): Promise<T>;
    getConfig(): Promise<HyperDBAdapterConfig | null>;
    readConfig(snapshot: HyperDBReader): Promise<HyperDBAdapterConfig | null>;
    ensureConfig(embeddingModelId: string, dimension: number, adapterConfig: StoredAdapterConfig): Promise<void>;
    validateEmbeddingBatch(embeddedDocs: EmbeddedDoc[]): {
        embeddingModelId: string;
        dimension: number;
    } | null;
    prepareDocument(doc: EmbeddedDoc, contentHash: string): PreparedDocument;
    saveEmbeddings<TDoc extends PreparedDocument, TWrite>(embeddedDocs: EmbeddedDoc[], opts: SaveEmbeddingsOpts, hooks: SavePipelineHooks<TDoc, TWrite>): Promise<SaveEmbeddingsResult[]>;
    deleteEmbeddings<TWrite>(ids: string[], hooks?: DeletePipelineHooks<TWrite>): Promise<void>;
    private _withWorkspaceWriteLock;
    deleteDocumentsAndVectors(tx: HyperDBTransaction, ids: string[]): Promise<void>;
    readCurrentRevision(reader: HyperDBReader): Promise<number>;
    evictDocuments(ids: string[]): void;
    clearCaches(): void;
    findEntries<T>(snapshot: HyperDBReader, table: string, query?: object): Promise<T[]>;
    getVectors(snapshot: HyperDBReader, docIds: string[]): Promise<Map<string, number[]>>;
    getDocumentContents(snapshot: HyperDBReader, ids: string[]): Promise<Map<string, string>>;
    private appendMutation;
    private insertDocumentsAndVectors;
    private cacheDocuments;
    private _getCached;
    private filterDuplicates;
    private _persistConfig;
    private _filterDuplicatesFromSnapshot;
}