/// <reference types="node" />
import * as stream from 'stream';
import ErrorSubclass from 'error-subclass';
import * as jrpc from './protocol';
export declare enum ErrorCodes {
    PARSE_ERROR = -32700,
    INVALID_REQUEST = -32600,
    METHOD_NOT_FOUND = -32601,
    INVALID_PARAMS = -32602,
    INTERNAL_ERROR = -32603
}
export declare class RPCError extends ErrorSubclass {
    readonly code: number;
    readonly data?: any;
    static displayName: string;
    constructor(message: string, code?: number, data?: any);
    toErrorObject(): jrpc.ErrorObject;
}
export declare class MethodNotFound extends RPCError {
    static displayName: string;
    constructor(message: string, data?: any);
}
export declare class InvalidParams extends RPCError {
    static displayName: string;
    constructor(message: string, data?: any);
}
export declare class ParseError extends RPCError {
    static displayName: string;
    constructor(message: string, data?: any);
}
export declare class MethodCallError extends ErrorSubclass {
    readonly method: string;
    static displayName: string;
    constructor(method: string, message?: string);
}
export declare class MethodCallTimeout extends MethodCallError {
    static displayName: string;
    constructor(method: string);
}
export declare class RPCStreamClosed extends MethodCallError {
    static displayName: string;
    constructor(method: string);
}
export declare class UnexpectedResponse extends ErrorSubclass {
    readonly id: jrpc.RPCID;
    readonly kind: string;
    static displayName: string;
    constructor(id: jrpc.RPCID, kind?: string);
}
export declare class NumericIdIterator implements Iterator<jrpc.RPCID> {
    state: number;
    constructor(initialValue?: number);
    next(): {
        value: number;
        done: boolean;
    };
}
export declare type RequestHandler = (this: void, method: string, params: jrpc.RPCParams) => Promise<any> | any;
export declare type NotificationHandler = (this: void, method: string, params: jrpc.RPCParams) => void;
export interface PeerOptions {
    idIterator?: Iterator<jrpc.RPCID>;
}
export declare class Peer extends stream.Duplex {
    onRequest?: RequestHandler;
    onNotification?: NotificationHandler;
    requestIdIterator: Iterator<jrpc.RPCID>;
    private pendingRequests;
    ended: boolean;
    constructor(handlers: {
        onRequest?: RequestHandler;
        onNotification?: NotificationHandler;
    }, options?: PeerOptions);
    private onend;
    callMethod(method: string, params?: jrpc.RPCParams, { timeout }?: {
        timeout?: number | undefined;
    }): Promise<any>;
    sendNotification(method: string, params?: jrpc.RPCParams): boolean;
    pushError(error: jrpc.ErrorObject): boolean;
    _read(): void;
    _write(chunk: any, encoding: string, callback: (err?: Error) => void): void;
    handleRequest(request: jrpc.Request): void;
    handleNotification(notification: jrpc.Notification): void;
    handleResponse(response: jrpc.Response): void;
    handleError(message: jrpc.Error): void;
}