import { ElectronMessagePortPolyfill } from '../interfaces/polyfill.interface.cjs';

interface BetterMessagePortOptions {
    additionalMessagePayload?: Record<string, unknown>;
}
interface BetterMessagePortResult {
    name: string;
    type: 'result';
    error?: boolean;
    result?: unknown;
    errorMessage?: string;
}
interface BetterMessagePortSend {
    name: string;
    type: 'send';
    args: unknown[];
    isSync?: boolean;
    messageId?: string;
}
type BetterMessagePayload = BetterMessagePortSend | BetterMessagePortResult;
type FuncType = (...args: any) => any;
type MessagePortType = MessagePort | ElectronMessagePortPolyfill;
type ExtractParams<T, K extends keyof T> = T[K] extends FuncType ? Parameters<T[K]> : T[K] extends Array<any> ? T[K] : [T[K]];
type ExtractReturnType<T, K extends keyof T> = T[K] extends FuncType ? ReturnType<T[K]> : void;
interface NormalizeMessagePort {
    postMessage: MessagePortType['postMessage'];
    onMessage<T = any>(callback: (event: {
        data: T;
    }) => void): void;
    offMessage<T = any>(callback: (event: {
        data: T;
    }) => void): void;
}
type PostMessageFunc = (data: unknown) => void;
interface BetterMessagePortAsyncOptions {
    eventTimeoutMs?: number;
}
declare class BetterMessagePortAsync<MessagePortEvents> {
    private postMessage;
    private options?;
    private messages;
    private listeners;
    constructor(postMessage: PostMessageFunc, options?: BetterMessagePortAsyncOptions | undefined);
    messageHandler(data: BetterMessagePayload): Promise<void>;
    on<K extends keyof MessagePortEvents, R = ExtractReturnType<MessagePortEvents, K>>(name: K, callback: (...args: ExtractParams<MessagePortEvents, K>) => Promise<Awaited<R>>): () => boolean;
    off<K extends keyof MessagePortEvents>(name: K): void;
    sendMessage<K extends keyof MessagePortEvents>(name: K | {
        name: K;
        messageId: string;
    }, ...args: ExtractParams<MessagePortEvents, K>): Promise<ExtractReturnType<MessagePortEvents, K>>;
    destroy(): void;
}
declare class BetterMessagePortSync<MessagePortEvents> {
    private postMessage;
    private listeners;
    constructor(postMessage: PostMessageFunc);
    messageHandler(data: BetterMessagePayload): void;
    on<K extends keyof MessagePortEvents>(name: K, callback: (...args: ExtractParams<MessagePortEvents, K>) => void): () => void;
    off<K extends keyof MessagePortEvents>(name: K, callback: (...args: ExtractParams<MessagePortEvents, K>) => void): void;
    sendMessage<K extends keyof MessagePortEvents>(name: K, ...args: ExtractParams<MessagePortEvents, K>): void;
    destroy(): void;
}
declare class BetterMessagePort<AsyncEvents = unknown, SyncEvents = unknown> {
    private messagePort;
    sync: BetterMessagePortSync<SyncEvents>;
    async: BetterMessagePortAsync<AsyncEvents>;
    private nomalizedMessagePort;
    constructor(messagePort: MessagePortType, options?: BetterMessagePortAsyncOptions);
    private onMessage;
    destroy(): void;
    static normalizeMessagePort(messagePort: MessagePortType): NormalizeMessagePort;
    static createStandalone<Events>(type: 'async', port: MessagePortType): BetterMessagePortAsync<Events>;
    static createStandalone<Events>(type: 'sync', port: MessagePortType): BetterMessagePortSync<Events>;
}

export { type BetterMessagePayload, BetterMessagePortAsync, type BetterMessagePortAsyncOptions, type BetterMessagePortOptions, type BetterMessagePortResult, type BetterMessagePortSend, BetterMessagePortSync, type NormalizeMessagePort, BetterMessagePort as default };