/**
 * QUIC + eBPF Kernel-Bypass Transport Layer
 *
 * MEV botları için sub-millisecond → microsecond seviyesinde işlem yayılımı.
 *
 * Pipeline:
 * [Agent SDK]
 *    ↳ QUIC Transport (Quinn)
 *       ↳ eBPF Kernel Bypass Module
 *            ↳ XDP (Express Data Path) packet pipeline
 *                 ↳ In-kernel QUIC packet parsing
 *                      ↳ Zero-copy handoff → Relay
 *
 * Performans Hedefi: 8-20 µs latency, 10-20x throughput artışı
 */
import { EventEmitter } from 'events';
export interface XDPProgram {
    name: string;
    path: string;
    interface: string;
    mode: 'native' | 'generic' | 'offload';
    mapSize: number;
}
export interface KernelBypassConfig {
    xdpProgram?: string;
    fastPath: boolean;
    interface?: string;
    mode?: 'native' | 'generic' | 'offload';
    zeroCopy?: boolean;
    batchSize?: number;
    pollInterval?: number;
    afXdpQueueCount?: number;
}
export interface QUICPacket {
    header: {
        type: 'initial' | 'handshake' | '0-rtt' | '1-rtt';
        version: number;
        dcid: Uint8Array;
        scid: Uint8Array;
        packetNumber: bigint;
    };
    payload: Uint8Array;
    timestamp: bigint;
}
export interface XDPStats {
    rxPackets: bigint;
    txPackets: bigint;
    rxBytes: bigint;
    txBytes: bigint;
    rxDropped: bigint;
    txDropped: bigint;
    latencyNs: bigint;
    throughputMbps: number;
}
export interface KernelBypassMetrics {
    avgLatencyUs: number;
    p50LatencyUs: number;
    p99LatencyUs: number;
    p999LatencyUs: number;
    packetsPerSecond: number;
    bytesPerSecond: number;
    kernelBypassRatio: number;
    xdpRedirects: number;
    zeroCopyHits: number;
}
/**
 * eBPF XDP Program Manager
 * Handles loading, attaching, and managing XDP programs
 */
export declare class XDPProgramManager {
    private programs;
    private attached;
    /**
     * Load XDP program from compiled object file
     */
    load(path: string, name?: string): Promise<XDPProgram>;
    /**
     * Attach XDP program to network interface
     */
    attach(programName: string, iface: string, mode?: 'native' | 'generic' | 'offload'): Promise<void>;
    /**
     * Detach XDP program from interface
     */
    detach(programName: string): Promise<void>;
    /**
     * Get XDP statistics from eBPF maps
     */
    getStats(programName: string): Promise<XDPStats>;
}
/**
 * AF_XDP Socket Pool
 * Manages AF_XDP sockets for zero-copy packet processing
 */
export declare class AFXDPSocketPool {
    private queueCount;
    private frameSize;
    private frameCount;
    private sockets;
    private fillRing;
    private compRing;
    private rxRing;
    private txRing;
    private umem;
    constructor(queueCount?: number, frameSize?: number, frameCount?: number);
    /**
     * Create AF_XDP socket for a queue
     */
    createSocket(queueId: number): Promise<AFXDPSocket>;
    /**
     * Poll all sockets for packets
     */
    poll(timeoutUs?: number): Promise<QUICPacket[]>;
    /**
     * Send packets through AF_XDP
     */
    send(packets: QUICPacket[]): Promise<number>;
}
/**
 * AF_XDP Socket
 * Individual socket for zero-copy packet I/O
 */
export declare class AFXDPSocket {
    private queueId;
    private umem;
    private frameSize;
    private frameCount;
    private fillIdx;
    private compIdx;
    private rxIdx;
    private txIdx;
    constructor(queueId: number, umem: ArrayBuffer, frameSize: number, frameCount: number);
    /**
     * Receive packets from RX ring
     */
    receive(timeoutUs: number): Promise<QUICPacket[]>;
    /**
     * Send packet through TX ring
     */
    send(packet: QUICPacket): Promise<void>;
}
/**
 * QUIC Packet Parser (In-Kernel Simulation)
 * Parses QUIC packets with minimal overhead
 */
export declare class QUICPacketParser {
    private static readonly QUIC_VERSION_1;
    private static readonly QUIC_VERSION_2;
    /**
     * Parse QUIC packet header (optimized for XDP)
     */
    static parseHeader(data: Uint8Array): QUICPacket['header'] | null;
    private static parseLongHeader;
    private static parseShortHeader;
    /**
     * Serialize QUIC packet for transmission
     */
    static serialize(packet: QUICPacket): Uint8Array;
    private static serializeHeader;
}
/**
 * Kernel-Bypass QUIC Transport
 * Main transport class combining XDP, AF_XDP, and QUIC
 */
export declare class KernelBypassQUICTransport extends EventEmitter {
    private xdpManager;
    private socketPool;
    private config;
    private running;
    private metrics;
    private latencyBuffer;
    constructor(config: KernelBypassConfig);
    /**
     * Initialize kernel-bypass transport
     */
    init(): Promise<void>;
    /**
     * Start packet processing loop
     */
    start(): Promise<void>;
    private pollLoop;
    private recordLatency;
    private updateMetrics;
    /**
     * Send QUIC packet through kernel-bypass path
     */
    send(packet: QUICPacket): Promise<void>;
    /**
     * Send batch of packets (optimized)
     */
    sendBatch(packets: QUICPacket[]): Promise<number>;
    /**
     * Stop transport
     */
    stop(): Promise<void>;
    /**
     * Get current metrics
     */
    getMetrics(): KernelBypassMetrics;
}
/**
 * High-level SDK API for Kernel-Bypass QUIC
 */
export declare class QUICKernelBypassSDK {
    private transport;
    /**
     * Enable kernel-bypass mode
     */
    enableKernelBypass(config: KernelBypassConfig): Promise<KernelBypassQUICTransport>;
    /**
     * Get current transport
     */
    getTransport(): KernelBypassQUICTransport | null;
    /**
     * Disable kernel-bypass and cleanup
     */
    disable(): Promise<void>;
}
export declare const quicKernelBypass: QUICKernelBypassSDK;
//# sourceMappingURL=quic-kernel-bypass.d.ts.map