/// <reference types="node" />
import { DefaultListener, ListenerSignature } from "tiny-typed-emitter";
import { MessagePort } from "worker_threads";
import type { Thread } from "./Thread";
export declare type InternalFunctions = {
    runQueue: Thread["_runQueue"];
    stopExecution: Thread["stopExecution"];
    require: Thread["require"];
    _getThreadReferenceData: Thread["_getThreadReferenceData"];
};
declare type UnsafeReturnType<T> = T extends (...args: any[]) => infer R ? R : any;
declare type UnsafeParameters<T> = T extends (...args: infer P) => any ? P : never;
export declare type PromisefulModule<M extends ThreadExports> = {
    [K in keyof M]: M[K] extends Function ? UnsafeReturnType<M[K]> extends PromiseLike<unknown> ? (...args: UnsafeParameters<M[K]>) => UnsafeReturnType<M[K]> : (...args: UnsafeParameters<M[K]>) => Promise<UnsafeReturnType<M[K]>> : () => Promise<M[K]>;
} & InternalFunctions;
export declare type ThreadExports = {
    [key: string]: unknown;
};
export declare type ThreadData = undefined | unknown;
export declare type ThreadExitInfo = {
    code?: number;
    err?: Error;
};
export declare type ThreadModule<Data = unknown, E extends ListenerSignature<E> = DefaultListener> = NodeJS.Module & {
    thread: Thread<{}, Data, E>;
};
export declare type ThreadOptions<T> = {
    threadModule?: string;
    eval?: boolean;
    sharedArrayBuffer?: SharedArrayBuffer;
    data?: T;
    count?: number;
};
export declare type UnknownFunction = (...args: any[]) => Promise<any>;
export declare type threadModule = {
    workerPort: MessagePort;
    workerData: {
        sharedArrayBuffer: SharedArrayBuffer;
    };
    transfers: [MessagePort];
};
export declare type Messages = {
    Reject: {
        type: "reject";
        data: Error;
        promiseKey: number;
    };
    Resolve: {
        type: "resolve";
        data: Array<unknown>;
        promiseKey: number;
    };
    Event: {
        type: "event";
        eventName: string;
        args: Array<unknown>;
        promiseKey: number;
    };
    Call: {
        func: keyof ThreadExports;
        type: "call";
        data: Array<unknown>;
        promiseKey: number;
    };
    Queue: {
        func: keyof ThreadExports;
        type: "queue";
        data: Array<unknown>;
        promiseKey: number;
    };
    Exit: {
        type: "exit";
        exitInfo: ThreadExitInfo;
    };
};
export declare type AnyMessage = Messages[keyof Messages];
export declare type RequiredThread<MM extends ThreadExports, DD extends ThreadData = undefined> = Thread<MM, DD> & Omit<PromisefulModule<MM>, "require">;
export {};
//# sourceMappingURL=Types.d.ts.map