import { ObjectMap } from './private_utils';
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;
}
/**
 * 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: any, handles: Local);
    private _handleRequestsAsync;
    [Symbol.asyncIterator](): AsyncIterator<{
        method: keyof ChannelMethods<Local>;
        args: any;
        result: Promise<any>;
    }>;
}
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: any): RequestChannel<H>;
export declare function createResponseChannel<H extends ChannelMethods<H>>(inner: any, handles: H): ResponseChannelImplementation<any>;
/**
 * Values that can be sent over a channel.
 */
export declare type ChannelArg = null | boolean | number | string | ChannelArg[] | {
    [key: string]: ChannelArg;
};
declare type ChannelReturn = Promise<ChannelArg | void> | ChannelArg | void;
declare 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 declare 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.
 */
declare 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 declare type ChannelMethods<T, K extends CallableKeys<T> = any> = {
    [key in K]: 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(method: any, ...args: any): Promise<any>;
}
export declare class RequestChannelAdapter {
    private _remote;
    constructor(remote: any);
    requestAsyncany(method: any, ...args: any): Promise<any>;
}
export {};