/**
 * this is a wrapper for workers. we want to support node in addition to the
 * browser. bun seems to support web APIs with no modification, but node needs
 * special attention. not sure about deno.
 *
 * switching to specific classes for different environments. also the plan is
 * to add a main-thread (i.e. no-worker, inline calc) version.
 *
 */
export interface WorkerProxy<TX, RX = TX> {
    /** terminate worker */
    Terminate: () => void;
    /** initialize, possibly loading code */
    Init: (url: string, browser_init_method: () => Worker) => Promise<void>;
    /** wrapper for postMessage */
    PostMessage: (message: TX) => void;
    /** wrapper for addEventListener */
    OnMessage: (fn: (message: MessageEvent<RX>) => void | Promise<void>) => void;
    /** wrapper for addEventListener */
    OnError: (fn: (message: ErrorEvent) => void | Promise<void>) => void;
}
export declare class WorkerProxyBrowser<TX, RX = TX> implements WorkerProxy<TX, RX> {
    worker?: Worker;
    Terminate(): void;
    /**
     * OK this changed to support svelte/vite/I guess it's all rollup under
     * the hood. whatever the tool is, it does static analysis and it has
     * to see the pattern loaded in order to bundle the worker module. so
     * we play ball. this is not a good situation.
     *
     * the browser init method should look something like this:
     *
     * () => {
     *    return new Worker(new URL(url, import.meta.url), {
     *       type: 'module'
     *    }) as Worker;
     * }
     *
     * so that the code analyzer will see it.
     *
     * @param url
     * @param browser_init_method
     */
    Init(url: string, browser_init_method: () => Worker): Promise<void>;
    PostMessage(message: TX): void;
    OnMessage(fn: (message: MessageEvent<RX>) => (void | Promise<void>)): void;
    OnError(fn: (message: ErrorEvent) => (void | Promise<void>)): void;
}
export declare class WorkerProxyNode<TX, RX = TX> implements WorkerProxy<TX, RX> {
    worker?: {
        postMessage: (message: TX) => void | Promise<void>;
        terminate: () => void;
        on: (type: 'message' | 'error', handler: (data: RX) => void | Promise<void>) => void;
    };
    Terminate(): void;
    Init(url: string): Promise<void>;
    PostMessage(message: TX): void;
    OnMessage(fn: (message: MessageEvent<RX>) => (void | Promise<void>)): void;
    OnError(fn: (message: ErrorEvent) => (void | Promise<void>)): void;
}
interface InProcessContext<TX, RX> {
    addEventListener: (type: 'message', handler: (event: MessageEvent<TX>) => void | Promise<void>) => void;
    postMessage: (data: RX) => void;
}
type composite<TX, RX> = WorkerProxy<TX, RX> & InProcessContext<TX, RX>;
export declare class WorkerProxyInProcess<TX, RX = TX> implements composite<TX, RX> {
    protected tx_cache: TX[];
    protected main_thread_to_worker_message_handler?: (event: MessageEvent<TX>) => void | Promise<void>;
    protected rx_cache: RX[];
    protected worker_to_main_thread_message_handler?: (message: MessageEvent<RX>) => void | Promise<void>;
    Terminate(): void;
    Init(url: string): Promise<void>;
    /** post message from "worker" to "main thread" */
    PostMessage(message: TX): void;
    /** callback when "main thread" sends message to "worker" */
    OnMessage(fn: (message: MessageEvent<RX>) => (void | Promise<void>)): void;
    OnError(fn: (message: ErrorEvent) => (void | Promise<void>)): void;
    FlushCache<T>(cache: T[], fn: (message: MessageEvent<T>) => void | Promise<void>): void;
    addEventListener(type: 'message', handler: (event: MessageEvent<TX>) => void | Promise<void>): void;
    postMessage(data: RX): void;
}
/**
 * factory method for workers. supports web workers (also bun), node workers
 * and (via parameter) in-process workers. we're still figuring out how to
 * signal that we're in process, currently somewhat clumsy
 *
 * @param in_process
 * @returns
 */
export declare function CreateWorker<TX, RX = TX>(in_process?: boolean): WorkerProxy<TX, RX>;
/**
 * this is for the worker side, to normalize postMessage/onmessage
 */
export declare const GetWorkerContext: () => Promise<Worker>;
export {};