import { CompletedWaitpoint, ExecutorToWorkerMessageCatalog, MachinePresetResources, ServerBackgroundWorker, TaskRunExecutionPayload, TaskRunExecutionResult, type TaskRunInternalError, WorkerManifest } from "@trigger.dev/core/v3";
import { Evt } from "evt";
import { InferSocketMessageSchema } from "@trigger.dev/core/v3/zodSocket";
export type OnSendDebugLogMessage = InferSocketMessageSchema<typeof ExecutorToWorkerMessageCatalog, "SEND_DEBUG_LOG">;
export type OnSetSuspendableMessage = InferSocketMessageSchema<typeof ExecutorToWorkerMessageCatalog, "SET_SUSPENDABLE">;
export type TaskRunProcessOptions = {
    workerManifest: WorkerManifest;
    serverWorker: ServerBackgroundWorker;
    env: Record<string, string>;
    machineResources: MachinePresetResources;
    isWarmStart?: boolean;
    cwd?: string;
    gracefulTerminationTimeoutInMs?: number;
};
export type TaskRunProcessExecuteParams = {
    payload: TaskRunExecutionPayload;
    messageId: string;
    env?: Record<string, string>;
};
export declare class TaskRunProcess {
    #private;
    readonly options: TaskRunProcessOptions;
    private _ipc?;
    private _child;
    private _childPid?;
    private _attemptPromises;
    private _attemptStatuses;
    private _currentExecution;
    private _gracefulExitTimeoutElapsed;
    private _isBeingKilled;
    private _isBeingCancelled;
    private _isBeingSuspended;
    private _isMaxDurationExceeded;
    private _maxDurationInfo?;
    private _stderr;
    onTaskRunHeartbeat: Evt<string>;
    onExit: Evt<{
        code: number | null;
        signal: NodeJS.Signals | null;
        pid?: number;
    }>;
    onSendDebugLog: Evt<OnSendDebugLogMessage>;
    onSetSuspendable: Evt<OnSetSuspendableMessage>;
    private _isPreparedForNextRun;
    private _isPreparedForNextAttempt;
    constructor(options: TaskRunProcessOptions);
    get isPreparedForNextRun(): boolean;
    get isPreparedForNextAttempt(): boolean;
    unsafeDetachEvtHandlers(): void;
    cancel(): Promise<void>;
    cleanup(kill?: boolean): Promise<void>;
    initialize(): this;
    execute(params: TaskRunProcessExecuteParams, isWarmStart?: boolean): Promise<TaskRunExecutionResult>;
    isExecuting(): boolean;
    waitpointCompleted(waitpoint: CompletedWaitpoint): void;
    /** This will never throw. */
    kill(signal?: number | NodeJS.Signals, timeoutInMs?: number): Promise<void>;
    suspend({ flush }: {
        flush: boolean;
    }): Promise<void>;
    get isBeingKilled(): boolean | undefined;
    get isBeingSuspended(): boolean;
    get pid(): number | undefined;
    get isHealthy(): boolean;
    static parseExecuteError(error: unknown, dockerMode?: boolean): TaskRunInternalError;
}