/// <reference types="node" />
import { EventEmitter } from "events";
export declare const MSG_RESOLVE = "resolve";
export declare const MSG_REJECT = "reject";
export declare const MSG_ERROR = "error";
export interface Listener<T> {
    (event: T): any;
}
export interface Disposable {
    dispose(): void;
}
export interface Transaction {
    id: number;
    htimeout?: any;
    resolve(result: any): void;
    reject(error: string): void;
}
export declare enum MessageType {
    signal = 0,
    rpc = 1,
    internal = 2,
}
export interface Dispatcher {
    (message: Message, transfer?: Array<any>): boolean;
}
export interface Message {
    type: MessageType;
    name: string;
    id?: number;
    payload?: any;
}
export interface ProviderOptions {
    dispatch?: Dispatcher;
    timeout?: number;
}
export declare class Provider extends EventEmitter {
    private _nextId;
    private _methods;
    private _pendings;
    protected _dispatch?: Dispatcher;
    protected _timeout: number;
    constructor(dispatch?: Dispatcher);
    constructor(options?: ProviderOptions);
    protected dispatch(message: Message): boolean;
    method(name: string, definition: any): void;
    methods(methods: {
        [name: string]: any;
    }): this;
    hasMethod(name: string): boolean;
    removeMethod(name: string): void;
    listen(event: string, listener: Listener<any>): Disposable;
    off(event: string, listener: Listener<any>): void;
    call(name: string, params: any): Promise<any>;
    handle(message: Message): boolean;
    request<T, U>(method: string, params?: T, options?: any | number): Promise<U>;
    signal(name: string, payload?: any): boolean;
    private _raiseError(error);
    private _handleSignal(message);
    private _handelRequest(message);
    private _handleInternal(message);
    private _handleTimeout(transaction);
    private _clearTransaction(transaction);
}