import type { RpcTransport } from './ipc-transport';
import type { GraphStats, TopFileResult, FileDepResult, FileCoChangeResult, FileSymbolResult, SymbolSearchResult, SymbolSignatureResult, CallerResult, CalleeResult, UnusedExportResult, DuplicateStructureResult, NearDuplicateResult, ExternalPackageResult, PrepareScanResult, ScanBatchResult, OrphanFileResult, CircularDependencyResult, ChangeImpactResult, SymbolReferenceResult, SymbolBlastRadiusResult, CallGraphCycleResult } from './types';
import type { Logger } from '../types';
interface GraphWorkerConfig {
    cwd: string;
    dbPath: string;
    logger?: Logger;
}
/**
 * GraphClient communicates with the graph worker via RPC
 * All tree-sitter parsing and SQLite queries run in worker thread
 */
export declare class GraphClient {
    private client;
    private worker;
    private ready;
    private workerError;
    private mode;
    private failoverProvider;
    private logger?;
    private activeFailover;
    private readOnlyDispatcher;
    initialize(_config: GraphWorkerConfig): Promise<void>;
    setWorker(worker: Worker, logger?: Logger): void;
    /**
     * Point the client at an arbitrary RpcTransport (used in follower mode
     * where we speak to a remote leader over a socket instead of owning a
     * worker ourselves).
     */
    setTransport(transport: RpcTransport, logger?: Logger, mode?: 'leader' | 'follower'): void;
    /**
     * Install the failover provider used by read-only retries. The provider
     * is called when an RPC fails with a transport error. It is responsible
     * for reinstalling a working transport (typically by calling
     * `setTransport()` or `promoteToLeader()` on this client). GraphClient
     * will then retry the failed call exactly once.
     */
    setFailoverProvider(provider: () => Promise<void>): void;
    clearFailoverProvider(): void;
    /**
     * Promote this client from follower to leader. Used by the failover
     * provider when the previous leader died and this process won the next
     * lock acquisition. The worker reference is retained so close() can
     * terminate it later.
     */
    promoteToLeader(worker: Worker, logger?: Logger): void;
    private attachClientHandlers;
    getMode(): 'leader' | 'follower' | null;
    /**
     * Install a local read-only dispatcher (Phase 5 fast path). When set,
     * read-only RPC methods are served locally via this function instead of
     * hopping over IPC to the leader. If the local dispatcher throws, we
     * fall back to the remote transport so a transient read-only-handle
     * problem (e.g. the file was rotated by a fresh scan) doesn't surface
     * as an error to the caller.
     */
    setReadOnlyDispatcher(dispatcher: (method: string, args: unknown[]) => Promise<unknown>): void;
    clearReadOnlyDispatcher(): void;
    /**
     * Forwarding entry point used by the leader's IPC server to route
     * follower RPC calls into the local worker. Delegates to the underlying
     * RpcClient, which handles callId multiplexing so multiple followers +
     * local callers can share the same worker safely.
     */
    forward<T = unknown>(method: string, args: unknown[]): Promise<T>;
    /**
     * Internal dispatch used by every typed method. On transport failure:
     *   - read-only methods: wait for failover (if provider installed) and
     *     retry exactly once;
     *   - write methods: surface `LeaderLostError` so the caller knows the
     *     operation may have been partially applied.
     */
    private invoke;
    private runFailover;
    markWorkerDead(error?: Error): void;
    getWorkerError(): Error | null;
    scan(): Promise<void>;
    prepareScan(): Promise<PrepareScanResult>;
    scanBatch(offset: number, batchSize: number): Promise<ScanBatchResult>;
    finalizeScan(): Promise<void>;
    getStats(): Promise<GraphStats>;
    getTopFiles(limit?: number): Promise<TopFileResult[]>;
    getFileDependents(relPath: string): Promise<FileDepResult[]>;
    getFileDependencies(relPath: string): Promise<FileDepResult[]>;
    getFileCoChanges(relPath: string): Promise<FileCoChangeResult[]>;
    getFileBlastRadius(relPath: string): Promise<number>;
    getFileSymbols(relPath: string): Promise<FileSymbolResult[]>;
    findSymbols(name: string, limit?: number): Promise<SymbolSearchResult[]>;
    searchSymbolsFts(query: string, limit?: number): Promise<SymbolSearchResult[]>;
    getSymbolSignature(path: string, line: number): Promise<SymbolSignatureResult | null>;
    getCallers(path: string, line: number, minConfidence?: number): Promise<CallerResult[]>;
    getCallees(path: string, line: number, minConfidence?: number): Promise<CalleeResult[]>;
    getUnusedExports(limit?: number): Promise<UnusedExportResult[]>;
    getDuplicateStructures(limit?: number): Promise<DuplicateStructureResult[]>;
    getNearDuplicates(threshold?: number, limit?: number): Promise<NearDuplicateResult[]>;
    getExternalPackages(limit?: number): Promise<ExternalPackageResult[]>;
    render(opts?: {
        maxFiles?: number;
        maxSymbols?: number;
    }): Promise<{
        content: string;
        paths: string[];
    }>;
    getOrphanFiles(limit?: number): Promise<OrphanFileResult[]>;
    getCircularDependencies(limit?: number): Promise<CircularDependencyResult[]>;
    getChangeImpact(paths: string[], maxDepth?: number): Promise<ChangeImpactResult>;
    getSymbolReferences(name: string, limit?: number): Promise<SymbolReferenceResult[]>;
    getSymbolBlastRadius(name: string, maxDepth?: number): Promise<SymbolBlastRadiusResult>;
    getCallGraphCycles(limit?: number): Promise<CallGraphCycleResult[]>;
    onFileChanged(absPath: string): Promise<void>;
    close(): Promise<void>;
    isReady(): boolean;
}
export {};
//# sourceMappingURL=client.d.ts.map