import { ScopeDBError } from "./errors.js";
export declare const MAX_TIMER_MS = 2147483647;
export declare function positiveIntegerConfig(name: string, value: number, max?: number): number;
export declare function nonnegativeIntegerConfig(name: string, value: number, max?: number): number;
export declare class Deferred<T> {
    readonly promise: Promise<T>;
    resolve: (value: T) => void;
    reject: (reason?: unknown) => void;
    constructor();
}
export declare const QUEUE_TIMEOUT: unique symbol;
export declare const QUEUE_CLOSED: unique symbol;
export declare const QUEUE_HEAD_UNAVAILABLE: unique symbol;
type QueueReceiveResult<T> = T | typeof QUEUE_TIMEOUT | typeof QUEUE_CLOSED;
export declare class AsyncBoundedQueue<T> {
    private readonly capacity;
    private readonly items;
    private readonly sendWaiters;
    private readonly recvWaiters;
    private closed;
    constructor(capacity: number);
    send(item: T, signal?: AbortSignal): Promise<void>;
    trySend(item: T): boolean;
    receive(timeoutMs: number): Promise<QueueReceiveResult<T>>;
    tryReceiveHeadIf(predicate: (item: T) => boolean): T | typeof QUEUE_HEAD_UNAVAILABLE;
    drain(): T[];
    close(): void;
    private drainSenders;
    private removeSenderAbortListener;
}
export declare class PendingBytesClosedError extends Error {
}
export declare class PendingBytesExceedsCapacityError extends Error {
    readonly capacity: number;
    constructor(capacity: number);
}
export declare class PendingBytesReservation {
    private readonly budget;
    readonly permits: number;
    private released;
    constructor(budget: PendingBytesBudget, permits: number);
    release(): void;
}
export declare class PendingBytesBudget {
    private readonly capacity;
    private available;
    private readonly waiters;
    private closed;
    constructor(capacity: number);
    acquire(requested: number, signal?: AbortSignal): Promise<PendingBytesReservation>;
    tryAcquire(requested: number): PendingBytesReservation | null;
    usedBytes(): number;
    release(permits: number): void;
    close(): void;
    private drainWaiters;
    private removeWaiterAbortListener;
}
export declare function abortReason(signal: AbortSignal): unknown;
export declare function throwIfAborted(signal?: AbortSignal): void;
export declare function byteLength(payload: string): number;
export declare function nextBackoff(currentMs: number, maxBackoffMs: number): number;
export declare function sleep(ms: number, signal?: AbortSignal): Promise<void>;
export declare function waitForAck<T>(deferred: Deferred<T>, makeClosedError: () => ScopeDBError): Promise<T>;
export {};
//# sourceMappingURL=stream-internals.d.ts.map