import { Packr as MsgPack } from 'msgpackr';
import { ReadBuffer, WriteBuffer } from './message-buffer';
/**
 * This code lets you encode rpc protocol messages (request/reply/notification/error/cancel)
 * into a channel write buffer and decode the same messages from a read buffer.
 * Custom encoders/decoders can be registered to specially handling certain types of values
 * to be encoded. Clients are responsible for ensuring that the set of tags for encoders
 * is distinct and the same at both ends of a channel.
 */
export declare type RpcMessage = RequestMessage | ReplyMessage | ReplyErrMessage | CancelMessage | NotificationMessage;
export declare const enum RpcMessageType {
    Request = 1,
    Notification = 2,
    Reply = 3,
    ReplyErr = 4,
    Cancel = 5
}
export interface CancelMessage {
    type: RpcMessageType.Cancel;
    id: number;
}
export interface RequestMessage {
    type: RpcMessageType.Request;
    id: number;
    method: string;
    args: any[];
}
export interface NotificationMessage {
    type: RpcMessageType.Notification;
    id: number;
    method: string;
    args: any[];
}
export interface ReplyMessage {
    type: RpcMessageType.Reply;
    id: number;
    res: any;
}
export interface ReplyErrMessage {
    type: RpcMessageType.ReplyErr;
    id: number;
    err: any;
}
export interface SerializedError {
    readonly $isError: true;
    readonly name: string;
    readonly message: string;
    readonly stack: string;
}
/**
 * A special error that can be returned in case a request
 * has failed. Provides additional information i.e. an error code
 * and additional error data.
 */
export declare class ResponseError extends Error {
    readonly code: number;
    readonly data: any;
    constructor(code: number, message: string, data: any);
}
/**
 * Custom error thrown by the {@link RpcMessageEncoder} if an error occurred during the encoding and the
 * object could not be written to the given {@link WriteBuffer}
 */
export declare class EncodingError extends Error {
    cause?: Error | undefined;
    constructor(msg: string, cause?: Error | undefined);
}
/**
 * A `RpcMessageDecoder` parses a a binary message received via {@link ReadBuffer} into a {@link RpcMessage}
 */
export interface RpcMessageDecoder {
    parse(buffer: ReadBuffer): RpcMessage;
}
/**
 * A `RpcMessageEncoder` writes {@link RpcMessage} objects to a {@link WriteBuffer}. Note that it is
 * up to clients to commit the message. This allows for multiple messages being
 * encoded before sending.
 */
export interface RpcMessageEncoder {
    cancel(buf: WriteBuffer, requestId: number): void;
    notification(buf: WriteBuffer, requestId: number, method: string, args: any[]): void;
    request(buf: WriteBuffer, requestId: number, method: string, args: any[]): void;
    replyOK(buf: WriteBuffer, requestId: number, res: any): void;
    replyErr(buf: WriteBuffer, requestId: number, err: any): void;
}
export declare const defaultMsgPack: MsgPack;
export declare class MsgPackMessageEncoder implements RpcMessageEncoder {
    protected readonly msgPack: MsgPack;
    constructor(msgPack?: MsgPack);
    cancel(buf: WriteBuffer, requestId: number): void;
    notification(buf: WriteBuffer, requestId: number, method: string, args: any[]): void;
    request(buf: WriteBuffer, requestId: number, method: string, args: any[]): void;
    replyOK(buf: WriteBuffer, requestId: number, res: any): void;
    replyErr(buf: WriteBuffer, requestId: number, err: any): void;
    encode<T = unknown>(buf: WriteBuffer, value: T): void;
}
export declare class MsgPackMessageDecoder implements RpcMessageDecoder {
    protected readonly msgPack: MsgPack;
    constructor(msgPack?: MsgPack);
    decode<T = any>(buf: ReadBuffer): T;
    parse(buffer: ReadBuffer): RpcMessage;
}
export declare function registerMsgPackExtensions(): void;
//# sourceMappingURL=rpc-message-encoder.d.ts.map