import type { Diagnostic, ResolvedServer } from './types';
export declare const LSP_TIMEOUTS: {
    start: number;
    request: number;
    diagnostics: number;
    openFileDelay: number;
    initializeDelay: number;
    diagnosticSettleDelay: number;
};
interface DiagnosticProviderCapabilities {
    identifier?: string;
    interFileDependencies?: boolean;
    workspaceDiagnostics?: boolean;
}
export declare function getDiagnosticsCapabilitySummary({ diagnosticProvider, publishDiagnosticsObserved, workspaceConfigurationRequested, }: {
    diagnosticProvider?: DiagnosticProviderCapabilities | null;
    publishDiagnosticsObserved?: boolean;
    workspaceConfigurationRequested?: boolean;
}): {
    availableModes: string[];
    preferredMode: 'push' | 'pull';
    inferredTransport: 'push' | 'pull' | 'hybrid';
    pull: boolean;
    pushObserved: boolean;
    pullResultTracking: boolean;
    workspaceDiagnostics: boolean;
    interFileDependencies: boolean;
    workspaceConfiguration: boolean;
};
export declare function getWorkspaceConfiguration(items: Array<{
    section?: string;
} | undefined>): Array<unknown>;
declare class LSPServerManager {
    private static instance;
    private clients;
    private cleanupInterval;
    private readonly IDLE_TIMEOUT;
    private constructor();
    private registerProcessCleanup;
    static getInstance(): LSPServerManager;
    private getKey;
    private startCleanupTimer;
    private cleanupIdleClients;
    getClient(root: string, server: ResolvedServer): Promise<LSPClient>;
    releaseClient(root: string, serverId: string): void;
    isServerInitializing(root: string, serverId: string): boolean;
    stopAll(): Promise<void>;
}
export declare const lspManager: LSPServerManager;
export declare class LSPClient {
    private root;
    private server;
    private proc;
    private connection;
    private openedFiles;
    private stderrBuffer;
    private processExited;
    private diagnosticsStore;
    private diagnosticResultIds;
    private documents;
    private diagnosticProvider;
    private publishDiagnosticsObserved;
    private supportsPullDiagnostics;
    private workspaceConfigurationRequested;
    constructor(root: string, server: ResolvedServer);
    start(): Promise<void>;
    private startStderrReading;
    initialize(): Promise<void>;
    private waitForPublishedDiagnostics;
    openFile(filePath: string): Promise<void>;
    private ensureDocumentSynced;
    definition(filePath: string, line: number, character: number): Promise<unknown>;
    references(filePath: string, line: number, character: number, includeDeclaration?: boolean): Promise<unknown>;
    diagnostics(filePath: string): Promise<{
        items: Diagnostic[];
    }>;
    rename(filePath: string, line: number, character: number, newName: string): Promise<unknown>;
    isAlive(): boolean;
    stop(): Promise<void>;
}
export {};