import type { WorkerPool } from '../workers/pool.ts';
import type { OperationOutcome, WorkerInboundMessage, WorkerOutboundMessage } from './types.ts';
import { WorkerExecutionOwnership } from './worker-execution-ownership.ts';
export interface WorkerExecutionDispatcherDependencies {
    pool: WorkerPool;
    ownership: WorkerExecutionOwnership;
    isDisposed: () => boolean;
    requireProtocolVersion: () => boolean;
    validateHostToWorkerMessage: (workflowId: string, message: WorkerInboundMessage, worker?: Worker) => boolean;
    attachWorkerListeners: (worker: Worker) => void;
    detachWorkerListenersIfIdle: (worker: Worker) => void;
    /**
     * Resolve once `worker`'s realm-ready handshake has settled (or
     * immediately, if realm-readiness isn't required). `false` means the
     * handshake failed or timed out; the implementation is responsible for
     * discarding the worker and emitting the workflow failure itself, the same
     * contract `validateHostToWorkerMessage` already uses.
     */
    ensureRealmReady: (worker: Worker, workflowId: string) => Promise<boolean>;
    beginTurn: (worker: Worker, workflowId: string, turnId: number, kind: 'run' | 'resume') => void;
    clearTurn: (worker: Worker) => void;
    discardWorkerAndFailWorkflows: (worker: Worker, options: {
        targetWorkflowId?: string;
        targetCategory?: 'application' | 'timeout' | 'cancellation' | 'resource' | 'system';
        targetError?: string;
        skipTarget?: boolean;
        otherCategory: 'application' | 'timeout' | 'cancellation' | 'resource' | 'system';
        otherError: string;
    }) => void;
    emit: (message: WorkerOutboundMessage) => void;
}
export interface WorkerResumeParameters {
    workflowId: string;
    checkpoint: ArrayBuffer;
    operationResult: OperationOutcome;
}
export declare class WorkerExecutionDispatcher {
    #private;
    constructor(dependencies: WorkerExecutionDispatcherDependencies);
    acquireAndSend(workflowId: string, message: WorkerInboundMessage & {
        type: 'run';
    }): Promise<void>;
    postResumeMessage(worker: Worker, parameters: WorkerResumeParameters, message: WorkerInboundMessage & {
        type: 'resume';
    }): void;
    resumeParkedWorkflow(parameters: WorkerResumeParameters, parkedWorker: Worker, message: WorkerInboundMessage & {
        type: 'resume';
    }): Promise<void>;
    cancelParkedWorkflow(workflowId: string, parkedWorker: Worker): Promise<void>;
}