/**
 * JSON-RPC stdio client for the Rust REPL supervisor.
 *
 * Spawns `claude-in-mobile repl-supervisor` once per plugin instance and
 * multiplexes requests over its stdin/stdout. Line-delimited JSON; correlation
 * by `id`. The supervisor process is killed on `dispose()` and on Node exit.
 */
export interface ReplBridgeOptions {
    /** Path to the claude-in-mobile binary. Defaults to the env override or "claude-in-mobile". */
    binaryPath?: string;
    /** Sanitized environment passed to the supervisor process. */
    env?: NodeJS.ProcessEnv;
    /** Per-request timeout (ms). Default 30s — well above any expect timeout. */
    requestTimeoutMs?: number;
    /**
     * Startup timeout (ms): how long to wait for the supervisor's `ready`
     * event before giving up. Default 10s. Guards against a supervisor binary
     * that spawns but never emits `ready` (wrong/old binary, hung process).
     */
    startTimeoutMs?: number;
}
export declare class ReplBridgeError extends Error {
    constructor(message: string);
}
export declare class ReplBridgeClient {
    private child?;
    private rl?;
    private nextId;
    private pending;
    private readyPromise?;
    private exitHandler?;
    private readonly binaryPath;
    private readonly env;
    private readonly requestTimeoutMs;
    private readonly startTimeoutMs;
    constructor(opts?: ReplBridgeOptions);
    start(): Promise<void>;
    /**
     * @param timeoutMs Per-call timeout override. Callers whose request can
     *   legitimately block longer than the default (e.g. `expect` with a large
     *   `timeoutMs`) must pass a value here, otherwise the request would be
     *   rejected client-side while the supervisor is still working — leaving the
     *   session wedged and the late response dropped.
     */
    call<T = unknown>(method: string, params?: unknown, timeoutMs?: number): Promise<T>;
    dispose(): Promise<void>;
    private onLine;
    private failAllPending;
}
//# sourceMappingURL=client.d.ts.map