import type { GenerateRequestId } from '../engine/inference-types.js';
/**
 * Tracks the lifecycle of a pending request: its promise, settlement state,
 * abort signal, and cleanup. Generic over the result type so both native
 * completions and worker call responses can share the same bookkeeping.
 */
export interface RequestHandle<TResult> {
    readonly promise: Promise<TResult>;
}
export declare class RequestTracker<TResult> {
    private readonly completions;
    private readonly abortRegistrations;
    private readonly activeRuns;
    get activeCount(): number;
    hasActive(requestId: GenerateRequestId): boolean;
    has(requestId: GenerateRequestId): boolean;
    isSettled(requestId: GenerateRequestId): boolean;
    isConsumed(requestId: GenerateRequestId): boolean;
    isCancelRequested(requestId: GenerateRequestId): boolean;
    requestCancel(requestId: GenerateRequestId): void;
    setTokenBatchSinkError(requestId: GenerateRequestId, error: unknown): void;
    tokenBatchSinkError(requestId: GenerateRequestId): unknown;
    /** All request IDs that appear in any internal collection. */
    allTrackedIds(): GenerateRequestId[];
    /**
     * Start tracking a request. Returns the existing tracker if already tracked,
     * or creates a new one. Marks the request as active.
     */
    track(requestId: GenerateRequestId): RequestHandle<TResult>;
    beginWait(requestId: GenerateRequestId): Promise<TResult>;
    endWait(requestId: GenerateRequestId): void;
    /**
     * Resolve a tracked request with a result.
     * No-op if already settled.
     */
    resolve(requestId: GenerateRequestId, result: TResult): void;
    /**
     * Reject a tracked request with an error.
     * No-op if already settled.
     */
    reject(requestId: GenerateRequestId, error: unknown): void;
    /** Reject all unsettled requests and clear everything. */
    rejectAll(error: unknown): void;
    /**
     * Attach an AbortSignal to a request. When the signal fires, `onAbort`
     * is called (typically to issue a cancellation to the engine).
     */
    attachSignal(requestId: GenerateRequestId, signal: AbortSignal, onAbort: () => void): () => void;
    /** Detach and clean up the AbortSignal listener for a request. */
    releaseSignal(requestId: GenerateRequestId): void;
    private releaseAbortRegistration;
    /**
     * Full cleanup for a finished request: release signal, remove from active,
     * and optionally delete its completion entry entirely.
     */
    finalize(requestId: GenerateRequestId, options?: {
        deleteCompletion?: boolean;
    }): void;
    /**
     * If a request is settled, consumed, and has no active waiters,
     * delete it from the map to free memory.
     */
    cleanupIfConsumed(requestId: GenerateRequestId): void;
    /** Clear all state (used during runtime reset). */
    clear(): void;
}