/**
 * 重试策略和网络请求重试机制
 * 提供统一的重试逻辑，支持指数退避
 */
export interface RetryOptions {
    /** 最大重试次数 */
    maxRetries?: number;
    /** 初始延迟时间（毫秒） */
    initialDelay?: number;
    /** 最大延迟时间（毫秒） */
    maxDelay?: number;
    /** 退避倍数 */
    backoffMultiplier?: number;
    /** 是否添加随机抖动 */
    jitter?: boolean;
    /** 判断是否应该重试的函数 */
    shouldRetry?: (error: Error, attempt: number) => boolean;
    /** 重试前的回调 */
    onRetry?: (error: Error, attempt: number, delay: number) => void;
}
/**
 * 计算下一次重试的延迟时间
 */
export declare function calculateDelay(attempt: number, options: Required<RetryOptions>): number;
/**
 * 带重试的异步函数执行器
 *
 * @example
 * ```typescript
 * const result = await retry(
 *     () => fetch('https://api.example.com/data'),
 *     { maxRetries: 3, initialDelay: 1000 }
 * );
 * ```
 */
export declare function retry<T>(fn: () => Promise<T>, options?: RetryOptions): Promise<T>;
/**
 * 创建一个带重试功能的函数包装器
 *
 * @example
 * ```typescript
 * const fetchWithRetry = withRetry(fetch, { maxRetries: 3 });
 * const response = await fetchWithRetry('https://api.example.com/data');
 * ```
 */
export declare function withRetry<T extends (...args: unknown[]) => Promise<unknown>>(fn: T, options?: RetryOptions): T;
/**
 * 重试策略预设
 */
export declare const RetryPresets: {
    /** 快速重试：3次，1秒起始 */
    fast: RetryOptions;
    /** 标准重试：5次，2秒起始 */
    standard: RetryOptions;
    /** 持久重试：10次，5秒起始 */
    persistent: RetryOptions;
    /** WebSocket 重连：无限重试 */
    websocket: RetryOptions;
};
/**
 * 日志接口（兼容 log4js Logger 和 console）
 */
export interface LoggerLike {
    info(...args: unknown[]): void;
    warn(...args: unknown[]): void;
    error(...args: unknown[]): void;
    debug?(...args: unknown[]): void;
}
/**
 * ConnectionManager 回调选项
 */
export interface ConnectionManagerCallbacks {
    /** 连接成功时回调（可用于 resetAttempts 后执行后续初始化） */
    onConnected?: () => void;
    /** 达到最大重试次数时回调 */
    onMaxRetriesReached?: (lastError?: Error) => void;
}
/**
 * 连接管理器 - 用于 WebSocket 等长连接的重连管理
 *
 * @example
 * ```typescript
 * const manager = new ConnectionManager(
 *     () => connectWebSocket(),
 *     RetryPresets.websocket,
 *     { logger: myLogger, onConnected: () => console.log('已连接') }
 * );
 * await manager.start();
 * ```
 */
export declare class ConnectionManager {
    private connect;
    private reconnectAttempt;
    private reconnectTimer;
    private active;
    private generation;
    private connectingGeneration?;
    private connectController?;
    private externalSignal?;
    private externalAbort?;
    private options;
    private logger;
    private callbacks;
    constructor(connect: (signal?: AbortSignal) => Promise<void>, options?: RetryOptions, { logger, ...callbacks }?: {
        logger?: LoggerLike;
    } & ConnectionManagerCallbacks);
    /**
     * 开始连接
     */
    start(signal?: AbortSignal): Promise<void>;
    /**
     * 停止连接和重连
     */
    stop(): void;
    /**
     * 触发重连
     */
    scheduleReconnect(error?: Error): void;
    private scheduleReconnectFor;
    /**
     * 重置重连计数（连接成功时调用）
     */
    resetAttempts(): void;
    /**
     * 获取当前重连次数
     */
    getAttempts(): number;
    private tryConnect;
}