import { SerializedError } from './error_utils';
import { ObjectMap } from './private_utils';
import { Result } from './result';
interface EventEmitterTransport<SendMessage, ReceiveMessage> {
    send(message: SendMessage): void;
    on(event: 'close', handle: () => void): this;
    on(event: 'message', handle: (message: ReceiveMessage) => void): this;
    removeListener(event: 'close', handle: () => void): this;
    removeListener(event: 'message', handle: (message: ReceiveMessage) => void): this;
}
/**
 * A communication link between two concurrent operations which may be
 * executing in separate operating system processes.
 */
interface Channel<TX, RX> {
    send(message: TX): void;
    [Symbol.asyncIterator](): AsyncIterator<RX>;
}
interface Closeable {
    close(): void;
}
declare enum ApplicationMessageType {
    REQUEST = 0,
    RESPONSE = 1,
    ERROR = 2
}
type Values<R extends ObjectMap<string, any>> = R[keyof R];
type RequestArgs<R> = Parameters<Values<ChannelMethods<R>>> & any[];
type RequestResults<R> = ReturnType<Values<ChannelMethods<R>>> extends Promise<infer P> ? P : never;
type RequestMessage<H> = [
    ApplicationMessageType.REQUEST,
    number,
    CallableKeys<ChannelMethods<H>>,
    RequestArgs<H>
];
type ResponseMessage<H> = [ApplicationMessageType.RESPONSE, number, RequestResults<H>] | [ApplicationMessageType.ERROR, number, SerializedError];
/**
 * An object that receives requests to invoke methods (by receiving "request"
 * messages) and sends the result (by transmitting "response" and "error"
 * messages).
 */
declare class ResponseChannelImplementation<Local extends {
    [key: string]: (...args: any[]) => Promise<any>;
}> {
    private _inner;
    private _handles;
    private _observer;
    channelClosedPromise: Promise<void>;
    constructor(inner: Channel<ResponseMessage<Local>, RequestMessage<Local>>, handles: Local);
    private _handleRequestsAsync;
    [Symbol.asyncIterator](): AsyncIterator<{
        method: keyof ChannelMethods<Local>;
        args: RequestArgs<Local>;
        result: Promise<Result<RequestResults<Local>>>;
    }>;
}
export declare function createEventEmitterChannel<TX = any, RX = any>(transport: EventEmitterTransport<TX, RX>): Channel<TX, RX> & Closeable;
export declare function createRequestChannel<H extends ChannelMethods<H>>(inner: Channel<RequestMessage<H>, ResponseMessage<H>>): RequestChannel<H>;
export declare function createResponseChannel<H extends ChannelMethods<H>>(inner: Channel<ResponseMessage<H>, RequestMessage<H>>, handles: H): ResponseChannelImplementation<H>;
/**
 * Values that can be sent over a channel.
 */
export type ChannelArg = null | boolean | number | string | ChannelArg[] | {
    [key: string]: ChannelArg;
};
type ChannelReturn = Promise<ChannelArg | void> | ChannelArg | void;
type Anonymize<T> = T extends Promise<infer P> ? Promise<Anonymize<P>> : T extends ObjectMap<any, any> ? {
    [key in keyof T]: Anonymize<T[key]>;
} : T;
/**
 * A function with argument and return types that can be sent over a channel.
 */
export type ChannelFunction<T extends (...args: any[]) => any> = T extends (...args: infer Args) => infer Return ? (...args: Extract<Anonymize<Args>, [] | ChannelArg[]>) => Extract<Anonymize<Return>, ChannelReturn> : never;
/**
 * Keys of an object whose values are anything except never.
 */
type CallableKeys<T> = {
    [key in Extract<keyof T, string>]: T[key] extends (...args: any[]) => any ? T[key] extends ChannelFunction<T[key]> ? key : never : never;
}[Extract<keyof T, string>];
/**
 * An object with methods that can be called over a channel.
 */
export type ChannelMethods<T> = {
    [key in CallableKeys<T>]: T[key];
};
/**
 * An object that can request the remote invocation of methods (by transmitting
 * "request" messages) and receive the result (by receiving "response" and
 * "error" messages).
 */
export interface RequestChannel<T extends ChannelMethods<T>> {
    requestAsync<N extends CallableKeys<ChannelMethods<T>>, F extends T[N], R extends ReturnType<F>>(method: N, ...args: Parameters<F>): Promise<R extends Promise<infer P> ? P : never>;
}
export declare class RequestChannelAdapter<T extends ChannelMethods<T>> implements RequestChannel<T> {
    private _remote;
    constructor(remote: T);
    requestAsync<N extends CallableKeys<ChannelMethods<T>>, F extends T[N], R extends ReturnType<F>>(method: N, ...args: Parameters<F> & any[]): Promise<R extends Promise<infer P> ? P : never>;
}
export {};