/** Internal liveness loop for User_Input polling. */
type PollPass<Report> = () => Promise<Report>;
export type SyncPollingWait = (durationMs: number) => Promise<void>;
export interface SyncPollingSupervisorOptions<Report = unknown> {
    readonly runPass: PollPass<Report>;
    readonly intervalMs?: number;
    readonly errorBackoffInitialMs?: number;
    readonly errorBackoffMaxMs?: number;
    readonly wait?: SyncPollingWait;
    /**
     * Deferral gate applied ONLY to the loop's FIRST pass (default: no gate).
     *
     * The first scheduled pass waits for this promise before any remote
     * read starts, so a host can keep the first polling pass out of an
     * initial drain on a shared request limiter. The gate is consulted once:
     * after it resolves, passes keep the normal interval cadence. A gate
     * that throws surfaces through the normal polling error path and is
     * retried (with backoff) before any pass runs. Manual `runOnce()` calls
     * are deliberately NOT gated: they are explicit caller-driven passes.
     */
    readonly waitForFirstPass?: () => Promise<void>;
    readonly onReport?: (report: Report) => void;
    readonly onError?: (error: unknown) => void;
}
/**
 * Coalesces polling passes and stops only after an active provider call returns.
 * The service can therefore close the shared SQLite adapter safely.
 */
export declare class SyncPollingSupervisor<Report = unknown> {
    private readonly runPass;
    private readonly intervalMs;
    private readonly errorBackoffInitialMs;
    private readonly errorBackoffMaxMs;
    private readonly wait;
    private readonly waitForFirstPass;
    private firstPassPending;
    private readonly onReport;
    private readonly onError;
    private running;
    private acceptingPasses;
    private loopPromise;
    private inFlight;
    private stopPromise;
    private wakeWaiter;
    constructor(options: SyncPollingSupervisorOptions<Report>);
    /** Starts the immediate-then-periodic polling loop. */
    start(): void;
    /** Returns whether a stop has been requested; used to interrupt gates. */
    isStopping(): boolean;
    /** Runs one pass or joins the pass already in flight. */
    runOnce(): Promise<Report>;
    /** Stops scheduling new polls and waits for the current remote read. */
    stop(): Promise<void>;
    private runLoop;
    private waitWhileRunning;
    private clearInFlight;
    private notifyReport;
    private notifyError;
}
export {};
//# sourceMappingURL=SyncPollingSupervisor.d.ts.map