/**
 * QUIC + WebTransport DAG Streams
 * Unidirectional Streaming for Low-Latency Data Distribution
 *
 * Pipeline:
 * Relay → WebTransport Stream
 *     → QUIC Datagram Channel
 *          → Agent DAG Processor
 *
 * Özellikler:
 * - Broadcast < 20–30 ms global latency
 * - Priority paths: MEV sinyali → priority=0
 * - Packet-loss tolerant (DAG yapısı)
 * - Multiple priority levels
 */
import { EventEmitter } from 'events';
export declare enum StreamPriority {
    CRITICAL = 0,// MEV signals, time-critical data
    HIGH = 1,// Price updates, block headers
    NORMAL = 2,// Regular transactions
    LOW = 3,// Background sync, historical data
    BULK = 4
}
export interface DAGMessage {
    id: string;
    type: 'vertex' | 'intent' | 'price' | 'block' | 'sync';
    timestamp: number;
    priority: StreamPriority;
    parents: string[];
    payload: Uint8Array;
    signature: Uint8Array;
}
export interface StreamConfig {
    maxConcurrentStreams?: number;
    maxDatagramSize?: number;
    flowControlWindow?: number;
    priorityLevels?: number;
    retransmitTimeout?: number;
    idleTimeout?: number;
}
export interface ConnectionState {
    connected: boolean;
    rtt: number;
    bandwidth: number;
    packetLoss: number;
    congestionWindow: number;
}
/**
 * Priority Queue for DAG Messages
 */
export declare class PriorityMessageQueue {
    private maxSize;
    private queues;
    private totalSize;
    constructor(maxSize?: number);
    /**
     * Enqueue message
     */
    enqueue(message: DAGMessage): boolean;
    /**
     * Dequeue highest priority message
     */
    dequeue(): DAGMessage | null;
    /**
     * Peek at highest priority message
     */
    peek(): DAGMessage | null;
    private dropLowest;
    /**
     * Get queue stats
     */
    getStats(): {
        total: number;
        byPriority: Map<StreamPriority, number>;
    };
    /**
     * Check if empty
     */
    isEmpty(): boolean;
    /**
     * Get size
     */
    size(): number;
}
/**
 * DAG Message Processor
 * Handles ordering and deduplication
 */
export declare class DAGMessageProcessor extends EventEmitter {
    private seen;
    private pending;
    private delivered;
    private maxSeen;
    /**
     * Process incoming message
     */
    process(message: DAGMessage): boolean;
    private deliver;
    private tryDeliverPending;
    private cleanupSeen;
    /**
     * Get stats
     */
    getStats(): {
        seen: number;
        pending: number;
        delivered: number;
    };
}
/**
 * WebTransport Stream (Simulated)
 * Represents a unidirectional QUIC stream
 */
export declare class UnidirectionalStream extends EventEmitter {
    readonly streamId: number;
    readonly priority: StreamPriority;
    private buffer;
    private closed;
    private readOffset;
    constructor(streamId: number, priority: StreamPriority);
    /**
     * Write data to stream
     */
    write(data: Uint8Array): Promise<void>;
    /**
     * Read data from stream
     */
    read(): Promise<Uint8Array | null>;
    /**
     * Close stream
     */
    close(): void;
    /**
     * Check if closed
     */
    isClosed(): boolean;
}
/**
 * Datagram Channel
 * For unreliable, low-latency delivery
 */
export declare class DatagramChannel extends EventEmitter {
    private maxSize;
    private sent;
    private received;
    private dropped;
    constructor(maxDatagramSize?: number);
    /**
     * Send datagram
     */
    send(data: Uint8Array): Promise<boolean>;
    /**
     * Receive datagram (simulated)
     */
    handleReceive(data: Uint8Array): void;
    /**
     * Get stats
     */
    getStats(): {
        sent: number;
        received: number;
        dropped: number;
    };
}
/**
 * WebTransport Connection
 * Manages streams and datagrams over QUIC
 */
export declare class WebTransportConnection extends EventEmitter {
    private url;
    private streams;
    private datagrams;
    private nextStreamId;
    private state;
    private config;
    constructor(url: string, config?: StreamConfig);
    /**
     * Connect to relay
     */
    connect(): Promise<void>;
    /**
     * Create unidirectional send stream
     */
    createUnidirectionalStream(priority?: StreamPriority): UnidirectionalStream;
    /**
     * Send datagram
     */
    sendDatagram(data: Uint8Array): Promise<boolean>;
    /**
     * Subscribe to datagrams
     */
    onDatagram(handler: (data: Uint8Array) => void): void;
    /**
     * Get connection state
     */
    getState(): ConnectionState;
    /**
     * Close connection
     */
    close(): void;
}
/**
 * DAG Stream Manager
 * High-level manager for DAG-based streaming
 */
export declare class DAGStreamManager extends EventEmitter {
    private config;
    private connection;
    private messageQueue;
    private processor;
    private subscriptions;
    private sendTimer;
    constructor(config: {
        url: string;
        batchIntervalMs?: number;
        maxBatchSize?: number;
    });
    /**
     * Connect to relay
     */
    connect(): Promise<void>;
    /**
     * Subscribe to message type
     */
    subscribe(channel: string, handler: (msg: DAGMessage) => void): () => void;
    /**
     * Publish message
     */
    publish(type: DAGMessage['type'], payload: Uint8Array, priority?: StreamPriority, parents?: string[]): Promise<string>;
    /**
     * Send batch of messages
     */
    private sendBatch;
    /**
     * Handle incoming datagram
     */
    private handleIncomingDatagram;
    /**
     * Deliver message to subscribers
     */
    private deliverToSubscribers;
    private serializeBatch;
    private deserializeBatch;
    /**
     * Get stats
     */
    getStats(): {
        queue: {
            total: number;
            byPriority: Map<StreamPriority, number>;
        };
        processor: {
            seen: number;
            pending: number;
            delivered: number;
        };
        connection: ConnectionState | null;
    };
    /**
     * Close connection
     */
    close(): void;
}
/**
 * High-level SDK API for DAG Streams
 */
export declare class DAGStreamSDK {
    private manager;
    /**
     * Subscribe to a stream
     */
    subscribe(channel: string, handler?: (msg: DAGMessage) => void): Promise<DAGStreamSubscription>;
    /**
     * Connect to relay
     */
    connect(url: string): Promise<void>;
    /**
     * Publish message
     */
    publish(type: DAGMessage['type'], payload: Uint8Array, priority?: StreamPriority): Promise<string>;
    /**
     * Get manager
     */
    getManager(): DAGStreamManager | null;
    /**
     * Close connection
     */
    close(): void;
}
/**
 * Stream Subscription
 */
export declare class DAGStreamSubscription {
    private channel;
    private manager;
    private unsubscribe;
    constructor(channel: string, manager: DAGStreamManager);
    /**
     * Register message handler
     */
    onMessage(handler: (msg: DAGMessage) => void): this;
    /**
     * Cancel subscription
     */
    cancel(): void;
}
export declare const dagStreams: DAGStreamSDK;
//# sourceMappingURL=dag-streams.d.ts.map