declare enum ActionType {
    Init = "init",// Start the worker initialization
    Call = "call",// Call any exported WASM function universally
    Terminate = "terminate"
}
declare class WorkerInitAction {
    readonly action = ActionType.Init;
}
declare class WorkerTerminateAction {
    readonly action = ActionType.Terminate;
}
declare class WorkerCallAction {
    id: number | string;
    functionName: string;
    params: any[];
    transferables?: ArrayBuffer[] | undefined;
    readonly action = ActionType.Call;
    constructor(id: number | string, functionName: string, params: any[], transferables?: ArrayBuffer[] | undefined);
}
type WorkerIncomingAction = WorkerInitAction | WorkerCallAction | WorkerTerminateAction;
declare enum WorkerResponseType {
    Result = "result",// Result of a successful 'Call'
    Error = "error",// Error occurred during initialization or processing
    Initialized = "initialized",// Worker setup complete, WASM runtime ready in proxied thread
    Log = "log"
}
interface WorkerResponse {
    type: WorkerResponseType;
    id?: number | string;
    result?: any;
    logMessage?: string;
    logLevel?: number;
    functionName?: string;
    error?: string;
}
declare const relativePath: string;
declare const workerScriptUrl: string;
declare const moduleBaseUrl: string;
declare const wasmParams: URLSearchParams;
declare const wasmFilePath: string;
declare const jsFilePath: string;
declare const locateWasm: (file: string) => string;
declare let ZenidModule: any;
declare var PThread: any;
declare enum WasmState {
    uninitialized = 0,// Before Init message received
    initializing = 1,// Main worker setting up proxy & proxied thread initializing runtime
    initialized = 2
}
declare let wasmState: WasmState;
declare let proxiedThread: Worker | null;
declare function postMessageToMain(message: any): void;
declare function postLog(message: string, level?: number): void;
declare function postError(message: string, id?: string | number, functionName?: string): void;
declare function safeCall<T>(func: () => T): T;
declare function preprocessArgs(args: any[], allocatedPtrs: number[]): any[];
declare function cleanupAllocatedMemory(allocatedPtrs: number[]): void;
declare function callNativeFunction(functionName: string, args: any[]): any;
declare let originalOnMessage: (((this: WindowEventHandlers, ev: MessageEvent<any>) => any) & ((this: Window, ev: MessageEvent<any>) => any)) | null;
declare function runOnChallenge(): void;
/** Handles messages WITHIN the proxied (em-pthread) worker AFTER initialization. */
declare function handleProxiedMessage(e: MessageEvent<WorkerIncomingAction>): void;
/** Handles messages in the MAIN worker, proxying them TO the proxied worker */
declare function handleProxyMessage(e: MessageEvent): void;
/** Handles the VERY FIRST message to the main worker to trigger initialization */
declare function handleInitialMessage(e: MessageEvent<WorkerIncomingAction>): void;
declare function setupProxyAndLoadEmscripten(): Promise<void>;
//# sourceMappingURL=zenid-worker.d.ts.map