import { ClientMessage, RemoteMessage } from './contract.js';
import { MetaScope, EventPathArgs, EventPath } from './type-utils.js';
import { default as RPCSource } from './RPCSource.js';
export type RPCChannelConnection = (onMessage: (...messages: RemoteMessage) => void, onClose: (reason?: any) => void) => (...messages: ClientMessage) => void;
interface MetaDesc<M = any, E = any, S = any> {
    methods?: M;
    events?: E;
    state?: S;
}
interface MetaType<M = any, E = any, S = any> {
    methods: M;
    events: E;
    state: S;
}
type MetaScopeToDesc<T extends MetaScope> = T extends MetaScope<infer M, infer E, infer S> ? MetaType<M, E, S> : never;
type ExtraKeys = "on" | "once" | "off" | "notify" | "then";
type ExtractMetaType<T extends MetaDesc | MetaScope> = ((T extends MetaScope ? MetaScopeToDesc<T> : T) extends infer D ? {
    methods: D extends {
        methods: infer M;
    } ? M : any;
    events: D extends {
        events: infer E;
    } ? E : any;
    state: D extends {
        state: infer S;
    } ? S : any;
} : never);
type RPCMethodsAny = {
    [key: string]: RPCMethodsAny & RPCMethod<any, any> & RPCConstructor<any, any>;
};
type RPCMethodsPart<T, EXCLUDE = ExtraKeys> = 0 extends (1 & T) ? RPCMethodsAny : (T extends ((...args: any) => any) | {
    new (...args: any): any;
} | MetaScope ? unknown : {
    [K in Exclude<keyof T & string, EXCLUDE>]: RPCMethodsPart<T[K]>;
}) & (T extends (...args: infer A) => infer R ? ([
    R
] extends [never] ? RPCMethod<A, R> : Exclude<Awaited<R>, MetaScope> extends infer RC ? ([RC] extends [never] ? unknown : RPCMethod<A, RC>) : unknown) & ([
    R
] extends [never] ? unknown : Extract<Awaited<R>, MetaScope> extends infer RC extends MetaScope ? RPCConstructor<A, RC> : unknown) : unknown) & (T extends (new (...args: infer A) => infer R extends MetaScope) ? RPCConstructor<A, R> : unknown) & (T extends PromiseLike<infer R extends MetaScope> ? RPCConstructor<[], R> : unknown) & (T extends MetaScope ? RPCConstructor<[], T> : unknown);
type RPCMethod<A extends any[], R> = {
    (...args: A): Promise<Awaited<R>>;
    notify(...args: A): void;
    call: never;
    bind: never;
    apply: never;
    name: never;
    length: never;
};
type RPCConstructor<A extends any[], R extends MetaScope> = {
    new (...args: A): RPCChannel<R>;
    call: never;
    bind: never;
    apply: never;
    name: never;
    length: never;
};
interface EventHandler<F, SPECIAL_EVENTS extends string> {
    on<E extends Exclude<EventPath<F>, SPECIAL_EVENTS>>(this: this, eventName: E, handler: (...args: EventPathArgs<E, F>) => void): this;
    once<E extends Exclude<EventPath<F>, SPECIAL_EVENTS>>(this: this, eventName: E, handler: (...args: EventPathArgs<E, F>) => void): this;
    off<E extends Exclude<EventPath<F>, SPECIAL_EVENTS>>(this: this, eventName: E, handler: (...args: EventPathArgs<E, F>) => void): this;
}
interface BaseEventHandler<S> {
    on<E extends keyof RPCChannelEvents<S>>(this: this, eventName: E, handler: (...args: RPCChannelEvents<S>[E]) => void): this;
    once<E extends keyof RPCChannelEvents<S>>(this: this, eventName: E, handler: (...args: RPCChannelEvents<S>[E]) => void): this;
    off<E extends keyof RPCChannelEvents<S>>(this: this, eventName: E, handler: (...args: RPCChannelEvents<S>[E]) => void): this;
}
type EventsOfAny<SPECIAL_EVENTS extends string = never> = EventHandlerAny<SPECIAL_EVENTS> & {
    [key: string]: EventsOfAny;
};
interface EventHandlerAny<SPECIAL_EVENTS extends string = never> {
    on<T extends string | number | (string | number)[]>(this: this, eventName: T extends SPECIAL_EVENTS ? never : T, handler: (...args: any) => void): this;
    once<T extends string | number | (string | number)[]>(this: this, eventName: T extends SPECIAL_EVENTS ? never : T, handler: (...args: any) => void): this;
    off<T extends string | number | (string | number)[]>(this: this, eventName: T extends SPECIAL_EVENTS ? never : T, handler: (...args: any) => void): this;
}
interface EventHandlerEmptyArray<E extends any[]> {
    on(eventName: [], handler: (this: this, ...args: E) => void): this;
    once(eventName: [], handler: (this: this, ...args: E) => void): this;
    off(eventName: [], handler: (this: this, ...args: E) => void): this;
}
type HasAnyValue<T, Y, N> = T[keyof T] extends infer V ? ([V] extends [never] ? N : Y) : N;
type RPCEventsPart<T, SPECIAL_EVENTS extends string = never> = [T] extends [never] ? unknown : (0 extends (1 & T) ? EventsOfAny<SPECIAL_EVENTS> : (Extract<T, any[]> extends infer F extends any[] ? [F] extends [never] ? unknown : EventHandlerEmptyArray<F> : never) & (Exclude<T, any[]> extends infer F ? (HasAnyValue<F, {
    [K in Exclude<keyof F, ExtraKeys> as F[K] extends any[] ? never : K]: RPCEventsPart<F[K]>;
} & EventHandler<F, SPECIAL_EVENTS>, unknown>) : never));
interface RPCChannelInstance<S = unknown> extends BaseEventHandler<S> {
    get state(): S;
    close(reason?: any): void;
    get closed(): boolean;
    get ready(): boolean;
    then: void;
    promise: Promise<this>;
}
type RPCChannel<T extends MetaScope | MetaDesc = {}> = ExtractMetaType<T> extends {
    methods: infer M;
    events: infer E;
    state: infer S;
} ? (Disposable & MetaScope<M, E, S> & RPCChannelInstance<S> & RPCEventsPart<E, keyof RPCChannelEvents<any>> & RPCMethodsPart<M, Exclude<keyof RPCChannelInstance | ExtraKeys, "notify">>) : never;
export type RPCChannelEvents<S> = {
    state: [newState: S, oldState?: S];
    close: [reason: any];
    ready: [];
    error: [error: any];
};
declare const RPCChannel: ({
    new <M extends MetaScope | MetaDesc = {}>(connection: RPCChannelConnection, options?: {
        getNextChannelId?: () => string | number;
        connectionTimeout?: number | AbortSignal;
    }): RPCChannel<M>;
    new <R extends RPCSource<any, any, any>>(source: R, options?: {
        getNextChannelId?: () => string | number;
        connectionTimeout?: number | AbortSignal;
    }): RPCChannel<R>;
});
export default RPCChannel;