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 {};