import type { Capability, Logger, Policy, ProviderInterface, ProviderModel, Task, TaskOutput, WorkerDefinition, WorkerInstance, WorkerPreferences, WorkerType } from './types.js';
import type { EventBus } from './event-bus.js';
import type { CapabilityRouter } from './router.js';
import type { ProviderManager } from './provider-manager.js';
import type { PolicyEngine } from './policies.js';
export interface WorkerContext {
    eventBus: EventBus;
    router: CapabilityRouter;
    providerManager: ProviderManager;
    policies: PolicyEngine;
    logger: Logger;
}
export type WorkerExecuteFn = (task: Task, provider: ProviderInterface, model: ProviderModel, ctx: WorkerContext) => Promise<TaskOutput>;
export interface WorkerHandler {
    type: WorkerType;
    capabilities: Capability[];
    preferences: WorkerPreferences;
    execute: WorkerExecuteFn;
    verify?: (task: Task, output: TaskOutput) => Promise<boolean>;
}
export declare class WorkerRuntime {
    private ctx;
    private handlers;
    private active;
    private registered;
    /** Default policy used when a mission doesn't specify one. */
    private defaultPolicyName;
    /** Per-worker-type model pins set by the host application. */
    private workerPins;
    constructor(ctx: WorkerContext);
    /** Override the default policy used for routing. */
    setDefaultPolicy(name: Policy['name']): void;
    /** Set a model pin for a worker type — overrides the router when healthy. */
    setWorkerPin(type: WorkerType, providerId: string, modelId: string): void;
    /** Bulk-set worker pins. */
    setWorkerPins(pins: Map<WorkerType, {
        providerId: string;
        modelId: string;
    }>): void;
    /** Clear all pins. */
    clearWorkerPins(): void;
    registerWorker(definition: WorkerDefinition): void;
    registerHandler(handler: WorkerHandler): void;
    getHandler(type: WorkerType): WorkerHandler | undefined;
    listWorkerTypes(): WorkerType[];
    listRegisteredDefinitions(): WorkerDefinition[];
    matchWorkerType(capabilities: Capability[]): WorkerType | undefined;
    private capabilityOverlap;
    spawn(type: WorkerType, missionId: string, taskId: string, capabilities: Capability[]): Promise<WorkerInstance>;
    execute(instance: WorkerInstance, task: Task, override?: {
        providerId: string;
        modelId: string;
    }): Promise<TaskOutput>;
    destroy(instance: WorkerInstance): Promise<void>;
    getActive(): WorkerInstance[];
    getInstance(id: string): WorkerInstance | undefined;
    /**
     * Build a routing plan: the chosen model plus the ranked alternatives the
     * router considered. Honors worker pins (a hard lock), otherwise defers to
     * the policy-driven capability router.
     */
    private planRoute;
    private lockedPlan;
    private emitRouting;
    private emit;
}