quico 0.7.0 → 0.8.0

package/index.d.ts

@@ -1,13 +1,63 @@
 /*
  * quico — TypeScript declarations
- * Pure JavaScript QUIC, HTTP/3, QPACK & WebTransport for Node.js
+ * A full HTTP stack in JavaScript: QUIC, HTTP/3, HTTP/2, HTTP/1.1, QPACK,
+ * WebTransport, WebSocket and CONNECT-UDP, for Node.js.
+ *
+ * The API mirrors node:https (server, request, Agent) and the browser's
+ * WebTransport and WebSocket. See README.md for every option and event.
  */
 
 /// <reference types="node" />
 
-import { IncomingMessage, ServerResponse } from 'node:http';
+import { IncomingMessage as NodeIncomingMessage, ServerResponse as NodeServerResponse, ClientRequest as NodeClientRequest } from 'node:http';
 import { Duplex, Readable, Writable } from 'node:stream';
 import { EventEmitter } from 'node:events';
+import { Socket as DgramSocket, RemoteInfo } from 'node:dgram';
+import { Socket as NetSocket } from 'node:net';
+
+// ============================================================
+//  Shared
+// ============================================================
+
+type PemInput = string | Buffer | Array<string | Buffer | { pem: string | Buffer; passphrase?: string }>;
+
+/** RFC 9218 priority: urgency 0 (first) – 7, default 3. */
+interface Priority {
+  urgency?: number;
+  incremental?: boolean;
+}
+
+/** QUIC's windows and stream limits, by RFC 9000's names in camelCase. */
+interface TransportParams {
+  initialMaxData?: number;
+  initialMaxStreamDataBidiLocal?: number;
+  initialMaxStreamDataBidiRemote?: number;
+  initialMaxStreamDataUni?: number;
+  initialMaxStreamsBidi?: number;
+  initialMaxStreamsUni?: number;
+  maxIdleTimeout?: number;
+  disableActiveMigration?: boolean;
+}
+
+type StartupCap = 'stall' | 'always' | 'off';
+type QuicVersion = 'v1' | 'v2' | number;
+
+/** QUIC connection options, as the server, a request, WebTransport and connectUdp take them. */
+interface QuicConnectionOptions {
+  initialCongestionWindow?: number;
+  startupCap?: StartupCap;
+  pmtuDiscovery?: boolean;
+  maxUdpPayloadSize?: number;
+  initialRtt?: number;
+  reorderWindow?: number;
+}
+
+/** A fingerprint: its hash, the raw string it was taken from, and its parts. */
+interface Fingerprint {
+  hash: string;
+  raw: string;
+  [part: string]: any;
+}
 
 // ============================================================
 //  Server
@@ -15,144 +65,1051 @@ import { EventEmitter } from 'node:events';
 
 type RequestHandler = (req: QuicoIncomingMessage, res: QuicoServerResponse) => void;
 
-interface ServerOptions {
-  key?: string | Buffer;
-  cert?: string | Buffer;
-  ca?: string | Buffer;
-  SNICallback?: (servername: string, cb: (err: Error | null, ctx: any) => void) => void;
+interface EchKey {
+  config: Uint8Array | Buffer;
+  privateKey: Uint8Array | Buffer;
+  /** false: kept to decrypt, not sent as retry_configs (rotation). */
+  retry?: boolean;
+}
+
+interface ConnectionOptionsInfo {
+  remoteAddress: string;
+  remotePort: number;
+  servername: string | null;
+  resumed: boolean;
+  previous: { rtt: number; bandwidth: number; age: number } | null;
+}
+
+interface ConnectionOptionsAnswer extends QuicConnectionOptions {
+  transportParams?: TransportParams;
+  carefulResume?: boolean;
+}
+
+interface ConnectUdpServerOptions {
+  template?: string;
+  allowPrivate?: boolean;
+  maxTunnelsPerConnection?: number;
+  idleTimeout?: number;
+  lookup?: (host: string, options: { all: true }, cb: (err: Error | null, addresses: Array<{ address: string; family: number }>) => void) => void;
+  proxyName?: string;
+}
+
+interface ServerOptions extends QuicConnectionOptions {
+  key?: PemInput;
+  cert?: PemInput;
+  ca?: PemInput;
+  passphrase?: string;
+  SNICallback?: (servername: string, cb: (err: Error | null, ctx?: any) => void, info?: { transport: 'tcp' | 'quic' }) => void;
+  http3?: boolean;
+  http2?: boolean;
+  http1?: boolean;
+  ALPNProtocols?: string[];
   maxConnections?: number;
+  ticketKeys?: Buffer;
+  ech?: { keys: EchKey[] };
+  earlyData?: boolean;
+  earlyDataMaxAge?: number;
+  earlyDataReplay?: (id: string, ttl: number, cb: (err: Error | null, isNew?: boolean) => void) => void;
+  earlyDataFilter?: (req: QuicoIncomingMessage, cb: (err: Error | null, allow?: boolean) => void) => void;
+  sessionTimeout?: number;
+  requestCert?: boolean;
+  rejectUnauthorized?: boolean;
+  minVersion?: 'TLSv1.2' | 'TLSv1.3';
+  maxVersion?: 'TLSv1.2' | 'TLSv1.3';
+  certificateCompression?: Array<'brotli' | 'zstd' | 'zlib'> | boolean;
+  honorCipherOrder?: boolean;
+  ciphers?: string;
+  ecdhCurve?: string;
+  sigalgs?: string;
+  handshakeTimeout?: number;
+  validateAddress?: boolean;
+  handshakeLoadThreshold?: number;
+  maxHandshakesPerAddress?: number;
+  resetTokenSecret?: Buffer;
+  tokenSecret?: Buffer;
+  socket?: DgramSocket;
+  socket6?: DgramSocket;
+  greaseQuicBit?: boolean;
+  port?: number;
+  altSvc?: string | false;
+  connectUdp?: ConnectUdpServerOptions;
+  shouldUpgradeCallback?: (req: QuicoIncomingMessage) => boolean;
+  headersTimeout?: number;
+  requestTimeout?: number;
+  keepAliveTimeout?: number;
+  streamResetBurst?: number;
+  streamResetRate?: number;
+  maxRequestsPerSocket?: number;
+  maxHeaderSize?: number;
+  maxHeaderCount?: number;
+  noDelay?: boolean;
+  keepAlive?: boolean;
+  keepAliveInitialDelay?: number;
+  transportParams?: TransportParams;
+  carefulResume?: boolean;
+  quicVersions?: QuicVersion[];
+  connectionOptions?: (info: ConnectionOptionsInfo, callback: (err: Error | null, options?: ConnectionOptionsAnswer) => void) => void;
+  maxWebTransportSessions?: number;
+  // HTTP/2 settings
+  maxConcurrentStreams?: number;
+  headerTableSize?: number;
+  initialWindowSize?: number;
+  maxFrameSize?: number;
+  maxHeaderListSize?: number;
+  connectionWindowSize?: number;
+  enableConnectProtocol?: boolean;
+  maxSessionMemory?: number;
+}
+
+/** The handle of an HTTP/2 or HTTP/3 connection ('connection', 'stream_open', 'stream_reset'). */
+interface ConnectionHandle {
+  readonly remoteAddress: string;
+  readonly remotePort: number;
+  readonly destroyed?: boolean;
+  /** HTTP/3: 'h3'-side handle; HTTP/2: the session. */
+  readonly httpVersion?: string;
+  fingerprint(): Fingerprint | null;
+  sendRstStream(streamId: number, code: 'refused' | 'cancelled' | number): void;
+  goaway(code?: 'overloaded' | number): void;
+  destroy(code?: 'overloaded' | number): void;
+  /** QUIC only: this connection's options (see README "One connection's"). */
+  setOptions?(options: QuicConnectionOptions & { carefulResume?: boolean }): this;
+  getOptions?(): QuicConnectionOptions & { carefulResume?: boolean };
+}
+
+interface ServerStats {
+  connections: { quic: number; tcp: number };
+  handshakes: { quic: { completed: number; failed: number }; tcp: { completed: number; failed: number }; resumed: number };
+  protocols: { h3: number; h2: number; 'http/1.1': number; other: number };
+  earlyData: { accepted: number; rejected: number; tooEarly: number };
+  closes: {
+    quic: { sent: Record<string, number>; received: Record<string, number>; silent: number };
+    h3: { sent: Record<string, number>; received: Record<string, number> };
+    h2: { sent: Record<string, number>; received: Record<string, number> };
+    http1: { sent: Record<string, number> };
+  };
+  streamResets: {
+    h3: { sent: Record<string, number>; received: Record<string, number> };
+    h2: { sent: Record<string, number>; received: Record<string, number> };
+  };
+  amplificationBlocked: number;
+  internalErrors: number;
+  since: number;
+  uptime: number;
+}
+
+interface ConnectUdpTunnelStats {
+  target: { host: string; port: number };
+  address: string | null;
+  port: number | null;
+  httpVersion: string;
+  state: 'pending' | 'open' | 'closed';
+  transport: 'datagram' | 'capsule';
+  openedAt: number | null;
+  closedAt: number | null;
+  durationMs: number | null;
+  packetsFromClient: number;
+  bytesFromClient: number;
+  packetsToClient: number;
+  bytesToClient: number;
+  droppedFromClient: number;
+  droppedToClient: number;
+}
+
+/** A CONNECT-UDP request, server side ('connectUdp'). */
+interface ConnectUdpTunnel extends EventEmitter {
+  readonly req: QuicoIncomingMessage;
+  readonly target: { host: string; port: number };
+  readonly state: 'pending' | 'open' | 'closed';
+  readonly closeReason: 'client' | 'local' | 'idle' | 'aborted' | 'socket' | 'rejected' | null;
+  readonly error: Error | null;
+  readonly stats: ConnectUdpTunnelStats;
+  accept(options?: {
+    target?: { host: string; port: number };
+    socket?: DgramSocket;
+    relay?: boolean;
+    headers?: Record<string, string | string[]>;
+    allowPrivate?: boolean;
+  }): void;
+  reject(status: number, headers?: Record<string, string | string[]>): void;
+  send(buf: Buffer | Uint8Array): boolean;
+  close(): void;
+  on(event: 'open', listener: () => void): this;
+  on(event: 'message', listener: (msg: Buffer) => void): this;
+  on(event: 'close', listener: (stats: ConnectUdpTunnelStats) => void): this;
+  on(event: string, listener: (...args: any[]) => void): this;
 }
 
 interface QuicoServer extends EventEmitter {
-  listen(port: number, callback?: () => void): this;
+  listen(port?: number, callback?: () => void): this;
   listen(port: number, host: string, callback?: () => void): this;
-  close(callback?: () => void): void;
+  /** As node:http's: requests in flight finish (HTTP/2, HTTP/3: GOAWAY), idle connections close now; then 'close'. */
+  close(callback?: (err?: Error) => void): this;
+  /** Connections with no request in flight, all versions. */
+  closeIdleConnections(): void;
+  /** Every connection, in flight or not (not HTTP/1.1 sockets handed to 'upgrade'). */
+  closeAllConnections(): void;
+  getConnections(callback: (err: Error | null, count: number) => void): this;
+  readonly listening: boolean;
+  headersTimeout: number;
+  requestTimeout: number;
+  /** HTTP/1.1. */
+  keepAliveTimeout: number;
+  /** HTTP/1.1. */
+  maxHeadersCount: number;
+  maxRequestsPerSocket: number;
+  ref(): this;
+  unref(): this;
+  [Symbol.asyncDispose](): Promise<void>;
+  /** node:tls's: the default certificate, from the next handshake on — all three versions. Throws on a bad one (the old stays). */
+  setSecureContext(options: { key?: PemInput | PemInput[]; cert?: PemInput | PemInput[]; ca?: PemInput; passphrase?: string } | ReturnType<typeof createSecureContext>): void;
+  /** node:tls's: a certificate for a name (SNI; '*.example.com' covers one label). */
+  addContext(hostname: string, context: { key?: PemInput | PemInput[]; cert?: PemInput | PemInput[]; ca?: PemInput; passphrase?: string } | ReturnType<typeof createSecureContext>): void;
+  address(): { address: string; family: string; port: number } | null;
+  handleConnection(socket: NetSocket): void;
+  setTimeout(msecs?: number, callback?: (socket: NetSocket) => void): this;
+  timeout: number;
+  /** External socket mode: feed a UDP datagram. */
+  handlePacket(msg: Buffer, rinfo: RemoteInfo): void;
+  /** External socket mode: whether a datagram belongs to a connection of this server. */
+  hasConnection(rinfo: RemoteInfo, msg?: Buffer): boolean;
+  addProtocol(name: string, handler: (socket: Duplex, protocol: string) => void, options?: { sniff?: (firstBytes: Buffer) => boolean | null }): this;
+  getTicketKeys(): Buffer;
+  setTicketKeys(keys: Buffer): void;
+  getEchKeys(): { keys: EchKey[] } | null;
+  setEchKeys(ech: { keys: EchKey[] }): void;
+  getValidateAddress(): boolean;
+  setValidateAddress(on: boolean): void;
+  getResetTokenSecret(): Buffer;
+  setResetTokenSecret(secret: Buffer): void;
+  getTokenSecret(): Buffer;
+  setTokenSecret(secret: Buffer): void;
+  setOptions(options: Partial<ServerOptions>): this;
+  getOptions(): ServerOptions;
+  getPendingHandshakes(): number;
+  getStats(): ServerStats;
+  getConnectUdpStats(): { active: number; accepted: number; rejected: number; closed: number; [counter: string]: number };
+
   on(event: 'request', listener: RequestHandler): this;
+  on(event: 'upgrade', listener: (req: QuicoIncomingMessage, socket: Duplex, head: Buffer) => void): this;
+  on(event: 'connectUdp', listener: (req: QuicoIncomingMessage, tunnel: ConnectUdpTunnel) => void): this;
+  on(event: 'timeout', listener: (socket: NetSocket) => void): this;
+  on(event: 'connection', listener: (conn: NetSocket | ConnectionHandle) => void): this;
+  on(event: 'secureConnection', listener: (conn: NetSocket | ConnectionHandle) => void): this;
+  on(event: 'stream_open', listener: (conn: ConnectionHandle, streamId: number) => void): this;
+  on(event: 'stream_reset', listener: (conn: ConnectionHandle, streamId: number, code: number) => void): this;
+  on(event: 'handshakeLoad', listener: (info: { pending: number; high: boolean }) => void): this;
+  on(event: 'OCSPRequest', listener: (certificate: Buffer, issuer: Buffer | null, callback: (err: Error | null, response: Buffer | null) => void) => void): this;
+  on(event: 'tlsClientError', listener: (err: Error, socket: NetSocket | ConnectionHandle) => void): this;
+  on(event: 'clientError', listener: (err: Error, socket: NetSocket) => void): this;
+  on(event: 'sessionError', listener: (err: Error, session: ConnectionHandle) => void): this;
   on(event: 'listening', listener: () => void): this;
+  on(event: 'close', listener: () => void): this;
   on(event: 'error', listener: (err: Error) => void): this;
   on(event: string, listener: (...args: any[]) => void): this;
 }
 
-interface QuicoIncomingMessage extends IncomingMessage {
-  /** QUIC stream ID */
-  streamId?: number;
+// ============================================================
+//  Request, response
+// ============================================================
+
+/** A request on the server, or a response on the client (node:http's). */
+interface QuicoIncomingMessage extends NodeIncomingMessage {
+  /** '3.0', '2.0' or '1.1'. */
+  httpVersion: string;
+  /** Server: true if it came in 0-RTT. Client: 'accepted', 'rejected' or null. */
+  earlyData: boolean | 'accepted' | 'rejected' | null;
+  /** HTTP/2 request's fingerprint. */
+  h2Fingerprint?(): Fingerprint;
+  /** HTTP/3 request's fingerprint. */
+  h3Fingerprint?(): Fingerprint;
 
-  // WebTransport events (available after res.writeHead(200) on WT sessions)
-  on(event: 'stream', listener: (stream: Duplex) => void): this;
-  on(event: 'unidirectionalStream', listener: (stream: Readable) => void): this;
+  // ---- WebTransport (server, after res.writeHead(200) on a session) ----
+  /** The protocols the client offered (WT-Available-Protocols), in its order. */
+  webTransportProtocols?: string[];
+  /** The client's CLOSE_WEBTRANSPORT_SESSION, when it sent one. */
+  closeInfo?: WebTransportCloseInfo;
+  on(event: 'stream', listener: (stream: WebTransportNodeStream & Duplex) => void): this;
+  on(event: 'unidirectionalStream', listener: (stream: WebTransportNodeStream & Readable) => void): this;
   on(event: 'datagram', listener: (data: Buffer) => void): this;
-  on(event: string, listener: (...args: any[]) => void): this;
-}
-
-interface QuicoServerResponse extends ServerResponse {
-  // WebTransport methods (available after res.writeHead(200) on WT sessions)
-  sendDatagram?(data: Buffer | Uint8Array | string): void;
-  createBidirectionalStream?(): Duplex;
-  createUnidirectionalStream?(): Writable;
+  on(event: 'draining', listener: () => void): this;
+  on(event: 'aborted', listener: () => void): this;
+  on(event: string | symbol, listener: (...args: any[]) => void): this;
 }
 
+interface QuicoServerResponse extends NodeServerResponse {
+  writeEarlyHints(hints: Record<string, string | string[]>, callback?: () => void): void;
+  /** HTTP/2 and HTTP/3: the response's priority (RFC 9218). */
+  setPriority(priority: Priority): void;
 
-// ============================================================
-//  Client
-// ============================================================
+  // ---- WebTransport (after res.writeHead(200) on a session) ----
+  /** true when queued, false when it cannot be sent at all. */
+  sendDatagram?(data: Buffer | Uint8Array | string, options?: WebTransportSendOptions): boolean;
+  maxDatagramSize?(): number;
+  readonly datagrams?: WebTransportDatagramDuplexStream | null;
+  getStats?(): Promise<WebTransportConnectionStats | null>;
+  exportKeyingMaterial?(label: BufferSource, context: BufferSource, outputLength: number): Promise<Uint8Array>;
+  /** null, without waitUntilAvailable, past the client's MAX_STREAMS. */
+  createBidirectionalStream?(options?: WebTransportSendStreamOptions | null, callback?: (err: Error | null, stream?: WebTransportNodeStream & Duplex) => void): (WebTransportNodeStream & Duplex) | null;
+  createUnidirectionalStream?(options?: WebTransportSendStreamOptions | null, callback?: (err: Error | null, stream?: WebTransportNodeStream & Writable) => void): (WebTransportNodeStream & Writable) | null;
+  canOpenStream?(options?: { bidirectional?: boolean }): boolean;
+  createSendGroup?(): WebTransportSendGroup;
+  /** Before writeHead(200): the protocol chosen among req.webTransportProtocols. */
+  setWebTransportProtocol?(name: string): void;
+  closeSession?(code?: number, reason?: string): void;
+  drainSession?(): void;
+}
 
-interface RequestOptions {
+interface RequestOptions extends QuicConnectionOptions {
+  protocol?: string;
   hostname?: string;
   host?: string;
   port?: number;
   path?: string;
   method?: string;
-  headers?: Record<string, string | string[]>;
-  agent?: QuicoAgent;
+  headers?: Record<string, string | string[] | number>;
+  priority?: Priority;
+  ech?: Buffer | Uint8Array | string;
+  echGrease?: boolean;
+  ecdhCurve?: string;
+  sigalgs?: string;
   rejectUnauthorized?: boolean;
+  ca?: PemInput;
+  key?: PemInput;
+  cert?: PemInput;
+  passphrase?: string;
+  servername?: string;
+  earlyData?: boolean;
+  session?: Buffer;
+  requestOCSP?: boolean;
+  quicVersions?: QuicVersion[];
+  agent?: Agent | false;
+  http2?: boolean;
+  http1?: boolean;
+  h3Timeout?: number;
   timeout?: number;
 }
 
-interface QuicoClientRequest extends Writable {
+interface QuicoClientRequest extends NodeClientRequest {
+  /** The transport actually used: 'h3', 'h2' or 'https'. */
+  protocol: string;
+  setPriority(priority: Priority): void;
   on(event: 'response', listener: (res: QuicoIncomingMessage) => void): this;
-  on(event: 'error', listener: (err: Error) => void): this;
-  on(event: 'timeout', listener: () => void): this;
-  on(event: string, listener: (...args: any[]) => void): this;
-  end(data?: string | Buffer): this;
-  abort(): void;
-  setTimeout(ms: number, callback?: () => void): this;
+  on(event: 'session', listener: (session: Buffer) => void): this;
+  on(event: 'OCSPResponse', listener: (response: Buffer) => void): this;
+  on(event: string | symbol, listener: (...args: any[]) => void): this;
 }
 
-
 // ============================================================
 //  Agent
 // ============================================================
 
-interface QuicoAgent {
-  destroy(): void;
+interface AgentOptions {
+  http2?: boolean;
+  http1?: boolean;
+  h3Timeout?: number;
+  keepAlive?: boolean;
+  keepAliveMsecs?: number;
+  maxSockets?: number;
+  maxFreeSockets?: number;
+  timeout?: number;
+  maxCachedSessions?: number;
+  ecdhCurve?: string;
 }
 
+declare class Agent extends EventEmitter {
+  constructor(options?: AgentOptions);
+  getName(options?: RequestOptions): string;
+  destroy(): void;
+}
 
 // ============================================================
-//  WebTransport
+//  WebTransport — the browser's API (W3C), and a Node-style one
 // ============================================================
 
-interface WebTransportOptions {
-  /** Skip certificate verification (default: true for self-signed) */
+type WebTransportReliabilityMode = 'pending' | 'reliable-only' | 'supports-unreliable';
+type WebTransportCongestionControl = 'default' | 'throughput' | 'low-latency';
+type WebTransportErrorSource = 'stream' | 'session';
+
+interface WebTransportHash {
+  algorithm: string;
+  value: BufferSource;
+}
+
+interface WebTransportCloseInfo {
+  closeCode?: number;
+  reason?: string;
+}
+
+interface WebTransportSendOptions {
+  sendGroup?: WebTransportSendGroup | null;
+  sendOrder?: number;
+}
+
+interface WebTransportSendStreamOptions extends WebTransportSendOptions {
+  waitUntilAvailable?: boolean;
+}
+
+interface WebTransportDatagramStats {
+  droppedIncoming: number;
+  expiredIncoming: number;
+  expiredOutgoing: number;
+  lostOutgoing: number | null;
+}
+
+interface WebTransportConnectionStats {
+  timestamp: number;
+  /** The application's bytes: new stream data and datagram payloads (no framing, no retransmissions). */
+  bytesSent: number | null;
+  bytesSentOverhead: number | null;
+  bytesAcknowledged: number | null;
+  packetsSent: number | null;
+  bytesLost: number | null;
+  packetsLost: number | null;
+  bytesReceived: number | null;
+  packetsReceived: number | null;
+  smoothedRtt: number | null;
+  rttVariation: number | null;
+  minRtt: number | null;
+  /** Bits per second; null until measured. */
+  estimatedSendRate: number | null;
+  atSendCapacity: boolean | null;
+  /** QUICO's: the congestion window, and the bytes in flight. */
+  congestionWindow: number | null;
+  bytesInFlight: number | null;
+  datagrams: WebTransportDatagramStats;
+}
+
+interface WebTransportSendStreamStats {
+  bytesWritten: number;
+  bytesSent: number;
+  bytesAcknowledged: number;
+}
+
+interface WebTransportReceiveStreamStats {
+  bytesReceived: number;
+  bytesRead: number;
+}
+
+interface WebTransportOptions extends QuicConnectionOptions {
+  // ---- The browser's ----
+  allowPooling?: boolean;
+  requireUnreliable?: boolean;
+  /** The browser's HeadersInit: a Headers, [name, value] pairs, or an object. */
+  headers?: HeadersInit | Record<string, string | string[]>;
+  serverCertificateHashes?: WebTransportHash[];
+  congestionControl?: WebTransportCongestionControl;
+  anticipatedConcurrentIncomingUnidirectionalStreams?: number | null;
+  anticipatedConcurrentIncomingBidirectionalStreams?: number | null;
+  protocols?: string[];
+  datagramsReadableType?: 'bytes';
+  // ---- Node's (as https.request / QUICO's WebSocket) ----
+  /** Sent as Origin on the CONNECT (a browser sends its page's). */
+  origin?: string;
+  /** Verify the server's certificate (default true). */
   rejectUnauthorized?: boolean;
+  ca?: PemInput;
+  key?: PemInput;
+  cert?: PemInput;
+  passphrase?: string;
+  /** A TLS session from an earlier 'session' event, to resume with. */
+  session?: Buffer;
+  transportParams?: TransportParams;
+  quicVersions?: QuicVersion[];
+  ech?: Buffer | Uint8Array | string;
+  echGrease?: boolean;
+  ecdhCurve?: string;
+  sigalgs?: string;
+}
+
+/** The browser's WebTransportError: a DOMException named 'WebTransportError'. */
+declare class WebTransportError extends DOMException {
+  constructor(message?: string, options?: { source?: WebTransportErrorSource; streamErrorCode?: number | null });
+  constructor(init: { message?: string; source?: WebTransportErrorSource; streamErrorCode?: number | null });
+  readonly source: WebTransportErrorSource;
+  readonly streamErrorCode: number | null;
+  /** QUICO's Node code, where it gives one (e.g. 'ERR_WEBTRANSPORT_SESSION_LOST'), in place of DOMException's number. */
+  readonly code: any;
+  /** The QUIC close that lost the session, when the peer closed the connection. */
+  readonly quicError?: { code: number; application: boolean; reason: string };
+}
+
+declare class WebTransportSendGroup {
+  private constructor();
+  getStats(): Promise<WebTransportSendStreamStats>;
+}
+
+declare class WebTransportWriter extends WritableStreamDefaultWriter<BufferSource> {
+  private constructor();
+  /** Sent only if all of it fits the flow-control window; otherwise rejects with an AbortError. */
+  atomicWrite(chunk: BufferSource): Promise<void>;
+  /** What was written so far reaches the peer even if the stream is aborted later (RESET_STREAM_AT). */
+  commit(): void;
+}
+
+declare class WebTransportSendStream extends WritableStream<BufferSource> {
+  private constructor();
+  sendGroup: WebTransportSendGroup | null;
+  sendOrder: number;
+  getWriter(): WebTransportWriter;
+  getStats(): Promise<WebTransportSendStreamStats>;
+}
+
+/** A byte stream: getReader({ mode: 'byob' }) works. */
+declare class WebTransportReceiveStream extends ReadableStream<Uint8Array> {
+  private constructor();
+  getStats(): Promise<WebTransportReceiveStreamStats>;
+}
+
+/** What a stream also is in QUICO: a Node stream with these. */
+interface WebTransportNodeStream {
+  readonly id: number;
+  readonly sessionId: number;
+  readonly sendState: 'open' | 'finished' | 'committed' | 'reset' | 'stopped' | null;
+  readonly recvState: 'open' | 'finished' | 'reset' | 'stopped' | null;
+  readonly pending: boolean;
+  readonly reliableResetSupported: boolean;
+  readonly streamErrorCode: number | null;
+  sendOrder: number;
+  sendGroup: WebTransportSendGroup | null;
+  resetStream(code?: number, options?: { reliableSize?: number }): boolean;
+  stopSending(code?: number): void;
+  getStats(): Promise<Partial<WebTransportSendStreamStats & WebTransportReceiveStreamStats>>;
+  on(event: 'peerReset' | 'peerStopSending', listener: (code: number | null) => void): this;
+  on(event: 'committed' | 'ready', listener: () => void): this;
+  on(event: string | symbol, listener: (...args: any[]) => void): this;
+}
+
+/**
+ * The browser's WebTransportBidirectionalStream. In QUICO it is a Node
+ * Duplex with the browser's .readable and .writable; instanceof recognises it.
+ */
+declare class WebTransportBidirectionalStream {
+  private constructor();
+  readonly readable: WebTransportReceiveStream;
+  readonly writable: WebTransportSendStream;
+}
+type WebTransportBidirectionalNodeStream = WebTransportBidirectionalStream & WebTransportNodeStream & Duplex;
+
+/** createUnidirectionalStream(): the browser's send stream, and Node's Writable on it. */
+type WebTransportUnidirectionalNodeStream = WebTransportSendStream & {
+  write(chunk: any, cb?: (err?: Error | null) => void): boolean;
+  write(chunk: any, encoding: BufferEncoding, cb?: (err?: Error | null) => void): boolean;
+  end(chunk?: any, cb?: () => void): void;
+  destroy(err?: Error): void;
+  resetStream(code?: number, options?: { reliableSize?: number }): boolean;
+  readonly id: number;
+  readonly sessionId: number;
+  readonly sendState: 'open' | 'finished' | 'committed' | 'reset' | 'stopped';
+  readonly pending: boolean;
+  readonly writableLength: number;
+  readonly writableNeedDrain: boolean;
+  on(event: string | symbol, listener: (...args: any[]) => void): any;
+  once(event: string | symbol, listener: (...args: any[]) => void): any;
+};
+
+declare class WebTransportDatagramsWritable extends WritableStream<BufferSource> {
+  private constructor();
+  sendGroup: WebTransportSendGroup | null;
+  sendOrder: number;
+}
+
+declare class WebTransportDatagramDuplexStream {
+  private constructor();
+  createWritable(options?: WebTransportSendOptions): WebTransportDatagramsWritable;
+  readonly readable: ReadableStream<Uint8Array>;
+  readonly maxDatagramSize: number;
+  /** ms; null (or 0 set) is none. */
+  incomingMaxAge: number | null;
+  outgoingMaxAge: number | null;
+  incomingMaxBufferedDatagrams: number;
+  outgoingMaxBufferedDatagrams: number;
+  /** @deprecated The spec's earlier names: use createWritable() and …MaxBufferedDatagrams. */
+  readonly writable: WebTransportDatagramsWritable;
+  /** @deprecated Use incomingMaxBufferedDatagrams. */
+  incomingHighWaterMark: number;
+  /** @deprecated Use outgoingMaxBufferedDatagrams. */
+  outgoingHighWaterMark: number;
 }
 
 declare class WebTransport extends EventEmitter {
-  constructor(url: string, options?: WebTransportOptions);
+  constructor(url: string | URL, options?: WebTransportOptions);
 
-  /** Resolves when the WebTransport session is established */
+  // ---- The browser's ----
   readonly ready: Promise<void>;
-  /** Current state: 'connecting' | 'connected' | 'closed' */
-  readonly state: string;
-  /** The URL of the WebTransport session */
+  readonly closed: Promise<WebTransportCloseInfo>;
+  readonly draining: Promise<void>;
+  readonly reliability: WebTransportReliabilityMode;
+  readonly congestionControl: WebTransportCongestionControl;
+  readonly protocol: string;
+  /** The server's answer to the CONNECT (immutable); null until ready. */
+  readonly responseHeaders: Headers | null;
+  anticipatedConcurrentIncomingUnidirectionalStreams: number | null;
+  anticipatedConcurrentIncomingBidirectionalStreams: number | null;
+  readonly datagrams: WebTransportDatagramDuplexStream;
+  readonly incomingBidirectionalStreams: ReadableStream<WebTransportBidirectionalNodeStream>;
+  readonly incomingUnidirectionalStreams: ReadableStream<WebTransportReceiveStream>;
+  /** false: HTTP/3 only. */
+  static readonly supportsReliableOnly: boolean;
+
+  close(closeInfo?: WebTransportCloseInfo): void;
+  getStats(): Promise<WebTransportConnectionStats>;
+  exportKeyingMaterial(label: BufferSource, context: BufferSource, outputLength: number): Promise<Uint8Array>;
+  createBidirectionalStream(options?: WebTransportSendStreamOptions): Promise<WebTransportBidirectionalNodeStream>;
+  createUnidirectionalStream(options?: WebTransportSendStreamOptions): Promise<WebTransportUnidirectionalNodeStream>;
+  createSendGroup(): WebTransportSendGroup;
+
+  // ---- QUICO's, for Node code ----
+  /** 'connecting', 'connected', 'closed' or 'failed'. */
+  readonly state: 'connecting' | 'connected' | 'closed' | 'failed';
   readonly url: string;
+  /** The server's CLOSE_WEBTRANSPORT_SESSION, or ours. */
+  readonly closeInfo?: WebTransportCloseInfo;
+  canOpenStream(options?: { bidirectional?: boolean }): boolean;
+  /** true when queued, false when it cannot be sent at all. */
+  sendDatagram(data: Buffer | Uint8Array | string, options?: WebTransportSendOptions): boolean;
+  maxDatagramSize(): number;
 
-  /** WHATWG-style datagram interface */
-  readonly datagrams: {
-    readonly readable: ReadableStream<Uint8Array>;
-    readonly writable: WritableStream<Uint8Array>;
-  };
+  on(event: 'ready' | 'draining' | 'close', listener: () => void): this;
+  on(event: 'stream', listener: (stream: WebTransportBidirectionalNodeStream) => void): this;
+  on(event: 'unidirectionalStream', listener: (stream: WebTransportNodeStream & Readable) => void): this;
+  on(event: 'datagram', listener: (data: Buffer) => void): this;
+  on(event: 'session', listener: (session: Buffer) => void): this;
+  on(event: 'error', listener: (err: WebTransportError) => void): this;
+  on(event: string | symbol, listener: (...args: any[]) => void): this;
+}
+
+// ============================================================
+//  WebSocket
+// ============================================================
+
+interface WebSocketClientOptions {
+  origin?: string;
+  headers?: Record<string, string | string[]>;
+  ca?: PemInput;
+  rejectUnauthorized?: boolean;
+  maxPayload?: number;
+  agent?: Agent;
+  session?: Buffer;
+}
+
+/**
+ * The ws package's listeners, beside the browser's addEventListener: they get
+ * Node-style arguments ('message': (data, isBinary); 'close': (code, reason)).
+ */
+interface WebSocketNodeEvents<T> {
+  on(event: 'message', listener: (this: T, data: Buffer, isBinary: boolean) => void): T;
+  on(event: 'close', listener: (this: T, code: number, reason: Buffer) => void): T;
+  on(event: 'ping' | 'pong', listener: (this: T, data: Buffer) => void): T;
+  on(event: 'open', listener: (this: T) => void): T;
+  on(event: 'error', listener: (this: T, err: Error) => void): T;
+  on(event: 'session', listener: (this: T, session: Buffer) => void): T;
+  on(event: string, listener: (this: T, ...args: any[]) => void): T;
+  once(event: string, listener: (this: T, ...args: any[]) => void): T;
+  addListener(event: string, listener: (this: T, ...args: any[]) => void): T;
+  off(event: string, listener: (...args: any[]) => void): T;
+  removeListener(event: string, listener: (...args: any[]) => void): T;
+  removeAllListeners(event?: string): T;
+  listenerCount(event: string): number;
+  eventNames(): string[];
+}
 
-  /** Create a bidirectional stream (Node.js Duplex + WHATWG .readable/.writable) */
-  createBidirectionalStream(): Promise<Duplex & {
-    readonly readable: ReadableStream<Uint8Array>;
-    readonly writable: WritableStream<Uint8Array>;
-  }>;
+/** What a WebSocket has, client or server side: the browser's interface, ping() and onpong. */
+interface WebSocketBase extends EventTarget {
+  readonly CONNECTING: 0;
+  readonly OPEN: 1;
+  readonly CLOSING: 2;
+  readonly CLOSED: 3;
+  readonly url: string;
+  readonly readyState: 0 | 1 | 2 | 3;
+  readonly bufferedAmount: number;
+  readonly protocol: string;
+  readonly extensions: string;
+  /** 'blob' (the browser's default) or 'arraybuffer'; 'nodebuffer' too. */
+  binaryType: 'blob' | 'arraybuffer' | 'nodebuffer';
+  onopen: ((event: Event) => void) | null;
+  onmessage: ((event: MessageEvent) => void) | null;
+  onerror: ((event: Event) => void) | null;
+  onclose: ((event: CloseEvent) => void) | null;
+  /** Not in the browser: the answer to ping(). */
+  onpong: ((event: Event) => void) | null;
+  /** options (the ws package's): binary forces a frame's type. */
+  send(data: string | ArrayBufferLike | ArrayBufferView | Blob, options?: { binary?: boolean }): void;
+  /** Not in the browser: a keepalive for a long-lived connection. */
+  ping(data?: string | Buffer | Uint8Array): void;
+  close(code?: number, reason?: string): void;
+}
 
-  /** Create a unidirectional stream for writing */
-  createUnidirectionalStream(): Promise<Writable>;
+/** The browser's WebSocket (WHATWG), with a third argument for Node's options. */
+declare class WebSocket extends EventTarget implements WebSocketBase {
+  /** protocols may also be an options bag, { protocols } (as WPT has it). */
+  constructor(url: string | URL, protocols?: string | string[] | { protocols?: string | string[] }, options?: WebSocketClientOptions);
+  static readonly CONNECTING: 0;
+  static readonly OPEN: 1;
+  static readonly CLOSING: 2;
+  static readonly CLOSED: 3;
+  readonly CONNECTING: 0;
+  readonly OPEN: 1;
+  readonly CLOSING: 2;
+  readonly CLOSED: 3;
+  readonly url: string;
+  readonly readyState: 0 | 1 | 2 | 3;
+  readonly bufferedAmount: number;
+  readonly protocol: string;
+  readonly extensions: string;
+  binaryType: 'blob' | 'arraybuffer' | 'nodebuffer';
+  onopen: ((event: Event) => void) | null;
+  onmessage: ((event: MessageEvent) => void) | null;
+  onerror: ((event: Event) => void) | null;
+  onclose: ((event: CloseEvent) => void) | null;
+  onpong: ((event: Event) => void) | null;
+  send(data: string | ArrayBufferLike | ArrayBufferView | Blob, options?: { binary?: boolean }): void;
+  ping(data?: string | Buffer | Uint8Array): void;
+  close(code?: number, reason?: string): void;
+}
+interface WebSocket extends WebSocketNodeEvents<WebSocket> {}
 
-  /** Send an unreliable datagram */
-  sendDatagram(data: Buffer | Uint8Array): void;
+interface WebSocketStreamOptions extends WebSocketClientOptions {
+  protocols?: string[];
+  signal?: AbortSignal;
+}
+interface WebSocketOpenInfo {
+  /** One chunk per message: a string for text, a Uint8Array for binary. */
+  readable: ReadableStream<string | Uint8Array>;
+  /** An ArrayBuffer or a view goes as binary, anything else as text. */
+  writable: WritableStream<string | BufferSource>;
+  protocol: string;
+  extensions: string;
+}
+interface WebSocketCloseInfo {
+  closeCode?: number;
+  reason?: string;
+}
 
-  /** Close the WebTransport session */
-  close(info?: { closeCode?: number; reason?: string }): void;
+/**
+ * EXPERIMENTAL — the browser's streams WebSocket (WICG explainer; Chrome has
+ * it, not yet a standard). Backpressure both ways: an unread message pauses
+ * the socket; write() resolves once the frame is sent.
+ */
+declare class WebSocketStream {
+  constructor(url: string | URL, options?: WebSocketStreamOptions);
+  readonly url: string;
+  readonly opened: Promise<WebSocketOpenInfo>;
+  readonly closed: Promise<{ closeCode: number; reason: string }>;
+  close(closeInfo?: WebSocketCloseInfo): void;
+}
 
-  on(event: 'datagram', listener: (data: Buffer) => void): this;
-  on(event: 'close', listener: () => void): this;
+/** The error of a WebSocketStream: a DOMException named 'WebSocketError'. */
+declare class WebSocketError extends DOMException {
+  constructor(message?: string, init?: WebSocketCloseInfo);
+  readonly closeCode: number | null;
+  readonly reason: string;
+}
+
+/** A connection a WebSocketServer accepted (or upgradeWebSocket made). */
+interface ServerWebSocket extends WebSocketBase, WebSocketNodeEvents<ServerWebSocket> {}
+
+interface UpgradeWebSocketOptions {
+  origin?: string | string[] | ((origin: string, req: QuicoIncomingMessage) => boolean);
+  verifyClient?: (req: QuicoIncomingMessage) => boolean | { code: number; message?: string; headers?: Record<string, string> };
+  protocol?: string | ((offered: string[], req: QuicoIncomingMessage) => string | false | null | undefined);
+  protocols?: string[];
+  headers?: Record<string, string | string[]>;
+  maxPayload?: number;
+}
+
+interface WebSocketServerOptions extends UpgradeWebSocketOptions {
+  server?: QuicoServer;
+  noServer?: boolean;
+  path?: string;
+  pingInterval?: number;
+}
+
+declare class WebSocketServer extends EventTarget {
+  constructor(options: WebSocketServerOptions);
+  readonly clients: Set<ServerWebSocket>;
+  onconnection: ((event: Event & { socket?: ServerWebSocket; request?: QuicoIncomingMessage }) => void) | null;
+  handleUpgrade(req: QuicoIncomingMessage, socket: Duplex, head: Buffer, cb: (ws: ServerWebSocket, req: QuicoIncomingMessage) => void): void;
+  startAutoPing(intervalMs: number): void;
+  stopAutoPing(): void;
+  close(code?: number, reason?: string): void;
+  on(event: 'connection', listener: (ws: ServerWebSocket, req: QuicoIncomingMessage) => void): this;
   on(event: string, listener: (...args: any[]) => void): this;
+  once(event: string, listener: (...args: any[]) => void): this;
+  off(event: string, listener: (...args: any[]) => void): this;
+}
+
+/** The socket, or null after answering the client itself (403, 401, …). */
+declare function upgradeWebSocket(req: QuicoIncomingMessage, socket: Duplex, head: Buffer, options?: UpgradeWebSocketOptions): ServerWebSocket | null;
+
+// ============================================================
+//  CONNECT-UDP client
+// ============================================================
+
+interface ConnectUdpOptions extends QuicConnectionOptions {
+  protocol?: 'auto' | 'h3' | 'h2' | 'http/1.1';
+  h3Timeout?: number;
+  fallback?: boolean;
+  shareConnection?: boolean;
+  headers?: Record<string, string | string[]>;
+  ech?: Buffer | Uint8Array | string;
+  echGrease?: boolean;
+  ecdhCurve?: string;
+  sigalgs?: string;
+  template?: string;
+  rejectUnauthorized?: boolean;
+  ca?: PemInput;
+  key?: PemInput;
+  cert?: PemInput;
+  passphrase?: string;
+  servername?: string;
+  quicVersions?: QuicVersion[];
+  agent?: Agent | false;
+  session?: Buffer;
+}
+
+interface UdpProxySocketStats {
+  protocol: string | null;
+  transport: 'datagram' | 'capsule' | null;
+  target: { host: string; port: number };
+  openedAt: number | null;
+  closedAt: number | null;
+  durationMs: number | null;
+  packetsSent: number;
+  bytesSent: number;
+  packetsReceived: number;
+  bytesReceived: number;
+  dropped: number;
+}
+
+/** A UDP socket through a proxy, behaving as a connected dgram.Socket. */
+interface UdpProxySocket extends EventEmitter {
+  send(msg: string | Buffer | Uint8Array | ReadonlyArray<string | Buffer | Uint8Array>, callback?: (err: Error | null, bytes?: number) => void): void;
+  send(msg: Buffer | Uint8Array, offset: number, length: number, callback?: (err: Error | null, bytes?: number) => void): void;
+  close(callback?: () => void): void;
+  remoteAddress(): { address: string; family: string; port: number };
+  address(): { address: string; family: string; port: number };
+  readonly maxPayloadSize: number;
+  readonly protocol: 'h3' | 'h2' | 'http/1.1' | null;
+  readonly statusCode: number | null;
+  readonly responseHeaders: Record<string, string | string[]> | null;
+  readonly closeReason: 'local' | 'proxy' | 'error' | null;
+  readonly stats: UdpProxySocketStats;
+  on(event: 'connect' | 'close', listener: () => void): this;
+  on(event: 'message', listener: (msg: Buffer, rinfo: RemoteInfo) => void): this;
+  on(event: 'error', listener: (err: Error & { code?: string; statusCode?: number; proxyStatus?: string }) => void): this;
+  on(event: 'session', listener: (session: Buffer) => void): this;
+  on(event: string | symbol, listener: (...args: any[]) => void): this;
+}
+
+declare function connectUdp(
+  proxy: string | URL | { hostname: string; port?: number; template?: string },
+  target: { host: string; port: number },
+  options?: ConnectUdpOptions,
+  callback?: () => void
+): UdpProxySocket;
+declare function connectUdp(
+  proxy: string | URL | { hostname: string; port?: number; template?: string },
+  target: { host: string; port: number },
+  callback?: () => void
+): UdpProxySocket;
+
+// ============================================================
+//  Fingerprinting
+// ============================================================
+
+declare function ja4h(req: NodeIncomingMessage): Fingerprint & { a: string; b: string; c: string; d: string };
+declare function h2Fingerprint(observed: any): Fingerprint;
+declare function h3Fingerprint(observed: any): Fingerprint;
+declare function observeH2(...args: any[]): any;
+declare function profileRequest(req: NodeIncomingMessage): {
+  claimed: any;
+  protocol: string;
+  fingerprints: { ja4: string | null; ja4s: string | null; h2: string | null; h2raw: string | null; h3: string | null; h3raw: string | null };
+  signals: any[];
+  suspicion: number;
+};
+
+// ============================================================
+//  TLS
+// ============================================================
+
+declare function createSecureContext(options: { key?: PemInput; cert?: PemInput; ca?: PemInput; passphrase?: string; [option: string]: any }): any;
+declare function generateEchKey(options: { publicName: string; [option: string]: any }): {
+  config: Uint8Array;
+  privateKey: Uint8Array;
+  configListBase64: string;
+  [field: string]: any;
+};
+
+// ============================================================
+//  Transport and protocol layers (see README "Protocol layers", "Low-level QUIC API")
+// ============================================================
+
+/** A QUIC connection (low-level API). */
+interface QUICConnection extends EventEmitter {
+  readonly state: 'idle' | 'handshaking' | 'connected' | 'closing' | 'draining' | 'closed';
+  readonly remoteAddress: string;
+  readonly remotePort: number;
+  readonly earlyDataStatus: null | 'offered' | 'accepted' | 'rejected';
+  readonly resetStreamAtSupported: boolean;
+  readonly alpnProtocol: string | null;
+  readonly servername: string | null;
+  sendStream(id: number, data: Uint8Array | Buffer, fin?: boolean): void;
+  whenStreamCommitted(id: number, cb: () => void): void;
+  resetStream(id: number, code: number, reliableSize?: number): boolean;
+  stopSending(id: number, code: number): void;
+  sendDatagram(data: Uint8Array | Buffer, prio?: { urgency?: number; group?: object; order?: number } | null): boolean;
+  setStreamPriority(id: number, priority: Priority & { group?: object; order?: number }, fromPeer?: boolean): boolean;
+  getStreamPriority(id: number): (Priority & { group?: object; order?: number }) | null;
+  canOpenStream(bidi: boolean): boolean;
+  isReceiving(id: number): boolean;
+  isEarlyStream(id: number): boolean;
+  maxDatagramSize(): number;
+  whenConfirmed(cb: () => void): void;
+  close(errorCode?: number, reason?: string, application?: boolean): void;
+  getCertificate(): any;
+  getTicketInfo(): any;
+  isSessionReused(): boolean;
+  exportKeyingMaterial(length: number, label: string, context?: Uint8Array | null): Buffer | null;
+  getStats(): Record<string, number | boolean | string | null>;
+  on(event: 'stream', listener: (id: number, data: Uint8Array, fin: boolean) => void): this;
+  on(event: 'stream_reset', listener: (id: number, code: number, finalSize: number) => void): this;
+  on(event: 'stop_sending', listener: (id: number, code: number) => void): this;
+  on(event: 'datagram', listener: (data: Uint8Array) => void): this;
+  on(event: 'path', listener: (address: string, port: number) => void): this;
+  /** The moment the connection is over for the application ('close' follows after the draining period). */
+  on(event: 'closing', listener: (peerClose: { error: number; application: boolean; reason: string } | null) => void): this;
+  on(event: string | symbol, listener: (...args: any[]) => void): this;
 }
 
+interface QuicServer extends EventEmitter {
+  listen(port?: number, host?: string, callback?: () => void): this;
+  close(callback?: () => void): void;
+  handlePacket(msg: Buffer, rinfo: RemoteInfo): void;
+  hasConnection(rinfo: RemoteInfo, msg?: Buffer): boolean;
+  getPendingHandshakes(): number;
+  setOptions(options: Record<string, any>): this;
+  getOptions(): Record<string, any>;
+  on(event: 'connection', listener: (quic: QUICConnection, peer: { address: string; port: number }) => void): this;
+  on(event: string | symbol, listener: (...args: any[]) => void): this;
+  [method: string]: any;
+}
+
+declare function createQuicServer(options: ServerOptions & { alpn?: string[]; [option: string]: any }): QuicServer;
+declare function createQuicClientSocket(options: {
+  remoteIp: string;
+  remotePort: number;
+  hostname?: string;
+  alpn?: string | string[];
+  ecdhCurve?: string;
+  idleTimeout?: number;
+  keepAlive?: boolean | number;
+  onConnect?: (quic: QUICConnection, socket: DgramSocket) => void;
+  onSocket?: (quic: QUICConnection, socket: DgramSocket) => void;
+  onError?: (err: Error) => void;
+  onClose?: () => void;
+  [option: string]: any;
+}): DgramSocket;
+declare function createTcpListener(options: Record<string, any>): {
+  register(alpn: string, handler: (socket: Duplex, protocol: string) => void, options?: { sniff?: (firstBytes: Buffer) => boolean | null }): void;
+  listen(port: number, host?: string, callback?: () => void): void;
+  [method: string]: any;
+};
+
+declare function createH1Server(options: ServerOptions, handler?: RequestHandler): any;
+declare function createH2Server(options: ServerOptions, handler?: RequestHandler): any;
+declare function createH3Server(options: ServerOptions, handler?: RequestHandler): any;
+declare function h1Request(options: RequestOptions, callback?: (res: QuicoIncomingMessage) => void): QuicoClientRequest;
+declare function h2Request(options: RequestOptions, callback?: (res: QuicoIncomingMessage) => void): QuicoClientRequest;
+declare function h3Request(options: RequestOptions, callback?: (res: QuicoIncomingMessage) => void): QuicoClientRequest;
 
 // ============================================================
 //  Main module
 // ============================================================
 
-declare const quico: {
-  createServer(options: ServerOptions, handler?: RequestHandler): QuicoServer;
+declare function createServer(handler?: RequestHandler): QuicoServer;
+declare function createServer(options: ServerOptions, handler?: RequestHandler): QuicoServer;
 
-  request(url: string | URL, callback?: (res: QuicoIncomingMessage) => void): QuicoClientRequest;
-  request(url: string | URL, options: RequestOptions, callback?: (res: QuicoIncomingMessage) => void): QuicoClientRequest;
-  request(options: RequestOptions, callback?: (res: QuicoIncomingMessage) => void): QuicoClientRequest;
+declare function request(url: string | URL, callback?: (res: QuicoIncomingMessage) => void): QuicoClientRequest;
+declare function request(url: string | URL, options: RequestOptions, callback?: (res: QuicoIncomingMessage) => void): QuicoClientRequest;
+declare function request(options: RequestOptions, callback?: (res: QuicoIncomingMessage) => void): QuicoClientRequest;
 
-  get(url: string | URL, callback?: (res: QuicoIncomingMessage) => void): QuicoClientRequest;
-  get(url: string | URL, options: RequestOptions, callback?: (res: QuicoIncomingMessage) => void): QuicoClientRequest;
-  get(options: RequestOptions, callback?: (res: QuicoIncomingMessage) => void): QuicoClientRequest;
+declare function get(url: string | URL, callback?: (res: QuicoIncomingMessage) => void): QuicoClientRequest;
+declare function get(url: string | URL, options: RequestOptions, callback?: (res: QuicoIncomingMessage) => void): QuicoClientRequest;
+declare function get(options: RequestOptions, callback?: (res: QuicoIncomingMessage) => void): QuicoClientRequest;
 
-  globalAgent: QuicoAgent;
+declare const globalAgent: Agent;
+
+/** node:http's classes, as QUICO's request and response are made. */
+declare const IncomingMessage: typeof NodeIncomingMessage;
+declare const ServerResponse: typeof NodeServerResponse;
+declare const ClientRequest: typeof NodeClientRequest;
+
+declare const quico: {
+  createServer: typeof createServer;
+  request: typeof request;
+  get: typeof get;
+  Agent: typeof Agent;
+  globalAgent: Agent;
+  IncomingMessage: typeof NodeIncomingMessage;
+  ServerResponse: typeof NodeServerResponse;
+  ClientRequest: typeof NodeClientRequest;
+  connectUdp: typeof connectUdp;
+  createSecureContext: typeof createSecureContext;
+  generateEchKey: typeof generateEchKey;
+  WebTransport: typeof WebTransport;
+  WebTransportError: typeof WebTransportError;
+  WebTransportBidirectionalStream: typeof WebTransportBidirectionalStream;
+  WebTransportReceiveStream: typeof WebTransportReceiveStream;
+  WebTransportSendStream: typeof WebTransportSendStream;
+  WebTransportWriter: typeof WebTransportWriter;
+  WebTransportSendGroup: typeof WebTransportSendGroup;
+  WebTransportDatagramsWritable: typeof WebTransportDatagramsWritable;
+  WebTransportDatagramDuplexStream: typeof WebTransportDatagramDuplexStream;
+  WebSocket: typeof WebSocket;
+  WebSocketStream: typeof WebSocketStream;
+  WebSocketError: typeof WebSocketError;
+  WebSocketServer: typeof WebSocketServer;
+  upgradeWebSocket: typeof upgradeWebSocket;
+  ja4h: typeof ja4h;
+  h2Fingerprint: typeof h2Fingerprint;
+  h3Fingerprint: typeof h3Fingerprint;
+  observeH2: typeof observeH2;
+  profileRequest: typeof profileRequest;
+  createQuicServer: typeof createQuicServer;
+  createQuicClientSocket: typeof createQuicClientSocket;
+  createTcpListener: typeof createTcpListener;
+  createH1Server: typeof createH1Server;
+  createH2Server: typeof createH2Server;
+  createH3Server: typeof createH3Server;
+  h1Request: typeof h1Request;
+  h2Request: typeof h2Request;
+  h3Request: typeof h3Request;
 };
 
 export default quico;
-export { WebTransport };
-export { QuicoServer, QuicoIncomingMessage, QuicoServerResponse, QuicoClientRequest, QuicoAgent };
-export { ServerOptions, RequestOptions, RequestHandler, WebTransportOptions };
+export {
+  createServer, request, get, Agent, globalAgent,
+  IncomingMessage, ServerResponse, ClientRequest,
+  connectUdp, createSecureContext, generateEchKey,
+  WebTransport, WebTransportError, WebTransportBidirectionalStream, WebTransportReceiveStream, WebTransportSendStream,
+  WebTransportWriter, WebTransportSendGroup, WebTransportDatagramsWritable, WebTransportDatagramDuplexStream,
+  WebSocket, WebSocketStream, WebSocketError, WebSocketServer, upgradeWebSocket,
+  ja4h, h2Fingerprint, h3Fingerprint, observeH2, profileRequest,
+  createQuicServer, createQuicClientSocket, createTcpListener,
+  createH1Server, createH2Server, createH3Server,
+  h1Request, h2Request, h3Request
+};
+export type {
+  ServerOptions, RequestOptions, RequestHandler, AgentOptions, Priority, TransportParams, StartupCap,
+  QuicConnectionOptions, ConnectionOptionsInfo, ConnectionHandle, ServerStats, EchKey, Fingerprint,
+  QuicoServer, QuicoIncomingMessage, QuicoServerResponse, QuicoClientRequest,
+  ConnectUdpServerOptions, ConnectUdpTunnel, ConnectUdpTunnelStats, ConnectUdpOptions, UdpProxySocket, UdpProxySocketStats,
+  WebTransportOptions, WebTransportHash, WebTransportCloseInfo, WebTransportSendOptions, WebTransportSendStreamOptions,
+  WebTransportConnectionStats, WebTransportDatagramStats, WebTransportSendStreamStats, WebTransportReceiveStreamStats,
+  WebTransportReliabilityMode, WebTransportCongestionControl, WebTransportErrorSource,
+  WebTransportNodeStream, WebTransportBidirectionalNodeStream, WebTransportUnidirectionalNodeStream,
+  WebSocketClientOptions, WebSocketStreamOptions, WebSocketOpenInfo, WebSocketCloseInfo, WebSocketServerOptions, UpgradeWebSocketOptions, ServerWebSocket,
+  QUICConnection, QuicServer
+};