/** Where the clock stands: never started, running, held by a pause, or finished. */
export type TimerPhase = 'idle' | 'running' | 'paused' | 'complete';
/** The clock as a consumer renders it, computed fresh on every read. */
export interface TimerState {
    /** Where the clock stands right now, as one of the four phases. */
    phase: TimerPhase;
    /** Milliseconds the clock has actually run, never counting paused time. */
    elapsed: number;
    /** Milliseconds left before completion, or `Infinity` when counting up. */
    remaining: number;
    /** The countdown length in force, `Infinity` for an open-ended count-up. */
    duration: number;
}
/** How one clock is configured; every field has a working default. */
export interface TimerOptions {
    /**
     * Countdown length in milliseconds; leave it out to count up with no end.
     *
     * @default Infinity
     */
    duration?: number | undefined;
    /**
     * Milliseconds between `onTick` calls while running; `0` reports no ticks.
     *
     * @default 0
     */
    tickMs?: number | undefined;
    /**
     * Whether a hidden or unloading page pauses the clock and a returning page resumes it.
     *
     * @default true
     */
    pauseWhenHidden?: boolean | undefined;
    /**
     * Called on every tick and once more at completion, for rendering the clock only.
     *
     * Ticks are far too frequent to announce: write them to a progress bar or a
     * `<time>`, never to a live region.
     */
    onTick?: ((state: TimerState) => void) | undefined;
    /**
     * Called when the phase changes, and only on an actual change, so it is the one place announcements belong.
     */
    onPhaseChange?: ((state: TimerState) => void) | undefined;
}
/** A framework-neutral countdown or count-up: `start`, `pause`, `resume`, `reset`, and a completion phase. */
export declare class Timer {
    private readonly options;
    private readonly tickMs;
    private duration;
    private phase;
    private accrued;
    private startedAt;
    private completion;
    private ticker;
    private pausedByPage;
    constructor(options?: TimerOptions);
    /** The phase, elapsed, remaining and duration as they read at this instant. */
    get state(): TimerState;
    /**
     * Runs the clock from zero, replacing whatever it was doing.
     *
     * @param duration a new countdown length to adopt, in milliseconds
     */
    start(duration?: number): void;
    /** Holds the clock where it stands; a second call while already paused changes nothing. */
    pause(): void;
    /** Runs the clock on from where a pause left it; ignored unless it is paused. */
    resume(): void;
    /** Stops the clock and returns it to zero, as it was before the first `start`. */
    reset(): void;
    /** Stops the clock and releases every listener and handle it holds. */
    destroy(): void;
    private measure;
    private run;
    private complete;
    private setPhase;
    private clearHandles;
    private readonly onVisibilityChange;
    private readonly onPageHide;
    private pauseForPage;
}