import { JsonLineProcess, type JsonLineProcessExit, type JsonLineProcessOptions } from "../supervisor/jsonline-process.js";
export type JsonRpcDialect = "acp" | "codex";
export type JsonRpcId = string | number;
export type JsonLineRpcState = "running" | "closing" | "closed" | "failed";
export interface JsonRpcErrorObject {
    code: number;
    message: string;
    data?: unknown;
}
export interface JsonRpcRequestOptions {
    signal?: AbortSignal;
    timeoutMs?: number | false;
}
export interface JsonRpcNotification {
    method: string;
    params?: unknown;
}
export interface JsonRpcServerRequest {
    id: JsonRpcId;
    method: string;
    params?: unknown;
    signal: AbortSignal;
}
export type JsonRpcServerRequestHandler = (request: JsonRpcServerRequest) => unknown | Promise<unknown>;
export interface JsonRpcUnknownMessage {
    reason: "unknown_message" | "orphan_response" | "late_response";
    message: unknown;
}
export interface JsonLineRpcClientOptions {
    dialect: JsonRpcDialect;
    defaultRequestTimeoutMs?: number | false;
    idPrefix?: string;
    serverRequestHandler?: JsonRpcServerRequestHandler;
}
export interface JsonRpcRequestHandle<TResult> {
    readonly id: JsonRpcId;
    readonly promise: Promise<TResult>;
    cancel(message?: string): boolean;
}
export declare class JsonRpcProtocolError extends Error {
    readonly causeError: Error | undefined;
    constructor(message: string, causeError?: Error);
}
export declare class JsonRpcTransportClosedError extends Error {
    constructor(message?: string);
}
export declare class JsonRpcRequestTimeoutError extends Error {
    readonly id: JsonRpcId;
    readonly method: string;
    readonly timeoutMs: number;
    constructor(id: JsonRpcId, method: string, timeoutMs: number);
}
export declare class JsonRpcRequestAbortedError extends Error {
    readonly id: JsonRpcId;
    readonly method: string;
    constructor(id: JsonRpcId, method: string, message?: string);
}
export declare class JsonRpcRemoteError extends Error {
    readonly code: number;
    readonly data: unknown;
    readonly requestId: JsonRpcId;
    constructor(requestId: JsonRpcId, error: JsonRpcErrorObject);
}
export declare class JsonRpcProcessExitedError extends Error {
    readonly exit: JsonLineProcessExit;
    constructor(exit: JsonLineProcessExit);
}
/** Throw this from a server-request handler to return a deliberate JSON-RPC error. */
export declare class JsonRpcServerError extends Error {
    readonly code: number;
    readonly data: unknown;
    constructor(code: number, message: string, data?: unknown);
}
type Listener<T> = (value: T) => void;
/**
 * Bidirectional JSON-RPC over a JsonLineProcess. ACP uses the JSON-RPC 2.0 header;
 * Codex App Server uses the same shapes while omitting that header on the wire.
 */
export declare class JsonLineRpcClient {
    private readonly process;
    private readonly dialect;
    private readonly defaultRequestTimeoutMs;
    private readonly idPrefix;
    private readonly pending;
    private readonly inboundControllers;
    private readonly notifications;
    private readonly unknownMessages;
    private readonly protocolErrors;
    private readonly exits;
    private readonly processDisposers;
    private nextRequestId;
    private stateValue;
    private serverRequestHandler;
    private closePromise;
    private protocolFailure;
    constructor(process: JsonLineProcess, options: JsonLineRpcClientOptions);
    static spawn(processOptions: JsonLineProcessOptions, clientOptions: JsonLineRpcClientOptions): JsonLineRpcClient;
    get state(): JsonLineRpcState;
    get pendingRequestCount(): number;
    get pid(): number | undefined;
    get stderr(): string;
    setServerRequestHandler(handler: JsonRpcServerRequestHandler | undefined): void;
    onNotification(listener: Listener<JsonRpcNotification>): () => void;
    onUnknownMessage(listener: Listener<JsonRpcUnknownMessage>): () => void;
    onProtocolError(listener: Listener<JsonRpcProtocolError>): () => void;
    onExit(listener: Listener<JsonLineProcessExit>): () => void;
    onStderr(listener: Listener<string>): () => void;
    request<TResult = unknown>(method: string, params?: unknown, options?: JsonRpcRequestOptions): Promise<TResult>;
    beginRequest<TResult = unknown>(method: string, params?: unknown, options?: JsonRpcRequestOptions): JsonRpcRequestHandle<TResult>;
    notify(method: string, params?: unknown, signal?: AbortSignal): Promise<void>;
    cancelPendingRequest(id: JsonRpcId, message?: string): boolean;
    close(): Promise<JsonLineProcessExit>;
    private acceptMessage;
    private validDialectHeader;
    private handleResponse;
    private handleServerRequest;
    private sendError;
    private frame;
    private allocateId;
    private rejectPending;
    private readonly lateResponseReasons;
    private rejectAll;
    private abortInbound;
    private failProtocol;
    private failTransport;
    private handleExit;
    private assertRunning;
    private closedMessage;
    private disposeProcessListeners;
}
/** Backwards-friendly process-oriented name for adapter implementations. */
export { JsonLineRpcClient as JsonLineRpcProcess };
//# sourceMappingURL=jsonline-rpc.d.ts.map