import { Stream } from '@libp2p/interface';

type Byte = Uint8Array[1];
type Frame = {
    length?: number;
    type: Byte;
    flags: Byte;
    streamId: number;
    payload?: unknown;
};

interface StreamWriterOptions {
    /** 分块大小（默认1MB） */
    chunkSize?: number;
    /** 背压缓冲区最大值（默认5MB） */
    bufferSize?: number;
    /** 失败重试次数（默认3次） */
    retries?: number;
}
declare class StreamWriter {
    private stream;
    private options;
    private p;
    private bytesWritten;
    private abortController;
    private backpressureHistory;
    private isBackpressure;
    private writeQueue;
    private isProcessingQueue;
    private lastBackpressureCheck;
    private bytesDrained;
    private lastDrainEventAt;
    private watchdogTimer;
    private stallStartAt;
    private lastBytesDrainedSeen;
    private lastBpWarnAt;
    private isHandlingError;
    /** drain 事件驱动等待者，替代 flush() 中的 setInterval 轮询 */
    private drainWaiters;
    private log?;
    constructor(stream: Stream, options?: StreamWriterOptions);
    get queueSize(): number;
    private getAverageQueueSize;
    private handleError;
    private startPipeline;
    private pipeToStream;
    private createTransform;
    private startWatchdog;
    write(data: ArrayBuffer | Uint8Array | Blob | string): Promise<void>;
    private convertToBuffer;
    private writeChunks;
    private retryableWrite;
    private monitorBackpressure;
    private calculateRetryDelay;
    private processQueue;
    private updateProgress;
    end(): Promise<void>;
    abort(reason?: string): void;
    private cleanup;
    flush(timeoutMs?: number): Promise<void>;
    private listeners;
    addEventListener(type: string, callback: (event: CustomEvent) => void): void;
    private dispatchEvent;
    private dispatchBackpressureEvent;
}

type ParserOptions = {
    compatibilityMode?: boolean;
};
declare class HTTP2Parser {
    /** 分段缓冲：避免每次 chunk 到达时 O(n) 全量拷贝 */
    private bufferChunks;
    private bufferTotalLength;
    /** 兼容旧代码读取 buffer —— 仅在必须全量访问时调用 _flattenBuffer() */
    get buffer(): Uint8Array;
    set buffer(v: Uint8Array);
    settingsAckReceived: boolean;
    peerSettingsReceived: boolean;
    connectionWindowSize: number;
    streams: Map<number, unknown>;
    defaultStreamWindowSize: number;
    sendConnWindow: number;
    sendStreamWindows: Map<number, number>;
    peerInitialStreamWindow: number;
    private sendWindowWaiters;
    private settingsAckWaiters;
    private peerSettingsWaiters;
    private endOfStreamWaiters;
    onSettings?: (frameHeader: Frame) => void;
    onData?: (payload: Uint8Array, frameHeader: Frame) => void;
    onEnd?: () => void;
    onHeaders?: (headers: Uint8Array, frameHeader: Frame) => void;
    onGoaway?: (info: {
        lastStreamId?: number;
        errorCode?: number;
    }) => void;
    onSettingsParsed?: (settings: {
        maxConcurrentStreams?: number;
        initialWindowSize?: number;
    }) => void;
    endFlag: boolean;
    writer: StreamWriter;
    private readonly compatibilityMode;
    constructor(writer: StreamWriter, options?: ParserOptions);
    /** 将所有分段合并为一个连续 Uint8Array（仅在必要时调用）*/
    private _flattenBuffer;
    /** 唤醒所有发送窗口等待者 */
    private _wakeWindowWaiters;
    processStream(stream: Stream): Promise<void>;
    private _processChunk;
    private isHttp2Preface;
    waitForSettingsAck(): Promise<void>;
    /** 内部调用：SETTINGS ACK 收到时唤醒所有等待者 */
    private _notifySettingsAck;
    waitForPeerSettings(timeoutMs?: number): Promise<void>;
    /** 内部调用：收到对端 SETTINGS（非 ACK）时唤醒等待者 */
    private _notifyPeerSettings;
    registerOutboundStream(streamId: number): void;
    getSendWindows(streamId: number): {
        conn: number;
        stream: number;
    };
    consumeSendWindow(streamId: number, bytes: number): void;
    unsafeForceExtendSendWindow(streamId: number, bytes: number): void;
    waitForSendWindow(streamId: number, minBytes?: number, timeoutMs?: number): Promise<void>;
    _handleFrame(frameHeader: Frame, frameData: Uint8Array): Promise<void>;
    _parseFrameHeader(buffer: Uint8Array): {
        length: number;
        type: number;
        flags: number;
        streamId: number;
        payload: Uint8Array<ArrayBuffer>;
    };
    _handlePingFrame(frameHeader: Frame, frameData: Uint8Array): void;
    waitForEndOfStream(waitTime: number): Promise<void>;
    /** 内部调用：流结束时唤醒所有 waitForEndOfStream 等待者 */
    private _notifyEndOfStream;
    parseWindowUpdateFrame(frameBuffer: Uint8Array, frameHeader: Frame): {
        windowSizeIncrement: number;
    };
    handleWindowUpdateFrame(frameHeader: Frame, payload: Uint8Array): {
        windowSizeIncrement: number;
    };
}

export { HTTP2Parser };