import type { AsyncJob, AsyncJobDeliverySink, AsyncJobDeliveryState, AsyncJobDetails, AsyncJobFilter, AsyncJobManagerApi, AsyncJobProcess, AsyncJobReapResult, AsyncJobRegisterOptions, AsyncJobRun, AsyncJobRunResult, AsyncJobType } from "../../async/job-manager.js";
import type { JobWidgetInputs, JobWidgetRegistry } from "../../job-widgets/types.js";
import type { RemoteObject } from "../rpc.js";
import { type AsyncJobManagerProtocol, type AsyncJobWire } from "./async-jobs-protocol.js";
type Remote = RemoteObject<AsyncJobManagerProtocol>;
/** Live inputs of a job registered from this worker. */
interface LocalInputs {
    readonly process?: AsyncJobProcess;
    readonly widgetInputs?: JobWidgetInputs;
}
/** Worker-side job row: a projection of main's row plus local stand-ins for its live fields. */
export declare class RemoteAsyncJob implements AsyncJob {
    #private;
    readonly id: string;
    readonly type: AsyncJobType;
    readonly status: AsyncJob["status"];
    readonly startTime: number;
    readonly endTime?: number;
    readonly label: string;
    readonly intent?: string;
    readonly resultText?: string;
    readonly errorText?: string;
    readonly structured?: AsyncJob["structured"];
    readonly progressText?: string;
    readonly latestDetails?: AsyncJobDetails;
    readonly ownerId?: string;
    readonly agentId?: string;
    readonly agentOutputPublished?: boolean;
    readonly queued?: boolean;
    readonly foreground?: boolean;
    readonly process?: AsyncJobProcess;
    readonly widgetInputs?: JobWidgetInputs;
    constructor(manager: RemoteAsyncJobManager, wire: AsyncJobWire, local: LocalInputs | undefined);
    /** Settles when main's run promise settles; never rejects. */
    get promise(): Promise<void>;
    /** Local controller aborted when main aborts the job. */
    get abortController(): AbortController;
    get retainedArtifactsCleanup(): (() => Promise<void>) | undefined;
    /** Hands the cleanup to main's row, which runs it on eviction. */
    set retainedArtifactsCleanup(cleanup: (() => Promise<void>) | undefined);
}
/** Worker-side root job manager; see the module doc. */
export declare class RemoteAsyncJobManager implements AsyncJobManagerApi {
    #private;
    constructor(remote: Remote);
    get widgets(): JobWidgetRegistry | undefined;
    get atCapacity(): boolean;
    onJobSettled(listener: () => void): () => void;
    register(type: AsyncJobType, label: string, run: AsyncJobRun, options?: AsyncJobRegisterOptions): string;
    publishCompleted(type: AsyncJobType, label: string, result: AsyncJobRunResult, options: {
        id?: string;
        ownerId?: string;
        agentId?: string;
    }): string;
    cancel(id: string, filter?: AsyncJobFilter): boolean;
    getJob(id: string): AsyncJob | undefined;
    getRunningJobs(filter?: AsyncJobFilter): AsyncJob[];
    getRecentJobs(limit?: number, filter?: AsyncJobFilter): AsyncJob[];
    getAllJobs(filter?: AsyncJobFilter): AsyncJob[];
    backgroundJob(jobId: string): boolean;
    /** A notification: nothing to wait for, and every later call reaches main after it. */
    releaseForegroundJob(jobId: string): void;
    getDeliveryState(filter?: AsyncJobFilter): AsyncJobDeliveryState;
    hasPendingDeliveries(filter?: AsyncJobFilter): boolean;
    watchJobs(jobIds: string[]): number;
    unwatchJobs(jobIds: string[]): number;
    acknowledgeDeliveries(jobIds: string[]): number;
    consumeJobResults(jobIds: string[]): number;
    isJobResultConsumed(jobId: string): boolean;
    cancelAll(filter?: AsyncJobFilter, reason?: unknown): void;
    evictCompletedJobs(filter?: AsyncJobFilter): number;
    waitForAll(): Promise<void>;
    registerDeliverySink(ownerId: string, sink: AsyncJobDeliverySink): () => void;
    waitForOwnerJobs(ownerId: string, options?: {
        timeoutMs?: number;
        excludeSuppressed?: boolean;
    }): Promise<boolean>;
    cancelAndReapOwnerJobs(ownerId: string, deadlineAt: number): Promise<AsyncJobReapResult>;
    drainDeliveries(options?: {
        timeoutMs?: number;
        filter?: AsyncJobFilter;
    }): Promise<boolean>;
    isDeliverySuppressed(jobId: string): boolean;
    isDeliveryPending(jobId: string): boolean;
    isDeliverySuperseded(jobId: string): boolean;
    /** One main `whenSettled` call per job id while it is pending; resolves (never rejects) on settle or link loss. */
    whenSettled(jobId: string): Promise<void>;
    /** Local controller for `jobId`, aborted with main's (unmapped) reason; one per job while it runs. */
    controllerFor(jobId: string): AbortController;
    /** Forward a row's `retainedArtifactsCleanup` assignment to main. */
    setRetainedArtifactsCleanup(jobId: string, cleanup: (() => Promise<void>) | undefined): void;
}
export {};