/// <reference types="node" />
import { MessagePort, Worker } from "worker_threads";
import { DefaultListener, ListenerSignature, TypedEmitter } from "tiny-typed-emitter";
import type { threadModule, ThreadOptions, ThreadExports, ThreadData, PromisefulModule, ThreadExitInfo } from "./Types";
import { ParentThread } from "./Parent";
export declare class Thread<M extends ThreadExports = ThreadExports, D extends ThreadData = undefined, E extends ListenerSignature<E> = DefaultListener> extends TypedEmitter<E> {
    private _threadStore;
    worker?: MessagePort | Worker;
    data?: D;
    threadModule?: string;
    protected _sharedArrayBuffer: SharedArrayBuffer;
    private _promises;
    private _promiseKey;
    private _functionQueue;
    private _stopExecution;
    importedThreads: Record<string, Thread<ThreadExports, ThreadData>>;
    private _internalFunctions?;
    static spawnedThreads: Record<string, Thread<ThreadExports, ThreadData>>;
    exited: Promise<ThreadExitInfo>;
    private _exited;
    private _exitResolve;
    get running(): boolean;
    private proxyPorts;
    /**
     * Returns a promise containing a constructed `Thread`.
     * @param {MessagePort} worker Port the thread will communicate on
     * @param {Object} options Data passed to thread on start
     * @param {SharedArrayBuffer} options.sharedArrayBuffer Shared memory containing thread parameters
     */
    constructor(worker: Worker | MessagePort | false, options: ThreadOptions<D>);
    loadExports: (exports: ThreadExports) => void;
    queue: M;
    static addThread: (threadName: string, thread: Thread<ThreadExports, ThreadData>) => void;
    static newProxyThread: <E_1 extends ThreadExports>(threadName: string, exports: E_1) => ParentThread<E_1, unknown, DefaultListener>;
    terminate: () => Promise<number>;
    emit: <U extends keyof E>(eventName: U, ...args: Parameters<E[U]>) => boolean;
    /**
     * Stops execution of the function queue.
     */
    stopExecution: () => Promise<true>;
    /**
     * Imports a reference to a running thread by its threadName,
     * @example // To load a reference to the thread running file `./somepath/helloWorld`
     * const helloWorldThread = thisThread.require('helloWorld')
     * thisThread.threads['helloWorld'] // Also set to the thread reference for non async access
     */
    require: <MM extends ThreadExports, DD extends unknown = undefined, EE extends ListenerSignature<EE> = DefaultListener>(threadName: string, options?: {
        isPath?: true | undefined;
    } | undefined) => Promise<Thread<MM, DD, EE> & Omit<PromisefulModule<MM>, "require">>;
    /**
     * Creates a new `workerPort` for xThread communication, handled by `_messageHandler`.
     * Returns the new `workerPort` and this threads `workerData`.
     * @returns {{MessagePort: MessagePort, workerData:{sharedArrayBuffer:SharedArrayBuffer} Transfers: [MessagePort]}} Object containing data needed to reference this thread.
     */
    _getThreadReferenceData: (threadName: string) => Promise<threadModule>;
    buildReferenceData: () => Promise<threadModule>;
    get working(): number;
    set working(value: number);
    get queued(): number;
    set queued(value: number);
    /**
     * Queues a function to be executed in the future.
     * @param {Object} message Object containing function info.
     * @param {string} message.func Function from `this._functions` to execute.
     * @param {*} message.data Data passed to `function`.
     * @param {string|number} message.promiseKey Unique key used for returned promise.
     */
    private _queueSelfFunction;
    /**
     * Runs thread queue.
     * @returns {Promise<number>} functions run.
     */
    private _runQueue;
    /**
     * Handler function for thread communication.
     * @param {Object} message
     * @param {string} message.type
     */
    private _messageHandler;
    /**
     * Returns a function for handling xThread funciton calls.
     * @param workerPort the port calls are handled over.
     * @returns xThread function handler.
     */
    private _functionHandler;
    /**
     * Calls a thread function.
     * @param {string} func Key of `function` to execute.
     * @param {*} data Data to give to the `function`.
     * @param {number|string} promiseKey Unique key used for returned promise.
     *
     * @returns {Promise} Promise that resolves with function result.
     */
    private _callThreadFunction;
}
//# sourceMappingURL=Thread.d.ts.map