import type { Region } from "../types.js";
import type { Clock } from "./abstractions.js";
import { SafeLogger } from "./logger.js";
import type { RateLimiter } from "./rate-limiter.js";
export type TransportRetryMode = "safe-read" | "never";
export interface TransportRequestPolicy {
    readonly region: Region;
    readonly operation: string;
    readonly retryMode: TransportRetryMode;
    readonly signal?: AbortSignal;
    readonly profileId?: string;
    readonly requestTimeoutMs?: number;
    readonly recoveryProbe?: boolean;
    readonly uncertainOnAbort?: boolean;
}
export interface TransportAttemptContext {
    readonly signal: AbortSignal;
    readonly attempt: number;
    readonly maxAttempts: number;
}
export type TransportAttempt<T> = (context: TransportAttemptContext) => Promise<T>;
export interface TransportPolicy {
    execute<T>(request: TransportRequestPolicy, attempt: TransportAttempt<T>): Promise<T>;
    close(): void;
}
export interface DefaultTransportPolicyOptions {
    rateLimiter?: RateLimiter;
    clock?: Clock;
    logger?: SafeLogger;
    random?: () => number;
    requestTimeoutMs?: number;
    readMaxAttempts?: number;
    baseRetryDelayMs?: number;
    maxRetryDelayMs?: number;
    maxRetryAfterMs?: number;
    circuitFailureThreshold?: number;
    circuitOpenMs?: number;
    timeoutScheduler?: TransportTimeoutScheduler;
}
export interface TransportTimeoutScheduler {
    schedule(delayMs: number, callback: () => void): () => void;
}
export declare class DefaultTransportPolicy implements TransportPolicy {
    #private;
    constructor(options?: DefaultTransportPolicyOptions);
    execute<T>(request: TransportRequestPolicy, attempt: TransportAttempt<T>): Promise<T>;
    close(): void;
}
export declare function createDefaultTransportPolicy(options?: DefaultTransportPolicyOptions): TransportPolicy;
//# sourceMappingURL=transport-policy.d.ts.map