import type { Context } from 'koishi';
import type { DreamNeighborQuery, DreamVectorProvider, MemoryHybridSearchHit, MemoryHybridSearchInput, MemoryIndexMutationBatch, MemoryIndexMutationSink, MemoryVectorIndexStatus, MemoryVectorSearch } from '../../contracts/vector_index';
import { type LivingMemoryVectorIndexRepository } from './maintenance';
import { LivingMemoryVectorIndexWorkerClient } from './worker_client';
import type { LivingMemoryLogger } from '../logging/logger';
export type VectorIndexWorkerFactory = (onFailure: (error: Error) => void, onWarning: (error: Error) => void) => LivingMemoryVectorIndexWorkerClient;
interface VectorIndexServiceOptions {
    schemaVersion?: number;
    workerFactory?: VectorIndexWorkerFactory;
}
export declare class LivingMemoryVectorIndexService implements DreamVectorProvider, MemoryIndexMutationSink, MemoryVectorSearch {
    private readonly config;
    private readonly repository;
    private readonly logger;
    private readonly operationGate;
    private readonly presetMutationQueue;
    private readonly status;
    private readonly indexDirectory;
    private readonly databaseDirectory;
    private readonly previousDatabaseDirectory;
    private readonly maintenance;
    private readonly directorySwitch;
    private readonly workerFactory;
    private worker;
    private initialization;
    private maintenanceTail;
    private workerFailure;
    private embeddingContext;
    private generation;
    private stopPromise;
    constructor(ctx: Context, config: {
        embeddingModel: string;
        debug: boolean;
    }, repository: LivingMemoryVectorIndexRepository, logger: LivingMemoryLogger, options?: VectorIndexServiceOptions);
    start(): Promise<void>;
    stop(): Promise<void>;
    beginStop(): void;
    private stopService;
    restart(): Promise<void>;
    getStatus(): MemoryVectorIndexStatus;
    waitForInitialization(): Promise<void>;
    readVectorSnapshot(presetId: string, memoryIds: string[], signal?: AbortSignal): Promise<import("../..").VectorSnapshot>;
    queryDreamNeighbors(queries: DreamNeighborQuery[], signal?: AbortSignal): Promise<import("../..").DreamNeighborPageResult>;
    searchHybrid(input: MemoryHybridSearchInput): Promise<MemoryHybridSearchHit[]>;
    private runPresetMutation;
    waitForMaintenance(): Promise<void>;
    applyMutation(batch: MemoryIndexMutationBatch): Promise<void>;
    clearPreset(presetId: string): Promise<void>;
    reconcilePreset(presetId: string, reason: string): Promise<import("../..").MemoryJobRecord>;
    private rebuild;
    private clearUnavailableIfHealthy;
    startRebuild(reason: string): void;
    private initialize;
    private removeLegacyIndexFiles;
    private embedSearchTexts;
    assertPresetReady(presetId: string): void;
    private requireEmbeddingContext;
    private markMutationFailed;
    private refreshInspection;
    private finalizeRebuild;
    private recoverAfterRollbackFailure;
    /**
     * 切换失败后在同一 worker 中重开 active 目录；若恢复出的 generation 与
     * 重建 manifest 不一致，说明 active 仍是旧库，清理孤立的 rebuild 目录。
     */
    private restoreActiveDatabase;
    private assertFinalizedInspection;
    private disposeWorker;
    private markBuilding;
    private markPresetBuilding;
    private awaitPresetReadBarrier;
    private handleMaintenanceFailure;
    private inspectAfterFailure;
    private recordWorkerFailure;
    private waitForMaintenanceDuringStop;
    private requireWorker;
    private queueMaintenance;
    private disposeCurrentWorker;
    private releaseGeneration;
}
export {};