import type { ErrorObject } from 'serialize-error';
import type { EventEmitter } from 'events';
import type { Readable } from 'stream';
import type { msgType } from './constants.js';
export interface test {
    foo: boolean;
}
export type NonEmptyArray<T> = [T, ...T[]];
export type MsgId = number;
export type Prop = string;
type EventName = string;
export type Args = Array<any>;
type Params = Array<any>;
type More = boolean;
type IsObjectMode = boolean;
export type MsgRequest = [
    typeof msgType.REQUEST,
    MsgId,
    NonEmptyArray<Prop>,
    Args
];
type MsgResponseEnd = [
    typeof msgType.RESPONSE,
    MsgId,
    ErrorObject | null,
    any,
    false,
    IsObjectMode
];
export type MsgResponse = [
    typeof msgType.RESPONSE,
    MsgId,
    null,
    any,
    More?
] | [typeof msgType.RESPONSE, MsgId, ErrorObject] | MsgResponseEnd;
export type MsgOn = [typeof msgType.ON, EventName, Array<Prop>];
export type MsgOff = [typeof msgType.OFF, EventName, Array<Prop>];
export type MsgEmit = [
    typeof msgType.EMIT,
    EventName,
    Array<Prop>,
    ErrorObject | null,
    Params?
];
export type Message = MsgRequest | MsgResponse | MsgOn | MsgOff | MsgEmit;
export type MessageContainer = {
    value: Message;
    metadata?: Record<string, string>;
};
export type SubClient = ((...args: any[]) => Promise<any>) & Client;
interface AnyMethod {
    [method: string]: SubClient;
}
export type Client = AnyMethod & EventEmitter;
export interface MessagePortLike {
    on(event: 'message', listener: (value: any) => void): this;
    off(event: 'message', listener: (value: any) => void): this;
    postMessage(value: any): void;
}
type Asyncify<T extends (...args: any[]) => any> = ReturnType<T> extends Promise<infer Value> ? T : ReturnType<T> extends Readable ? (...args: Parameters<T>) => Promise<string | Buffer | Uint8Array | any[]> : (...args: Parameters<T>) => Promise<ReturnType<T>>;
type Filter<KeyType, ExcludeType> = KeyType extends ExcludeType ? never : KeyType;
type UnavailableEmitterMethods = 'setMaxListeners' | 'getMaxListeners' | 'prependListener' | 'prependOnceListener';
export type ClientApi<ServerApi extends {}> = {
    [KeyType in keyof ServerApi as Filter<KeyType, Symbol | UnavailableEmitterMethods>]: KeyType extends keyof EventEmitter ? ServerApi[KeyType] : ServerApi[KeyType] extends (...args: any[]) => any ? Asyncify<ServerApi[KeyType]> : ServerApi[KeyType] extends Array<infer T> ? () => Promise<T[]> : ServerApi[KeyType] extends {
        [key: string]: any;
    } ? ClientApi<ServerApi[KeyType]> & (() => Promise<ServerApi[KeyType]>) : ServerApi[KeyType] extends Symbol ? never : () => Promise<ServerApi[KeyType]>;
};
export type Metadata = Record<string, string>;
export type MsgRequestObj = {
    msgId: MsgId;
    method: NonEmptyArray<Prop>;
    args: Args;
    metadata?: Metadata;
};
export type Result = Promise<any> | Readable;
export {};