export interface Clock {
    now(): number;
    setTimeout(handler: () => void, ms: number): TimerHandle;
    clearTimeout(handle: TimerHandle): void;
}
export type TimerHandle = {
    readonly id: unknown;
};
export declare const systemClock: Clock;
export declare class AsyncMutex {
    private tail;
    run<T>(fn: () => Promise<T> | T): Promise<T>;
}
export declare class FinalizeOnce<T> {
    private promise;
    private winnerReason;
    get started(): boolean;
    get reason(): string | undefined;
    run(reason: string, fn: () => Promise<T>): Promise<T>;
    join(): Promise<T> | undefined;
}
export type Unsubscribe = () => void;
export declare class Notifier {
    private version;
    private readonly listeners;
    get current(): number;
    bump(): void;
    subscribe(listener: (version: number) => void): Unsubscribe;
    clear(): void;
}
export interface SessionTimers {
    idle?: TimerHandle | undefined;
    lifetime?: TimerHandle | undefined;
}
export declare class TimerSet {
    private readonly clock;
    private readonly onExpire;
    private readonly timers;
    constructor(clock: Clock, onExpire: (reason: "idle-timeout" | "lifetime-timeout") => void);
    armIdle(ms: number | undefined): void;
    armLifetime(ms: number | undefined): void;
    clearAll(): void;
}
export interface Waiter {
    cancel(): void;
}
export declare class WaiterSet {
    private readonly waiters;
    add(waiter: Waiter): Unsubscribe;
    cancelAll(): void;
    get size(): number;
}
export interface QueuedInputAction {
    readonly sequence: number;
    readonly queuedBytes: number;
    readonly cursorAtAcceptance: number;
    readonly deliver: () => Promise<InputDeliveryOutcome>;
    readonly settle: (outcome: InputDeliveryOutcome) => void;
}
export interface InputDeliveryOutcome {
    readonly status: "delivered" | "not-delivered" | "unknown";
    readonly deliveredBytes: number;
    readonly cause?: unknown;
}
export declare class OrderedInputQueue {
    private readonly queue;
    private draining;
    private nextSequence;
    private queuedBytes;
    get depth(): number;
    get pendingBytes(): number;
    peekSequence(): number;
    reserve(bytes: number): number;
    enqueue(action: QueuedInputAction): void;
    private drain;
    rejectAll(outcome: InputDeliveryOutcome): void;
}