export type ChannelFactory = (handler: IChannelHandler) => IChannel;
export interface IChannel {
    sendNotification(data: unknown): void;
    sendRequest(data: unknown): Promise<RpcRequestResult>;
}
export interface IChannelHandler {
    handleNotification(notificationData: unknown): void;
    handleRequest(requestData: unknown): Promise<RpcRequestResult> | RpcRequestResult;
}
export type RpcRequestResult = {
    type: 'result';
    value: unknown;
} | {
    type: 'error';
    value: unknown;
};
export type API = {
    host: Side;
    client: Side;
};
export type Side = {
    notifications: Record<string, (...args: any[]) => void>;
    requests: Record<string, (...args: any[]) => Promise<unknown> | unknown>;
};
type MakeAsyncIfNot<TFn> = TFn extends (...args: infer TArgs) => infer TResult ? TResult extends Promise<unknown> ? TFn : (...args: TArgs) => Promise<TResult> : never;
export type MakeSideAsync<T extends Side> = {
    notifications: T['notifications'];
    requests: {
        [K in keyof T['requests']]: MakeAsyncIfNot<T['requests'][K]>;
    };
};
export declare class SimpleTypedRpcConnection<T extends Side> {
    private readonly _channelFactory;
    private readonly _getHandler;
    static createHost<T extends API>(channelFactory: ChannelFactory, getHandler: () => T['host']): SimpleTypedRpcConnection<MakeSideAsync<T['client']>>;
    static createClient<T extends API>(channelFactory: ChannelFactory, getHandler: () => T['client']): SimpleTypedRpcConnection<MakeSideAsync<T['host']>>;
    readonly api: T;
    private readonly _channel;
    private constructor();
}
export {};
//# sourceMappingURL=rpc.d.ts.map