import { ClientMessage, RemoteMessage } from './contract.js';
import { default as RPCSourceChannel } from './RPCSourceChannel.js';
import { MetaScopeValue } from './type-utils.js';
export type RPCSourceConnection = (onMessage: (...messages: ClientMessage) => void, onClose: (reason?: any) => void) => (...messages: RemoteMessage) => void;
export type RPCHandler<T extends RPCSource<any, any> = any> = (channel: RPCSource.Channel<T>, path: string[], args: any[], newChannel: boolean) => any | Promise<any> | RPCSource;
type EventPath<T, K extends keyof T = keyof T> = (K extends (string | number) ? (T[K] extends infer P ? (0 extends (1 & P) ? (K | [K, ...(number | string)[]]) : P extends unknown[] ? (K | [K]) : [
    K,
    ...(EventPath<T[K]> extends infer NEXT extends ((string | number) | (string | number)[]) ? (NEXT extends any[] ? NEXT : [NEXT]) : never)
]) : never) : never);
type EventPathArgs<PATH extends number | string | (number | string)[], FORM> = (0 extends (1 & FORM) ? any[] : PATH extends (number | string) ? EventPathArgs<[PATH], FORM> : PATH extends [] ? FORM extends any[] ? 0 extends (1 & FORM) ? any[] : FORM : never : PATH extends [infer PROP, ...infer TAIL extends (number | string)[]] ? (PROP extends keyof FORM ? EventPathArgs<TAIL, FORM[PROP]> : never) : never);
type BoxMethods<T, PREFIX extends string> = {
    [KEY in keyof T as KEY extends `${PREFIX}${infer NAME}` ? NAME : never]: T[KEY];
};
declare class RPCSource<METHODS extends (Record<string, any> | string) = {}, STATE = undefined, EVENTS = any> implements Disposable {
    #private;
    static with<const BIND_METHODS extends string | Record<string, any> = {}, BIND_STATE = undefined, const BIND_EVENTS = {}>(): {
        [K in keyof typeof RPCSource]: (typeof RPCSource)[K];
    } & {
        new <METHODS extends Record<string, any> | string = BIND_METHODS, STATE = BIND_STATE, EVENTS = BIND_EVENTS>(methods: METHODS, state?: STATE): RPCSource<METHODS, STATE, EVENTS>;
    };
    static with<const BIND_METHODS extends Record<string, any> | string = {}, BIND_STATE = undefined, const BIND_EVENTS = {}>(methods: BIND_METHODS | RPCHandler): {
        [K in keyof typeof RPCSource]: (typeof RPCSource)[K];
    } & {
        new <STATE = BIND_STATE, EVENTS = BIND_EVENTS>(state?: STATE): RPCSource<BIND_METHODS, STATE, EVENTS>;
    };
    static with<const BIND_METHODS extends Record<string, any> | string = {}, BIND_STATE = undefined, const BIND_EVENTS = {}>(methods: BIND_METHODS | RPCHandler, state: BIND_STATE): {
        [K in keyof typeof RPCSource]: (typeof RPCSource)[K];
    } & {
        new <EVENTS = BIND_EVENTS>(): RPCSource<BIND_METHODS, BIND_STATE, EVENTS>;
    };
    [Symbol.unscopables]: MetaScopeValue<METHODS extends string ? BoxMethods<this, METHODS> : METHODS, EVENTS, STATE>;
    get channel(): RPCSource.Channel<this>;
    static get channel(): RPCSource.Channel<RPCSource<any, any>>;
    get context(): any;
    static get context(): any;
    get state(): STATE;
    constructor(handler?: RPCHandler | METHODS, initialState?: STATE);
    static createDefaultHandler(parameters: {
        methods: any;
        thisValue?: any;
    }, prefix?: string): RPCHandler;
    static normalize<V extends ((this: RPCSource<any, any>, args: any[]) => boolean | readonly any[]) | ((this: RPCSource<any, any>, args: any[]) => args is any[]), A extends (this: RPCSource<any, any>, ...args: (V extends ((args: any[]) => args is infer R extends any[]) ? R : (V extends ((args: any[]) => false | infer R extends readonly any[]) ? R : (Parameters<V>[0])))) => any>(normalizer: V, handler: A): NoInfer<A>;
    static validate: typeof RPCSource.normalize;
    withEventTypes<E = EVENTS>(): RPCSource<METHODS, STATE, E>;
    setState(changeState: (oldState: STATE) => STATE): STATE;
    setState(newState: STATE extends (...args: any) => any ? never : STATE): STATE;
    withState<S>(): RPCSource<METHODS, S, EVENTS>;
    withState<S>(state: S): RPCSource<METHODS, S, EVENTS>;
    get disposed(): boolean;
    emit<P extends 0 extends (1 & EVENTS) ? (string | number | (string | number)[]) : EventPath<EVENTS>>(event: P, ...args: 0 extends (1 & EVENTS) ? any[] : EventPathArgs<P, EVENTS>): this;
    dispose(reason?: any): void;
    [Symbol.dispose](): void;
    static start(rpcSource: RPCSource<any, any, any>, connection: RPCSourceConnection, { maxChannelsPerClient, context, onCreateChannel }?: {
        maxChannelsPerClient?: number;
        context?: any;
        onCreateChannel?: (channel: RPCSource.Channel, parentChannel: RPCSource.Channel | undefined) => void;
    }): (reason?: any) => void;
    static Channel: typeof RPCSourceChannel;
}
declare namespace RPCSource {
    type Channel<T extends RPCSource<any, any> = RPCSource<any, any>> = RPCSourceChannel<T>;
}
export default RPCSource;