/**
 * 跨框架通信工具包类型定义
 */
type MessageType = `${string}:${string}`;
interface BaseMessage<T = any> {
    type: MessageType;
    payload: T;
    windowId?: string;
    timestamp: number;
}
interface RequestMessage<T = any> extends BaseMessage<T> {
    id: string;
    needResponse: true;
}
interface ResponseMessage<T = any> {
    id: string;
    success: boolean;
    data?: T;
    error?: string;
    windowId?: string;
    timestamp: number;
    isResponse: true;
}
interface EventMessage<T = any> extends BaseMessage<T> {
    needResponse?: false;
}
interface BridgeConfig {
    targetOrigin?: string;
    timeout?: number;
    debug?: boolean;
    enableMultiWindow?: boolean;
    windowId?: string;
}
type EventListener<T = any, R = any> = (payload: T) => R | Promise<R>;

/**
 * 消息处理器
 * 负责处理消息的发送、接收和响应逻辑
 */

declare class MessageHandler {
    private pendingRequests;
    private eventListeners;
    private messageId;
    private targetOrigin;
    private timeout?;
    private debug;
    private timeoutChecker;
    private checkInterval;
    constructor(targetOrigin: string, timeout?: number, debug?: boolean);
    /**
     * 启动集中式超时检查器
     */
    private startTimeoutChecker;
    /**
     * 检查所有待处理请求的超时
     */
    private checkTimeouts;
    /**
     * 生成唯一的消息ID
     */
    generateMessageId(): string;
    /**
     * 调试日志
     */
    log(...args: any[]): void;
    /**
     * 处理响应消息
     */
    handleResponse(response: ResponseMessage): void;
    /**
     * 处理请求消息
     */
    handleRequest(request: RequestMessage, source: Window): Promise<void>;
    /**
     * 创建待处理的请求
     * @param id 请求ID
     * @param resolve 成功回调
     * @param reject 失败回调
     * @param requestTimeout 可选的单个请求超时时间，覆盖全局设置
     */
    createPendingRequest(id: string, resolve: Function, reject: Function, requestTimeout?: number): void;
    /**
     * 添加事件监听器
     */
    addEventListener(type: MessageType, listener: EventListener): () => void;
    /**
     * 移除事件监听器
     */
    removeEventListener(type: MessageType, listener?: EventListener): void;
    /**
     * 清理所有待处理的请求
     */
    cleanup(): void;
    /**
     * 获取待处理请求数量（用于调试）
     */
    getPendingRequestsCount(): number;
    /**
     * 获取监听器数量（用于调试）
     */
    getListenersCount(): number;
}

/**
 * 跨框架通信基础桥梁类
 */

declare abstract class IframeBridge {
    protected messageHandler: MessageHandler;
    protected config: Required<BridgeConfig>;
    protected windowId?: string;
    constructor(config?: BridgeConfig);
    /**
     * 生成唯一窗口ID
     */
    private generateWindowId;
    /**
     * 设置消息监听器
     */
    protected abstract setupMessageListener(): void;
    /**
     * 获取目标窗口
     */
    protected abstract getTargetWindow(): Window | null;
    /**
     * 发送消息（无返回值）
     */
    send<T = any>(type: MessageType, payload: T): void;
    /**
     * 发送请求（有返回值）
     * @param type 消息类型
     * @param payload 消息负载
     * @param requestTimeout 单个请求的超时时间（毫秒），覆盖全局设置
     */
    request<T = any, R = any>(type: MessageType, payload: T, requestTimeout?: number): Promise<R>;
    /**
     * 监听消息
     */
    on<T = any, R = any>(type: MessageType, listener: EventListener<T, R>): () => void;
    /**
     * 取消监听
     */
    off<T = any, R = any>(type: MessageType, listener?: EventListener<T, R>): void;
    /**
     * 处理接收到的消息
     */
    protected handleIncomingMessage(event: MessageEvent): void;
    /**
     * 获取调试信息
     */
    getDebugInfo(): {
        config: Required<BridgeConfig>;
        windowId: string | undefined;
        pendingRequests: number;
        listeners: number;
    };
    /**
     * 销毁桥梁
     */
    destroy(): void;
}

/**
 * 消息队列管理器
 * 提供批量消息处理和流量控制功能
 */

interface QueueOptions {
    maxSize?: number;
    flushInterval?: number;
    batchSize?: number;
    priority?: boolean;
}
declare class QueueManager {
    private options;
    private bridge;
    private messageQueue;
    private processing;
    private flushTimer?;
    constructor(bridge: IframeBridge, options?: QueueOptions);
    private setupQueue;
    private enqueue;
    private startFlushTimer;
    private flush;
    flushNow(): Promise<void>;
    setPriority(type: MessageType, payload: any, priority: number): void;
    getQueueStatus(): {
        size: number;
        maxSize: number;
        processing: boolean;
        usage: number;
    };
    clear(): void;
    destroy(): void;
}
declare function createQueueManager(bridge: IframeBridge, options?: QueueOptions): QueueManager;

/**
 * 重试插件
 * 为 iframe-connect 提供自动重试功能
 */

interface RetryOptions {
    maxRetries?: number;
    baseDelay?: number;
    maxDelay?: number;
    backoff?: "linear" | "exponential";
    retryCondition?: (error: Error) => boolean;
}
declare class RetryManager {
    private options;
    private bridge;
    constructor(bridge: IframeBridge, options?: RetryOptions);
    private setupRetry;
    private requestWithRetry;
    private calculateDelay;
    private sleep;
    retryRequest<T, R>(type: MessageType, payload: T, customOptions?: Partial<RetryOptions>): Promise<R>;
    private calculateDelayWithOptions;
}
declare function createRetryManager(bridge: IframeBridge, options?: RetryOptions): RetryManager;

/**
 * 为 iframe-connect 提供详细的日志记录功能
 * 日志插件
 */

interface LoggerOptions {
    prefix?: string;
    timestamp?: boolean;
    colors?: boolean;
    level?: "debug" | "info" | "warn" | "error";
}
declare class Logger {
    private options;
    private bridge;
    constructor(bridge: IframeBridge, options?: LoggerOptions);
    private setupLogging;
    private log;
    private shouldLog;
    private colorize;
}
declare function createLogger(bridge: IframeBridge, options?: LoggerOptions): Logger;

interface PluginsConfig {
    logger?: boolean | LoggerOptions;
    retry?: boolean | RetryOptions;
    queue?: boolean | QueueOptions;
}

export { type BridgeConfig as B, type EventMessage as E, IframeBridge as I, Logger as L, type MessageType as M, type PluginsConfig as P, QueueManager as Q, type RequestMessage as R, type BaseMessage as a, type ResponseMessage as b, type EventListener as c, MessageHandler as d, createLogger as e, type LoggerOptions as f, RetryManager as g, createRetryManager as h, type RetryOptions as i, createQueueManager as j, type QueueOptions as k };