@fkn/lib 0.6.0 → 0.6.1

package/dgram.d.ts

@@ -0,0 +1,91 @@
+import { n as UdpSocketOption, t as Resolvers } from "./api-BYUraih6.js";
+import { Buffer } from "buffer";
+import { AddressInfo } from "net";
+import { EventEmitter } from "events";
+import { BindOptions, RemoteInfo, Socket as Socket$2, SocketOptions, SocketType } from "dgram";
+
+//#region src/lib/webvpn/dgram.d.ts
+declare namespace dgram_d_exports {
+  export { Socket, createSocket, _default as default };
+}
+type WebVpnUdpSocket = Resolvers['cloud']['webvpn']['udpSocket'];
+interface EventEmitterOptions {
+  /**
+   * Enables automatic capturing of promise rejection.
+   */
+  captureRejections?: boolean | undefined;
+}
+declare class Socket extends EventEmitter implements Socket$2 {
+  _type: 'udp4' | 'udp6';
+  _localAddress?: {
+    address: string;
+    family: string;
+    port: number;
+  };
+  _remoteAddress?: {
+    address: string;
+    family: string;
+    port: number;
+  };
+  _webVPNUdpSocketPromise?: Promise<Awaited<ReturnType<WebVpnUdpSocket>> | undefined>;
+  _dataPort?: MessagePort;
+  _socketId?: number;
+  _sendQueue: Uint8Array[];
+  _sendQueueBytes: number;
+  _sendFlushScheduled: boolean;
+  _peerTailCache: Map<string, Uint8Array<ArrayBufferLike>>;
+  constructor(options: SocketOptions & EventEmitterOptions & {
+    connection?: ReturnType<WebVpnUdpSocket>;
+  });
+  _lastRecvBufferSize: number;
+  _lastSendBufferSize: number;
+  _lastTtl: number;
+  _lastMulticastTtl: number;
+  _lastMulticastLoopback: boolean;
+  _setUdpOption(option: UdpSocketOption): void;
+  _onDataPortBatch(buffer: ArrayBuffer): void;
+  _peerTail(address: string | undefined, port: number | undefined): Uint8Array;
+  _portSend(message: Uint8Array, address: string | undefined, port: number | undefined): void;
+  addMembership(multicastAddress: string, multicastInterface?: string | undefined): void;
+  address(): AddressInfo;
+  bind(port?: number | undefined, address?: string | undefined, callback?: (() => void) | undefined): this;
+  bind(port?: number | undefined, callback?: (() => void) | undefined): this;
+  bind(callback?: (() => void) | undefined): this;
+  bind(options: BindOptions, callback?: (() => void) | undefined): this;
+  close(callback?: (() => void) | undefined): this;
+  connect(port: number, address?: string, callback?: () => void): void;
+  connect(port: number, callback: () => void): void;
+  disconnect(): void;
+  dropMembership(multicastAddress: string, multicastInterface?: string | undefined): void;
+  getRecvBufferSize(): number;
+  getSendBufferSize(): number;
+  getSendQueueSize(): number;
+  getSendQueueCount(): number;
+  ref(): this;
+  remoteAddress(): AddressInfo;
+  send(msg: string | readonly any[] | Uint8Array, port?: number | undefined, address?: string | undefined, callback?: ((error: Error | null, bytes: number) => void) | undefined): void;
+  send(msg: string | readonly any[] | Uint8Array, port?: number | undefined, callback?: ((error: Error | null, bytes: number) => void) | undefined): void;
+  send(msg: string | readonly any[] | Uint8Array, callback?: ((error: Error | null, bytes: number) => void) | undefined): void;
+  send(msg: string | Uint8Array, offset: number, length: number, port?: number | undefined, address?: string | undefined, callback?: ((error: Error | null, bytes: number) => void) | undefined): void;
+  send(msg: string | Uint8Array, offset: number, length: number, port?: number | undefined, callback?: ((error: Error | null, bytes: number) => void) | undefined): void;
+  send(msg: string | Uint8Array, offset: number, length: number, callback?: ((error: Error | null, bytes: number) => void) | undefined): void;
+  send(msg: unknown, offset?: unknown, length?: unknown, port?: unknown, address?: unknown, callback?: unknown): void;
+  setBroadcast(flag: boolean): void;
+  setMulticastInterface(multicastInterface: string): void;
+  setMulticastLoopback(flag: boolean): boolean;
+  setMulticastTTL(ttl: number): number;
+  setRecvBufferSize(size: number): void;
+  setSendBufferSize(size: number): void;
+  setTTL(ttl: number): number;
+  unref(): this;
+  addSourceSpecificMembership(sourceAddress: string, groupAddress: string, multicastInterface?: string | undefined): void;
+  dropSourceSpecificMembership(sourceAddress: string, groupAddress: string, multicastInterface?: string | undefined): void;
+  [Symbol.asyncDispose](): Promise<void>;
+}
+declare const createSocket: (options: SocketType | SocketOptions, callback?: (msg: Buffer, rinfo: RemoteInfo) => void) => Socket;
+declare const _default: {
+  Socket: typeof Socket;
+  createSocket: (options: SocketType | SocketOptions, callback?: (msg: Buffer, rinfo: RemoteInfo) => void) => Socket;
+};
+//#endregion
+export { Socket, createSocket, _default as default, dgram_d_exports as t };

package/dns.d.ts

@@ -0,0 +1,12 @@
+import { t as AddressLookupResult } from "./lookup-BtwWaCZJ.js";
+
+//#region src/lib/dns.d.ts
+declare namespace dns_d_exports {
+  export { AddressLookupResult, lookup };
+}
+declare const lookup: <T extends boolean = false>(hostname: string, options?: {
+  all?: T;
+  family?: 0 | 4 | 6;
+}) => Promise<T extends true ? AddressLookupResult[] : AddressLookupResult | undefined>;
+//#endregion
+export { type AddressLookupResult, lookup, dns_d_exports as t };

package/extension-3pxUYwrA.d.ts

@@ -0,0 +1,16 @@
+import { A as RequestHeaderRule, B as assertFetchableUrl, C as attachFramePermission, D as assertLockdownApplicable, E as assertAttachableFrameUrl, F as SiteCookie, G as isBlockedFetchUrl, H as fetchCredentialedPermission, I as cookies, K as isLocalNetworkUrl, L as readCookiePermission, M as removeRequestHeaderRule, N as setRequestHeaderRule, O as isBlockedFrameUrl, P as CookieDetails, R as FetchInit, S as GotoOptions, T as gotoPermission, U as fetchLocalPermission, V as fetch$1, W as fetchPermission, _ as ATTACH_FRAME_EVENT_KEY, a as handleRevivableModules, b as Frame, c as VideoElementState, d as isType, f as revive, g as permissions, h as PermissionRequest, i as waitForExtensionExposure, j as modifyRequestHeadersPermission, k as HeaderOperation, l as box, m as PermissionGrant, n as isExtensionExposed, o as BoxedVideoElement, p as type, r as setMissingExtensionHandler, s as RemoteVideoElement, t as extension, u as createVideoElementHandle, v as attachFrame, w as createFrame, x as FrameBackend, y as AttachFrameOptions, z as ProxyFetchRequest } from "./index-BJztAQIP.js";
+
+//#region src/lib/extension-prompt.d.ts
+declare const promptInstall: (reason?: string) => Promise<boolean>;
+//#endregion
+//#region src/lib/auto.d.ts
+declare const isExtensionAvailable: () => boolean;
+declare const fetch: (input: RequestInfo | URL, init?: RequestInit & {
+  reason?: string;
+  render?: boolean;
+}) => Promise<Response>;
+declare namespace extension_d_exports {
+  export { ATTACH_FRAME_EVENT_KEY, AttachFrameOptions, BoxedVideoElement, CookieDetails, FetchInit, Frame, FrameBackend, GotoOptions, HeaderOperation, PermissionGrant, PermissionRequest, ProxyFetchRequest, RemoteVideoElement, RequestHeaderRule, SiteCookie, VideoElementState, assertAttachableFrameUrl, assertFetchableUrl, assertLockdownApplicable, attachFrame, attachFramePermission, isExtensionAvailable as available, box, cookies, createFrame, createVideoElementHandle, extension as events, extension, fetch$1 as fetch, fetchCredentialedPermission, fetchLocalPermission, fetchPermission, gotoPermission, handleRevivableModules, isBlockedFetchUrl, isBlockedFrameUrl, isExtensionExposed, isLocalNetworkUrl, isType, modifyRequestHeadersPermission, permissions, promptInstall, readCookiePermission, removeRequestHeaderRule, revive, setMissingExtensionHandler, setRequestHeaderRule, type, waitForExtensionExposure };
+}
+//#endregion
+export { promptInstall as i, fetch as n, isExtensionAvailable as r, extension_d_exports as t };

package/extension.d.ts

@@ -0,0 +1,3 @@
+import { A as RequestHeaderRule, B as assertFetchableUrl, C as attachFramePermission, D as assertLockdownApplicable, E as assertAttachableFrameUrl, F as SiteCookie, G as isBlockedFetchUrl, H as fetchCredentialedPermission, I as cookies, K as isLocalNetworkUrl, L as readCookiePermission, M as removeRequestHeaderRule, N as setRequestHeaderRule, O as isBlockedFrameUrl, P as CookieDetails, R as FetchInit, S as GotoOptions, T as gotoPermission, U as fetchLocalPermission, V as fetch, W as fetchPermission, _ as ATTACH_FRAME_EVENT_KEY, a as handleRevivableModules, b as Frame, c as VideoElementState, d as isType, f as revive, g as permissions, h as PermissionRequest, i as waitForExtensionExposure, j as modifyRequestHeadersPermission, k as HeaderOperation, l as box, m as PermissionGrant, n as isExtensionExposed, o as BoxedVideoElement, p as type, r as setMissingExtensionHandler, s as RemoteVideoElement, t as extension, u as createVideoElementHandle, v as attachFrame, w as createFrame, x as FrameBackend, y as AttachFrameOptions, z as ProxyFetchRequest } from "./index-BJztAQIP.js";
+import { i as promptInstall, r as isExtensionAvailable } from "./extension-3pxUYwrA.js";
+export { ATTACH_FRAME_EVENT_KEY, AttachFrameOptions, BoxedVideoElement, CookieDetails, FetchInit, Frame, FrameBackend, GotoOptions, HeaderOperation, PermissionGrant, PermissionRequest, ProxyFetchRequest, RemoteVideoElement, RequestHeaderRule, SiteCookie, VideoElementState, assertAttachableFrameUrl, assertFetchableUrl, assertLockdownApplicable, attachFrame, attachFramePermission, isExtensionAvailable as available, box, cookies, createFrame, createVideoElementHandle, extension as events, extension, fetch, fetchCredentialedPermission, fetchLocalPermission, fetchPermission, gotoPermission, handleRevivableModules, isBlockedFetchUrl, isBlockedFrameUrl, isExtensionExposed, isLocalNetworkUrl, isType, modifyRequestHeadersPermission, permissions, promptInstall, readCookiePermission, removeRequestHeaderRule, revive, setMissingExtensionHandler, setRequestHeaderRule, type, waitForExtensionExposure };

package/fs/promises.d.ts

@@ -0,0 +1,12 @@
+import { a as WriteData, i as Stats, n as MakeOptions, o as WriteOptions, r as ReadOptions } from "../index-C6ZoDJg8.js";
+import { promises } from "../fs.js";
+
+//#region src/lib/fs/promises.d.ts
+declare const readFile: (path: import("node:fs").PathLike, options?: ReadOptions) => Promise<Buffer | string>, writeFile: (path: import("node:fs").PathLike, data: WriteData, options?: WriteOptions) => Promise<void>, appendFile: (path: import("node:fs").PathLike, data: WriteData, options?: WriteOptions) => Promise<void>, unlink: (path: import("node:fs").PathLike) => Promise<void>, rename: (from: import("node:fs").PathLike, to: import("node:fs").PathLike) => Promise<void>, readdir: (path: import("node:fs").PathLike) => Promise<string[]>, mkdir: (path: import("node:fs").PathLike, options?: MakeOptions) => Promise<void>, rm: (path: import("node:fs").PathLike, options?: {
+    recursive?: boolean;
+    force?: boolean;
+  }) => Promise<void>, rmdir: (path: import("node:fs").PathLike, options?: {
+    recursive?: boolean;
+  }) => Promise<void>, stat: (path: import("node:fs").PathLike) => Promise<Stats>, lstat: (path: import("node:fs").PathLike) => Promise<Stats>, access: (path: import("node:fs").PathLike) => Promise<void>;
+//#endregion
+export { access, appendFile, promises as default, lstat, mkdir, readFile, readdir, rename, rm, rmdir, stat, unlink, writeFile };

package/fs-K7ROdxDx.d.ts

@@ -0,0 +1,41 @@
+import { a as WriteData, i as Stats, n as MakeOptions, o as WriteOptions, r as ReadOptions, t as Callback } from "./index-C6ZoDJg8.js";
+
+//#region src/lib/storage.d.ts
+type FileEntry = {
+  path: string;
+  size: number;
+  contentType: string | null;
+  updatedAt: string;
+};
+type StorageQuota = {
+  usedBytes: number;
+  limitBytes: number;
+  remaining: number;
+  objects: number;
+  maxObjects: number;
+};
+declare const quota: () => Promise<StorageQuota>;
+declare namespace fs_d_exports {
+  export { FileEntry, Stats, StorageQuota, available, mkdir, promises, quota, readFile, readdir, rename, rm, stat, unlink, writeFile };
+}
+declare const available: () => Promise<boolean>, readFile: (path: import("node:fs").PathLike, a: ReadOptions | Callback<Buffer | string>, b?: Callback<Buffer | string>) => void, writeFile: (path: import("node:fs").PathLike, data: WriteData, a: WriteOptions | Callback<void>, b?: Callback<void>) => void, unlink: (path: import("node:fs").PathLike, callback: Callback<void>) => void, rename: (from: import("node:fs").PathLike, to: import("node:fs").PathLike, callback: Callback<void>) => void, readdir: (path: import("node:fs").PathLike, a: unknown, b?: Callback<string[]>) => void, mkdir: (path: import("node:fs").PathLike, a: MakeOptions | Callback<void>, b?: Callback<void>) => void, rm: (path: import("node:fs").PathLike, a: {
+    recursive?: boolean;
+  } | Callback<void>, b?: Callback<void>) => void, stat: (path: import("node:fs").PathLike, callback: Callback<Stats>) => void, promises: {
+    readFile: (path: import("node:fs").PathLike, options?: ReadOptions) => Promise<Buffer | string>;
+    writeFile: (path: import("node:fs").PathLike, data: WriteData, options?: WriteOptions) => Promise<void>;
+    unlink: (path: import("node:fs").PathLike) => Promise<void>;
+    rename: (from: import("node:fs").PathLike, to: import("node:fs").PathLike) => Promise<void>;
+    readdir: (path: import("node:fs").PathLike) => Promise<string[]>;
+    mkdir: (_path?: import("node:fs").PathLike, _options?: MakeOptions) => Promise<void>;
+    rm: (path: import("node:fs").PathLike, options?: {
+      recursive?: boolean;
+    }) => Promise<void>;
+    rmdir: (path: import("node:fs").PathLike, options?: {
+      recursive?: boolean;
+    }) => Promise<void>;
+    stat: (path: import("node:fs").PathLike) => Promise<Stats>;
+    lstat: (path: import("node:fs").PathLike) => Promise<Stats>;
+    access: (path: import("node:fs").PathLike) => Promise<void>;
+  };
+//#endregion
+export { readFile as a, rm as c, writeFile as d, FileEntry as f, promises as i, stat as l, quota as m, fs_d_exports as n, readdir as o, StorageQuota as p, mkdir as r, rename as s, available as t, unlink as u };

package/fs.d.ts

@@ -0,0 +1,92 @@
+import { a as WriteData, i as Stats, n as MakeOptions, o as WriteOptions, r as ReadOptions, t as Callback } from "./index-C6ZoDJg8.js";
+
+//#region src/lib/fs/index.d.ts
+declare namespace index_d_exports {
+  export { Stats, appendFile, appendFileSync, available, _default as default, exists, existsSync, flush, lstatSync, mkdir, mkdirSync, mount, promises, pull, readFile, readFileSync, readdir, readdirSync, remount, rename, renameSync, rm, rmSync, rmdirSync, stat, statSync, unlink, unlinkSync, writeFile, writeFileSync };
+}
+declare const available: () => Promise<boolean>, readFileSync: (path: import("node:fs").PathLike, options?: ReadOptions) => Buffer | string, writeFileSync: (path: import("node:fs").PathLike, data: WriteData, options?: WriteOptions) => void, appendFileSync: (path: import("node:fs").PathLike, data: WriteData, options?: WriteOptions) => void, existsSync: (path: import("node:fs").PathLike) => boolean, statSync: (path: import("node:fs").PathLike) => Stats, lstatSync: (path: import("node:fs").PathLike) => Stats, readdirSync: (path: import("node:fs").PathLike) => string[], mkdirSync: (path: import("node:fs").PathLike, options?: MakeOptions) => void, rmSync: (path: import("node:fs").PathLike, options?: {
+    recursive?: boolean;
+    force?: boolean;
+  }) => void, rmdirSync: (path: import("node:fs").PathLike, options?: {
+    recursive?: boolean;
+  }) => void, unlinkSync: (path: import("node:fs").PathLike) => void, renameSync: (from: import("node:fs").PathLike, to: import("node:fs").PathLike) => void, readFile: (path: import("node:fs").PathLike, a: ReadOptions | Callback<Buffer | string>, b?: Callback<Buffer | string>) => void, writeFile: (path: import("node:fs").PathLike, data: WriteData, a: WriteOptions | Callback<void>, b?: Callback<void>) => void, appendFile: (path: import("node:fs").PathLike, data: WriteData, a: WriteOptions | Callback<void>, b?: Callback<void>) => void, stat: (path: import("node:fs").PathLike, callback: Callback<Stats>) => void, readdir: (path: import("node:fs").PathLike, a: unknown, b?: Callback<string[]>) => void, mkdir: (path: import("node:fs").PathLike, a: MakeOptions | Callback<void>, b?: Callback<void>) => void, rm: (path: import("node:fs").PathLike, a: {
+    recursive?: boolean;
+    force?: boolean;
+  } | Callback<void>, b?: Callback<void>) => void, unlink: (path: import("node:fs").PathLike, callback: Callback<void>) => void, rename: (from: import("node:fs").PathLike, to: import("node:fs").PathLike, callback: Callback<void>) => void, exists: (path: import("node:fs").PathLike, callback: (exists: boolean) => void) => void, promises: {
+    readFile: (path: import("node:fs").PathLike, options?: ReadOptions) => Promise<Buffer | string>;
+    writeFile: (path: import("node:fs").PathLike, data: WriteData, options?: WriteOptions) => Promise<void>;
+    appendFile: (path: import("node:fs").PathLike, data: WriteData, options?: WriteOptions) => Promise<void>;
+    stat: (path: import("node:fs").PathLike) => Promise<Stats>;
+    lstat: (path: import("node:fs").PathLike) => Promise<Stats>;
+    readdir: (path: import("node:fs").PathLike) => Promise<string[]>;
+    mkdir: (path: import("node:fs").PathLike, options?: MakeOptions) => Promise<void>;
+    rm: (path: import("node:fs").PathLike, options?: {
+      recursive?: boolean;
+      force?: boolean;
+    }) => Promise<void>;
+    rmdir: (path: import("node:fs").PathLike, options?: {
+      recursive?: boolean;
+    }) => Promise<void>;
+    unlink: (path: import("node:fs").PathLike) => Promise<void>;
+    rename: (from: import("node:fs").PathLike, to: import("node:fs").PathLike) => Promise<void>;
+    access: (path: import("node:fs").PathLike) => Promise<void>;
+  }, mount: () => Promise<void>, flush: () => Promise<void>, remount: () => Promise<void>;
+declare const pull: (path: string) => Promise<Blob>;
+declare const _default: {
+  available: () => Promise<boolean>;
+  readFileSync: (path: import("node:fs").PathLike, options?: ReadOptions) => Buffer | string;
+  writeFileSync: (path: import("node:fs").PathLike, data: WriteData, options?: WriteOptions) => void;
+  appendFileSync: (path: import("node:fs").PathLike, data: WriteData, options?: WriteOptions) => void;
+  existsSync: (path: import("node:fs").PathLike) => boolean;
+  statSync: (path: import("node:fs").PathLike) => Stats;
+  lstatSync: (path: import("node:fs").PathLike) => Stats;
+  readdirSync: (path: import("node:fs").PathLike) => string[];
+  mkdirSync: (path: import("node:fs").PathLike, options?: MakeOptions) => void;
+  rmSync: (path: import("node:fs").PathLike, options?: {
+    recursive?: boolean;
+    force?: boolean;
+  }) => void;
+  rmdirSync: (path: import("node:fs").PathLike, options?: {
+    recursive?: boolean;
+  }) => void;
+  unlinkSync: (path: import("node:fs").PathLike) => void;
+  renameSync: (from: import("node:fs").PathLike, to: import("node:fs").PathLike) => void;
+  readFile: (path: import("node:fs").PathLike, a: ReadOptions | Callback<Buffer | string>, b?: Callback<Buffer | string>) => void;
+  writeFile: (path: import("node:fs").PathLike, data: WriteData, a: WriteOptions | Callback<void>, b?: Callback<void>) => void;
+  appendFile: (path: import("node:fs").PathLike, data: WriteData, a: WriteOptions | Callback<void>, b?: Callback<void>) => void;
+  stat: (path: import("node:fs").PathLike, callback: Callback<Stats>) => void;
+  readdir: (path: import("node:fs").PathLike, a: unknown, b?: Callback<string[]>) => void;
+  mkdir: (path: import("node:fs").PathLike, a: MakeOptions | Callback<void>, b?: Callback<void>) => void;
+  rm: (path: import("node:fs").PathLike, a: {
+    recursive?: boolean;
+    force?: boolean;
+  } | Callback<void>, b?: Callback<void>) => void;
+  unlink: (path: import("node:fs").PathLike, callback: Callback<void>) => void;
+  rename: (from: import("node:fs").PathLike, to: import("node:fs").PathLike, callback: Callback<void>) => void;
+  exists: (path: import("node:fs").PathLike, callback: (exists: boolean) => void) => void;
+  promises: {
+    readFile: (path: import("node:fs").PathLike, options?: ReadOptions) => Promise<Buffer | string>;
+    writeFile: (path: import("node:fs").PathLike, data: WriteData, options?: WriteOptions) => Promise<void>;
+    appendFile: (path: import("node:fs").PathLike, data: WriteData, options?: WriteOptions) => Promise<void>;
+    stat: (path: import("node:fs").PathLike) => Promise<Stats>;
+    lstat: (path: import("node:fs").PathLike) => Promise<Stats>;
+    readdir: (path: import("node:fs").PathLike) => Promise<string[]>;
+    mkdir: (path: import("node:fs").PathLike, options?: MakeOptions) => Promise<void>;
+    rm: (path: import("node:fs").PathLike, options?: {
+      recursive?: boolean;
+      force?: boolean;
+    }) => Promise<void>;
+    rmdir: (path: import("node:fs").PathLike, options?: {
+      recursive?: boolean;
+    }) => Promise<void>;
+    unlink: (path: import("node:fs").PathLike) => Promise<void>;
+    rename: (from: import("node:fs").PathLike, to: import("node:fs").PathLike) => Promise<void>;
+    access: (path: import("node:fs").PathLike) => Promise<void>;
+  };
+  mount: () => Promise<void>;
+  flush: () => Promise<void>;
+  remount: () => Promise<void>;
+  pull: (path: string) => Promise<Blob>;
+};
+//#endregion
+export { type Stats, appendFile, appendFileSync, available, _default as default, exists, existsSync, flush, lstatSync, mkdir, mkdirSync, mount, promises, pull, readFile, readFileSync, readdir, readdirSync, remount, rename, renameSync, rm, rmSync, rmdirSync, stat, statSync, index_d_exports as t, unlink, unlinkSync, writeFile, writeFileSync };

package/http.d.ts

@@ -0,0 +1,186 @@
+import { n as Socket, t as Server$1 } from "./net-BDW1AVX1.js";
+import { Buffer } from "buffer";
+import { Stream } from "stream";
+import { IncomingHttpHeaders, OutgoingHttpHeaders, RequestOptions } from "http";
+
+//#region src/lib/webvpn/http.d.ts
+declare namespace http_d_exports {
+  export { Agent, ClientRequest, ClientRequestArgs, HTTPParser, IncomingMessage, METHODS, ParsedHead, RequestListener, STATUS_CODES, Server, ServerResponse, ServerResponseOptions, _default, createServer, _default as default, get, globalAgent, request };
+}
+declare const METHODS: string[];
+declare const STATUS_CODES: Record<number, string>;
+interface ParsedHead {
+  /** request only */
+  method?: string;
+  /** request only */
+  url?: string;
+  /** response only */
+  statusCode?: number;
+  /** response only */
+  statusMessage?: string;
+  httpVersionMajor: number;
+  httpVersionMinor: number;
+  httpVersion: string;
+  headers: IncomingHttpHeaders;
+  rawHeaders: string[];
+}
+interface ParserHandlers {
+  onHeaders: (head: ParsedHead) => void;
+  onBody: (chunk: Uint8Array) => void;
+  onComplete: () => void;
+}
+declare class HTTPParser {
+  private readonly mode;
+  private readonly handlers;
+  private buf;
+  private state;
+  private framing;
+  private bodyRemaining;
+  private chunkState;
+  skipBody: boolean;
+  constructor(mode: 'request' | 'response', handlers: ParserHandlers);
+  execute(chunk: Uint8Array): void;
+  finish(): void;
+  private reset;
+  private parseHead;
+  private applyVersion;
+  private addHeader;
+  private setupBody;
+  private consumeBody;
+  private consumeChunked;
+}
+declare class IncomingMessage extends Stream.Readable {
+  httpVersion: string;
+  httpVersionMajor: number;
+  httpVersionMinor: number;
+  headers: IncomingHttpHeaders;
+  rawHeaders: string[];
+  trailers: Record<string, string>;
+  rawTrailers: string[];
+  /** request only */
+  method?: string;
+  /** request only */
+  url?: string;
+  /** response only */
+  statusCode?: number;
+  /** response only */
+  statusMessage?: string;
+  complete: boolean;
+  socket: Socket;
+  constructor(socket: Socket);
+  get connection(): Socket;
+  _applyHead(head: ParsedHead): void;
+  _read(): void;
+  setTimeout(msecs: number, callback?: () => void): this;
+}
+declare abstract class OutgoingMessage extends Stream.Writable {
+  private _headerStore;
+  headersSent: boolean;
+  chunkedEncoding: boolean;
+  finished: boolean;
+  protected _bodyWritten: boolean;
+  abstract socket: Socket | null;
+  setHeader(name: string, value: number | string | readonly string[]): this;
+  getHeader(name: string): number | string | string[] | undefined;
+  getHeaderNames(): string[];
+  getHeaders(): OutgoingHttpHeaders;
+  hasHeader(name: string): boolean;
+  removeHeader(name: string): void;
+  protected _storeHeader(startLine: string): string;
+  protected abstract _shouldSendBody(): boolean;
+  protected abstract _implicitHeader(): void;
+  protected _writeToSocket(data: Buffer, callback: (error?: Error | null) => void): void;
+  write(chunk: unknown, encoding?: BufferEncoding | ((error: Error | null | undefined) => void), callback?: (error: Error | null | undefined) => void): boolean;
+  _write(chunk: Buffer, _encoding: BufferEncoding, callback: (error?: Error | null) => void): void;
+  _final(callback: (error?: Error | null) => void): void;
+  end(chunk?: unknown, encoding?: BufferEncoding | (() => void), callback?: () => void): this;
+  protected _headBlock?: string;
+}
+interface ServerResponseOptions {
+  req: IncomingMessage;
+}
+declare class ServerResponse extends OutgoingMessage {
+  statusCode: number;
+  statusMessage?: string;
+  private _writeHeadCalled;
+  sendDate: boolean;
+  req: IncomingMessage;
+  socket: Socket | null;
+  _keepAlive: boolean;
+  constructor(req: IncomingMessage);
+  protected _shouldSendBody(): boolean;
+  writeHead(statusCode: number, statusMessage?: string | OutgoingHttpHeaders | OutgoingHttpHeaders[keyof OutgoingHttpHeaders][], headers?: OutgoingHttpHeaders): this;
+  private _appendHeader;
+  protected _implicitHeader(): void;
+  writeContinue(): void;
+  setTimeout(msecs: number, callback?: () => void): this;
+}
+interface ClientRequestArgs extends RequestOptions {
+  host?: string;
+  hostname?: string;
+  port?: number | string;
+  path?: string;
+}
+declare class ClientRequest extends OutgoingMessage {
+  method: string;
+  path: string;
+  host: string;
+  protocol: string;
+  socket: Socket;
+  /** alias retained for Node compatibility */
+  get connection(): Socket;
+  res: IncomingMessage | null;
+  aborted: boolean;
+  private _aborted;
+  constructor(options: ClientRequestArgs, callback?: (res: IncomingMessage) => void);
+  protected _shouldSendBody(): boolean;
+  protected _implicitHeader(): void;
+  private _attachResponseParser;
+  abort(): void;
+  destroy(error?: Error): this;
+  end(chunk?: unknown, encoding?: unknown, callback?: unknown): this;
+  protected _writeToSocket(data: Buffer, callback: (error?: Error | null) => void): void;
+  setTimeout(timeout: number, callback?: () => void): this;
+  setNoDelay(noDelay?: boolean): void;
+  setSocketKeepAlive(enable?: boolean, initialDelay?: number): void;
+}
+type RequestListener = (req: IncomingMessage, res: ServerResponse) => void;
+declare class ServerImpl extends Server$1 {
+  constructor(options?: object | RequestListener, requestListener?: RequestListener);
+  private _handleConnection;
+}
+declare const Server: typeof ServerImpl;
+type Server = ServerImpl;
+declare class Agent {
+  maxSockets: number;
+  maxFreeSockets: number;
+  keepAlive: boolean;
+  options: Record<string, unknown>;
+  constructor(options?: Record<string, unknown>);
+  getName(options?: {
+    host?: string;
+    port?: number;
+    localAddress?: string;
+  }): string;
+  destroy(): void;
+}
+declare const globalAgent: Agent;
+declare const request: (...args: [options: string | URL | ClientRequestArgs, callback?: (res: IncomingMessage) => void] | [url: string | URL, options: ClientRequestArgs, callback?: (res: IncomingMessage) => void]) => ClientRequest;
+declare const get: (...args: [options: string | URL | ClientRequestArgs, callback?: (res: IncomingMessage) => void] | [url: string | URL, options: ClientRequestArgs, callback?: (res: IncomingMessage) => void]) => ClientRequest;
+declare const createServer: (options?: object | RequestListener, requestListener?: RequestListener) => Server;
+declare const _default: {
+  METHODS: string[];
+  STATUS_CODES: Record<number, string>;
+  Agent: typeof Agent;
+  globalAgent: Agent;
+  Server: typeof ServerImpl;
+  ServerResponse: typeof ServerResponse;
+  IncomingMessage: typeof IncomingMessage;
+  ClientRequest: typeof ClientRequest;
+  OutgoingMessage: typeof OutgoingMessage;
+  createServer: (options?: object | RequestListener, requestListener?: RequestListener) => Server;
+  request: (...args: [options: string | URL | ClientRequestArgs, callback?: (res: IncomingMessage) => void] | [url: string | URL, options: ClientRequestArgs, callback?: (res: IncomingMessage) => void]) => ClientRequest;
+  get: (...args: [options: string | URL | ClientRequestArgs, callback?: (res: IncomingMessage) => void] | [url: string | URL, options: ClientRequestArgs, callback?: (res: IncomingMessage) => void]) => ClientRequest;
+};
+//#endregion
+export { Agent, ClientRequest, ClientRequestArgs, HTTPParser, IncomingMessage, METHODS, ParsedHead, RequestListener, STATUS_CODES, Server, ServerResponse, ServerResponseOptions, _default, _default as default, createServer, get, globalAgent, request, http_d_exports as t };