/* The FALLBACK Node-ish declarations — shipped into the program ONLY when
 * the target project has no @types/node (see loadProgram): console, the
 * process global, and the "node:fs" module, typed as exactly the supported
 * surface so unsupported uses are honest TYPE errors. Where a member is
 * part of the stock lib surface but has no lowering, prefer DECLARING it
 * (console's non-lowered members below): a program that typechecks under
 * its own tsc then reaches the per-site lowering fence with its hint,
 * instead of a fallback-manufactured type error it cannot reproduce.
 *
 * When the project's node_modules contains @types/node, this file STANDS
 * DOWN — its declarations would collide with @types/node's own (`declare
 * var process`, `declare var console`, `declare module "node:fs"`), and
 * the project's real types win. The LOWERED surface does not change: the
 * lowerer recognizes the same members by name + provenance (shipped
 * ambient OR @types/node — see isStdlibFile/isNodeTypesPath), and
 * everything else @types/node declares hits the SC2020-family fence at
 * its use site. scriptc.d.ts holds the always-shipped core (divergence
 * overrides, comptime, setTimeout — which MERGES with
 * @types/node's as an overload instead of colliding). */

/* NodeJS.ErrnoException — the Error shape @types/node attaches to fs and
 * child failures. The TYPE maps to the runtime Error root; only `code`
 * has a lowering (throw sites stamp the errno name — "ENOENT" and
 * friends; reads answer `string | undefined`), errno/syscall/path
 * typecheck and fence per member. */
declare namespace NodeJS {
  interface ProcessVersions {
    readonly node: string;
    readonly openssl?: string;
    readonly [name: string]: string | undefined;
  }
  /* The process introspection records — named interfaces so the type
   * mapper interns their record shapes (the RemoteInfo pattern; the
   * names match @types/node's, so the mappings hold when it adopts). */
  interface CpuUsage {
    user: number;
    system: number;
  }
  interface MemoryUsage {
    rss: number;
    heapTotal: number;
    heapUsed: number;
    external: number;
    arrayBuffers: number;
  }
  /* process.memoryUsage(): rss from the OS, heapTotal/heapUsed from the
   * runtime heap's own accounting; external and arrayBuffers are 0. */
  interface MemoryUsageFn {
    (): MemoryUsage;
    rss(): number;
  }
  interface ProcessRelease {
    name: string;
    sourceUrl?: string | undefined;
    headersUrl?: string | undefined;
    libUrl?: string | undefined;
    lts?: string | undefined;
  }
  interface ResourceUsage {
    userCPUTime: number;
    systemCPUTime: number;
    maxRSS: number;
    sharedMemorySize: number;
    unsharedDataSize: number;
    unsharedStackSize: number;
    minorPageFault: number;
    majorPageFault: number;
    swappedOut: number;
    fsRead: number;
    fsWrite: number;
    ipcSent: number;
    ipcReceived: number;
    signalsCount: number;
    voluntaryContextSwitches: number;
    involuntaryContextSwitches: number;
  }
  interface ErrnoException extends Error {
    errno?: number | undefined;
    code?: string | undefined;
    path?: string | undefined;
    syscall?: string | undefined;
  }
  /* The piped child-output stream (child.stdout / child.stderr under
   * stdio ["ignore", "pipe", "pipe"]): 'data' fires one Buffer chunk per
   * read (≤64KB, consumer-driven — no listener, no read), 'end' fires
   * once at EOF and always BEFORE the child's 'exit'. A flowing stream
   * keeps the loop alive. */
  interface ReadableStream {
    on(event: "data", listener: (chunk: Buffer) => void): void;
    on(event: "data", listener: (chunk: string) => void): void;
    on(event: "end", listener: () => void): void;
    once(event: "data", listener: (chunk: Buffer) => void): void;
    once(event: "data", listener: (chunk: string) => void): void;
    once(event: "end", listener: () => void): void;
    /* setEncoding('utf8') makes subsequent data chunks strings, including
     * multibyte sequences split across native pipe reads. */
    setEncoding(encoding: string): this;
  }
}

/* log/info/debug write stdout (info and debug ARE log in Node); error and
 * warn are ONE stream (warn IS error under another name) and write stderr
 * with the exact same formatting. Each call submits its output promptly;
 * stdout settles first under merged 2>&1 output. Arguments take Node's
 * console semantics: strings verbatim, everything else through the static
 * util.inspect rendering — so the parameters are unknown[], like stock
 * lib's console; values inspect cannot render statically (functions inside
 * composites, class hierarchies, `any`) fence per argument with a hint.
 * assert, count/countReset, dir/dirxml, group/groupCollapsed/groupEnd,
 * table, time/timeEnd/timeLog, clear, and the inspector-only
 * profile/profileEnd/timeStamp lower on the global console.
 *
 * trace is declared too — not because it lowers, but so a program that
 * typechecks under its own tsc reaches the per-site SC2020 fence naming
 * the member and the supported surface, instead of dying on a
 * fallback-manufactured type error its own tsc cannot reproduce. */
declare const console: {
  log(...args: unknown[]): void;
  info(...args: unknown[]): void;
  debug(...args: unknown[]): void;
  error(...args: unknown[]): void;
  warn(...args: unknown[]): void;
  assert(condition?: unknown, ...data: unknown[]): void;
  clear(): void;
  count(label?: string): void;
  countReset(label?: string): void;
  dir(item?: unknown, options?: unknown): void;
  dirxml(...data: unknown[]): void;
  group(...data: unknown[]): void;
  groupCollapsed(...data: unknown[]): void;
  groupEnd(): void;
  table(tabularData?: unknown, properties?: readonly string[]): void;
  time(label?: string): void;
  timeEnd(label?: string): void;
  timeLog(label?: string, ...data: unknown[]): void;
  timeStamp(label?: string): void;
  profile(label?: string): void;
  profileEnd(label?: string): void;
  trace(...data: unknown[]): void;
  Console: typeof import("node:console").Console;
};

// node:console exports the global instance's bound methods and the Console
// constructor: instances over process.stdout/process.stderr or node:stream
// writables lower their log/info/debug/error/warn members; their remaining
// methods are declared so unsupported uses reach named fences.
type ScriptcConsoleMethods = typeof console;
declare module "node:console" {
  export class Console {
    constructor(stdout: unknown, stderr?: unknown, ignoreErrors?: boolean);
  }
  export interface Console extends ScriptcConsoleMethods {}
  export const log: ScriptcConsoleMethods["log"];
  export const info: ScriptcConsoleMethods["info"];
  export const debug: ScriptcConsoleMethods["debug"];
  export const error: ScriptcConsoleMethods["error"];
  export const warn: ScriptcConsoleMethods["warn"];
  export const assert: ScriptcConsoleMethods["assert"];
  export const clear: ScriptcConsoleMethods["clear"];
  export const count: ScriptcConsoleMethods["count"];
  export const countReset: ScriptcConsoleMethods["countReset"];
  export const dir: ScriptcConsoleMethods["dir"];
  export const dirxml: ScriptcConsoleMethods["dirxml"];
  export const group: ScriptcConsoleMethods["group"];
  export const groupCollapsed: ScriptcConsoleMethods["groupCollapsed"];
  export const groupEnd: ScriptcConsoleMethods["groupEnd"];
  export const table: ScriptcConsoleMethods["table"];
  export const time: ScriptcConsoleMethods["time"];
  export const timeEnd: ScriptcConsoleMethods["timeEnd"];
  export const timeLog: ScriptcConsoleMethods["timeLog"];
  export const timeStamp: ScriptcConsoleMethods["timeStamp"];
  export const profile: ScriptcConsoleMethods["profile"];
  export const profileEnd: ScriptcConsoleMethods["profileEnd"];
  export const trace: ScriptcConsoleMethods["trace"];
  const defaultConsole: ScriptcConsoleMethods & { Console: typeof Console };
  export default defaultConsole;
}
declare module "console" {
  export * from "node:console";
  export { default } from "node:console";
}

/* The process global (Node-like, deliberately tiny). Every member lowers to
 * a `libCall` and is implemented in the runtime's scr_lib.c. `argv` is one
 * interned array (identity and mutation semantics match Node's stable
 * process.argv); `exit` flushes stdout and ends the process immediately.
 * `env` reads (`process.env.NAME` / `process.env[name]`) are getenv(3)
 * behind a `string | undefined` union — narrow with `!== undefined` before
 * use — and writes are setenv(3): later reads and spawned children observe
 * them, like Node. `process.env` as a WHOLE value is a fresh
 * `{ [k: string]: string | undefined }` SNAPSHOT record over environ
 * (spreads, Object.keys, spawn-env flows). `pid`/`getuid()` are the POSIX
 * identities (getuid is declared optional to match @types/node — the
 * `?.()` call lowers as the plain call on this POSIX-only target), and
 * `kill` has Node's exact semantics: signal names or numbers, SIGTERM
 * default, signal 0 as an existence probe, and Node's error shapes
 * (`kill ESRCH`/`kill EPERM` Errors, TypeErrors for unknown signals and
 * non-int32 pids). */
declare var process: {
  getBuiltinModule(id: string): unknown;
  hrtime: {
    (time?: [number, number]): [number, number];
    bigint(): bigint;
  };
  argv: string[];
  platform: string;
  /* The binary's OWN architecture ("arm64", "x64") — Node's answer for
   * its own build on the same machine. */
  readonly arch: string;
  /* Stable native dictionary. node and openssl name compatibility targets;
   * components absent from the runtime have no entries. */
  readonly versions: NodeJS.ProcessVersions;
  /* "v" plus versions.node: the compatibility target's release. */
  readonly version: string;
  /* The build-configuration snapshot Node exposes from its gyp config.
   * A scriptc binary has no V8 and no gyp, so `variables` answers the
   * honest capability record (v8_enable_i18n_support: 0 — no ICU; asan
   * mirrors the sanitizer build flag) and `target_defaults` is absent —
   * probe code takes its documented fallbacks. Reads of undeclared
   * variables go through the index signature (string | number | boolean
   * | undefined) and answer undefined. */
  readonly config: {
    readonly variables: { readonly [name: string]: string | number | boolean | undefined };
    readonly target_defaults?: { readonly default_configuration: string };
  };
  /* Node's feature probes — a compiled binary has no inspector and is
   * not a debug build; undeclared members read undefined through the
   * index signature. */
  readonly features: { readonly [name: string]: boolean | undefined };
  /* umask(2) — sets the file-mode creation mask and returns the previous
   * one; the no-argument form reads without setting (Node's shape). */
  umask(mask?: number): number;
  /* chdir(2) — failures throw Node's fs-shaped catchable error. */
  chdir(directory: string): void;
  loadEnvFile(path?: string | URL | Uint8Array): void;
  /* The extra CLI arguments Node itself consumed (--expose-internals,
   * ...): a compiled binary consumed none, so this is always []. */
  readonly execArgv: string[];
  /* Node's internal "exit sequence started" flag (real, undocumented
   * surface — the test harness reads it): true while 'exit' listeners
   * run, false otherwise. */
  readonly _exiting: boolean;
  /* Node's raw synchronous stderr write (internal surface the test
   * harness uses on its failure paths). */
  _rawDebug(...args: unknown[]): void;
  pid: number;
  /* The compiled binary's own resolved absolute path — Node's is the node
   * executable's (SEMANTICS.md divergence 12, the argv[0]/argv[1] story). */
  readonly execPath: string;
  getuid?(): number;
  getgid?(): number;
  geteuid?(): number;
  getegid?(): number;
  getgroups?(): number[];
  readonly ppid: number;
  /* libuv's process title: argv[0] until set; a write is truncated to
   * the original argument area on POSIX and sets the console title on
   * Windows. */
  title: string;
  argv0: string;
  readonly release: NodeJS.ProcessRelease;
  /* signal admits null (Node treats it as the SIGTERM default) — real
   * callers forward a `string | null` result field. */
  kill(pid: number, signal?: string | number | null): true;
  env: { [name: string]: string | undefined };
  /** Numeric writes set the status returned by ordinary program exit. */
  exitCode?: number;
  /* Silence and throw DeprecationWarnings (util.deprecate,
   * process.emitWarning); undefined until assigned. */
  noDeprecation?: boolean;
  throwDeprecation?: boolean;
  /* `never`, like @types/node: code behind an early-exit guard narrows
   * (`if (!x) process.exit(1)` proves x afterwards) — typed `void` the
   * guard narrows nothing and correct programs fail preflight. The
   * lowering already handles the optional code (bare exit() uses exitCode,
   * or zero when it was never set). */
  exit(code?: number | null): never;
  cwd(): string;
  /* The user tick queue: callbacks run before promise jobs at every loop
   * checkpoint (Node's tick-then-microtask order); trailing arguments
   * pass to the callback at fire time, like Node. */
  nextTick(callback: (...args: any[]) => void, ...args: any[]): void;
  /* The process introspection statics — Node's shapes and units. */
  uptime(): number;
  cpuUsage(previousValue?: NodeJS.CpuUsage): NodeJS.CpuUsage;
  threadCpuUsage(previousValue?: NodeJS.CpuUsage): NodeJS.CpuUsage;
  resourceUsage(): NodeJS.ResourceUsage;
  memoryUsage: NodeJS.MemoryUsageFn;
  availableMemory(): number;
  constrainedMemory(): number;
  /* The loop's own bookkeeping: 'Timeout' per armed timer, 'Immediate'
   * per queued unfired immediate; unmodeled kinds absent (SEMANTICS.md). */
  getActiveResourcesInfo(): string[];
  /* The raw byte writes — no newline, no formatting. stdout shares
   * console.log's stream, each call is submitted promptly, and ordering is
   * preserved. The boolean is Node's backpressure signal — these synchronous
   * writes always return true. Static BufferEncoding arguments and the
   * completion callback overloads match Node's WritableStream surface. */
  stdout: import("tty").WriteStream;
  stderr: import("tty").WriteStream;
  /* The stdin stream, the piped-input slice: the TTY probe, the
   * data/end/error events (on and once — a 'data' listener keeps the
   * event loop alive until EOF, like Node's flowing stdin), destroy()
   * (full teardown: nothing fires after, the loop stops waiting), and
   * async iteration (`for await (const chunk of process.stdin)` — chunks
   * are Uint8Array values, ending at EOF). setEncoding has no lowering
   * (chunks stay bytes; decode with TextDecoder). */
  stdin: {
    readonly isTTY: boolean;
    on(event: "data", listener: (chunk: Uint8Array) => void): void;
    on(event: "end", listener: () => void): void;
    on(event: "error", listener: (err: Error) => void): void;
    once(event: "data", listener: (chunk: Uint8Array) => void): void;
    once(event: "end", listener: () => void): void;
    once(event: "error", listener: (err: Error) => void): void;
    destroy(): void;
    setEncoding(encoding: "utf8"): void;
    /* Termios raw mode on a TTY stdin (libuv's UV_TTY_MODE_RAW, the mode
     * Node applies); on a NON-TTY stdin the member does not exist in Node
     * and the call throws Node's exact catchable TypeError. Node returns
     * `this` for chaining; here the call is statement-position only. */
    setRawMode(mode: boolean): void;
    [Symbol.asyncIterator](): AsyncIterableIterator<Uint8Array>;
  };
  /* Process events, the CLI slice: SIGINT/SIGTERM handlers (watching a
   * signal replaces its default disposition; removing the last listener
   * restores it; signal listeners never keep the loop alive — all Node's
   * rules) and the 'exit' hook (runs synchronously at termination with
   * the exit code; scheduling anything from it is too late, like Node).
   * `once` auto-removes after the first delivery; `off` removes by
   * listener identity — bind the listener to a const so registration and
   * removal see the same value. */
  on(event: "SIGINT" | "SIGTERM", listener: () => void): void;
  on(event: "exit", listener: (code: number) => void): void;
  /* 'warning' — Node's process-warning channel: listeners receive the
   * warning Error (as a dyn value); emitWarning and the runtime's
   * deprecation sites dispatch synchronously (SEMANTICS.md). */
  on(event: "warning", listener: (warning: Error & { code?: string }) => void): void;
  /* 'unhandledRejection' — dispatched per never-observed rejection at
   * the completed nextTick/microtask checkpoint (reason, promise),
   * suppressing the default report. 'rejectionHandled' — the sibling
   * event, fired once when a delivered promise later gains a handler
   * (promise payload, Node's shape). */
  on(event: "unhandledRejection", listener: (reason: unknown, promise: unknown) => void): void;
  on(event: "rejectionHandled", listener: (promise: unknown) => void): void;
  once(event: "SIGINT" | "SIGTERM", listener: () => void): void;
  once(event: "exit", listener: (code: number) => void): void;
  once(event: "unhandledRejection", listener: (reason: unknown, promise: unknown) => void): void;
  once(event: "rejectionHandled", listener: (promise: unknown) => void): void;
  off(event: "SIGINT" | "SIGTERM", listener: () => void): void;
  off(event: "exit", listener: (code: number) => void): void;
  off(event: "warning", listener: (warning: Error & { code?: string }) => void): void;
  off(event: "unhandledRejection", listener: (reason: unknown, promise: unknown) => void): void;
  off(event: "rejectionHandled", listener: (promise: unknown) => void): void;
  /* removeListener IS off — Node aliases them; both lower identically. */
  removeListener(event: "SIGINT" | "SIGTERM", listener: () => void): void;
  removeListener(event: "exit", listener: (code: number) => void): void;
  removeListener(event: "warning", listener: (warning: Error & { code?: string }) => void): void;
  removeListener(
    event: "unhandledRejection",
    listener: (reason: unknown, promise: unknown) => void,
  ): void;
  removeListener(event: "rejectionHandled", listener: (promise: unknown) => void): void;
  /* emitWarning — Node's full grammar (string or Error warning; type/
   * ctor/options second; code/ctor third). */
  emitWarning(warning: string | Error, ...args: any[]): void;
  /** Present in a child created by child_process.fork(). */
  readonly connected: boolean;
  send?(message: object, callback?: (error: Error | null) => void): boolean;
  disconnect(): void;
  on(event: "message", listener: (message: any) => void): void;
  on(event: "disconnect", listener: () => void): void;
  once(event: "message", listener: (message: any) => void): void;
  once(event: "disconnect", listener: () => void): void;
};

/* Node's process module default export is the global process object. These
 * declaration aliases let the ESM spelling typecheck against the same
 * deliberately narrow fallback surface when @types/node is absent. */
declare module "process" {
  export = process;
}
declare module "node:process" {
  import process = require("process");
  export = process;
}

/* ── globals a real CLI's sources reference (all @types/node or dyn-lib
 * territory; the fallback declares the slice so projects PREFLIGHT and
 * every reached use lands on the SC2020 fence — or a real lowering where
 * one exists — instead of "Cannot find name"). With @types/node these
 * stand down with the rest of the file. ─────────────────────────────── */

/* The CommonJS module globals. `__dirname`/`__filename` are compile-time
 * constants — each MODULE's real directory/file path (Node's per-module
 * values exactly; the build machine's paths are baked in, which is also
 * what Node answers when the same tree runs in place). In a file with ESM
 * syntax they fence: Node throws ReferenceError there. */
declare var __dirname: string;
declare var __filename: string;

interface ScriptcModule {
  children: ScriptcModule[];
  exports: any;
  filename: string;
  id: string;
  isPreloading: boolean;
  loaded: boolean;
  parent: ScriptcModule | null | undefined;
  path: string;
  paths: string[];
  require(id: string): any;
}
declare var module: ScriptcModule;

/* `global` IS globalThis (Node's alias), and `declare var process` above
 * puts process on `typeof globalThis` — so `globalThis.process` and
 * `global.process` read the same object as the bare name. */
declare var global: typeof globalThis;

/* The `require` VALUE's non-call surface. require() CALLS are module
 * edges (the checker models them as imports); the object's own members
 * are declared here so harness idioms typecheck. The main/cache values and
 * the CommonJS module graph lower to native process-lifetime handles. */
interface ScriptcRequireResolveOptions {
  paths?: string[];
}
interface ScriptcRequireResolve {
  (id: string, options?: ScriptcRequireResolveOptions): string;
  paths(id: string): string[] | null;
}
interface ScriptcRequire {
  /* The call signature types NON-IMPORT-SHAPED require expressions (the
   * checker models import-shaped requires as module aliases regardless,
   * exactly like under @types/node's NodeRequire). `any`, like
   * @types/node: the value's home is the module system, not the static
   * value model — reached uses fence per site. */
  (id: string): any;
  main: ScriptcModule | undefined;
  resolve: ScriptcRequireResolve;
  cache: { [id: string]: ScriptcModule | undefined };
}
declare var require: ScriptcRequire;

/* setImmediate/clearImmediate — Node's macrotask pair (fires after I/O
 * events of the current loop turn, before timers due later). The handle
 * follows the Timeout pattern: loop-liveness bookkeeping. */
interface Immediate extends Disposable {
  ref(): Immediate;
  unref(): Immediate;
  hasRef(): boolean;
  [Symbol.dispose](): void;
}
declare function setImmediate(callback: () => void): Immediate;
/* The trailing-argument form — Node passes the extras to the callback. */
declare function setImmediate(callback: (...args: never[]) => void, ...args: unknown[]): Immediate;
declare function clearImmediate(handle?: Immediate | null | undefined): void;

/* queueMicrotask — the microtask queue (the promise-continuation queue:
 * runs before any timer/immediate/I/O callback scheduled later). */
declare function queueMicrotask(callback: () => void): void;

/* structuredClone — the JSON-safe + bytes subset clones deep (cycles
 * fence; functions throw the spec's DataCloneError; DOMException clones
 * per WebIDL serialization). `value` is optional and `options` is
 * `unknown` so Node's own RUNTIME errors fire (ERR_MISSING_ARGS for the
 * zero-argument call, the dictionary/sequence TypeErrors for bad
 * options) where a tighter signature would reject at compile time —
 * the suite exercises exactly those. */
declare function structuredClone<T = undefined>(value?: T, options?: unknown): T;

/* AbortController — the signal factory for the fetch-cancellation slice
 * (AbortSignal above). */
interface AbortController {
  readonly signal: AbortSignal;
  abort(reason?: unknown): void;
}
declare var AbortController: { new (): AbortController };

/* atob/btoa — Node globals since v16 (the "buffer" module re-exports
 * them below): base64 → binary string and back, Latin-1 domain like the
 * WHATWG originals. The parameter is `unknown` because WebIDL ToStrings
 * whatever arrives (Node's atob(null) decodes "null") — the coercion
 * runs in the runtime over the dyn kind, and the Node suite exercises
 * it; malformed input throws the catchable DOMException
 * InvalidCharacterError, the zero-argument call Node's TypeError
 * [ERR_MISSING_ARGS]. */
declare function atob(data?: unknown): string;
declare function btoa(data?: unknown): string;

/* DOMException — the web-standard error shape (a Node global since
 * v17): an Error subclass whose `code` is the WebIDL legacy NUMBER
 * (InvalidCharacterError = 5, 0 for off-table names) and whose options
 * form carries `cause`. `new DOMException(msg)` has name "Error" like
 * the spec's default. Subclassing is fenced (the runtime layout carries
 * hidden slots) — extend Error instead. */
interface DOMException extends Error {
  readonly code: number;
}
declare var DOMException: {
  new (message?: unknown, nameOrOptions?: unknown): DOMException;
  readonly prototype: DOMException;
};

/* Capability-gated globals harness code probes behind feature guards
 * (globalThis.crypto under a hasCrypto check, the SQLite-backed storage
 * pair): typed `unknown` — no lowering exists, the guard is expected to
 * be false in a compiled binary, and any reached use fences per site. */
declare var crypto: unknown;
declare var Crypto: unknown;
declare var CryptoKey: unknown;
declare var SubtleCrypto: unknown;
declare var localStorage: unknown;
declare var sessionStorage: unknown;

/* Node's Buffer, typed as a Uint8Array subtype with the members CLI code
 * touches — ONE runtime representation with Uint8Array (the u8 bytes
 * kind); the members beyond the lowered surface fence per site. */
/* Node's encoding-name union (aliases included — the compiler folds them
 * to the runtime's canonical spellings at the call site). */
type BufferEncoding =
  | "utf8"
  | "utf-8"
  | "hex"
  | "base64"
  | "base64url"
  | "latin1"
  | "ascii"
  | "binary"
  | "utf16le"
  | "utf-16le"
  | "ucs2"
  | "ucs-2";
interface Buffer<
  TArrayBuffer extends ArrayBufferLike = ArrayBufferLike,
> extends Uint8Array<TArrayBuffer> {
  toString(encoding?: BufferEncoding, start?: number, end?: number): string;
  equals(otherBuffer: Uint8Array): boolean;
  compare(
    target: Uint8Array,
    targetStart?: number,
    targetEnd?: number,
    sourceStart?: number,
    sourceEnd?: number,
  ): number;
  indexOf(
    value: string | number | Uint8Array,
    byteOffset?: number | BufferEncoding,
    encoding?: BufferEncoding,
  ): number;
  lastIndexOf(
    value: string | number | Uint8Array,
    byteOffset?: number | BufferEncoding,
    encoding?: BufferEncoding,
  ): number;
  includes(
    value: string | number | Buffer,
    byteOffset?: number | BufferEncoding,
    encoding?: BufferEncoding,
  ): boolean;
  fill(
    value: string | number | Uint8Array,
    offset?: number | BufferEncoding,
    end?: number | BufferEncoding,
    encoding?: BufferEncoding,
  ): this;
  copy(target: Uint8Array, targetStart?: number, sourceStart?: number, sourceEnd?: number): number;
  swap16(): Buffer;
  swap32(): Buffer;
  swap64(): Buffer;
  write(
    string: string,
    offset?: number | BufferEncoding,
    length?: number | BufferEncoding,
    encoding?: BufferEncoding,
  ): number;
  subarray(start?: number, end?: number): Buffer<TArrayBuffer>;
  /* @types/node's spelling — the ArrayBuffer instantiation keeps the
   * override compatible with the lib's Uint8Array.slice. */
  slice(start?: number, end?: number): Buffer<ArrayBuffer>;
  writeUInt8(value: number, offset?: number): number;
  writeUInt16BE(value: number, offset?: number): number;
  writeUInt16LE(value: number, offset?: number): number;
  writeUInt32BE(value: number, offset?: number): number;
  writeUInt32LE(value: number, offset?: number): number;
  writeInt8(value: number, offset?: number): number;
  writeInt16BE(value: number, offset?: number): number;
  writeInt16LE(value: number, offset?: number): number;
  writeInt32BE(value: number, offset?: number): number;
  writeInt32LE(value: number, offset?: number): number;
  writeFloatBE(value: number, offset?: number): number;
  writeFloatLE(value: number, offset?: number): number;
  writeDoubleBE(value: number, offset?: number): number;
  writeDoubleLE(value: number, offset?: number): number;
  writeUIntBE(value: number, offset: number, byteLength: number): number;
  writeUIntLE(value: number, offset: number, byteLength: number): number;
  writeIntBE(value: number, offset: number, byteLength: number): number;
  writeIntLE(value: number, offset: number, byteLength: number): number;
  writeBigInt64BE(value: bigint, offset?: number): number;
  writeBigInt64LE(value: bigint, offset?: number): number;
  writeBigUInt64BE(value: bigint, offset?: number): number;
  writeBigUInt64LE(value: bigint, offset?: number): number;
  writeBigUint64BE(value: bigint, offset?: number): number;
  writeBigUint64LE(value: bigint, offset?: number): number;
  readUInt8(offset?: number): number;
  readUInt16BE(offset?: number): number;
  readUInt16LE(offset?: number): number;
  readUInt32BE(offset?: number): number;
  readUInt32LE(offset?: number): number;
  readInt8(offset?: number): number;
  readInt16BE(offset?: number): number;
  readInt16LE(offset?: number): number;
  readInt32BE(offset?: number): number;
  readInt32LE(offset?: number): number;
  readFloatBE(offset?: number): number;
  readFloatLE(offset?: number): number;
  readDoubleBE(offset?: number): number;
  readDoubleLE(offset?: number): number;
  readUIntBE(offset: number, byteLength: number): number;
  readUIntLE(offset: number, byteLength: number): number;
  readIntBE(offset: number, byteLength: number): number;
  readIntLE(offset: number, byteLength: number): number;
  readBigInt64BE(offset?: number): bigint;
  readBigInt64LE(offset?: number): bigint;
  readBigUInt64BE(offset?: number): bigint;
  readBigUInt64LE(offset?: number): bigint;
  readBigUint64BE(offset?: number): bigint;
  readBigUint64LE(offset?: number): bigint;
}
interface BufferConstructor {
  from(data: string, encoding?: BufferEncoding): Buffer;
  /* The ArrayBuffer form is the VIEW construction: x.buffer with an
   * optional byte offset/length shares x's storage (the subarray rule). */
  from(data: ArrayBuffer | SharedArrayBuffer, byteOffset?: number, length?: number): Buffer;
  from(data: Uint8Array | readonly number[]): Buffer;
  alloc(size: number, fill?: string | number | Uint8Array, encoding?: BufferEncoding): Buffer;
  compare(buf1: Uint8Array, buf2: Uint8Array): number;
  /* alloc without the zero-fill guarantee. Below Buffer.poolSize >>> 1
   * bytes it returns a view into the shared pool slab. */
  allocUnsafe(size: number): Buffer;
  allocUnsafeSlow(size: number): Buffer;
  /* The pool slab size for allocUnsafe, from, and concat. */
  poolSize: number;
  concat(list: readonly Uint8Array[], totalLength?: number): Buffer;
  isBuffer(obj: unknown): obj is Buffer;
  byteLength(input: string | Uint8Array, encoding?: BufferEncoding): number;
  isEncoding(encoding: string): boolean;
}
declare var Buffer: BufferConstructor;

/* The WHATWG codec constructors. Instance types live in scriptc.d.ts so
 * programs with @types/node have the same global type names. */
declare var TextEncoder: { new (): TextEncoder };
declare var TextDecoder: {
  new (label?: string, options?: { fatal?: boolean; ignoreBOM?: boolean }): TextDecoder;
};

interface Event {
  readonly type: string;
  readonly bubbles: boolean;
  readonly cancelable: boolean;
  readonly composed: boolean;
  readonly defaultPrevented: boolean;
  readonly eventPhase: number;
  readonly target: EventTarget | null;
  readonly currentTarget: EventTarget | null;
  readonly srcElement: EventTarget | null;
  readonly isTrusted: boolean;
  readonly timeStamp: number;
  cancelBubble: boolean;
  returnValue: boolean;
  preventDefault(): void;
  stopPropagation(): void;
  stopImmediatePropagation(): void;
  composedPath(): unknown[];
}
declare var Event: {
  new (
    type: string,
    eventInitDict?: { bubbles?: boolean; cancelable?: boolean; composed?: boolean },
  ): Event;
  readonly prototype: Event;
  readonly NONE: 0;
  readonly CAPTURING_PHASE: 1;
  readonly AT_TARGET: 2;
  readonly BUBBLING_PHASE: 3;
};
interface CustomEvent<T = unknown> extends Event {
  readonly detail: T;
}
declare var CustomEvent: {
  new <T = unknown>(
    type: string,
    eventInitDict?: { detail?: T; bubbles?: boolean; cancelable?: boolean; composed?: boolean },
  ): CustomEvent<T>;
  readonly prototype: CustomEvent;
};
interface MessageEvent<T = unknown> extends Event {
  readonly data: T;
  readonly origin: string;
  readonly lastEventId: string;
  readonly ports: readonly MessagePort[];
}
declare var MessageEvent: {
  new <T = unknown>(
    type: string,
    eventInitDict?: { data?: T; origin?: string; lastEventId?: string },
  ): MessageEvent<T>;
  readonly prototype: MessageEvent;
};
interface AddEventListenerOptions {
  capture?: boolean;
  once?: boolean;
  passive?: boolean;
  signal?: AbortSignal;
}
interface EventTarget {
  addEventListener(
    type: string,
    listener: ((event: Event) => void) | { handleEvent(event: Event): void } | null,
    options?: AddEventListenerOptions | boolean,
  ): void;
  removeEventListener(
    type: string,
    listener: ((event: Event) => void) | { handleEvent(event: Event): void } | null,
    options?: { capture?: boolean } | boolean,
  ): void;
  dispatchEvent(event: Event): boolean;
}
declare var EventTarget: {
  new (): EventTarget;
  readonly prototype: EventTarget;
};

interface MessagePort extends EventTarget {
  postMessage(value: unknown, transferOrOptions?: unknown): void;
  start(): void;
  close(): void;
  ref(): void;
  unref(): void;
  onmessage: ((event: MessageEvent) => void) | null;
  onmessageerror: ((event: MessageEvent) => void) | null;
  onclose: ((event: Event) => void) | null;
}
declare var MessagePort: {
  readonly prototype: MessagePort;
};
interface MessageChannel {
  readonly port1: MessagePort;
  readonly port2: MessagePort;
}
declare var MessageChannel: {
  new (): MessageChannel;
  readonly prototype: MessageChannel;
};

interface AbortSignal extends EventTarget {
  readonly aborted: boolean;
  readonly reason: unknown;
  onabort: ((event: Event) => void) | null;
  throwIfAborted(): void;
}
declare var AbortSignal: {
  timeout(ms: number): AbortSignal;
  abort(reason?: unknown): AbortSignal;
  any(signals: readonly AbortSignal[]): AbortSignal;
  readonly prototype: AbortSignal;
};

interface QueuingStrategySize<T = unknown> {
  (chunk: T): number;
}
interface QueuingStrategy<T = unknown> {
  highWaterMark?: number;
  size?: QueuingStrategySize<T>;
}
interface ReadableStreamReadValueResult<T> {
  done: false;
  value: T;
}
interface ReadableStreamReadDoneResult<T> {
  done: true;
  value: T | undefined;
}
type ReadableStreamReadResult<T> =
  | ReadableStreamReadValueResult<T>
  | ReadableStreamReadDoneResult<T>;
interface ReadableStreamDefaultReader<T = unknown> {
  readonly closed: Promise<void>;
  read(): Promise<ReadableStreamReadResult<T>>;
  cancel(reason?: unknown): Promise<void>;
  releaseLock(): void;
}
interface ReadableStreamDefaultController<T = unknown> {
  readonly desiredSize: number | null;
  enqueue(chunk?: T): void;
  close(): void;
  error(reason?: unknown): void;
}
interface UnderlyingSource<T = unknown> {
  start?(controller: ReadableStreamDefaultController<T>): unknown;
  pull?(controller: ReadableStreamDefaultController<T>): unknown;
  cancel?(reason?: unknown): unknown;
}
interface ReadableStream<T = unknown> {
  readonly locked: boolean;
  cancel(reason?: unknown): Promise<void>;
  getReader(): ReadableStreamDefaultReader<T>;
  [Symbol.asyncIterator](options?: { preventCancel?: boolean }): AsyncIterableIterator<T>;
  values(options?: { preventCancel?: boolean }): AsyncIterableIterator<T>;
}
declare var ReadableStream: {
  new <T = unknown>(source?: UnderlyingSource<T>): ReadableStream<T>;
  from<T>(iterable: readonly T[]): ReadableStream<T>;
  from(iterable: Uint8Array): ReadableStream<number>;
  from(iterable: string): ReadableStream<string>;
  readonly prototype: ReadableStream<unknown>;
};

/* fetch, typed as the native JSON + readable-stream slice: one URL, an
 * optional init with the members CLI requests carry, and a Response
 * whose body is the same stream consumed by json(). json() returns
 * unknown — the same dynamic boundary as JSON.parse: cast and validate. */
/* Headers — a response's native header map (lowercase names,
 * combine-on-append, sorted iteration). The value is a checked-dynamic
 * native handle like Response itself. */
interface Headers {
  append(name: string, value: string): void;
  delete(name: string): void;
  get(name: string): string | null;
  getSetCookie(): string[];
  has(name: string): boolean;
  set(name: string, value: string): void;
  forEach(
    callbackfn: (value: string, key: string, parent: Headers) => void,
    thisArg?: unknown,
  ): void;
  [Symbol.iterator](): IterableIterator<[string, string]>;
}
declare var Headers: {
  new (init?: Headers | Record<string, string> | readonly (readonly [string, string])[]): Headers;
  readonly prototype: Headers;
};
interface Response {
  readonly ok: boolean;
  readonly status: number;
  readonly statusText: string;
  readonly url: string;
  readonly redirected: boolean;
  readonly headers: Headers;
  readonly body: ReadableStream<Uint8Array> | null;
  readonly bodyUsed: boolean;
  json(): Promise<unknown>;
  text(): Promise<string>;
  /* The whole body as bytes: bytes() answers a Uint8Array in both tiers.
   * arrayBuffer() remains unsupported because static programs have no
   * free-standing ArrayBuffer representation; the compiler diagnoses its
   * direct use and points at bytes(). */
  arrayBuffer(): Promise<ArrayBuffer>;
  bytes(): Promise<Uint8Array>;
}
interface ResponseInit {
  headers?: Headers | Record<string, string> | readonly (readonly [string, string])[];
  status?: number;
  statusText?: string;
}
declare var Response: {
  new (
    body?: string | Uint8Array | ReadableStream<Uint8Array> | null,
    init?: ResponseInit,
  ): Response;
  readonly prototype: Response;
  error(): Response;
  json(data: unknown, init?: ResponseInit): Response;
  redirect(url: string | URL, status?: number): Response;
};
/* Blob and File (node:buffer, also globals): immutable bytes with a
 * content type. Sources are copied when the Blob is built. */
interface BlobPropertyBag {
  endings?: "transparent" | "native";
  type?: string;
}
interface FilePropertyBag extends BlobPropertyBag {
  lastModified?: number;
}
interface Blob {
  readonly size: number;
  readonly type: string;
  slice(start?: number, end?: number, contentType?: string): Blob;
  text(): Promise<string>;
  arrayBuffer(): Promise<ArrayBuffer>;
  bytes(): Promise<Uint8Array>;
  stream(): ReadableStream<Uint8Array>;
  textStream(): ReadableStream<string>;
}
declare var Blob: {
  new (
    sources?: readonly (string | ArrayBuffer | ArrayBufferView | Blob)[],
    options?: BlobPropertyBag,
  ): Blob;
  readonly prototype: Blob;
};
interface File extends Blob {
  readonly name: string;
  readonly lastModified: number;
}
declare var File: {
  new (
    sources: readonly (string | ArrayBuffer | ArrayBufferView | Blob)[],
    fileName: string,
    options?: FilePropertyBag,
  ): File;
  readonly prototype: File;
};
interface Request {
  readonly method: string;
  readonly url: string;
  readonly headers: Headers;
  readonly destination: string;
  readonly referrer: string;
  readonly referrerPolicy: string;
  readonly mode: string;
  readonly credentials: string;
  readonly cache: string;
  readonly redirect: "follow" | "error" | "manual";
  readonly integrity: string;
  readonly keepalive: boolean;
  readonly isReloadNavigation: boolean;
  readonly isHistoryNavigation: boolean;
  readonly duplex: "half";
  readonly signal: AbortSignal;
  readonly body: ReadableStream<Uint8Array> | null;
  readonly bodyUsed: boolean;
  json(): Promise<unknown>;
  text(): Promise<string>;
  arrayBuffer(): Promise<ArrayBuffer>;
  bytes(): Promise<Uint8Array>;
}
interface RequestInit {
  method?: string;
  headers?: Headers | Record<string, string> | readonly (readonly [string, string])[];
  body?: string | Uint8Array | ReadableStream<Uint8Array> | null;
  duplex?: "half";
  redirect?: "follow" | "error" | "manual";
  signal?: AbortSignal;
}
declare var Request: {
  new (input: RequestInfo, init?: RequestInit): Request;
  readonly prototype: Request;
};
declare function fetch(input: string | URL, init?: RequestInit): Promise<Response>;

/* The repeating timer pair (setTimeout lives in scriptc.d.ts — always
 * shipped). The handle is the Timeout interface, like Node's — it maps to
 * the numeric timer id, so ReturnType<typeof setInterval> stays a
 * representable type and `.unref()/.ref()/.hasRef()/.refresh()` chain over
 * setInterval results exactly like setTimeout's. clearInterval keeps the
 * historic number arm (the id IS the handle) alongside Node's undefined
 * tolerance. */
declare function setInterval(callback: () => void, ms?: number): Timeout;
/* The trailing-argument form — setTimeout's exact story, every tick. */
declare function setInterval(
  callback: (...args: never[]) => void,
  ms?: number,
  ...args: unknown[]
): Timeout;
declare function clearInterval(handle?: Timeout | number | null | undefined): void;

/* node:timers — the module twins of the timer globals (Node's timers
 * module re-exports them: require('timers').setTimeout IS setTimeout).
 * Named imports, destructured requires, and namespace calls all lower to
 * the same libCalls as the globals; the surface beyond these six
 * (enroll/unenroll, promises) fences per member. */
declare module "node:timers" {
  export function setTimeout(callback: () => void, ms?: number): Timeout;
  export function setTimeout(
    callback: (...args: never[]) => void,
    ms?: number,
    ...args: unknown[]
  ): Timeout;
  export function clearTimeout(handle?: Timeout | number | null | undefined): void;
  export function setInterval(callback: () => void, ms?: number): Timeout;
  export function setInterval(
    callback: (...args: never[]) => void,
    ms?: number,
    ...args: unknown[]
  ): Timeout;
  export function clearInterval(handle?: Timeout | number | null | undefined): void;
  export function setImmediate(callback: () => void): Immediate;
  export function setImmediate(callback: (...args: never[]) => void, ...args: unknown[]): Immediate;
  export function clearImmediate(handle?: Immediate | null | undefined): void;
}
declare module "timers" {
  export * from "node:timers";
}

/* node:timers/promises — the promisified pair the Node test harness leans
 * on (`await setTimeout(ms)` as a sleep). setTimeout and setImmediate
 * settle with their resolve value (undefined without one) from the shared
 * timer heap and the immediate queue; setInterval(delay, value) lowers to a
 * typed async iterator. The options object takes `ref`; AbortSignal
 * options remain declared surface that fences per site. */
declare module "node:timers/promises" {
  export interface TimerOptions {
    ref?: boolean;
    signal?: AbortSignal;
  }
  export function setTimeout<T = void>(
    delay?: number,
    value?: T,
    options?: TimerOptions,
  ): Promise<T>;
  export function setImmediate<T = void>(value?: T, options?: TimerOptions): Promise<T>;
  export function setInterval<T = unknown>(
    delay?: number,
    value?: T,
    options?: unknown,
  ): AsyncGenerator<T, void, undefined>;
  export const scheduler: {
    wait(delay?: number): Promise<void>;
    yield(): Promise<void>;
  };
}
declare module "timers/promises" {
  export * from "node:timers/promises";
}

/* node:diagnostics_channel — the in-process pub/sub core: named channels,
 * subscribe/unsubscribe (module-level and channel-level), publish with any
 * dyn-convertible message. Channel values are f64 handles into the
 * runtime's channel registry (the readline.Interface precedent — channels
 * are process-lived in Node too, its WeakRef machinery aside).
 * The store-binding surface (bindStore/unbindStore/runStores) lowers onto
 * the AsyncLocalStorage integration (dc.chan* libCalls).
 *
 * TracingChannel (tracingChannel) is the five-event-channel collection:
 * an f64 handle into the runtime's tracing registry (type-mapper.ts maps the
 * name like Channel). subscribe/unsubscribe walk a handlers object;
 * traceSync/traceCallback run Node's publish choreography in the runtime
 * (context defaults to a fresh {}); tracePromise is declared (the member
 * exists in Node) but fences at the call site — the traced function's
 * promise cannot cross the checked-dynamic tree boundary yet. */
declare module "node:diagnostics_channel" {
  export type ChannelListener = (message: unknown, name: string) => void;
  export interface Channel {
    readonly name: string;
    readonly hasSubscribers: boolean;
    publish(message: unknown): void;
    subscribe(onMessage: ChannelListener): void;
    unsubscribe(onMessage: ChannelListener): boolean;
    bindStore(
      store: import("async_hooks").AsyncLocalStorage<any>,
      transform?: (context: any) => any,
    ): void;
    unbindStore(store: import("async_hooks").AsyncLocalStorage<any>): boolean;
    runStores(context: unknown, fn: (...args: any[]) => any, thisArg?: any, ...args: any[]): any;
  }
  export function channel(name: string): Channel;
  export function subscribe(name: string, onMessage: ChannelListener): void;
  export function unsubscribe(name: string, onMessage: ChannelListener): boolean;
  export function hasSubscribers(name: string): boolean;
  export interface TracingChannelSubscribers {
    start?: (message: any) => void;
    end?: (message: any) => void;
    asyncStart?: (message: any) => void;
    asyncEnd?: (message: any) => void;
    error?: (message: any) => void;
  }
  export interface TracingChannelCollection {
    start: Channel;
    end: Channel;
    asyncStart: Channel;
    asyncEnd: Channel;
    error: Channel;
  }
  export interface TracingChannel {
    start: Channel;
    end: Channel;
    asyncStart: Channel;
    asyncEnd: Channel;
    error: Channel;
    readonly hasSubscribers: boolean;
    subscribe(subscribers: TracingChannelSubscribers): void;
    /** True when every present handler was found and removed (Node's
     * all-found conjunction; @types/node under-declares this as void). */
    unsubscribe(subscribers: TracingChannelSubscribers): boolean;
    traceSync<ThisArg = any, Args extends any[] = any[], Result = any>(
      fn: (this: ThisArg, ...args: Args) => Result,
      context?: object,
      thisArg?: ThisArg,
      ...args: Args
    ): Result;
    tracePromise<ThisArg = any, Args extends any[] = any[], Result = any>(
      fn: (this: ThisArg, ...args: Args) => Promise<Result>,
      context?: object,
      thisArg?: ThisArg,
      ...args: Args
    ): Promise<Result>;
    traceCallback<ThisArg = any, Args extends any[] = any[], Result = any>(
      fn: (this: ThisArg, ...args: Args) => Result,
      position?: number,
      context?: object,
      thisArg?: ThisArg,
      ...args: Args
    ): Result;
  }
  export function tracingChannel(nameOrChannels: string | TracingChannelCollection): TracingChannel;
}
declare module "diagnostics_channel" {
  export * from "node:diagnostics_channel";
}

/* node:perf_hooks — performance.now() over the runtime's process-start-
 * anchored monotonic clock (Node's timeOrigin for a compiled program),
 * fractional milliseconds. The .bind(performance) spelling lowers to the
 * same clock as a plain () => number function value (the mockable-clock idiom's
 * getTimestamp). mark, measure, the getEntries family and the clears run
 * over the thread's performance timeline with Node's validation; everything
 * else fences per member. */
declare module "node:perf_hooks" {
  export type EntryType = "mark" | "measure";
  export class PerformanceEntry {
    protected constructor();
    readonly duration: number;
    readonly name: string;
    readonly startTime: number;
    readonly entryType: EntryType;
    toJSON(): any;
  }
  export class PerformanceMark extends PerformanceEntry {
    readonly detail: any;
    readonly duration: 0;
    readonly entryType: "mark";
  }
  export class PerformanceMeasure extends PerformanceEntry {
    readonly detail: any;
    readonly entryType: "measure";
  }
  export interface MarkOptions {
    detail?: unknown | undefined;
    startTime?: number | undefined;
  }
  export interface MeasureOptions {
    detail?: unknown;
    duration?: number | undefined;
    end?: number | string | undefined;
    start?: number | string | undefined;
  }
  export interface Performance {
    now(): number;
    mark(name: string, options?: MarkOptions): PerformanceMark;
    measure(name: string, startMark?: string, endMark?: string): PerformanceMeasure;
    measure(name: string, options: MeasureOptions): PerformanceMeasure;
    getEntries(): PerformanceEntry[];
    getEntriesByName(name: string, type?: EntryType): PerformanceEntry[];
    getEntriesByType(type: EntryType): PerformanceEntry[];
    clearMarks(name?: string): void;
    clearMeasures(name?: string): void;
  }
  export const performance: Performance;
}
declare module "perf_hooks" {
  export * from "node:perf_hooks";
}
/* Node also exposes the same performance object as a GLOBAL (no import
 * needed) — the module export and the global are one value, so the global
 * spelling lowers through the identical perf_hooks tables (name +
 * provenance, like console/process). With @types/node present this file
 * stands down and its wider global serves; the lowered surface stays
 * performance.now() either way. */
declare var performance: import("node:perf_hooks").Performance;

declare module "node:module" {
  export function createRequire(filename: string | URL): ScriptcRequire;
  export const builtinModules: string[];
  export function isBuiltin(moduleName: string): boolean;
  export function syncBuiltinESMExports(): void;
}
declare module "module" {
  export * from "node:module";
}
/* import.meta: module-loader metadata with no value representation —
 * direct file-backed fields lower to constants, while the object and
 * remaining members fence (SC1090) EXCEPT as createRequire's base, where it
 * only NAMES the containing file. Declared so unsupported forms reach their
 * named lowering fences; @types/node's own augmentation stands in when
 * adopted. */
interface ImportMeta {
  url: string;
  filename: string;
  dirname: string;
  main: boolean;
  resolve(specifier: string, parent?: string | URL): string;
}

/* The synchronous node:fs surface — utf8-only, no options objects, no
 * Buffers. Importing "node:fs" resolves here (preflight allowlists exactly
 * the ambient-declared node: modules); every function lowers to a `libCall`
 * with a scr_fs_* runtime implementation. Failures throw CATCHABLE string
 * values formatted like Node's error messages ("ENOENT: no such file or
 * directory, open 'x'"). `rmSync` removes FILES only (like Node without
 * `recursive`); empty directories go through `rmdirSync`. */
declare module "node:fs" {
  import { Readable, Writable } from "stream";
  export function readFileSync(path: string | number, encoding: BufferEncoding): string;
  export function readFileSync(
    path: string | number,
    options: { encoding: BufferEncoding },
  ): string;
  export function readFileSync(path: string | number): Buffer;
  export function readFileSync(path: string, options: unknown): string | Buffer;
  /* Error-first callbacks select string or Buffer data from their encoding.
   * Unknown options retain that union until the caller validates the value. */
  export function readFile(
    path: string,
    options: unknown,
    callback: (error: Error | null, data: string | Buffer) => void,
  ): void;
  /* The options form carries the mode (applied at CREATION only, like
   * Node — an existing file keeps its permissions) and/or the utf8
   * encoding spelling. */
  export function writeFileSync(
    path: string,
    data: string,
    /* The options-record stance (see http.RequestOptions): flag fences
     * by name at the call site; undocumented keys drop like Node. */
    options?: {
      mode?: number;
      encoding?: "utf8" | "utf-8";
      flag?: string;
      [option: string]: unknown;
    },
  ): void;
  /* The bare-encoding spelling — the options record's encoding key alone. */
  export function writeFileSync(path: string, data: string, encoding: "utf8" | "utf-8"): void;
  export function writeFileSync(path: string, data: string | Uint8Array): void;
  export function appendFileSync(path: string, data: string | Uint8Array): void;
  export function existsSync(path: string): boolean;
  export function mkdirSync(path: string): void;
  export function mkdirSync(path: string, options: { recursive?: boolean; mode?: number }): void;
  export function unlinkSync(path: string): void;
  export function chmodSync(path: string, mode: number): void;
  export function fchmodSync(fd: number, mode: number): void;
  export function fsyncSync(fd: number): void;
  export function linkSync(
    existingPath: string | Uint8Array | URL,
    newPath: string | Uint8Array | URL,
  ): void;
  export function symlinkSync(
    target: string | Uint8Array | URL,
    path: string | Uint8Array | URL,
    type?: string | null,
  ): void;
  export function symlink(
    target: string | Uint8Array | URL,
    path: string | Uint8Array | URL,
    callback: (err: NodeJS.ErrnoException | null) => void,
  ): void;
  export function symlink(
    target: string | Uint8Array | URL,
    path: string | Uint8Array | URL,
    type: string | null | undefined,
    callback: (err: NodeJS.ErrnoException | null) => void,
  ): void;
  export function link(
    existingPath: string | Uint8Array | URL,
    newPath: string | Uint8Array | URL,
    callback: (err: NodeJS.ErrnoException | null) => void,
  ): void;
  export function readlink(
    path: string | Uint8Array | URL,
    callback: (err: NodeJS.ErrnoException | null, target: string) => void,
  ): void;
  export function readlink(
    path: string | Uint8Array | URL,
    options: "buffer" | { encoding: "buffer" },
    callback: (err: NodeJS.ErrnoException | null, target: Buffer) => void,
  ): void;
  export function readlink(
    path: string | Uint8Array | URL,
    options: BufferEncoding | { encoding?: BufferEncoding | null } | null,
    callback: (err: NodeJS.ErrnoException | null, target: string) => void,
  ): void;
  export function readlink(
    path: string | Uint8Array | URL,
    options: string | { encoding?: string | null } | null,
    callback: (err: NodeJS.ErrnoException | null, target: string | Buffer) => void,
  ): void;
  export function readlinkSync(
    path: string | Uint8Array | URL,
    options: "buffer" | { encoding: "buffer" },
  ): Buffer;
  export function readlinkSync(
    path: string | Uint8Array | URL,
    options?: BufferEncoding | { encoding?: BufferEncoding | null } | null,
  ): string;
  export function readlinkSync(
    path: string | Uint8Array | URL,
    options: string | { encoding?: string | null } | null,
  ): string | Buffer;
  export function chownSync(path: string, uid: number, gid: number): void;
  export function lchownSync(path: string, uid: number, gid: number): void;
  export function fchownSync(fd: number, uid: number, gid: number): void;
  export function truncateSync(path: string, len?: number): void;
  /* The 2-argument form only (Node's mode flags have no lowering). The
   * destination is created or truncated carrying the SOURCE's mode. */
  export function copyFileSync(src: string, dest: string): void;
  export function rename(
    oldPath: string,
    newPath: string,
    callback: (err: NodeJS.ErrnoException | null) => void,
  ): void;
  export function renameSync(oldPath: string, newPath: string): void;
  export function rmSync(path: string): void;
  /* maxRetries/retryDelay are accepted no-ops (Node retries around
   * EBUSY-class races; the synchronous lowering has no re-entrancy that
   * needs them). */
  export function rmSync(
    path: string,
    options: { recursive?: boolean; force?: boolean; maxRetries?: number; retryDelay?: number },
  ): void;
  export function rmdirSync(path: string): void;
  export function readdirSync(path: string): string[];
  /* The withFileTypes form: Dirent rows (name + parentPath + the type
   * probes — the honest subset of Node's Dirent surface). The type is
   * interned explicitly in type-mapper.ts (the record's hidden %dtype field
   * carries the entry kind; isFile/isDirectory/isSymbolicLink lower as
   * reads of it in builtins/process.ts). */
  export interface Dirent {
    name: string;
    parentPath: string;
    isFile(): boolean;
    isDirectory(): boolean;
    isSymbolicLink(): boolean;
  }
  export function readdirSync(
    path: string,
    /* The options-record stance (see http.RequestOptions): recursive
     * fences by name at the call site; undocumented keys drop like Node. */
    options: { withFileTypes: true; recursive?: boolean; [option: string]: unknown },
  ): Dirent[];
  /* fs.globSync / fs.glob: Node's glob walk over the file system. Patterns
   * are minimatch globs (case-insensitive on macOS and Windows); results
   * are relative to cwd unless the pattern is absolute. withFileTypes must
   * be a literal so the result type is known. */
  export interface GlobOptions {
    cwd?: string | URL;
    exclude?: readonly string[] | ((fileName: string) => boolean);
    followSymlinks?: boolean;
    withFileTypes?: false;
  }
  export interface GlobOptionsWithFileTypes {
    cwd?: string | URL;
    exclude?: readonly string[];
    followSymlinks?: boolean;
    withFileTypes: true;
  }
  export function globSync(pattern: string | readonly string[], options?: GlobOptions): string[];
  export function globSync(
    pattern: string | readonly string[],
    options: GlobOptionsWithFileTypes,
  ): Dirent[];
  export function glob(
    pattern: string | readonly string[],
    callback: (err: NodeJS.ErrnoException | null, matches?: string[]) => void,
  ): void;
  export function glob(
    pattern: string | readonly string[],
    options: GlobOptions,
    callback: (err: NodeJS.ErrnoException | null, matches?: string[]) => void,
  ): void;
  /* fs.Dir: an open directory stream (opendirSync, fs.promises.opendir)
   * read one Dirent at a time in OS order; utf8 names, no recursive walk. */
  export interface Dir {
    readonly path: string;
    readSync(): Dirent | null;
    read(): Promise<Dirent | null>;
    closeSync(): void;
    close(): Promise<void>;
    [Symbol.asyncIterator](): AsyncIterableIterator<Dirent>;
  }
  export interface OpenDirOptions {
    encoding?: "utf8" | "utf-8";
    bufferSize?: number;
  }
  export function opendirSync(path: string, options?: OpenDirOptions): Dir;
  /* fs.ReadStream / fs.WriteStream: runtime Readable and Writable streams
   * over a file (scr_fs_stream.c). The options are checked at runtime
   * with Node's rules; flags and mode are checked when the file opens, so
   * their errors arrive as 'error' events. Instances also emit 'open'
   * (with the fd) and 'ready'. */
  export interface StreamOptions {
    flags?: string;
    encoding?: BufferEncoding;
    fd?: number;
    mode?: number | string;
    autoClose?: boolean;
    emitClose?: boolean;
    start?: number;
    highWaterMark?: number;
  }
  export interface ReadStreamOptions extends StreamOptions {
    end?: number;
  }
  export interface WriteStreamOptions extends StreamOptions {
    flush?: boolean;
  }
  export class ReadStream extends Readable {
    readonly bytesRead: number;
    readonly path: string | Buffer;
    readonly pending: boolean;
    close(callback?: () => void): void;
  }
  export class WriteStream extends Writable {
    readonly bytesWritten: number;
    readonly path: string | Buffer;
    readonly pending: boolean;
    close(callback?: () => void): void;
  }
  export function createReadStream(
    path: string | Buffer | URL,
    options?: BufferEncoding | ReadStreamOptions,
  ): ReadStream;
  export function createWriteStream(
    path: string | Buffer | URL,
    options?: BufferEncoding | WriteStreamOptions,
  ): WriteStream;
  export function accessSync(path: string, mode?: number): void;
  export function mkdtempSync(prefix: string): string;
  export const constants: {
    readonly F_OK: number;
    readonly R_OK: number;
    readonly W_OK: number;
    readonly X_OK: number;
    readonly O_RDONLY: number;
    readonly O_WRONLY: number;
    readonly O_RDWR: number;
    readonly O_CREAT: number;
    readonly O_EXCL: number;
    readonly O_NOFOLLOW: number;
    readonly O_NONBLOCK: number;
    readonly O_TRUNC: number;
    readonly O_APPEND: number;
  };
  /* A stat(2) snapshot (statSync follows symlinks, lstatSync does not —
   * Node's split) — immutable; the supported surface is exactly these
   * members. dev/ino identify the filesystem entry, blocks is the allocated
   * size in 512-byte units, and the time fields are milliseconds with their
   * sub-second fractions. */
  export interface Stats {
    isFile(): boolean;
    isDirectory(): boolean;
    isSymbolicLink(): boolean;
    isBlockDevice(): boolean;
    isCharacterDevice(): boolean;
    isFIFO(): boolean;
    isSocket(): boolean;
    readonly dev: number;
    readonly mode: number;
    readonly nlink: number;
    readonly uid: number;
    readonly gid: number;
    readonly rdev: number;
    readonly blksize: number;
    readonly ino: number;
    readonly size: number;
    readonly blocks: number;
    readonly atimeMs: number;
    readonly mtimeMs: number;
    readonly ctimeMs: number;
    readonly birthtimeMs: number;
    readonly atime: Date;
    readonly mtime: Date;
    readonly ctime: Date;
    readonly birthtime: Date;
  }
  /* throwIfNoEntry: false answers undefined for a missing entry (ENOENT or
   * ENOTDIR) instead of throwing. BigIntStats (bigint: true) has no
   * lowering. */
  export interface StatSyncOptions {
    bigint?: boolean;
    throwIfNoEntry?: boolean;
  }
  export function statSync(path: string, options?: undefined): Stats;
  export function statSync(
    path: string,
    options: StatSyncOptions & { bigint?: false; throwIfNoEntry: false },
  ): Stats | undefined;
  export function statSync(
    path: string,
    options: StatSyncOptions & { bigint?: false; throwIfNoEntry?: true },
  ): Stats;
  /* bigint: true type-checks so the lowering can name it as unsupported. */
  export function statSync(path: string, options: StatSyncOptions & { bigint: true }): Stats;
  export function statSync(path: string, options: StatSyncOptions): Stats | undefined;
  export function lstatSync(path: string, options?: undefined): Stats;
  export function lstatSync(
    path: string,
    options: StatSyncOptions & { bigint?: false; throwIfNoEntry: false },
  ): Stats | undefined;
  export function lstatSync(
    path: string,
    options: StatSyncOptions & { bigint?: false; throwIfNoEntry?: true },
  ): Stats;
  /* bigint: true type-checks so the lowering can name it as unsupported. */
  export function lstatSync(path: string, options: StatSyncOptions & { bigint: true }): Stats;
  export function lstatSync(path: string, options: StatSyncOptions): Stats | undefined;
  /* The fd pair behind spawn's fd-stdio form: openSync(path, flags) →
   * the raw fd. Numeric flags use an inline OR of the O_* constants. */
  export function openSync(path: string, flags: string): number;
  export function openSync(path: string, flags: number, mode?: number): number;
  export function closeSync(fd: number): void;
  export function fdatasyncSync(fd: number): void;
  export function ftruncateSync(fd: number, len?: number): void;
  export function utimesSync(
    path: string | Uint8Array | URL,
    atime: number | string | Date,
    mtime: number | string | Date,
  ): void;
  export function futimesSync(
    fd: number,
    atime: number | string | Date,
    mtime: number | string | Date,
  ): void;
  export function lutimesSync(
    path: string | Uint8Array | URL,
    atime: number | string | Date,
    mtime: number | string | Date,
  ): void;
  export function utimes(
    path: string | Uint8Array | URL,
    atime: number | string | Date,
    mtime: number | string | Date,
    callback: (err: NodeJS.ErrnoException | null) => void,
  ): void;
  export function futimes(
    fd: number,
    atime: number | string | Date,
    mtime: number | string | Date,
    callback: (err: NodeJS.ErrnoException | null) => void,
  ): void;
  export function lutimes(
    path: string | Uint8Array | URL,
    atime: number | string | Date,
    mtime: number | string | Date,
    callback: (err: NodeJS.ErrnoException | null) => void,
  ): void;
  export function readvSync(fd: number, buffers: Uint8Array[], position?: number | null): number;
  export function writevSync(fd: number, buffers: Uint8Array[], position?: number | null): number;
  /* Read into a caller buffer from the fd's current position when position
   * is omitted/null, or from a numeric byte position without advancing the
   * fd. Answers the byte count, 0 at EOF. */
  export interface ReadSyncOptions {
    offset?: number;
    length?: number;
    position?: number | null;
  }
  export function readSync(fd: number, buffer: Uint8Array, options?: ReadSyncOptions): number;
  export function readSync(
    fd: number,
    buffer: Uint8Array,
    offset: number,
    length: number,
    position?: number | null,
  ): number;
  /* Write a caller-buffer window, or a utf8 string, at the fd's current
   * position when position is omitted/null (advancing it), or at a numeric
   * byte position without advancing it. Answers the byte count. */
  export interface WriteSyncOptions {
    offset?: number;
    length?: number;
    position?: number | null;
  }
  export function writeSync(fd: number, buffer: Uint8Array, options: WriteSyncOptions): number;
  export function writeSync(
    fd: number,
    buffer: Uint8Array,
    offset?: number,
    length?: number,
    position?: number | null,
  ): number;
  export function writeSync(
    fd: number,
    string: string,
    position?: number | null,
    encoding?: "utf8" | "utf-8",
  ): number;
  /* statSync over an open fd — the same Stats snapshot. */
  export function fstatSync(fd: number): Stats;
  /* realpath(3) — resolves symlinks, `.`/`..`, throwing Node's fs error
   * shapes for missing paths. */
  export function realpathSync(path: string): string;
  export namespace realpathSync {
    function native(path: string): string;
  }
  /* statfs(2)/statvfs(3) — the filesystem-capacity snapshot (the fields
   * Node's statfsSync reports; bavail × bsize is the free-space probe). */
  export interface StatsFsBase<T> {
    type: T;
    bsize: T;
    blocks: T;
    bfree: T;
    bavail: T;
    files: T;
    ffree: T;
  }
  export interface StatsFs extends StatsFsBase<number> {}
  export interface BigIntStatsFs extends StatsFsBase<bigint> {}
  export interface StatFsOptions {
    bigint?: boolean;
  }
  export function statfsSync(
    path: string | Uint8Array | URL,
    options?: StatFsOptions & { bigint?: false },
  ): StatsFs;
  export function statfsSync(
    path: string | Uint8Array | URL,
    options: StatFsOptions & { bigint: true },
  ): BigIntStatsFs;
  export function statfsSync(
    path: string | Uint8Array | URL,
    options?: StatFsOptions,
  ): StatsFs | BigIntStatsFs;
  export function statfs(
    path: string | Uint8Array | URL,
    callback: (err: NodeJS.ErrnoException | null, stats: StatsFs) => void,
  ): void;
  export function statfs(
    path: string | Uint8Array | URL,
    options: (StatFsOptions & { bigint?: false }) | undefined,
    callback: (err: NodeJS.ErrnoException | null, stats: StatsFs) => void,
  ): void;
  export function statfs(
    path: string | Uint8Array | URL,
    options: StatFsOptions & { bigint: true },
    callback: (err: NodeJS.ErrnoException | null, stats: BigIntStatsFs) => void,
  ): void;
  export function statfs(
    path: string | Uint8Array | URL,
    options: StatFsOptions | undefined,
    callback: (err: NodeJS.ErrnoException | null, stats: StatsFs | BigIntStatsFs) => void,
  ): void;
  /* fs.watch — the file-watching slice (scr_watch.c, kqueue EVFILT_VNODE):
   * "rename"/"change" events on ONE path, watcher.close() to stop. The
   * listener takes zero parameters or the eventType string (the filename
   * parameter has no lowering); an open watcher keeps the loop alive. A
   * path that cannot be opened THROWS Node's fs error synchronously. */
  export interface FSWatcher {
    close(): void;
  }
  /* The options-record stance (see http.RequestOptions): persistent: true,
   * recursive: false, and encoding: "utf8" state the lowered behavior and
   * are accepted; persistent: false, recursive: true, and signal fence by
   * name at the call site; undocumented keys drop like Node. */
  export interface WatchOptions {
    persistent?: boolean;
    recursive?: boolean;
    encoding?: string;
    [option: string]: unknown;
  }
  export function watch(path: string, listener?: (eventType: string) => void): FSWatcher;
  export function watch(
    path: string,
    options: WatchOptions,
    listener?: (eventType: string) => void,
  ): FSWatcher;
  /* fs.promises IS the fs/promises module (Node's rule) — the namespace-
   * import form `fs.promises.readFile(...)` lowers through the same
   * fs/promises table as `import { readFile } from "node:fs/promises"`. */
  export const promises: typeof import("node:fs/promises");
}
/* Every builtin answers to BOTH specifier forms, like in Node: the bare
 * module re-exports its node:-prefixed twin (or holds the declarations
 * itself — one of the pair forwards). The lowerer recognizes members by
 * their import SPECIFIER, so both forms lower identically. */
declare module "fs" {
  export * from "node:fs";
}

/* fs/promises — the SAME synchronous operations behind already-settled
 * promises: success fulfills, failure REJECTS with the would-be thrown
 * error (catchable at the await, like Node). DOCUMENTED DIVERGENCE
 * (SEMANTICS.md): the syscall blocks the event loop, so I/O never
 * interleaves with timers or other fibers — observable only in concurrent
 * code. readFile is utf8-only, like readFileSync. */
declare module "fs/promises" {
  export interface FileReadResult<T extends Uint8Array> {
    bytesRead: number;
    buffer: T;
  }
  export interface FileWriteResult<T> {
    bytesWritten: number;
    buffer: T;
  }
  export interface FileReadvResult<T extends Uint8Array[]> {
    bytesRead: number;
    buffers: T;
  }
  export interface FileWritevResult<T extends Uint8Array[]> {
    bytesWritten: number;
    buffers: T;
  }
  export interface FileReadOptions<T extends Uint8Array = Buffer> {
    buffer?: T;
    offset?: number | null;
    length?: number | null;
    position?: number | null;
  }
  /* The streams over a FileHandle (createReadStream, createWriteStream,
   * readLines): fs streams that hold the handle until they close; closing
   * the stream closes the handle unless autoClose is false. */
  export interface CreateReadStreamOptions {
    encoding?: BufferEncoding | null;
    autoClose?: boolean;
    emitClose?: boolean;
    start?: number;
    end?: number;
    highWaterMark?: number;
  }
  export interface CreateWriteStreamOptions {
    encoding?: BufferEncoding | null;
    autoClose?: boolean;
    emitClose?: boolean;
    start?: number;
    highWaterMark?: number;
    flush?: boolean;
  }
  export interface FileHandle extends AsyncDisposable {
    readonly fd: number;
    close(): Promise<void>;
    createReadStream(options?: CreateReadStreamOptions): import("node:fs").ReadStream;
    createWriteStream(options?: CreateWriteStreamOptions): import("node:fs").WriteStream;
    readLines(options?: CreateReadStreamOptions): import("node:readline").Interface;
    sync(): Promise<void>;
    datasync(): Promise<void>;
    truncate(len?: number): Promise<void>;
    chmod(mode: number): Promise<void>;
    utimes(atime: number | string | Date, mtime: number | string | Date): Promise<void>;
    readv<T extends Uint8Array[]>(
      buffers: T,
      position?: number | null,
    ): Promise<FileReadvResult<T>>;
    writev<T extends Uint8Array[]>(
      buffers: T,
      position?: number | null,
    ): Promise<FileWritevResult<T>>;
    read<T extends Uint8Array = Buffer>(
      options?: FileReadOptions<T> | null,
    ): Promise<FileReadResult<T>>;
    read<T extends Uint8Array>(
      buffer: T,
      options: Omit<FileReadOptions<T>, "buffer">,
    ): Promise<FileReadResult<T>>;
    read<T extends Uint8Array>(
      buffer: T,
      offset?: number | null,
      length?: number | null,
      position?: number | null,
    ): Promise<FileReadResult<T>>;
    write<T extends Uint8Array>(
      buffer: T,
      offset?: number | null,
      length?: number | null,
      position?: number | null,
    ): Promise<FileWriteResult<T>>;
    write<T extends Uint8Array>(
      buffer: T,
      options: Omit<FileReadOptions<T>, "buffer">,
    ): Promise<FileWriteResult<T>>;
    write(
      data: string,
      position?: number | null,
      encoding?: "utf8" | "utf-8" | null,
    ): Promise<FileWriteResult<string>>;
    readFile(options?: null): Promise<Buffer>;
    readFile(encoding: "utf8" | "utf-8"): Promise<string>;
    writeFile(data: string | Uint8Array, encoding?: "utf8" | "utf-8" | null): Promise<void>;
    appendFile(data: string | Uint8Array, encoding?: "utf8" | "utf-8" | null): Promise<void>;
    stat(): Promise<import("node:fs").Stats>;
    [Symbol.asyncDispose](): Promise<void>;
  }
  export function open(path: string, flags?: string, mode?: number): Promise<FileHandle>;
  export function link(
    existingPath: string | Uint8Array | URL,
    newPath: string | Uint8Array | URL,
  ): Promise<void>;
  export function symlink(
    target: string | Uint8Array | URL,
    path: string | Uint8Array | URL,
    type?: string | null,
  ): Promise<void>;
  export function readlink(
    path: string | Uint8Array | URL,
    options: "buffer" | { encoding: "buffer" },
  ): Promise<Buffer>;
  export function readlink(
    path: string | Uint8Array | URL,
    options?: BufferEncoding | { encoding?: BufferEncoding | null } | null,
  ): Promise<string>;
  export function readlink(
    path: string | Uint8Array | URL,
    options: string | { encoding?: string | null } | null,
  ): Promise<string | Buffer>;
  export function utimes(
    path: string | Uint8Array | URL,
    atime: number | string | Date,
    mtime: number | string | Date,
  ): Promise<void>;
  export function lutimes(
    path: string | Uint8Array | URL,
    atime: number | string | Date,
    mtime: number | string | Date,
  ): Promise<void>;
  export function readFile(path: string, encoding: "utf8" | "utf-8"): Promise<string>;
  export function readFile(
    path: string,
    options: BufferEncoding | { encoding: BufferEncoding },
  ): Promise<string>;
  export function readFile(path: string): Promise<Buffer>;
  export function writeFile(
    path: string,
    data: string,
    options?: {
      mode?: number;
      encoding?: "utf8" | "utf-8";
      flag?: string;
      [option: string]: unknown;
    },
  ): Promise<void>;
  export function writeFile(path: string, data: string, encoding: "utf8" | "utf-8"): Promise<void>;
  export function mkdir(
    path: string,
    options?: { recursive?: boolean; mode?: number },
  ): Promise<void>;
  export function readdir(path: string): Promise<string[]>;
  export function readdir(
    path: string,
    options: {
      encoding?: "utf8" | "utf-8";
      withFileTypes: true;
      recursive?: boolean;
      [option: string]: unknown;
    },
  ): Promise<import("node:fs").Dirent[]>;
  /* The async iterator form of fs.globSync: iterate it with for await. */
  export function glob(
    pattern: string | readonly string[],
    options?: import("node:fs").GlobOptions,
  ): AsyncIterableIterator<string>;
  export function glob(
    pattern: string | readonly string[],
    options: import("node:fs").GlobOptionsWithFileTypes,
  ): AsyncIterableIterator<import("node:fs").Dirent>;
  export function rm(path: string): Promise<void>;
  export function stat(path: string): Promise<import("node:fs").Stats>;
  export function statfs(
    path: string | Uint8Array | URL,
    options?: import("node:fs").StatFsOptions & { bigint?: false },
  ): Promise<import("node:fs").StatsFs>;
  export function statfs(
    path: string | Uint8Array | URL,
    options: import("node:fs").StatFsOptions & { bigint: true },
  ): Promise<import("node:fs").BigIntStatsFs>;
  export function statfs(
    path: string | Uint8Array | URL,
    options?: import("node:fs").StatFsOptions,
  ): Promise<import("node:fs").StatsFs | import("node:fs").BigIntStatsFs>;
  export function realpath(path: string): Promise<string>;
  export function lstat(path: string): Promise<import("node:fs").Stats>;
  export function unlink(path: string): Promise<void>;
  export function chmod(path: string, mode: number): Promise<void>;
  export function chown(path: string, uid: number, gid: number): Promise<void>;
  export function lchown(path: string, uid: number, gid: number): Promise<void>;
  export function access(path: string, mode?: number): Promise<void>;
  export function truncate(path: string, len?: number): Promise<void>;
  export function appendFile(path: string, data: string | Uint8Array): Promise<void>;
  export function copyFile(src: string, dest: string): Promise<void>;
  export function mkdtemp(prefix: string): Promise<string>;
  export function rmdir(path: string): Promise<void>;
  export function rename(oldPath: string, newPath: string): Promise<void>;
  export function opendir(
    path: string,
    options?: import("node:fs").OpenDirOptions,
  ): Promise<import("node:fs").Dir>;
}
declare module "node:fs/promises" {
  export * from "fs/promises";
}

/* node:path — the TARGET platform's implementation (Node's rule): posix
 * on posix triples, path.win32 under a win32 triple, with the posix and
 * win32 namespaces answering their own platform anywhere. Every function
 * is a pure string algorithm matching Node's implementations
 * exactly; join/resolve are variadic like Node's. */
declare module "path" {
  export function join(...paths: string[]): string;
  export function resolve(...paths: string[]): string;
  export function normalize(path: string): string;
  export function dirname(path: string): string;
  export function basename(path: string, suffix?: string): string;
  export function extname(path: string): string;
  export function isAbsolute(path: string): boolean;
  export function relative(from: string, to: string): string;
  export function toNamespacedPath(path: string): string;
  /* matchesGlob() is Node's glob matcher: brace expansion, extglobs, POSIX
   * classes and the ** and dot rules. */
  export function matchesGlob(path: string, pattern: string): boolean;
  /* parse() splits a path into its root, directory, base, extension and
   * name; format() joins those fields back (Node's `||` defaults). */
  export interface ParsedPath {
    root: string;
    dir: string;
    base: string;
    ext: string;
    name: string;
  }
  export interface FormatInputPathObject {
    root?: string | undefined;
    dir?: string | undefined;
    base?: string | undefined;
    ext?: string | undefined;
    name?: string | undefined;
  }
  export function parse(path: string): ParsedPath;
  export function format(pathObject: FormatInputPathObject): string;
  /* The union @types/node declares: the bare module answers the TARGET
   * platform's value (a compile-time constant — "\\"/";" under a win32
   * triple, "/"/":" everywhere else). */
  export const sep: "\\" | "/";
  export const delimiter: ";" | ":";
  /* The platform-specific namespaces (real Node submodules too —
   * "node:path/posix" resolves). Each carries the FULL surface and
   * answers ITS platform's rules on any target, Node's own contract;
   * the bare module IS the target platform's implementation. */
  export const posix: typeof import("path/posix");
  export const win32: typeof import("path/win32");
}
declare module "node:path" {
  export * from "path";
}
declare module "path/posix" {
  export function join(...paths: string[]): string;
  export function resolve(...paths: string[]): string;
  export function normalize(path: string): string;
  export function dirname(path: string): string;
  export function basename(path: string, suffix?: string): string;
  export function extname(path: string): string;
  export function isAbsolute(path: string): boolean;
  export function relative(from: string, to: string): string;
  export function toNamespacedPath(path: string): string;
  export function matchesGlob(path: string, pattern: string): boolean;
  export function parse(path: string): import("path").ParsedPath;
  export function format(pathObject: import("path").FormatInputPathObject): string;
  export const sep: "/";
  export const delimiter: ":";
}
declare module "node:path/posix" {
  export * from "path/posix";
}
declare module "path/win32" {
  export function join(...paths: string[]): string;
  export function resolve(...paths: string[]): string;
  export function normalize(path: string): string;
  export function dirname(path: string): string;
  export function basename(path: string, suffix?: string): string;
  export function extname(path: string): string;
  export function isAbsolute(path: string): boolean;
  export function relative(from: string, to: string): string;
  export function toNamespacedPath(path: string): string;
  export function matchesGlob(path: string, pattern: string): boolean;
  export function parse(path: string): import("path").ParsedPath;
  export function format(pathObject: import("path").FormatInputPathObject): string;
  export const sep: "\\";
  export const delimiter: ";";
}
declare module "node:path/win32" {
  export * from "path/win32";
}

/* node:os — the slice a CLI needs: platform() (same implementation as
 * process.platform), homedir(), tmpdir() (Node's env cascade), EOL
 * (always "\n" — POSIX pinned, like path.sep), and networkInterfaces()
 * (getifaddrs(3); the interface shapes mirror @types/node's exactly so
 * both type worlds map to the same IR structure). */
declare module "os" {
  export function platform(): string;
  export function homedir(): string;
  export function tmpdir(): string;
  /* uname(2)'s release field — Node's own implementation. */
  export function release(): string;
  /* uname(2)'s sysname field ("Darwin", "Linux") — Node's os.type(). */
  export function type(): string;
  /* Total system memory in bytes (sysctl hw.memsize / sysconf). */
  export function totalmem(): number;
  export function availableParallelism(): number;
  /* The passwd-entry snapshot (uv_os_get_passwd): shell is `string |
   * null` to match @types/node (POSIX always answers the string arm);
   * homedir is pw_dir — NOT os.homedir()'s $HOME-first cascade. The type
   * is interned explicitly in type-mapper.ts (the AddressInfo pattern — this
   * concrete form and @types/node's UserInfo<string> both), and the call
   * assembles field-by-field in lowerOsUserInfoCall. */
  export interface UserInfo {
    username: string;
    uid: number;
    gid: number;
    shell: string | null;
    homedir: string;
  }
  export function userInfo(): UserInfo;
  /* The TARGET platform's line terminator (a compile-time constant:
   * "\r\n" under a win32 triple, "\n" everywhere else). */
  export const EOL: "\r\n" | "\n";
  export interface NetworkInterfaceBase {
    address: string;
    netmask: string;
    mac: string;
    internal: boolean;
    cidr: string | null;
    scopeid?: number;
  }
  export interface NetworkInterfaceInfoIPv4 extends NetworkInterfaceBase {
    family: "IPv4";
  }
  export interface NetworkInterfaceInfoIPv6 extends NetworkInterfaceBase {
    family: "IPv6";
    scopeid: number;
  }
  export type NetworkInterfaceInfo = NetworkInterfaceInfoIPv4 | NetworkInterfaceInfoIPv6;
  export function networkInterfaces(): { [name: string]: NetworkInterfaceInfo[] | undefined };
  /* Host facts, libuv's answers: model/speed/times per logical CPU, the
   * host name, the 1/5/15-minute load averages, uptime in seconds, free
   * memory in bytes, process.arch, uname's machine and version fields,
   * the byte order, and a process's scheduling priority (an omitted pid
   * is the current process). Shapes mirror @types/node's. */
  export interface CpuInfo {
    model: string;
    speed: number;
    times: {
      user: number;
      nice: number;
      sys: number;
      idle: number;
      irq: number;
    };
  }
  export function cpus(): CpuInfo[];
  export function hostname(): string;
  export function loadavg(): number[];
  export function uptime(): number;
  export function freemem(): number;
  export function arch(): string;
  export function machine(): string;
  export function version(): string;
  export function endianness(): "BE" | "LE";
  export function getPriority(pid?: number): number;
  /* The TARGET platform's null device ("\\\\.\\nul" under a win32 triple). */
  export const devNull: string;
  /* The platform's constants: null-prototype objects with read-only
   * members, `signals` frozen (Node's internalBinding('constants').os). */
  export type SignalConstants = {
    [
      key in
        | "SIGABRT"
        | "SIGALRM"
        | "SIGBUS"
        | "SIGCHLD"
        | "SIGCONT"
        | "SIGFPE"
        | "SIGHUP"
        | "SIGILL"
        | "SIGINT"
        | "SIGIO"
        | "SIGIOT"
        | "SIGKILL"
        | "SIGPIPE"
        | "SIGPOLL"
        | "SIGPROF"
        | "SIGPWR"
        | "SIGQUIT"
        | "SIGSEGV"
        | "SIGSTKFLT"
        | "SIGSTOP"
        | "SIGSYS"
        | "SIGTERM"
        | "SIGTRAP"
        | "SIGTSTP"
        | "SIGTTIN"
        | "SIGTTOU"
        | "SIGUNUSED"
        | "SIGURG"
        | "SIGUSR1"
        | "SIGUSR2"
        | "SIGVTALRM"
        | "SIGWINCH"
        | "SIGXCPU"
        | "SIGXFSZ"
        | "SIGBREAK"
        | "SIGLOST"
        | "SIGINFO"
    ]: number;
  };
  export namespace constants {
    const UV_UDP_REUSEADDR: number;
    namespace signals {}
    const signals: SignalConstants;
    namespace errno {
      const E2BIG: number;
      const EACCES: number;
      const EADDRINUSE: number;
      const EADDRNOTAVAIL: number;
      const EAFNOSUPPORT: number;
      const EAGAIN: number;
      const EALREADY: number;
      const EBADF: number;
      const EBADMSG: number;
      const EBUSY: number;
      const ECANCELED: number;
      const ECHILD: number;
      const ECONNABORTED: number;
      const ECONNREFUSED: number;
      const ECONNRESET: number;
      const EDEADLK: number;
      const EDESTADDRREQ: number;
      const EDOM: number;
      const EDQUOT: number;
      const EEXIST: number;
      const EFAULT: number;
      const EFBIG: number;
      const EHOSTUNREACH: number;
      const EIDRM: number;
      const EILSEQ: number;
      const EINPROGRESS: number;
      const EINTR: number;
      const EINVAL: number;
      const EIO: number;
      const EISCONN: number;
      const EISDIR: number;
      const ELOOP: number;
      const EMFILE: number;
      const EMLINK: number;
      const EMSGSIZE: number;
      const EMULTIHOP: number;
      const ENAMETOOLONG: number;
      const ENETDOWN: number;
      const ENETRESET: number;
      const ENETUNREACH: number;
      const ENFILE: number;
      const ENOBUFS: number;
      const ENODATA: number;
      const ENODEV: number;
      const ENOENT: number;
      const ENOEXEC: number;
      const ENOLCK: number;
      const ENOLINK: number;
      const ENOMEM: number;
      const ENOMSG: number;
      const ENOPROTOOPT: number;
      const ENOSPC: number;
      const ENOSR: number;
      const ENOSTR: number;
      const ENOSYS: number;
      const ENOTCONN: number;
      const ENOTDIR: number;
      const ENOTEMPTY: number;
      const ENOTSOCK: number;
      const ENOTSUP: number;
      const ENOTTY: number;
      const ENXIO: number;
      const EOPNOTSUPP: number;
      const EOVERFLOW: number;
      const EPERM: number;
      const EPIPE: number;
      const EPROTO: number;
      const EPROTONOSUPPORT: number;
      const EPROTOTYPE: number;
      const ERANGE: number;
      const EROFS: number;
      const ESPIPE: number;
      const ESRCH: number;
      const ESTALE: number;
      const ETIME: number;
      const ETIMEDOUT: number;
      const ETXTBSY: number;
      const EWOULDBLOCK: number;
      const EXDEV: number;
      const WSAEINTR: number;
      const WSAEBADF: number;
      const WSAEACCES: number;
      const WSAEFAULT: number;
      const WSAEINVAL: number;
      const WSAEMFILE: number;
      const WSAEWOULDBLOCK: number;
      const WSAEINPROGRESS: number;
      const WSAEALREADY: number;
      const WSAENOTSOCK: number;
      const WSAEDESTADDRREQ: number;
      const WSAEMSGSIZE: number;
      const WSAEPROTOTYPE: number;
      const WSAENOPROTOOPT: number;
      const WSAEPROTONOSUPPORT: number;
      const WSAESOCKTNOSUPPORT: number;
      const WSAEOPNOTSUPP: number;
      const WSAEPFNOSUPPORT: number;
      const WSAEAFNOSUPPORT: number;
      const WSAEADDRINUSE: number;
      const WSAEADDRNOTAVAIL: number;
      const WSAENETDOWN: number;
      const WSAENETUNREACH: number;
      const WSAENETRESET: number;
      const WSAECONNABORTED: number;
      const WSAECONNRESET: number;
      const WSAENOBUFS: number;
      const WSAEISCONN: number;
      const WSAENOTCONN: number;
      const WSAESHUTDOWN: number;
      const WSAETOOMANYREFS: number;
      const WSAETIMEDOUT: number;
      const WSAECONNREFUSED: number;
      const WSAELOOP: number;
      const WSAENAMETOOLONG: number;
      const WSAEHOSTDOWN: number;
      const WSAEHOSTUNREACH: number;
      const WSAENOTEMPTY: number;
      const WSAEPROCLIM: number;
      const WSAEUSERS: number;
      const WSAEDQUOT: number;
      const WSAESTALE: number;
      const WSAEREMOTE: number;
      const WSASYSNOTREADY: number;
      const WSAVERNOTSUPPORTED: number;
      const WSANOTINITIALISED: number;
      const WSAEDISCON: number;
      const WSAENOMORE: number;
      const WSAECANCELLED: number;
      const WSAEINVALIDPROCTABLE: number;
      const WSAEINVALIDPROVIDER: number;
      const WSAEPROVIDERFAILEDINIT: number;
      const WSASYSCALLFAILURE: number;
      const WSASERVICE_NOT_FOUND: number;
      const WSATYPE_NOT_FOUND: number;
      const WSA_E_NO_MORE: number;
      const WSA_E_CANCELLED: number;
      const WSAEREFUSED: number;
    }
    namespace dlopen {
      const RTLD_LAZY: number;
      const RTLD_NOW: number;
      const RTLD_GLOBAL: number;
      const RTLD_LOCAL: number;
      const RTLD_DEEPBIND: number;
    }
    namespace priority {
      const PRIORITY_LOW: number;
      const PRIORITY_BELOW_NORMAL: number;
      const PRIORITY_NORMAL: number;
      const PRIORITY_ABOVE_NORMAL: number;
      const PRIORITY_HIGH: number;
      const PRIORITY_HIGHEST: number;
    }
  }
}
declare module "node:os" {
  export * from "os";
}

/* The WHATWG URL class (a Node global; the es2023 lib doesn't declare it),
 * typed as exactly the supported surface: construction from an input and
 * optional base (invalid input throws a catchable TypeError, like Node), the
 * protocol/origin/username/pathname/href/host/hostname/port/search/hash getters, searchParams (the
 * LIVE query view — mutations through it re-serialize into the URL, so
 * href reflects immediately; every read answers the same object, Node's
 * caching), toString()/toJSON() (href serialization), and the non-throwing
 * canParse()/parse() factories (conversion errors still propagate).
 * URL components except origin and searchParams support assignment;
 * the live searchParams view also mutates the query. URL values participate in
 * unions (URL | undefined). The parser covers the common CLI schemes
 * exactly (http/https/ws/wss/ftp/file authority URLs, opaque paths like
 * data: and mailto:) — divergences from the full WHATWG algorithm are
 * documented in SEMANTICS.md. */
interface URL {
  protocol: string;
  readonly origin: string;
  username: string;
  password: string;
  pathname: string;
  href: string;
  host: string;
  hostname: string;
  port: string;
  search: string;
  hash: string;
  readonly searchParams: URLSearchParams;
  toString(): string;
  toJSON(): string;
}
declare var URL: {
  new (input: string | { toString: () => string }, base?: string | URL): URL;
  canParse(input: string | URL, base?: string | URL): boolean;
  parse(input: string | URL, base?: string | URL): URL | null;
};

/* URLSearchParams — the WHATWG application/x-www-form-urlencoded list.
 * Constructed standalone (string / string[][] pairs / inline record
 * literal / another URLSearchParams) or read live off a URL via
 * url.searchParams. keys()/values()/entries() lower when a for-of head
 * consumes them directly; stored iterator OBJECTS have no lowering. */
interface URLSearchParams {
  readonly size: number;
  append(name: string, value: string): void;
  delete(name: string, value?: string): void;
  get(name: string): string | null;
  getAll(name: string): string[];
  has(name: string, value?: string): boolean;
  set(name: string, value: string): void;
  sort(): void;
  toString(): string;
  forEach(callback: (value: string, name: string, searchParams: URLSearchParams) => void): void;
  keys(): IterableIterator<string>;
  values(): IterableIterator<string>;
  entries(): IterableIterator<[string, string]>;
  [Symbol.iterator](): IterableIterator<[string, string]>;
}
declare var URLSearchParams: {
  new (init?: string | string[][] | { [key: string]: string } | URLSearchParams): URLSearchParams;
};

/* node:url — the file-URL bridge pair. fileURLToPath accepts a URL value
 * or a URL string and throws Node's TypeErrors (non-file scheme, encoded
 * slashes, non-empty host); pathToFileURL resolves the path and percent-
 * encodes it into a file: URL. The legacy API: parse() answers a Url
 * object, format() serializes a Url-shaped object, a string, or a URL,
 * resolve() resolves one URL string against another, and the domain pair
 * converts a hostname to and from its Punycode form. */
declare module "url" {
  export type URL = globalThis.URL;
  export type URLSearchParams = globalThis.URLSearchParams;
  export const URL: typeof globalThis.URL;
  export const URLSearchParams: typeof globalThis.URLSearchParams;
  export function fileURLToPath(url: string | URL, options?: { windows?: boolean }): string;
  export function fileURLToPathBuffer(url: string | URL, options?: { windows?: boolean }): Buffer;
  export function pathToFileURL(path: string, options?: { windows?: boolean }): URL;
  export interface UrlObject {
    auth?: string | null | undefined;
    hash?: string | null | undefined;
    host?: string | null | undefined;
    hostname?: string | null | undefined;
    href?: string | null | undefined;
    pathname?: string | null | undefined;
    protocol?: string | null | undefined;
    search?: string | null | undefined;
    slashes?: boolean | null | undefined;
    port?: string | number | null | undefined;
    query?: string | null | import("querystring").ParsedUrlQueryInput | undefined;
  }
  export interface Url {
    auth: string | null;
    hash: string | null;
    host: string | null;
    hostname: string | null;
    href: string;
    path: string | null;
    pathname: string | null;
    protocol: string | null;
    search: string | null;
    slashes: boolean | null;
    port: string | null;
    query: string | null | import("querystring").ParsedUrlQuery;
  }
  export interface UrlWithParsedQuery extends Url {
    query: import("querystring").ParsedUrlQuery;
  }
  export interface UrlWithStringQuery extends Url {
    query: string | null;
  }
  export interface URLFormatOptions {
    auth?: boolean | undefined;
    fragment?: boolean | undefined;
    search?: boolean | undefined;
    unicode?: boolean | undefined;
  }
  export function parse(
    urlString: string,
    parseQueryString?: false,
    slashesDenoteHost?: boolean,
  ): UrlWithStringQuery;
  export function parse(
    urlString: string,
    parseQueryString: true,
    slashesDenoteHost?: boolean,
  ): UrlWithParsedQuery;
  export function parse(
    urlString: string,
    parseQueryString: boolean,
    slashesDenoteHost?: boolean,
  ): Url;
  export function format(urlObject: URL, options?: URLFormatOptions): string;
  export function format(urlObject: UrlObject | string): string;
  export function resolve(from: string, to: string): string;
  export function domainToASCII(domain: string): string;
  export function domainToUnicode(domain: string): string;
}
declare module "node:url" {
  export * from "url";
}

/* node:crypto: the static hashing/MAC/random/key-derivation utility slice. */
declare module "crypto" {
  export type KeyObjectType = "secret" | "public" | "private";
  export interface JsonWebKey {
    kty?: string;
    k?: string;
  }
  export interface JwkKeyExportOptions {
    format: "jwk";
  }
  export interface KeyExportOptions {
    format?: "buffer" | undefined;
  }
  /** Secret keys only; the asymmetric key types are not available. */
  export class KeyObject {
    private constructor();
    type: KeyObjectType;
    symmetricKeySize?: number;
    asymmetricKeyType?: string;
    export(options?: KeyExportOptions): Buffer;
    export(options: JwkKeyExportOptions): JsonWebKey;
    equals(otherKeyObject: KeyObject): boolean;
  }
  export function createSecretKey(key: ArrayBufferView | ArrayBufferLike): KeyObject;
  export function createSecretKey(key: string, encoding: BufferEncoding): KeyObject;
  export function generateKeySync(type: "hmac" | "aes", options: { length: number }): KeyObject;
  export function generateKey(
    type: "hmac" | "aes",
    options: { length: number },
    callback: (err: Error | null, key: KeyObject) => void,
  ): void;
  export interface RandomUUIDOptions {
    disableEntropyCache?: boolean | undefined;
  }
  export function randomUUID(options?: RandomUUIDOptions): string;
  export function randomUUIDv7(options?: RandomUUIDOptions): string;
  export function randomBytes(size: number): Buffer;
  export type BinaryToTextEncoding = "base64" | "base64url" | "hex" | "binary";
  export type CharacterEncoding = "utf8" | "utf-8" | "utf16le" | "utf-16le" | "latin1";
  export type LegacyCharacterEncoding = "ascii" | "binary" | "ucs2" | "ucs-2";
  export type Encoding = BinaryToTextEncoding | CharacterEncoding | LegacyCharacterEncoding;
  export interface HashOptions {
    outputLength?: number | undefined;
  }
  export interface Hash {
    copy(options?: HashOptions): Hash;
    update(data: string | ArrayBufferView): Hash;
    update(data: string, inputEncoding: Encoding): Hash;
    digest(): Buffer;
    digest(encoding: BinaryToTextEncoding): string;
  }
  export interface Hmac {
    update(data: string | ArrayBufferView): Hmac;
    update(data: string, inputEncoding: Encoding): Hmac;
    digest(): Buffer;
    digest(encoding: BinaryToTextEncoding): string;
  }
  export function createHash(algorithm: string, options?: HashOptions): Hash;
  export function createHmac(
    algorithm: string,
    key: BinaryLike | KeyObject,
    options?: { encoding?: BufferEncoding | undefined },
  ): Hmac;
  export interface OneShotDigestOptions {
    outputEncoding?: BinaryToTextEncoding | "buffer" | undefined;
    outputLength?: number | undefined;
  }
  export interface OneShotDigestOptionsWithStringEncoding extends OneShotDigestOptions {
    outputEncoding?: BinaryToTextEncoding | undefined;
  }
  export interface OneShotDigestOptionsWithBufferEncoding extends OneShotDigestOptions {
    outputEncoding: "buffer";
  }
  export function hash(
    algorithm: string,
    data: string | ArrayBufferView,
    options?: OneShotDigestOptionsWithStringEncoding | BinaryToTextEncoding,
  ): string;
  export function hash(
    algorithm: string,
    data: string | ArrayBufferView,
    options: OneShotDigestOptionsWithBufferEncoding | "buffer",
  ): Buffer;
  export function hash(
    algorithm: string,
    data: string | ArrayBufferView,
    options: OneShotDigestOptions | BinaryToTextEncoding | "buffer",
  ): string | Buffer;
  export function timingSafeEqual(
    a: ArrayBufferView | ArrayBufferLike,
    b: ArrayBufferView | ArrayBufferLike,
  ): boolean;
  export function randomFillSync<T extends ArrayBufferView | ArrayBufferLike>(
    buffer: T,
    offset?: number,
    size?: number,
  ): T;
  export function randomFill<T extends ArrayBufferView | ArrayBufferLike>(
    buffer: T,
    callback: (err: Error | null, buf: T) => void,
  ): void;
  export function randomFill<T extends ArrayBufferView | ArrayBufferLike>(
    buffer: T,
    offset: number,
    callback: (err: Error | null, buf: T) => void,
  ): void;
  export function randomFill<T extends ArrayBufferView | ArrayBufferLike>(
    buffer: T,
    offset: number,
    size: number,
    callback: (err: Error | null, buf: T) => void,
  ): void;
  export function randomInt(max: number): number;
  export function randomInt(min: number, max: number): number;
  export function randomInt(
    max: number,
    callback: (err: Error | null, value: number) => void,
  ): void;
  export function randomInt(
    min: number,
    max: number,
    callback: (err: Error | null, value: number) => void,
  ): void;
  export function pbkdf2Sync(
    password: string | Uint8Array,
    salt: string | Uint8Array,
    iterations: number,
    keylen: number,
    digest: string,
  ): Buffer;
  export function pbkdf2(
    password: string | Uint8Array,
    salt: string | Uint8Array,
    iterations: number,
    keylen: number,
    digest: string,
    callback: (error: Error | null, derivedKey: Buffer) => void,
  ): void;
  export function randomBytes(
    size: number,
    callback: (error: Error | null, buffer: Buffer) => void,
  ): void;
  export type BinaryLike = string | ArrayBuffer | ArrayBufferView;
  /* Cipheriv/Decipheriv: aes-128/192/256 in cbc, ctr, and gcm modes and
   * chacha20-poly1305. The stream.Transform members are not declared. */
  export type CipherGCMTypes = "aes-128-gcm" | "aes-192-gcm" | "aes-256-gcm";
  export type CipherChaCha20Poly1305Types = "chacha20-poly1305";
  export type CipherKey = BinaryLike | KeyObject;
  export interface CipherGCMOptions {
    authTagLength?: number;
  }
  export interface CipherChaCha20Poly1305Options {
    authTagLength?: number;
  }
  export interface Cipheriv {
    update(data: string | ArrayBufferView): Buffer;
    update(data: string, inputEncoding: BufferEncoding): Buffer;
    update(data: ArrayBufferView, inputEncoding: undefined, outputEncoding: BufferEncoding): string;
    update(
      data: string,
      inputEncoding: BufferEncoding | undefined,
      outputEncoding: BufferEncoding,
    ): string;
    final(): Buffer;
    final(outputEncoding: BufferEncoding): string;
    setAutoPadding(autoPadding?: boolean): this;
  }
  export interface CipherGCM extends Cipheriv {
    setAAD(buffer: ArrayBufferView, options?: { plaintextLength: number }): this;
    getAuthTag(): Buffer;
  }
  export interface CipherChaCha20Poly1305 extends Cipheriv {
    setAAD(buffer: ArrayBufferView, options?: { plaintextLength: number }): this;
    getAuthTag(): Buffer;
  }
  export interface Decipheriv {
    update(data: ArrayBufferView): Buffer;
    update(data: string, inputEncoding: BufferEncoding): Buffer;
    update(data: ArrayBufferView, inputEncoding: undefined, outputEncoding: BufferEncoding): string;
    update(
      data: string,
      inputEncoding: BufferEncoding | undefined,
      outputEncoding: BufferEncoding,
    ): string;
    final(): Buffer;
    final(outputEncoding: BufferEncoding): string;
    setAutoPadding(autoPadding?: boolean): this;
  }
  export interface DecipherGCM extends Decipheriv {
    setAuthTag(buffer: ArrayBufferView): this;
    setAAD(buffer: ArrayBufferView, options?: { plaintextLength: number }): this;
  }
  export interface DecipherChaCha20Poly1305 extends Decipheriv {
    setAuthTag(buffer: ArrayBufferView): this;
    setAAD(buffer: ArrayBufferView, options?: { plaintextLength: number }): this;
  }
  export function createCipheriv(
    algorithm: CipherGCMTypes,
    key: CipherKey,
    iv: BinaryLike,
    options?: CipherGCMOptions,
  ): CipherGCM;
  export function createCipheriv(
    algorithm: CipherChaCha20Poly1305Types,
    key: CipherKey,
    iv: BinaryLike,
    options?: CipherChaCha20Poly1305Options,
  ): CipherChaCha20Poly1305;
  export function createCipheriv(
    algorithm: string,
    key: CipherKey,
    iv: BinaryLike | null,
    options?: { authTagLength?: number },
  ): Cipheriv;
  export function createDecipheriv(
    algorithm: CipherGCMTypes,
    key: CipherKey,
    iv: BinaryLike,
    options?: CipherGCMOptions,
  ): DecipherGCM;
  export function createDecipheriv(
    algorithm: CipherChaCha20Poly1305Types,
    key: CipherKey,
    iv: BinaryLike,
    options?: CipherChaCha20Poly1305Options,
  ): DecipherChaCha20Poly1305;
  export function createDecipheriv(
    algorithm: string,
    key: CipherKey,
    iv: BinaryLike | null,
    options?: { authTagLength?: number },
  ): Decipheriv;
  export interface ScryptOptions {
    N?: number;
    r?: number;
    p?: number;
    cost?: number;
    blockSize?: number;
    parallelization?: number;
    maxmem?: number;
  }
  export function scryptSync(
    password: BinaryLike,
    salt: BinaryLike,
    keylen: number,
    options?: ScryptOptions,
  ): Buffer;
  export function scrypt(
    password: BinaryLike,
    salt: BinaryLike,
    keylen: number,
    callback: (error: Error | null, derivedKey: Buffer) => void,
  ): void;
  export function scrypt(
    password: BinaryLike,
    salt: BinaryLike,
    keylen: number,
    options: ScryptOptions,
    callback: (error: Error | null, derivedKey: Buffer) => void,
  ): void;
  export function hkdfSync(
    digest: string,
    ikm: BinaryLike | KeyObject,
    salt: BinaryLike,
    info: BinaryLike,
    keylen: number,
  ): ArrayBuffer;
  export function hkdf(
    digest: string,
    ikm: BinaryLike | KeyObject,
    salt: BinaryLike,
    info: BinaryLike,
    keylen: number,
    callback: (error: Error | null, derivedKey: ArrayBuffer) => void,
  ): void;
  /* The lowered X509Certificate surface is the data-record slice:
   * fingerprint (the SHA-1 of the DER, uppercase colon-separated) and
   * the validFrom/validTo validity window (Node's ASN1_TIME_print
   * strings — "Jul  1 00:00:00 2026 GMT"; the cert-expiry idiom composes
   * them with new Date(...).getTime()). All compute at construction;
   * unparseable input throws Node's ERR_OSSL_PEM_NO_START_LINE Error. */
  export class X509Certificate {
    constructor(buffer: Uint8Array | string);
    readonly fingerprint: string;
    readonly validFrom: string;
    readonly validTo: string;
  }
  /* The crypto introspection statics: getFips() answers 0 (a compiled
   * binary is never a FIPS build), the three name lists bake as fresh
   * string[] literals of Node v24 answers, and constants (below) bakes
   * per member like http2.constants. */
  export function getFips(): 1 | 0;
  export function getCiphers(): string[];
  export function getHashes(): string[];
  export function getCurves(): string[];
  /* Node v24 crypto.constants, literal-typed (the Http2Constants
   * stance). Every ACCESS bakes as its literal at lowering; the object
   * itself never materializes (bare crypto.constants value uses fence). */
  export interface CryptoConstants {
    readonly OPENSSL_VERSION_NUMBER: 810549376;
    readonly SSL_OP_ALL: 2147485776;
    readonly SSL_OP_ALLOW_NO_DHE_KEX: 1024;
    readonly SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION: 262144;
    readonly SSL_OP_CIPHER_SERVER_PREFERENCE: 4194304;
    readonly SSL_OP_CISCO_ANYCONNECT: 32768;
    readonly SSL_OP_COOKIE_EXCHANGE: 8192;
    readonly SSL_OP_CRYPTOPRO_TLSEXT_BUG: 2147483648;
    readonly SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS: 2048;
    readonly SSL_OP_LEGACY_SERVER_CONNECT: 4;
    readonly SSL_OP_NO_COMPRESSION: 131072;
    readonly SSL_OP_NO_ENCRYPT_THEN_MAC: 524288;
    readonly SSL_OP_NO_QUERY_MTU: 4096;
    readonly SSL_OP_NO_RENEGOTIATION: 1073741824;
    readonly SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION: 65536;
    readonly SSL_OP_NO_SSLv2: 0;
    readonly SSL_OP_NO_SSLv3: 33554432;
    readonly SSL_OP_NO_TICKET: 16384;
    readonly SSL_OP_NO_TLSv1: 67108864;
    readonly SSL_OP_NO_TLSv1_1: 268435456;
    readonly SSL_OP_NO_TLSv1_2: 134217728;
    readonly SSL_OP_NO_TLSv1_3: 536870912;
    readonly SSL_OP_PRIORITIZE_CHACHA: 2097152;
    readonly SSL_OP_TLS_ROLLBACK_BUG: 8388608;
    readonly ENGINE_METHOD_RSA: 1;
    readonly ENGINE_METHOD_DSA: 2;
    readonly ENGINE_METHOD_DH: 4;
    readonly ENGINE_METHOD_RAND: 8;
    readonly ENGINE_METHOD_EC: 2048;
    readonly ENGINE_METHOD_CIPHERS: 64;
    readonly ENGINE_METHOD_DIGESTS: 128;
    readonly ENGINE_METHOD_PKEY_METHS: 512;
    readonly ENGINE_METHOD_PKEY_ASN1_METHS: 1024;
    readonly ENGINE_METHOD_ALL: 65535;
    readonly ENGINE_METHOD_NONE: 0;
    readonly DH_CHECK_P_NOT_SAFE_PRIME: 2;
    readonly DH_CHECK_P_NOT_PRIME: 1;
    readonly DH_UNABLE_TO_CHECK_GENERATOR: 4;
    readonly DH_NOT_SUITABLE_GENERATOR: 8;
    readonly RSA_PKCS1_PADDING: 1;
    readonly RSA_SSLV23_PADDING: 2;
    readonly RSA_NO_PADDING: 3;
    readonly RSA_PKCS1_OAEP_PADDING: 4;
    readonly RSA_X931_PADDING: 5;
    readonly RSA_PKCS1_PSS_PADDING: 6;
    readonly RSA_PSS_SALTLEN_DIGEST: -1;
    readonly RSA_PSS_SALTLEN_MAX_SIGN: -2;
    readonly RSA_PSS_SALTLEN_AUTO: -2;
    readonly defaultCoreCipherList: "TLS_AES_256_GCM_SHA384:TLS_CHACHA20_POLY1305_SHA256:TLS_AES_128_GCM_SHA256:ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-AES256-GCM-SHA384:DHE-RSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-SHA256:DHE-RSA-AES128-SHA256:ECDHE-RSA-AES256-SHA384:DHE-RSA-AES256-SHA384:ECDHE-RSA-AES256-SHA256:DHE-RSA-AES256-SHA256:HIGH:!aNULL:!eNULL:!EXPORT:!DES:!RC4:!MD5:!PSK:!SRP:!CAMELLIA";
    readonly TLS1_VERSION: 769;
    readonly TLS1_1_VERSION: 770;
    readonly TLS1_2_VERSION: 771;
    readonly TLS1_3_VERSION: 772;
    readonly POINT_CONVERSION_COMPRESSED: 2;
    readonly POINT_CONVERSION_UNCOMPRESSED: 4;
    readonly POINT_CONVERSION_HYBRID: 6;
    readonly defaultCipherList: "TLS_AES_256_GCM_SHA384:TLS_CHACHA20_POLY1305_SHA256:TLS_AES_128_GCM_SHA256:ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-AES256-GCM-SHA384:DHE-RSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-SHA256:DHE-RSA-AES128-SHA256:ECDHE-RSA-AES256-SHA384:DHE-RSA-AES256-SHA384:ECDHE-RSA-AES256-SHA256:DHE-RSA-AES256-SHA256:HIGH:!aNULL:!eNULL:!EXPORT:!DES:!RC4:!MD5:!PSK:!SRP:!CAMELLIA";
  }
  export const constants: CryptoConstants;
}
declare module "node:crypto" {
  export * from "crypto";
}

/* node:child_process — the synchronous slice: spawnSync(command, args?)
 * runs the child to completion (posix_spawn + waitpid) with stdout/stderr
 * captured as utf8 strings. `status` is the exit code, or null when the
 * child died to a signal OR could not be spawned at all (nonexistent
 * binary, permission denied) — Node reports spawn failure through the
 * result's `error` property, which this surface does not carry, and types
 * stdout/stderr null there where scriptc returns "" (SEMANTICS.md).
 * No shell, no options object: the command runs directly (PATH-searched,
 * like Node). */
declare module "child_process" {
  export interface SpawnSyncReturns {
    readonly status: number | null;
    readonly stdout: string;
    readonly stderr: string;
    /* The termination signal's name ("SIGTERM", ...) when a signal
     * killed the child (a timeout's killSignal included), null otherwise
     * — Node's shape. */
    readonly signal: string | null;
    /* Node's spawn-failure carrier: a real Error ("spawnSync <file>
     * ENOENT", `code` stamped) when the spawn itself failed — status is
     * null and both outputs "" then — or ETIMEDOUT after a timeout kill;
     * undefined otherwise. */
    readonly error?: Error;
  }
  /* scriptc always captures utf8 strings; pass { encoding: "utf8" }
   * whenever stdout/stderr is READ so plain Node agrees (without it Node
   * hands Buffers). The other supported options: timeout (ms — sends
   * killSignal at the deadline and the result carries error: ETIMEDOUT +
   * the signal, never a throw), killSignal (a signal NAME literal),
   * stdio ("ignore"/"inherit"/"pipe" or a 3-tuple of those — captures
   * read "" for non-piped streams), and windowsHide (a POSIX no-op). */
  export function spawnSync(
    command: string,
    args?: string[],
    options?: {
      encoding?: "utf8" | "utf-8";
      timeout?: number;
      killSignal?: string;
      stdio?: "pipe" | "ignore" | "inherit" | ("pipe" | "ignore" | "inherit")[];
      windowsHide?: boolean;
    },
  ): SpawnSyncReturns;

  /* The asynchronous slice: spawn with stdio "ignore"/"inherit"/fd/"pipe"
   * tuples (piped stdin is writable through child.stdin; piped stdout/stderr
   * deliver through child.stdout/stderr) and the terminal events. "exit"
   * fires once with the exit code, or
   * null when the child died to a signal; "error" fires ONLY when the
   * child could not be spawned at all (Node's split: a spawn failure
   * emits "error" and never "exit"). "close" fires after exit/error and
   * every piped stdio handle reaches EOF. Exit/close listeners may take
   * Node's code and signal parameters. `on`/`once` return void here (Node
   * returns the child; chaining is fenced). The event loop keeps the process
   * alive until every spawned child is reaped, like Node — reaping polls at
   * loop quiescence (SEMANTICS.md documents the divergence). An "error"
   * event with no registered listener prints the error and exits 1,
   * exactly the unhandled-'error' EventEmitter behavior. */
  export interface ChildStdin {
    readonly writable: boolean;
    write(chunk: string | Uint8Array): boolean;
    end(): void;
    destroy(): void;
    on(event: "drain" | "finish", listener: () => void): void;
    on(event: "error", listener: (err: Error) => void): void;
    once(event: "drain" | "finish", listener: () => void): void;
    once(event: "error", listener: (err: Error) => void): void;
  }

  export interface ChildProcess extends Disposable {
    ref(): void;
    on(event: "spawn", listener: () => void): void;
    once(event: "spawn", listener: () => void): void;
    /* The exit listener may also take Node's second parameter — the
     * terminating signal's name, null for a normal exit. */
    on(event: "exit", listener: (code: number | null, signal: string | null) => void): void;
    on(event: "close", listener: (code: number | null, signal: string | null) => void): void;
    on(event: "error", listener: (err: Error) => void): void;
    once(event: "exit", listener: (code: number | null, signal: string | null) => void): void;
    once(event: "close", listener: (code: number | null, signal: string | null) => void): void;
    once(event: "error", listener: (err: Error) => void): void;
    on(event: "message", listener: (message: any) => void): void;
    on(event: "disconnect", listener: () => void): void;
    once(event: "message", listener: (message: any) => void): void;
    once(event: "disconnect", listener: () => void): void;
    /* The lifecycle members, Node's exact shapes: pid is undefined exactly
     * when the spawn failed; exitCode is null while running, the code
     * after a normal exit, null for a signal death, and -errno once a
     * spawn failure's "error" event has fired; kill resolves signal names
     * through Node's table (unknown names throw the Unknown signal
     * TypeError), answers true when the signal was sent, false once the
     * child was reaped (or never spawned), and sets `killed` on success;
     * unref() drops the child from the event loop's keep-alive set (it is
     * still reaped while the loop runs for other reasons — SEMANTICS.md
     * has the reap story). */
    readonly pid: number | undefined;
    readonly exitCode: number | null;
    readonly killed: boolean;
    kill(signal?: string | number): boolean;
    unref(): void;
    readonly connected: boolean;
    send(message: object, callback?: (error: Error | null) => void): boolean;
    disconnect(): void;
    [Symbol.dispose](): void;
    /* The piped streams — non-null exactly when the matching stdio slot
     * was "pipe" (Node's shape). */
    readonly stdin: ChildStdin | null;
    readonly stdout: NodeJS.ReadableStream | null;
    readonly stderr: NodeJS.ReadableStream | null;
  }
  export interface SpawnOptions {
    /* The 3-tuple form admits number fds in the stdout/stderr slots —
     * openSync results dup2'd into the child (the daemon-log idiom
     * ["ignore", logFd, logFd]) — and "pipe" there too (child.stdout/
     * child.stderr streams); "pipe" in the stdin slot exposes
     * child.stdin. */
    stdio?: "ignore" | "inherit" | "pipe" | ("ignore" | "inherit" | "pipe" | number)[];
    /* detached gives the child its own session and process group
     * (POSIX_SPAWN_SETSID); env REPLACES the child environment; cwd
     * sets its working directory; windowsHide is a POSIX no-op; shell
     * runs the complete command string through /bin/sh or cmd.exe. */
    detached?: boolean;
    env?: { [k: string]: string | undefined };
    cwd?: string;
    windowsHide?: boolean;
    shell?: boolean;
  }
  export function spawn(command: string, args?: string[], options?: SpawnOptions): ChildProcess;
  export function spawn(command: string, options?: SpawnOptions): ChildProcess;

  export function fork(
    modulePath: string | URL,
    args?: string[],
    options?: {
      cwd?: string;
      env?: { [k: string]: string | undefined };
      execArgv?: string[];
      silent?: boolean;
      stdio?: "pipe" | "ignore" | "inherit" | ("pipe" | "ignore" | "inherit" | "ipc")[];
      serialization?: "json" | "advanced";
      windowsHide?: boolean;
    },
  ): ChildProcess;

  /* The synchronous exec pair: execFileSync runs a file directly (no
   * shell), execSync runs a command through /bin/sh -c. Both capture
   * stdout as a utf8 string (pass { encoding: "utf8" } so plain Node
   * agrees — without it Node returns a Buffer) and THROW on a non-zero
   * exit / signal death — the Error's message is Node's "Command failed:
   * <cmd>" (with the captured stderr appended). Supported options:
   * encoding ("utf8"), cwd, env (REPLACES the child environment), input
   * (fed to stdin), timeout (ms — SIGTERMs the child, then throws
   * ETIMEDOUT), stdio ("pipe"/"ignore" or a 3-tuple of those — the
   * default captures stderr AND echoes it to the parent, like Node), and
   * maxBuffer (accepted, not enforced). Node's status/stdout/stderr error
   * properties are not carried (SEMANTICS.md). */
  interface ExecSyncOptions {
    encoding?: "utf8" | "utf-8";
    cwd?: string;
    env?: { [k: string]: string | undefined };
    input?: string;
    timeout?: number;
    stdio?: "pipe" | "ignore" | "inherit" | ("pipe" | "ignore" | "inherit")[];
    maxBuffer?: number;
    killSignal?: string;
    windowsHide?: boolean;
    shell?: boolean;
  }
  /* The named options interface for the string-encoding exec form —
   * @types/node's ExecFileSyncOptionsWithStringEncoding, narrowed to the
   * honestly-implemented members. VALUES of this type are a real record
   * (type-mapper.ts interns the shape), so a typed const or a runner function's
   * options parameter flows to execFileSync at runtime — the windows-ca
   * command-runner idiom. */
  export interface ExecFileSyncOptionsWithStringEncoding {
    encoding: "utf8" | "utf-8";
    cwd?: string;
    input?: string;
    timeout?: number;
    stdio?: "pipe" | "ignore" | "inherit" | ("pipe" | "ignore" | "inherit")[];
    maxBuffer?: number;
    windowsHide?: boolean;
  }
  export function execFileSync(file: string, args?: string[], options?: ExecSyncOptions): string;
  export function execSync(command: string, options?: ExecSyncOptions): string;
  export type ExecFileCallback = (error: Error | null, stdout: string, stderr: string) => void;
  /* The callback form starts an asynchronous child and captures utf8
   * stdout/stderr. The no-callback overload remains for util.promisify's
   * static target recognition; reached no-callback calls still fence. */
  export function execFile(file: string, callback: ExecFileCallback): ChildProcess;
  export function execFile(
    file: string,
    args: string[] | null,
    callback: ExecFileCallback,
  ): ChildProcess;
  export function execFile(
    file: string,
    args: string[] | null,
    options: ExecSyncOptions,
    callback: ExecFileCallback,
  ): ChildProcess;
  export function execFile(
    file: string,
    args?: string[] | null,
    options?: ExecSyncOptions,
  ): unknown;
  /* The async shell form — declared surface without full lowering (the
   * type-level tolerance story): harness code on paths tests don't reach
   * must typecheck; a reached call fences at its site. util.promisify
   * recognizes it statically, as it does execFile. */
  export function exec(
    command: string,
    options?: ExecSyncOptions | ((error: Error | null, stdout: string, stderr: string) => void),
    callback?: (error: Error | null, stdout: string, stderr: string) => void,
  ): ChildProcess;
}
declare module "node:child_process" {
  export * from "child_process";
}

/* node:util — compile-time projections for child_process.execFile,
 * child_process.exec and fs.readFile. The first two retain Node's custom
 * { stdout, stderr } result; the last resolves the callback's data
 * argument. Other targets and bare
 * promisify values fence per site. */
declare module "util" {
  export * as types from "util/types";
  export function getSystemErrorName(err: number): string;
  export function getSystemErrorMessage(err: number): string;
  export function getSystemErrorMap(): Map<number, [string, string]>;
  export function stripVTControlCharacters(str: string): string;
  export function toUSVString(string: string): string;
  export function isDeepStrictEqual(val1: unknown, val2: unknown, skipPrototype?: boolean): boolean;
  export function styleText(
    format: string | readonly string[],
    text: string,
    options?: { validateStream?: boolean; stream?: unknown },
  ): string;
  export function parseEnv(content: string): { [key: string]: string | undefined };
  export function inherits(constructor: unknown, superConstructor: unknown): void;
  export interface DeprecateOptions {
    modifyPrototype?: boolean;
  }
  export function deprecate<T extends Function>(
    fn: T,
    msg: string,
    code?: string,
    options?: DeprecateOptions,
  ): T;
  /* The callback receives null on success and the rejection reason
   * otherwise (falsy reasons arrive as ERR_FALSY_VALUE_REJECTION). */
  export function callbackify(
    fn: () => Promise<void>,
  ): (callback: (err: NodeJS.ErrnoException | null) => void) => void;
  export function callbackify<TResult>(
    fn: () => Promise<TResult>,
  ): (callback: (err: NodeJS.ErrnoException | null, result: TResult) => void) => void;
  export function callbackify<T1>(
    fn: (arg1: T1) => Promise<void>,
  ): (arg1: T1, callback: (err: NodeJS.ErrnoException | null) => void) => void;
  export function callbackify<T1, TResult>(
    fn: (arg1: T1) => Promise<TResult>,
  ): (arg1: T1, callback: (err: NodeJS.ErrnoException | null, result: TResult) => void) => void;
  export function callbackify<T1, T2>(
    fn: (arg1: T1, arg2: T2) => Promise<void>,
  ): (arg1: T1, arg2: T2, callback: (err: NodeJS.ErrnoException | null) => void) => void;
  export function callbackify<T1, T2, TResult>(
    fn: (arg1: T1, arg2: T2) => Promise<TResult>,
  ): (
    arg1: T1,
    arg2: T2,
    callback: (err: NodeJS.ErrnoException | null, result: TResult) => void,
  ) => void;
  export function callbackify<T1, T2, T3>(
    fn: (arg1: T1, arg2: T2, arg3: T3) => Promise<void>,
  ): (arg1: T1, arg2: T2, arg3: T3, callback: (err: NodeJS.ErrnoException | null) => void) => void;
  export function callbackify<T1, T2, T3, TResult>(
    fn: (arg1: T1, arg2: T2, arg3: T3) => Promise<TResult>,
  ): (
    arg1: T1,
    arg2: T2,
    arg3: T3,
    callback: (err: NodeJS.ErrnoException | null, result: TResult) => void,
  ) => void;
  export type DebugLoggerFunction = (msg: string, ...param: unknown[]) => void;
  export interface DebugLogger extends DebugLoggerFunction {
    enabled: boolean;
  }
  export function debuglog(
    section: string,
    callback?: (fn: DebugLoggerFunction) => void,
  ): DebugLogger;
  export { debuglog as debug };
  export type TextEncoder = globalThis.TextEncoder;
  export type TextDecoder = globalThis.TextDecoder;
  export var TextEncoder: typeof globalThis.TextEncoder;
  export var TextDecoder: typeof globalThis.TextDecoder;
  export function promisify(
    fn: typeof import("node:fs").readFile,
  ): (path: string, encoding: "utf8" | "utf-8") => Promise<string>;
  export function promisify(
    fn: (file: string, args?: string[] | null, options?: object) => unknown,
  ): (
    file: string,
    args?: string[],
    options?: {
      encoding?: "utf8" | "utf-8";
      cwd?: string;
      env?: { [k: string]: string | undefined };
      timeout?: number;
      maxBuffer?: number;
      killSignal?: string;
      windowsHide?: boolean;
    },
  ) => Promise<{ stdout: string; stderr: string }>;
  export function promisify(fn: typeof import("node:child_process").exec): (
    command: string,
    options?: {
      encoding?: "utf8" | "utf-8";
      cwd?: string;
      env?: { [k: string]: string | undefined };
      timeout?: number;
      maxBuffer?: number;
      killSignal?: string;
      windowsHide?: boolean;
    },
  ) => Promise<{ stdout: string; stderr: string }>;
  /* Declared surface without full lowering (the type-level tolerance
   * story: guarded/diagnostic-path code must TYPECHECK; a reached use
   * without a lowering fences at its site). inspect's options carry the
   * documented knobs through an index signature. */
  export function inspect(
    object: unknown,
    options?: { depth?: number | null; colors?: boolean; [k: string]: unknown },
  ): string;
  export function format(format?: unknown, ...args: unknown[]): string;
  export function formatWithOptions(
    inspectOptions: { depth?: number | null; colors?: boolean; [k: string]: unknown },
    format?: unknown,
    ...args: unknown[]
  ): string;
  export type ParseArgsOptionsType = "boolean" | "string";
  export interface ParseArgsOptionDescriptor {
    type: ParseArgsOptionsType;
    multiple?: boolean;
    short?: string;
    default?: string | boolean | string[] | boolean[];
  }
  export interface ParseArgsOptionsConfig {
    [longOption: string]: ParseArgsOptionDescriptor;
  }
  export interface ParseArgsConfig {
    args?: readonly string[];
    options?: ParseArgsOptionsConfig;
    strict?: boolean;
    allowPositionals?: boolean;
    allowNegative?: boolean;
    tokens?: boolean;
  }
  export type ParseArgsToken =
    | {
        kind: "option";
        index: number;
        name: string;
        rawName: string;
        value: string | undefined;
        inlineValue: boolean | undefined;
      }
    | { kind: "positional"; index: number; value: string }
    | { kind: "option-terminator"; index: number };
  export interface ParseArgsResult {
    values: { [longOption: string]: undefined | string | boolean | Array<string | boolean> };
    positionals: string[];
    tokens?: ParseArgsToken[];
  }
  export function parseArgs(config?: ParseArgsConfig): ParseArgsResult;
  /* util.getCallSites (Node ≥22.9): the captured-frame slice harness
   * code reads. No stack bookkeeping exists in a compiled binary — every
   * reached call fences per site. */
  export interface CallSite {
    readonly functionName: string;
    readonly scriptName: string;
    readonly lineNumber: number;
    readonly column: number;
  }
  export function getCallSites(frameCount?: number): CallSite[];
}
declare module "node:util" {
  export * from "util";
}

/* node:util/types — native runtime brands. Other forms retain their
 * per-member lowering boundaries. */
declare module "util/types" {
  export function isAnyArrayBuffer(value: unknown): boolean;
  export function isArrayBuffer(value: unknown): value is ArrayBuffer;
  export function isArrayBufferView(value: unknown): value is ArrayBufferView;
  export function isDataView(value: unknown): value is DataView;
  export function isTypedArray(value: unknown): boolean;
  export function isUint8Array(value: unknown): value is Uint8Array;
  export function isUint8ClampedArray(value: unknown): value is Uint8ClampedArray;
  export function isUint16Array(value: unknown): value is Uint16Array;
  export function isUint32Array(value: unknown): value is Uint32Array;
  export function isInt8Array(value: unknown): value is Int8Array;
  export function isInt16Array(value: unknown): value is Int16Array;
  export function isInt32Array(value: unknown): value is Int32Array;
  export function isFloat32Array(value: unknown): value is Float32Array;
  export function isFloat64Array(value: unknown): value is Float64Array;
  export function isMap(value: unknown): value is Map<unknown, unknown>;
  export function isSet(value: unknown): value is Set<unknown>;
  export function isWeakMap(value: unknown): value is WeakMap<object, unknown>;
  export function isWeakSet(value: unknown): value is WeakSet<object>;
  export function isRegExp(value: unknown): value is RegExp;
  export function isNativeError(value: unknown): value is Error;
  export function isPromise(value: unknown): value is Promise<unknown>;
  export function isProxy(value: unknown): boolean;
  export function isAsyncFunction(value: unknown): boolean;
  export function isGeneratorFunction(value: unknown): boolean;
  export function isGeneratorObject(value: unknown): boolean;
  export function isModuleNamespaceObject(value: unknown): boolean;
}
declare module "node:util/types" {
  export * from "util/types";
}

/* node:assert — the static assertion surface. The module object IS a
 * callable function (`assert(x)` is `assert.ok(x)`), so the declaration
 * is the callable-namespace `export =` shape and BOTH `import assert
 * from "node:assert"` and `const assert = require("assert")` bind the
 * callable; named imports take the members. Failures throw
 * AssertionError (name "AssertionError", code "ERR_ASSERTION" — catch and
 * read .name/.message/.code). strictEqual/deepStrictEqual compare with
 * Object.is over scalars; deepStrictEqual compares composites
 * structurally per their static types. The messages here are plain
 * strings (Node accepts Errors — that form fences per site), and the
 * shallow legacy pair (equal/notEqual) follows Node's == coercions for
 * primitive and primitive-union operands, including Node v24's NaN
 * exception. deepEqual/notDeepEqual remain declared-but-fenced;
 * assert/strict's loose names alias the strict forms and lower. */
/* node:test — the in-process test runner (prefix-only in Node too:
 * require("test") is MODULE_NOT_FOUND). test/it register tests (sync and
 * async bodies, skip/todo/only options and method twins), describe/suite
 * group them (bodies run at registration, Node's collection phase),
 * before/after/beforeEach/afterEach hook the enclosing suite, and the
 * TestContext argument carries subtests (t.test), t.skip/t.todo,
 * t.diagnostic, and t.assert. mock/run/snapshot are DECLARED so real
 * suites typecheck but fence at their use sites (no lowering). */
declare module "node:test" {
  type TestFn = (t: TestContext) => void | Promise<void>;
  type SuiteFn = () => void;
  type HookFn = () => void | Promise<void>;
  interface TestOptions {
    skip?: boolean | string;
    todo?: boolean | string;
    only?: boolean;
    concurrency?: number | boolean;
    timeout?: number;
    plan?: number;
  }
  interface TestContext {
    readonly name: string;
    readonly fullName: string;
    readonly assert: TestContextAssert;
    readonly mock: MockTracker;
    test(name: string, fn?: TestFn): Promise<void>;
    test(name: string, options: TestOptions, fn?: TestFn): Promise<void>;
    skip(message?: string): void;
    todo(message?: string): void;
    diagnostic(message: string): void;
    plan(count: number): void;
    after(fn: HookFn): void;
    before(fn: HookFn): void;
    beforeEach(fn: HookFn): void;
    afterEach(fn: HookFn): void;
  }
  interface TestContextAssert {
    ok(value: unknown, message?: string): void;
    strictEqual(actual: unknown, expected: unknown, message?: string): void;
    notStrictEqual(actual: unknown, expected: unknown, message?: string): void;
    deepStrictEqual(actual: unknown, expected: unknown, message?: string): void;
    notDeepStrictEqual(actual: unknown, expected: unknown, message?: string): void;
    equal(actual: unknown, expected: unknown, message?: string): void;
    notEqual(actual: unknown, expected: unknown, message?: string): void;
    deepEqual(actual: unknown, expected: unknown, message?: string): void;
    notDeepEqual(actual: unknown, expected: unknown, message?: string): void;
    fail(message?: string): never;
    throws(fn: () => unknown, expected?: unknown, message?: string): void;
    match(value: string, regExp: RegExp, message?: string): void;
    doesNotMatch(value: string, regExp: RegExp, message?: string): void;
  }
  function test(name: string, fn?: TestFn): Promise<void>;
  function test(name: string, options: TestOptions, fn?: TestFn): Promise<void>;
  namespace test {
    function skip(name: string, fn?: TestFn): Promise<void>;
    function skip(name: string, options: TestOptions, fn?: TestFn): Promise<void>;
    function todo(name: string, fn?: TestFn): Promise<void>;
    function todo(name: string, options: TestOptions, fn?: TestFn): Promise<void>;
    function only(name: string, fn?: TestFn): Promise<void>;
    function only(name: string, options: TestOptions, fn?: TestFn): Promise<void>;
  }
  const it: typeof test;
  function describe(name: string, fn?: SuiteFn): void;
  function describe(name: string, options: TestOptions, fn?: SuiteFn): void;
  namespace describe {
    function skip(name: string, fn?: SuiteFn): void;
    function todo(name: string, fn?: SuiteFn): void;
    function only(name: string, fn?: SuiteFn): void;
  }
  const suite: typeof describe;
  function before(fn: HookFn): void;
  function after(fn: HookFn): void;
  function beforeEach(fn: HookFn): void;
  function afterEach(fn: HookFn): void;
  /* The mock function surface: mock.fn and t.mock.fn, with the calls log
   * and the implementation controls on fn.mock. */
  interface MockFunctionCall<
    F extends Function,
    ReturnType = F extends (...args: any) => infer T ? T : unknown,
    Args = F extends (...args: infer Y) => any ? Y : unknown[],
  > {
    arguments: Args;
    error: unknown | undefined;
    result: ReturnType | undefined;
    this: unknown;
  }
  interface MockFunctionContext<F extends Function> {
    readonly calls: MockFunctionCall<F>[];
    callCount(): number;
    mockImplementation(implementation: F): void;
    mockImplementationOnce(implementation: F, onCall?: number): void;
    resetCalls(): void;
    restore(): void;
  }
  type Mock<F extends Function> = F & { mock: MockFunctionContext<F> };
  interface MockTracker {
    fn<F extends Function = (...args: any[]) => undefined>(original?: F): Mock<F>;
    fn<F extends Function = (...args: any[]) => undefined, Implementation extends Function = F>(
      original?: F,
      implementation?: Implementation,
    ): Mock<F | Implementation>;
    method<MockedObject extends object>(
      object: MockedObject,
      methodName: keyof MockedObject,
      implementation?: Function,
    ): Mock<Function>;
    reset(): void;
    restoreAll(): void;
  }
  const mock: MockTracker;
  /* Declared for typechecking only — every use fences (no lowering).
   * `assert` is the module-level custom-assertion registry (v24's
   * `const { assert } = require('node:test')`), not TestContext.assert. */
  const assert: { register(name: string, fn: (...args: unknown[]) => unknown): void };
  function run(options?: unknown): unknown;
  function snapshot(...args: unknown[]): unknown;
  export {
    test,
    it,
    describe,
    suite,
    before,
    after,
    beforeEach,
    afterEach,
    mock,
    assert,
    run,
    snapshot,
    TestContext,
    TestOptions,
    Mock,
    MockFunctionContext,
    MockFunctionCall,
    MockTracker,
  };
  export default test;
}

declare module "assert" {
  function assert(value: unknown, message?: string): void;
  namespace assert {
    interface AssertionErrorOptions {
      message?: string | undefined;
      actual?: unknown;
      expected?: unknown;
      operator?: string | undefined;
      stackStartFn?: Function | undefined;
      diff?: "simple" | "full" | undefined;
    }
    class AssertionError extends Error {
      constructor(options: AssertionErrorOptions);
      actual: unknown;
      expected: unknown;
      generatedMessage: boolean;
      code: "ERR_ASSERTION";
      operator: string;
    }
    function ok(value: unknown, message?: string): void;
    function strictEqual(actual: unknown, expected: unknown, message?: string): void;
    function notStrictEqual(actual: unknown, expected: unknown, message?: string): void;
    function deepStrictEqual(actual: unknown, expected: unknown, message?: string): void;
    function notDeepStrictEqual(actual: unknown, expected: unknown, message?: string): void;
    function partialDeepStrictEqual(actual: unknown, expected: unknown, message?: string): void;
    function equal(actual: unknown, expected: unknown, message?: string): void;
    function notEqual(actual: unknown, expected: unknown, message?: string): void;
    function deepEqual(actual: unknown, expected: unknown, message?: string): void;
    function notDeepEqual(actual: unknown, expected: unknown, message?: string): void;
    function fail(message?: string): never;
    function throws(fn: () => unknown, expected?: unknown, message?: string): void;
    function doesNotThrow(fn: () => unknown, expected?: unknown, message?: string): void;
    function rejects(
      fn: (() => Promise<unknown>) | Promise<unknown>,
      expected?: unknown,
      message?: string,
    ): Promise<void>;
    function doesNotReject(
      fn: (() => Promise<unknown>) | Promise<unknown>,
      expected?: unknown,
      message?: string,
    ): Promise<void>;
    function match(value: string, regExp: RegExp, message?: string): void;
    function doesNotMatch(value: string, regExp: RegExp, message?: string): void;
    function ifError(value: unknown): void;
    const strict: typeof import("assert/strict");
    interface AssertOptions {
      diff?: "simple" | "full" | undefined;
      strict?: boolean | undefined;
      skipPrototype?: boolean | undefined;
    }
    type AssertMethodNames =
      | "deepEqual"
      | "deepStrictEqual"
      | "doesNotMatch"
      | "doesNotReject"
      | "doesNotThrow"
      | "equal"
      | "fail"
      | "ifError"
      | "match"
      | "notDeepEqual"
      | "notDeepStrictEqual"
      | "notEqual"
      | "notStrictEqual"
      | "ok"
      | "partialDeepStrictEqual"
      | "rejects"
      | "strictEqual"
      | "throws";
    interface Assert extends Pick<typeof assert, AssertMethodNames> {}
    interface AssertStrict extends Pick<typeof strict, AssertMethodNames> {}
    const Assert: {
      new (options?: AssertOptions & { strict?: true | undefined }): AssertStrict;
      new (options: AssertOptions): Assert;
    };
  }
  export = assert;
}
declare module "node:assert" {
  import assert = require("assert");
  export = assert;
}
/* node:assert/strict — the same surface with the loose names bound to the
 * strict comparisons (equal IS strictEqual, ...), exactly Node's aliasing;
 * the module object is callable like assert's. */
declare module "assert/strict" {
  function strict(value: unknown, message?: string): void;
  namespace strict {
    function ok(value: unknown, message?: string): void;
    function equal(actual: unknown, expected: unknown, message?: string): void;
    function notEqual(actual: unknown, expected: unknown, message?: string): void;
    function deepEqual(actual: unknown, expected: unknown, message?: string): void;
    function notDeepEqual(actual: unknown, expected: unknown, message?: string): void;
    function strictEqual(actual: unknown, expected: unknown, message?: string): void;
    function notStrictEqual(actual: unknown, expected: unknown, message?: string): void;
    function deepStrictEqual(actual: unknown, expected: unknown, message?: string): void;
    function notDeepStrictEqual(actual: unknown, expected: unknown, message?: string): void;
    function partialDeepStrictEqual(actual: unknown, expected: unknown, message?: string): void;
    function fail(message?: string): never;
    function throws(fn: () => unknown, expected?: unknown, message?: string): void;
    function doesNotThrow(fn: () => unknown, expected?: unknown, message?: string): void;
    function rejects(
      fn: (() => Promise<unknown>) | Promise<unknown>,
      expected?: unknown,
      message?: string,
    ): Promise<void>;
    function doesNotReject(
      fn: (() => Promise<unknown>) | Promise<unknown>,
      expected?: unknown,
      message?: string,
    ): Promise<void>;
    function match(value: string, regExp: RegExp, message?: string): void;
    function doesNotMatch(value: string, regExp: RegExp, message?: string): void;
    function ifError(value: unknown): void;
    const strict: typeof import("assert/strict");
    type AssertOptions = import("assert").AssertOptions;
    type Assert = import("assert").Assert;
    type AssertStrict = import("assert").AssertStrict;
    const Assert: typeof import("assert").Assert;
  }
  export = strict;
}
declare module "node:assert/strict" {
  import strict = require("assert/strict");
  export = strict;
}

/* node:string_decoder — StringDecoder over Node's whole encoding set:
 * write() decodes complete sequences and buffers a trailing partial one
 * across chunk boundaries (utf8's truncated sequence, base64's mod-3
 * remainder, utf16le's odd byte / trailing lead surrogate; latin1, ascii
 * and hex are stateless); end() flushes the buffered partial. `encoding`
 * answers the normalized name. Node's exact algorithms (SEMANTICS.md);
 * the encoding must be a literal, and end(buffer) fences — write the
 * buffer, then end(). */
declare module "string_decoder" {
  export class StringDecoder {
    constructor(encoding?: BufferEncoding);
    readonly encoding: string;
    write(buffer: Uint8Array): string;
    end(buffer?: Uint8Array): string;
  }
}
declare module "node:string_decoder" {
  export * from "string_decoder";
}

/* node:querystring — Node's legacy query-string codec (NOT
 * URLSearchParams: '+' means space on the parse side and escape encodes
 * spaces as %20). parse answers the null-prototype dictionary as a pure
 * index-signature record (repeated keys become string[] buckets;
 * @types/node's Dict adds an undefined arm the lowering tolerates);
 * stringify serializes string/number/boolean values and arrays of those
 * (Node's rules: arrays expand to repeated keys, null/undefined and
 * anything else serialize as the empty value). The maxKeys option lowers
 * (0 removes the cap, Node's rule); the custom encoder/decoder options
 * typecheck under the options-record stance and fence by name at the
 * call. decode/encode are Node's own aliases of parse/stringify. */
declare module "querystring" {
  export interface ParseOptions {
    maxKeys?: number;
    decodeURIComponent?: (str: string) => string;
    [option: string]: unknown;
  }
  export interface StringifyOptions {
    encodeURIComponent?: (str: string) => string;
    [option: string]: unknown;
  }
  export interface ParsedUrlQuery {
    [key: string]: string | string[] | undefined;
  }
  export interface ParsedUrlQueryInput {
    [key: string]:
      | string
      | number
      | boolean
      | ReadonlyArray<string | number | boolean>
      | null
      | undefined;
  }
  export function parse(
    str: string,
    sep?: string | null,
    eq?: string | null,
    options?: ParseOptions,
  ): ParsedUrlQuery;
  export function stringify(
    obj?: ParsedUrlQueryInput,
    sep?: string | null,
    eq?: string | null,
    options?: StringifyOptions,
  ): string;
  export const decode: typeof parse;
  export const encode: typeof stringify;
  export function escape(str: string): string;
  export function unescape(str: string): string;
}
declare module "node:querystring" {
  export * from "querystring";
}

/* node:readline — the question/close slice: createInterface over exactly
 * { input: process.stdin, output: process.stdout }, question(query, cb)
 * (the query writes to stdout, the callback gets the next line's text),
 * close() (fires 'close' synchronously, like Node's inline emit), and
 * on("close", cb). An open interface keeps the process alive until
 * close()/EOF, Node's semantics; lines split on \n and \r\n. */
declare module "readline" {
  /* The non-terminal Interface over process.stdin or a stream input
   * (scr_readline.c). Listener registrations are statements: chaining
   * on()/once() results has no lowering. */
  export interface Interface extends Disposable {
    /* The non-terminal members: terminal is false and line ''; history
     * is the history option itself (or the interface's own empty array),
     * never recorded without a terminal. */
    readonly terminal: boolean;
    readonly line: string;
    history: string[];
    readonly historySize: number;
    readonly historyIndex: number;
    readonly crlfDelay: number;
    readonly tabSize: number;
    readonly escapeCodeTimeout: number;
    question(query: string, callback: (answer: string) => void): void;
    close(): void;
    pause(): this;
    resume(): this;
    prompt(preserveCursor?: boolean): void;
    setPrompt(prompt: string): void;
    getPrompt(): string;
    write(data: string): void;
    on(event: "line", listener: (input: string) => void): this;
    on(event: "close" | "pause" | "resume", listener: () => void): this;
    on(event: "error", listener: (err: Error) => void): this;
    on(event: "history", listener: (history: string[]) => void): this;
    once(event: "line", listener: (input: string) => void): this;
    once(event: "close" | "pause" | "resume", listener: () => void): this;
    once(event: "error", listener: (err: Error) => void): this;
    once(event: "history", listener: (history: string[]) => void): this;
    addListener(event: "line", listener: (input: string) => void): this;
    addListener(event: "close" | "pause" | "resume", listener: () => void): this;
    addListener(event: "error", listener: (err: Error) => void): this;
    addListener(event: "history", listener: (history: string[]) => void): this;
    [Symbol.asyncIterator](): AsyncIterableIterator<string>;
    [Symbol.dispose](): void;
  }
  export interface ReadLineOptions {
    input: unknown;
    output?: unknown;
    terminal?: boolean;
    /* Node's crlfDelay: a \n arriving within this many ms (at least 100)
     * after a line ended by \r is dropped. completer and the history
     * options are validated and kept; without a terminal neither is used.
     * The options-record
     * stance (see http.RequestOptions) admits every key; the walk
     * decides. */
    crlfDelay?: number;
    completer?: unknown;
    signal?: AbortSignal;
    history?: string[];
    historySize?: number;
    removeHistoryDuplicates?: boolean;
    tabSize?: number;
    escapeCodeTimeout?: number;
    [option: string]: unknown;
  }
  export function createInterface(options: ReadLineOptions): Interface;
  export function createInterface(input: unknown, output?: unknown): Interface;
}
declare module "node:readline" {
  export * from "readline";
}
declare module "readline/promises" {
  import { ReadLineOptions } from "readline";
  /* The readline Interface with the promise question: it resolves with
   * the next line, rejects with an AbortError when options.signal aborts,
   * and with ERR_USE_AFTER_CLOSE after close(). */
  export interface Interface extends Disposable {
    /* The non-terminal members: terminal is false and line ''; history
     * is the history option itself (or the interface's own empty array),
     * never recorded without a terminal. */
    readonly terminal: boolean;
    readonly line: string;
    history: string[];
    readonly historySize: number;
    readonly historyIndex: number;
    readonly crlfDelay: number;
    readonly tabSize: number;
    readonly escapeCodeTimeout: number;
    question(query: string, options?: { signal?: AbortSignal }): Promise<string>;
    close(): void;
    pause(): this;
    resume(): this;
    prompt(preserveCursor?: boolean): void;
    setPrompt(prompt: string): void;
    getPrompt(): string;
    write(data: string): void;
    on(event: "line", listener: (input: string) => void): this;
    on(event: "close" | "pause" | "resume", listener: () => void): this;
    on(event: "error", listener: (err: Error) => void): this;
    on(event: "history", listener: (history: string[]) => void): this;
    once(event: "line", listener: (input: string) => void): this;
    once(event: "close" | "pause" | "resume", listener: () => void): this;
    once(event: "error", listener: (err: Error) => void): this;
    once(event: "history", listener: (history: string[]) => void): this;
    addListener(event: "line", listener: (input: string) => void): this;
    addListener(event: "close" | "pause" | "resume", listener: () => void): this;
    addListener(event: "error", listener: (err: Error) => void): this;
    addListener(event: "history", listener: (history: string[]) => void): this;
    [Symbol.asyncIterator](): AsyncIterableIterator<string>;
    [Symbol.dispose](): void;
  }
  export function createInterface(options: ReadLineOptions): Interface;
  export function createInterface(input: unknown, output?: unknown): Interface;
}
declare module "node:readline/promises" {
  export * from "readline/promises";
}

/* node:zlib — the one-shot zlib/raw/gzip codecs lower for string/Buffer
 * inputs with Node's default options; libz links only into zlib-using
 * binaries. Callback forms use the executable worker pool. Options stay
 * declared so reached uses receive a named SC2020 refusal. The Deflate,
 * Inflate, Gzip, Gunzip, DeflateRaw, InflateRaw and Unzip streams are
 * runtime Transform streams; Brotli and Zstd remain outside the lowered
 * surface. */
declare module "zlib" {
  import { Transform } from "stream";
  export interface ZlibOptions {
    [option: string]: unknown;
  }
  export type ZlibCallback = (error: NodeJS.ErrnoException | null, result: Buffer) => void;
  export function deflate(data: string | Uint8Array, callback: ZlibCallback): void;
  export function deflate(
    data: string | Uint8Array,
    options: ZlibOptions,
    callback: ZlibCallback,
  ): void;
  export function deflateSync(data: string | Uint8Array, options?: ZlibOptions): Buffer;
  export function inflate(data: string | Uint8Array, callback: ZlibCallback): void;
  export function inflate(
    data: string | Uint8Array,
    options: ZlibOptions,
    callback: ZlibCallback,
  ): void;
  export function inflateSync(data: string | Uint8Array, options?: ZlibOptions): Buffer;
  export function deflateRaw(data: string | Uint8Array, callback: ZlibCallback): void;
  export function deflateRaw(
    data: string | Uint8Array,
    options: ZlibOptions,
    callback: ZlibCallback,
  ): void;
  export function deflateRawSync(data: string | Uint8Array, options?: ZlibOptions): Buffer;
  export function inflateRaw(data: string | Uint8Array, callback: ZlibCallback): void;
  export function inflateRaw(
    data: string | Uint8Array,
    options: ZlibOptions,
    callback: ZlibCallback,
  ): void;
  export function inflateRawSync(data: string | Uint8Array, options?: ZlibOptions): Buffer;
  export function gzip(data: string | Uint8Array, callback: ZlibCallback): void;
  export function gzip(
    data: string | Uint8Array,
    options: ZlibOptions,
    callback: ZlibCallback,
  ): void;
  export function gzipSync(data: string | Uint8Array, options?: ZlibOptions): Buffer;
  export function gunzip(data: string | Uint8Array, callback: ZlibCallback): void;
  export function gunzip(
    data: string | Uint8Array,
    options: ZlibOptions,
    callback: ZlibCallback,
  ): void;
  export function gunzipSync(data: string | Uint8Array, options?: ZlibOptions): Buffer;
  export function unzip(data: string | Uint8Array, callback: ZlibCallback): void;
  export function unzip(
    data: string | Uint8Array,
    options: ZlibOptions,
    callback: ZlibCallback,
  ): void;
  export function unzipSync(data: string | Uint8Array, options?: ZlibOptions): Buffer;
  export function crc32(data: string | Uint8Array, value?: number): number;
  export function brotliCompressSync(data: string | Uint8Array): Buffer;
  export function brotliDecompressSync(data: Uint8Array): Buffer;
  /* Brotli needs a codec the static runtime does not vendor: these are
   * declared so their uses receive the named refusal. */
  export function brotliCompress(data: string | Uint8Array, callback: ZlibCallback): void;
  export function brotliDecompress(data: Uint8Array, callback: ZlibCallback): void;
  export function createBrotliCompress(options?: ZlibOptions): Transform;
  export function createBrotliDecompress(options?: ZlibOptions): Transform;
  export class BrotliCompress extends Transform {
    constructor(options?: ZlibOptions);
  }
  export class BrotliDecompress extends Transform {
    constructor(options?: ZlibOptions);
  }
  /* The stream classes: runtime Transform streams over the zlib engine
   * (scr_zlib_stream.c). createGzip(options) and new Gzip(options) build
   * the same stream; options are validated at runtime with Node's rules. */
  class ZlibBase extends Transform {
    readonly bytesWritten: number;
    flush(kind?: number, callback?: () => void): void;
    flush(callback: () => void): void;
    params(level: number, strategy: number, callback?: () => void): void;
    close(callback?: () => void): void;
    reset(): void;
  }
  export class Deflate extends ZlibBase {
    constructor(options?: ZlibOptions);
  }
  export class Inflate extends ZlibBase {
    constructor(options?: ZlibOptions);
  }
  export class Gzip extends ZlibBase {
    constructor(options?: ZlibOptions);
  }
  export class Gunzip extends ZlibBase {
    constructor(options?: ZlibOptions);
  }
  export class DeflateRaw extends ZlibBase {
    constructor(options?: ZlibOptions);
  }
  export class InflateRaw extends ZlibBase {
    constructor(options?: ZlibOptions);
  }
  export class Unzip extends ZlibBase {
    constructor(options?: ZlibOptions);
  }
  export function createDeflate(options?: ZlibOptions): Deflate;
  export function createInflate(options?: ZlibOptions): Inflate;
  export function createGzip(options?: ZlibOptions): Gzip;
  export function createGunzip(options?: ZlibOptions): Gunzip;
  export function createDeflateRaw(options?: ZlibOptions): DeflateRaw;
  export function createInflateRaw(options?: ZlibOptions): InflateRaw;
  export function createUnzip(options?: ZlibOptions): Unzip;
  /* Node v24 zlib.constants, literal-typed (the CryptoConstants stance):
   * every access bakes as its literal; the object never materializes. The
   * members outside BROTLI_* are also module properties (zlib.Z_SYNC_FLUSH). */
  export interface ZlibConstants {
    readonly Z_NO_FLUSH: 0;
    readonly Z_PARTIAL_FLUSH: 1;
    readonly Z_SYNC_FLUSH: 2;
    readonly Z_FULL_FLUSH: 3;
    readonly Z_FINISH: 4;
    readonly Z_BLOCK: 5;
    readonly Z_OK: 0;
    readonly Z_STREAM_END: 1;
    readonly Z_NEED_DICT: 2;
    readonly Z_ERRNO: -1;
    readonly Z_STREAM_ERROR: -2;
    readonly Z_DATA_ERROR: -3;
    readonly Z_MEM_ERROR: -4;
    readonly Z_BUF_ERROR: -5;
    readonly Z_VERSION_ERROR: -6;
    readonly Z_NO_COMPRESSION: 0;
    readonly Z_BEST_SPEED: 1;
    readonly Z_BEST_COMPRESSION: 9;
    readonly Z_DEFAULT_COMPRESSION: -1;
    readonly Z_FILTERED: 1;
    readonly Z_HUFFMAN_ONLY: 2;
    readonly Z_RLE: 3;
    readonly Z_FIXED: 4;
    readonly Z_DEFAULT_STRATEGY: 0;
    readonly ZLIB_VERNUM: 4897;
    readonly DEFLATE: 1;
    readonly INFLATE: 2;
    readonly GZIP: 3;
    readonly GUNZIP: 4;
    readonly DEFLATERAW: 5;
    readonly INFLATERAW: 6;
    readonly UNZIP: 7;
    readonly BROTLI_DECODE: 8;
    readonly BROTLI_ENCODE: 9;
    readonly ZSTD_DECOMPRESS: 11;
    readonly ZSTD_COMPRESS: 10;
    readonly Z_MIN_WINDOWBITS: 8;
    readonly Z_MAX_WINDOWBITS: 15;
    readonly Z_DEFAULT_WINDOWBITS: 15;
    readonly Z_MIN_CHUNK: 64;
    readonly Z_MAX_CHUNK: number;
    readonly Z_DEFAULT_CHUNK: 16384;
    readonly Z_MIN_MEMLEVEL: 1;
    readonly Z_MAX_MEMLEVEL: 9;
    readonly Z_DEFAULT_MEMLEVEL: 8;
    readonly Z_MIN_LEVEL: -1;
    readonly Z_MAX_LEVEL: 9;
    readonly Z_DEFAULT_LEVEL: -1;
    readonly BROTLI_OPERATION_PROCESS: 0;
    readonly BROTLI_OPERATION_FLUSH: 1;
    readonly BROTLI_OPERATION_FINISH: 2;
    readonly BROTLI_OPERATION_EMIT_METADATA: 3;
    readonly BROTLI_PARAM_MODE: 0;
    readonly BROTLI_MODE_GENERIC: 0;
    readonly BROTLI_MODE_TEXT: 1;
    readonly BROTLI_MODE_FONT: 2;
    readonly BROTLI_DEFAULT_MODE: 0;
    readonly BROTLI_PARAM_QUALITY: 1;
    readonly BROTLI_MIN_QUALITY: 0;
    readonly BROTLI_MAX_QUALITY: 11;
    readonly BROTLI_DEFAULT_QUALITY: 11;
    readonly BROTLI_PARAM_LGWIN: 2;
    readonly BROTLI_MIN_WINDOW_BITS: 10;
    readonly BROTLI_MAX_WINDOW_BITS: 24;
    readonly BROTLI_LARGE_MAX_WINDOW_BITS: 30;
    readonly BROTLI_DEFAULT_WINDOW: 22;
    readonly BROTLI_PARAM_LGBLOCK: 3;
    readonly BROTLI_MIN_INPUT_BLOCK_BITS: 16;
    readonly BROTLI_MAX_INPUT_BLOCK_BITS: 24;
    readonly BROTLI_PARAM_DISABLE_LITERAL_CONTEXT_MODELING: 4;
    readonly BROTLI_PARAM_SIZE_HINT: 5;
    readonly BROTLI_PARAM_LARGE_WINDOW: 6;
    readonly BROTLI_PARAM_NPOSTFIX: 7;
    readonly BROTLI_PARAM_NDIRECT: 8;
    readonly BROTLI_DECODER_RESULT_ERROR: 0;
    readonly BROTLI_DECODER_RESULT_SUCCESS: 1;
    readonly BROTLI_DECODER_RESULT_NEEDS_MORE_INPUT: 2;
    readonly BROTLI_DECODER_RESULT_NEEDS_MORE_OUTPUT: 3;
    readonly BROTLI_DECODER_PARAM_DISABLE_RING_BUFFER_REALLOCATION: 0;
    readonly BROTLI_DECODER_PARAM_LARGE_WINDOW: 1;
    readonly BROTLI_DECODER_NO_ERROR: 0;
    readonly BROTLI_DECODER_SUCCESS: 1;
    readonly BROTLI_DECODER_NEEDS_MORE_INPUT: 2;
    readonly BROTLI_DECODER_NEEDS_MORE_OUTPUT: 3;
    readonly BROTLI_DECODER_ERROR_FORMAT_EXUBERANT_NIBBLE: -1;
    readonly BROTLI_DECODER_ERROR_FORMAT_RESERVED: -2;
    readonly BROTLI_DECODER_ERROR_FORMAT_EXUBERANT_META_NIBBLE: -3;
    readonly BROTLI_DECODER_ERROR_FORMAT_SIMPLE_HUFFMAN_ALPHABET: -4;
    readonly BROTLI_DECODER_ERROR_FORMAT_SIMPLE_HUFFMAN_SAME: -5;
    readonly BROTLI_DECODER_ERROR_FORMAT_CL_SPACE: -6;
    readonly BROTLI_DECODER_ERROR_FORMAT_HUFFMAN_SPACE: -7;
    readonly BROTLI_DECODER_ERROR_FORMAT_CONTEXT_MAP_REPEAT: -8;
    readonly BROTLI_DECODER_ERROR_FORMAT_BLOCK_LENGTH_1: -9;
    readonly BROTLI_DECODER_ERROR_FORMAT_BLOCK_LENGTH_2: -10;
    readonly BROTLI_DECODER_ERROR_FORMAT_TRANSFORM: -11;
    readonly BROTLI_DECODER_ERROR_FORMAT_DICTIONARY: -12;
    readonly BROTLI_DECODER_ERROR_FORMAT_WINDOW_BITS: -13;
    readonly BROTLI_DECODER_ERROR_FORMAT_PADDING_1: -14;
    readonly BROTLI_DECODER_ERROR_FORMAT_PADDING_2: -15;
    readonly BROTLI_DECODER_ERROR_FORMAT_DISTANCE: -16;
    readonly BROTLI_DECODER_ERROR_DICTIONARY_NOT_SET: -19;
    readonly BROTLI_DECODER_ERROR_INVALID_ARGUMENTS: -20;
    readonly BROTLI_DECODER_ERROR_ALLOC_CONTEXT_MODES: -21;
    readonly BROTLI_DECODER_ERROR_ALLOC_TREE_GROUPS: -22;
    readonly BROTLI_DECODER_ERROR_ALLOC_CONTEXT_MAP: -25;
    readonly BROTLI_DECODER_ERROR_ALLOC_RING_BUFFER_1: -26;
    readonly BROTLI_DECODER_ERROR_ALLOC_RING_BUFFER_2: -27;
    readonly BROTLI_DECODER_ERROR_ALLOC_BLOCK_TYPE_TREES: -30;
    readonly BROTLI_DECODER_ERROR_UNREACHABLE: -31;
    readonly ZSTD_e_continue: 0;
    readonly ZSTD_e_flush: 1;
    readonly ZSTD_e_end: 2;
    readonly ZSTD_fast: 1;
    readonly ZSTD_dfast: 2;
    readonly ZSTD_greedy: 3;
    readonly ZSTD_lazy: 4;
    readonly ZSTD_lazy2: 5;
    readonly ZSTD_btlazy2: 6;
    readonly ZSTD_btopt: 7;
    readonly ZSTD_btultra: 8;
    readonly ZSTD_btultra2: 9;
    readonly ZSTD_c_compressionLevel: 100;
    readonly ZSTD_c_windowLog: 101;
    readonly ZSTD_c_hashLog: 102;
    readonly ZSTD_c_chainLog: 103;
    readonly ZSTD_c_searchLog: 104;
    readonly ZSTD_c_minMatch: 105;
    readonly ZSTD_c_targetLength: 106;
    readonly ZSTD_c_strategy: 107;
    readonly ZSTD_c_enableLongDistanceMatching: 160;
    readonly ZSTD_c_ldmHashLog: 161;
    readonly ZSTD_c_ldmMinMatch: 162;
    readonly ZSTD_c_ldmBucketSizeLog: 163;
    readonly ZSTD_c_ldmHashRateLog: 164;
    readonly ZSTD_c_contentSizeFlag: 200;
    readonly ZSTD_c_checksumFlag: 201;
    readonly ZSTD_c_dictIDFlag: 202;
    readonly ZSTD_c_nbWorkers: 400;
    readonly ZSTD_c_jobSize: 401;
    readonly ZSTD_c_overlapLog: 402;
    readonly ZSTD_d_windowLogMax: 100;
    readonly ZSTD_CLEVEL_DEFAULT: 3;
    readonly ZSTD_error_no_error: 0;
    readonly ZSTD_error_GENERIC: 1;
    readonly ZSTD_error_prefix_unknown: 10;
    readonly ZSTD_error_version_unsupported: 12;
    readonly ZSTD_error_frameParameter_unsupported: 14;
    readonly ZSTD_error_frameParameter_windowTooLarge: 16;
    readonly ZSTD_error_corruption_detected: 20;
    readonly ZSTD_error_checksum_wrong: 22;
    readonly ZSTD_error_literals_headerWrong: 24;
    readonly ZSTD_error_dictionary_corrupted: 30;
    readonly ZSTD_error_dictionary_wrong: 32;
    readonly ZSTD_error_dictionaryCreation_failed: 34;
    readonly ZSTD_error_parameter_unsupported: 40;
    readonly ZSTD_error_parameter_combination_unsupported: 41;
    readonly ZSTD_error_parameter_outOfBound: 42;
    readonly ZSTD_error_tableLog_tooLarge: 44;
    readonly ZSTD_error_maxSymbolValue_tooLarge: 46;
    readonly ZSTD_error_maxSymbolValue_tooSmall: 48;
    readonly ZSTD_error_stabilityCondition_notRespected: 50;
    readonly ZSTD_error_stage_wrong: 60;
    readonly ZSTD_error_init_missing: 62;
    readonly ZSTD_error_memory_allocation: 64;
    readonly ZSTD_error_workSpace_tooSmall: 66;
    readonly ZSTD_error_dstSize_tooSmall: 70;
    readonly ZSTD_error_srcSize_wrong: 72;
    readonly ZSTD_error_dstBuffer_null: 74;
    readonly ZSTD_error_noForwardProgress_destFull: 80;
    readonly ZSTD_error_noForwardProgress_inputEmpty: 82;
  }
  export const constants: ZlibConstants;
  export const Z_NO_FLUSH: 0;
  export const Z_PARTIAL_FLUSH: 1;
  export const Z_SYNC_FLUSH: 2;
  export const Z_FULL_FLUSH: 3;
  export const Z_FINISH: 4;
  export const Z_BLOCK: 5;
  export const Z_OK: 0;
  export const Z_STREAM_END: 1;
  export const Z_NEED_DICT: 2;
  export const Z_ERRNO: -1;
  export const Z_STREAM_ERROR: -2;
  export const Z_DATA_ERROR: -3;
  export const Z_MEM_ERROR: -4;
  export const Z_BUF_ERROR: -5;
  export const Z_VERSION_ERROR: -6;
  export const Z_NO_COMPRESSION: 0;
  export const Z_BEST_SPEED: 1;
  export const Z_BEST_COMPRESSION: 9;
  export const Z_DEFAULT_COMPRESSION: -1;
  export const Z_FILTERED: 1;
  export const Z_HUFFMAN_ONLY: 2;
  export const Z_RLE: 3;
  export const Z_FIXED: 4;
  export const Z_DEFAULT_STRATEGY: 0;
  export const ZLIB_VERNUM: 4897;
  export const DEFLATE: 1;
  export const INFLATE: 2;
  export const GZIP: 3;
  export const GUNZIP: 4;
  export const DEFLATERAW: 5;
  export const INFLATERAW: 6;
  export const UNZIP: 7;
  export const ZSTD_DECOMPRESS: 11;
  export const ZSTD_COMPRESS: 10;
  export const Z_MIN_WINDOWBITS: 8;
  export const Z_MAX_WINDOWBITS: 15;
  export const Z_DEFAULT_WINDOWBITS: 15;
  export const Z_MIN_CHUNK: 64;
  export const Z_MAX_CHUNK: number;
  export const Z_DEFAULT_CHUNK: 16384;
  export const Z_MIN_MEMLEVEL: 1;
  export const Z_MAX_MEMLEVEL: 9;
  export const Z_DEFAULT_MEMLEVEL: 8;
  export const Z_MIN_LEVEL: -1;
  export const Z_MAX_LEVEL: 9;
  export const Z_DEFAULT_LEVEL: -1;
  export const ZSTD_e_continue: 0;
  export const ZSTD_e_flush: 1;
  export const ZSTD_e_end: 2;
  export const ZSTD_fast: 1;
  export const ZSTD_dfast: 2;
  export const ZSTD_greedy: 3;
  export const ZSTD_lazy: 4;
  export const ZSTD_lazy2: 5;
  export const ZSTD_btlazy2: 6;
  export const ZSTD_btopt: 7;
  export const ZSTD_btultra: 8;
  export const ZSTD_btultra2: 9;
  export const ZSTD_c_compressionLevel: 100;
  export const ZSTD_c_windowLog: 101;
  export const ZSTD_c_hashLog: 102;
  export const ZSTD_c_chainLog: 103;
  export const ZSTD_c_searchLog: 104;
  export const ZSTD_c_minMatch: 105;
  export const ZSTD_c_targetLength: 106;
  export const ZSTD_c_strategy: 107;
  export const ZSTD_c_enableLongDistanceMatching: 160;
  export const ZSTD_c_ldmHashLog: 161;
  export const ZSTD_c_ldmMinMatch: 162;
  export const ZSTD_c_ldmBucketSizeLog: 163;
  export const ZSTD_c_ldmHashRateLog: 164;
  export const ZSTD_c_contentSizeFlag: 200;
  export const ZSTD_c_checksumFlag: 201;
  export const ZSTD_c_dictIDFlag: 202;
  export const ZSTD_c_nbWorkers: 400;
  export const ZSTD_c_jobSize: 401;
  export const ZSTD_c_overlapLog: 402;
  export const ZSTD_d_windowLogMax: 100;
  export const ZSTD_CLEVEL_DEFAULT: 3;
  export const ZSTD_error_no_error: 0;
  export const ZSTD_error_GENERIC: 1;
  export const ZSTD_error_prefix_unknown: 10;
  export const ZSTD_error_version_unsupported: 12;
  export const ZSTD_error_frameParameter_unsupported: 14;
  export const ZSTD_error_frameParameter_windowTooLarge: 16;
  export const ZSTD_error_corruption_detected: 20;
  export const ZSTD_error_checksum_wrong: 22;
  export const ZSTD_error_literals_headerWrong: 24;
  export const ZSTD_error_dictionary_corrupted: 30;
  export const ZSTD_error_dictionary_wrong: 32;
  export const ZSTD_error_dictionaryCreation_failed: 34;
  export const ZSTD_error_parameter_unsupported: 40;
  export const ZSTD_error_parameter_combination_unsupported: 41;
  export const ZSTD_error_parameter_outOfBound: 42;
  export const ZSTD_error_tableLog_tooLarge: 44;
  export const ZSTD_error_maxSymbolValue_tooLarge: 46;
  export const ZSTD_error_maxSymbolValue_tooSmall: 48;
  export const ZSTD_error_stabilityCondition_notRespected: 50;
  export const ZSTD_error_stage_wrong: 60;
  export const ZSTD_error_init_missing: 62;
  export const ZSTD_error_memory_allocation: 64;
  export const ZSTD_error_workSpace_tooSmall: 66;
  export const ZSTD_error_dstSize_tooSmall: 70;
  export const ZSTD_error_srcSize_wrong: 72;
  export const ZSTD_error_dstBuffer_null: 74;
  export const ZSTD_error_noForwardProgress_destFull: 80;
  export const ZSTD_error_noForwardProgress_inputEmpty: 82;
}
declare module "node:zlib" {
  export * from "zlib";
}

/* node:net — the inbound-networking slice (scr_net.c links only into
 * net-using binaries). TCP only, Node's shapes narrowed to what lowers:
 * createServer with an optional connection handler; listen(port[, cb])
 * with the real port discoverable as address().port (the composed read
 * is the lowered form — bare address() has no lowering); close([cb])
 * firing once connections drain; socket write/end/destroy/pipe and the
 * data/end/close/error/connect events (on and once — listeners take at
 * most the declared parameter). write/end return void here (Node returns
 * the backpressure boolean / the socket); on/once return void (chaining
 * is fenced). connect's host is a numeric IP or "localhost" (pinned to
 * 127.0.0.1 — SEMANTICS.md); every failure is the async 'error' event,
 * and an 'error' with no listener exits 1 like an unhandled EventEmitter
 * 'error'. */
declare module "net" {
  export interface Socket {
    /* Whether the socket keeps the event loop alive (ref'd by default). */
    ref(): void;
    unref(): void;
    readonly remoteAddress: string | undefined;
    /* The peer's fields are cached at first read, like remoteAddress; the
     * local ones are undefined while connecting and after close. */
    readonly remotePort: number | undefined;
    readonly remoteFamily: string | undefined;
    readonly localAddress: string | undefined;
    readonly localPort: number | undefined;
    readonly localFamily: string | undefined;
    readonly bytesRead: number;
    readonly connecting: boolean;
    readonly pending: boolean;
    readonly readyState: "opening" | "open" | "readOnly" | "writeOnly" | "closed";
    /* true once the fd is gone (destroy() or full close) — Node's flag. */
    readonly destroyed: boolean;
    /* the write half is open: no end() yet, no FIN sent, fd alive. */
    readonly writable: boolean;
    /* true until the read half is done (peer FIN / destroy). */
    readonly readable: boolean;
    /* every byte the write paths accepted (buffered included — Node
     * counts those too; plaintext on TLS sockets). */
    readonly bytesWritten: number;
    /* write's callback runs once the data is flushed, with null; end's
     * once the socket finishes. */
    write(data: string | Uint8Array, callback?: (err?: Error | null) => void): void;
    end(callback?: () => void): void;
    end(data: string | Uint8Array, callback?: () => void): void;
    destroy(): void;
    /* Flow control: pause holds reads off (kernel/TCP backpressure is
     * the buffer); resume flows — and discards without listeners, so
     * 'end' stays reachable. Both chain, Node's shape. */
    pause(): Socket;
    resume(): Socket;
    /* TCP_NODELAY on the live fd; missing means true. Chains. */
    setNoDelay(noDelay?: boolean): Socket;
    /* SO_KEEPALIVE with the initial delay in ms. Chains. */
    setKeepAlive(enable?: boolean, initialDelay?: number): Socket;
    /* end() now, destroy once the FIN actually flushed. */
    destroySoon(): void;
    /* An RST instead of a FIN; a connecting socket resets once it
     * connects. Throws ERR_INVALID_HANDLE_TYPE on a TLS socket. */
    resetAndDestroy(): Socket;
    /* The local address, or {} while connecting and once destroyed. */
    address(): AddressInfo | {};
    /* setEncoding('utf8'): 'data' delivers strings — the IncomingMessage
     * twin's contract. */
    setEncoding(encoding: string): void;
    /* socket→socket, and socket→response (the extended-CONNECT bridge
     * leg: raw chunks become response body writes; EOF ends it). */
    pipe(
      destination: Socket | import("http").ServerResponse | import("http2").Http2ServerResponse,
    ): void;
    /* The callback is a once('timeout') listener (removed again by 0). */
    setTimeout(ms: number, callback?: () => void): void;
    /* The paused-mode demux surface: once('readable') + read(1) +
     * unshift — read answers exactly n buffered bytes or null. */
    read(size?: number): Buffer | null;
    unshift(chunk: Uint8Array): void;
    /* secureConnect/session are TLS-socket events declared on the shared
     * socket surface (the lowering collapses TLSSocket onto this kind):
     * the runtime gates on the transport, so a plain socket's
     * registration never fires — Node's exact split. 'session' fires
     * once with the serialized session (the received-ticket event). */
    on(event: "data", listener: (chunk: Buffer) => void): void;
    /* After setEncoding the chunk is a string. */
    on(event: "data", listener: (chunk: string) => void): void;
    on(
      event: "end" | "connect" | "ready" | "timeout" | "readable" | "finish" | "secureConnect",
      listener: () => void,
    ): void;
    on(event: "close", listener: (hadError: boolean) => void): void;
    on(event: "error", listener: (err: Error) => void): void;
    on(event: "session", listener: (session: Buffer) => void): void;
    /* addListener IS on (Node aliases them) — the suite spells both. */
    addListener(event: "data", listener: (chunk: Buffer) => void): void;
    /* After setEncoding the chunk is a string. */
    addListener(event: "data", listener: (chunk: string) => void): void;
    addListener(
      event: "end" | "connect" | "ready" | "timeout" | "readable" | "finish" | "secureConnect",
      listener: () => void,
    ): void;
    addListener(event: "close", listener: (hadError: boolean) => void): void;
    addListener(event: "error", listener: (err: Error) => void): void;
    addListener(event: "session", listener: (session: Buffer) => void): void;
    once(event: "data", listener: (chunk: Buffer) => void): void;
    /* After setEncoding the chunk is a string. */
    once(event: "data", listener: (chunk: string) => void): void;
    once(
      event: "end" | "connect" | "ready" | "timeout" | "readable" | "finish" | "secureConnect",
      listener: () => void,
    ): void;
    once(event: "close", listener: (hadError: boolean) => void): void;
    once(event: "error", listener: (err: Error) => void): void;
    once(event: "session", listener: (session: Buffer) => void): void;
  }
  export interface Server {
    /* Whether the server keeps the event loop alive (ref'd by default). */
    ref(): void;
    unref(): void;
    readonly listening: boolean;
    /* Connections past this many are closed with a 'drop' event;
     * undefined (the default) or null lifts the cap. */
    maxConnections: number | undefined;
    /* Node reads it only in cluster mode: a stored value here. */
    dropMaxConnection: boolean | undefined;
    /* cb(null, count) on the next tick. */
    getConnections(callback: (error: Error | null, count: number) => void): Server;
    /* Node answers the server itself (`return this` chaining). */
    listen(port: number, callback?: () => void): Server;
    /* The positional bind address (the options form's host in argument
     * spelling). */
    listen(port: number, host: string, callback?: () => void): Server;
    /* The explicit-interface bind: host is an IP literal (absent = the
     * host-less dual-stack any); ipv6Only sets IPV6_V6ONLY and reusePort
     * requests kernel connection distribution where Node supports it. */
    listen(
      options: { port: number; host?: string; ipv6Only?: boolean; reusePort?: boolean },
      callback?: () => void,
    ): Server;
    close(callback?: () => void): void;
    /* The bound AddressInfo (Node answers null before listen — this
     * surface answers the record with port 0 there, the serverPort
     * stance). */
    address(): import("node:dgram").AddressInfo;
    /* The demux route: hand an accepted socket to another server. */
    emit(event: "connection", socket: Socket): boolean;
    on(event: "connection" | "secureConnection", listener: (socket: Socket) => void): void;
    on(event: "close" | "listening", listener: () => void): void;
    on(event: "drop", listener: (data?: DropArgument) => void): void;
    on(event: "timeout", listener: (socket: Socket) => void): void;
    on(event: "error", listener: (err: Error) => void): void;
    /* The WebSocket handover: fires INSTEAD of 'request' for
     * Connection: upgrade requests, with the raw socket + head bytes. */
    on(
      event: "upgrade",
      listener: (req: import("http").IncomingMessage, socket: Socket, head: Buffer) => void,
    ): void;
    /* http.createServer(handler)'s event twin (a no-parser net server
     * never fires it, like Node). */
    on(
      event: "request",
      listener: (req: import("http").IncomingMessage, res: import("http").ServerResponse) => void,
    ): void;
    /* addListener IS on (Node aliases them) — the suite spells both. */
    addListener(event: "connection" | "secureConnection", listener: (socket: Socket) => void): void;
    addListener(event: "close" | "listening", listener: () => void): void;
    addListener(event: "drop", listener: (data?: DropArgument) => void): void;
    addListener(event: "timeout", listener: (socket: Socket) => void): void;
    addListener(event: "error", listener: (err: Error) => void): void;
    addListener(
      event: "upgrade",
      listener: (req: import("http").IncomingMessage, socket: Socket, head: Buffer) => void,
    ): void;
    addListener(
      event: "request",
      listener: (req: import("http").IncomingMessage, res: import("http").ServerResponse) => void,
    ): void;
    once(event: "connection" | "secureConnection", listener: (socket: Socket) => void): void;
    once(event: "close" | "listening", listener: () => void): void;
    once(event: "drop", listener: (data?: DropArgument) => void): void;
    once(event: "timeout", listener: (socket: Socket) => void): void;
    once(event: "error", listener: (err: Error) => void): void;
    once(
      event: "upgrade",
      listener: (req: import("http").IncomingMessage, socket: Socket, head: Buffer) => void,
    ): void;
    once(
      event: "request",
      listener: (req: import("http").IncomingMessage, res: import("http").ServerResponse) => void,
    ): void;
  }
  /* The 'drop' payload: the turned-away connection's addresses. */
  export interface DropArgument {
    localAddress?: string;
    localPort?: number;
    localFamily?: string;
    remoteAddress?: string;
    remotePort?: number;
    remoteFamily?: string;
  }
  export type AddressInfo = import("node:dgram").AddressInfo;
  /* Node's IPv4Reg and IPv6Reg tests: 4, 6, or 0 for isIP. */
  export function isIP(input: string): number;
  export function isIPv4(input: string): boolean;
  export function isIPv6(input: string): boolean;
  /* The Socket VALUE — the `x instanceof net.Socket` narrowing target
   * (the h2 compat 'connect' listener's test). Constructing bare sockets
   * has no lowering; the construct signature exists for instanceof. */
  export const Socket: abstract new () => Socket;
  export function createServer(connectionListener?: (socket: Socket) => void): Server;
  export function connect(port: number, host?: string, connectListener?: () => void): Socket;
  export function createConnection(
    port: number,
    host?: string,
    connectListener?: () => void,
  ): Socket;
  /* The caller-resolver dial (@types/node's net.LookupFunction, narrowed
   * to the lowered shape): the runtime invokes it as Node does and dials
   * the answered addresses in order under autoSelectFamily: true. */
  export type LookupFunction = (
    hostname: string,
    options: unknown,
    callback: (
      err: NodeJS.ErrnoException | null,
      addresses: { address: string; family: number }[],
    ) => void,
  ) => void;
  export function connect(
    options: {
      port: number;
      host?: string;
      autoSelectFamily?: boolean;
      lookup?: LookupFunction;
    },
    connectListener?: () => void,
  ): Socket;
  export function createConnection(
    options: {
      port: number;
      host?: string;
      autoSelectFamily?: boolean;
      lookup?: LookupFunction;
    },
    connectListener?: () => void,
  ): Socket;
  /* The happy-eyeballs attempt budget (Node's process-wide knob; the
   * autoSelectFamily dial consults it): one runtime int, default 250ms
   * like Node's. */
  export function getDefaultAutoSelectFamilyAttemptTimeout(): number;
  export function setDefaultAutoSelectFamilyAttemptTimeout(value: number): void;
}
declare module "node:net" {
  export * from "net";
}

/* node:http — the SERVER and CLIENT slices (scr_http.c layers a
 * hand-written HTTP/1.1 parser + serializer on scr_net.c; both link only
 * into using binaries). createServer(handler) returns a net.Server —
 * listen/close/address().port/'error' are the same lowered surface. The
 * request carries url/method (always present on server requests),
 * statusCode (a number on client responses, undefined on server
 * requests), the underlying socket, and lowercased headers read as
 * `string | undefined`; the body streams through on("data"/"end"). The
 * response is setHeader/writeHead/write/end/destroy with Node's framing
 * (Content-Length for a single end(body), chunked after writeHead/write)
 * and the auto Date/Connection headers; writeHead's headers argument is
 * an object literal or a Record<string, string>. request/get dial one
 * connection per call (no agent pooling) with Node's exact wire head. */
declare module "http" {
  import { Server as NetServer, Socket } from "net";
  export const METHODS: string[];
  export const STATUS_CODES: { [status: number]: string | undefined };
  export const maxHeaderSize: number;
  export interface Server extends NetServer {
    timeout: number;
    setTimeout(msecs: number, callback?: (socket: Socket) => void): this;
    closeAllConnections(): void;
    closeIdleConnections(): void;
    keepAliveTimeout: number;
    keepAliveTimeoutBuffer: number;
    headersTimeout: number;
    requestTimeout: number;
  }
  export type RequestListener = (req: IncomingMessage, res: ServerResponse) => void;
  /* The Server VALUE — Node's constructor works with and without `new`
   * (test/parallel's http.Server(fn) spelling); both route to the
   * createServer lowering. */
  export const Server: {
    new (requestListener?: (req: IncomingMessage, res: ServerResponse) => void): Server;
    new (
      options: ServerOptions,
      requestListener?: (req: IncomingMessage, res: ServerResponse) => void,
    ): Server;
    (requestListener?: (req: IncomingMessage, res: ServerResponse) => void): Server;
    (
      options: ServerOptions,
      requestListener?: (req: IncomingMessage, res: ServerResponse) => void,
    ): Server;
  };
  /* The options-record stance (the RequestOptions precedent): every
   * documented key typechecks; the lowering's option walk decides per
   * key — requireHostHeader: false, joinDuplicateHeaders, and
   * keepAliveTimeoutBuffer lower,
   * documented-but-unlowered keys fence by name, unknown keys drop. */
  export interface ServerOptions {
    requireHostHeader?: boolean;
    joinDuplicateHeaders?: boolean;
    keepAliveTimeoutBuffer?: number;
    [option: string]: unknown;
  }
  /* The outgoing-header shape, @types/node's matrix: numbers format via
   * String(n), arrays write one line per element (set-cookie's shape).
   * Incoming headers stay `string | undefined` — what the parser answers
   * (under @types/node the two SLOTS unify so `{ ...req.headers }`
   * merges into outgoing literals as a copy; the fallback keeps reads
   * simple and spreads target the same string | undefined slot). */
  export type OutgoingHttpHeaders = { [name: string]: number | string | string[] | undefined };
  export interface IncomingMessage {
    readonly url: string;
    readonly method: string;
    readonly httpVersion: string;
    readonly complete: boolean;
    readonly aborted: boolean;
    readonly statusCode: number | undefined;
    readonly statusMessage: string | undefined;
    readonly socket: Socket;
    readonly connection: Socket;
    readonly headers: { [name: string]: string | undefined };
    readonly headersDistinct: { [name: string]: string[] | undefined };
    readonly rawHeaders: string[];
    readonly trailers: { [name: string]: string | undefined };
    readonly trailersDistinct: { [name: string]: string[] | undefined };
    readonly rawTrailers: string[];
    resume(): void;
    destroy(): void;
    setTimeout(msecs: number, callback?: () => void): this;
    /* setEncoding('utf8'): 'data' delivers strings (other real encodings
     * throw a "not supported yet" Error at runtime; unknown names throw
     * ERR_UNKNOWN_ENCODING). */
    setEncoding(encoding: string): void;
    /* The proxy legs: the body streams into a ServerResponse, a
     * ClientRequest, or a raw Socket; natural end ends the destination. */
    pipe(
      destination: ServerResponse | import("http2").Http2ServerResponse | ClientRequest | Socket,
    ): void;
    on(event: "data", listener: (chunk: any) => void): void;
    on(event: "end" | "close" | "aborted", listener: () => void): void;
    on(event: "error", listener: (err: Error) => void): void;
    /* addListener IS on (Node aliases them) — the suite spells both. */
    addListener(event: "data", listener: (chunk: any) => void): void;
    addListener(event: "end" | "close" | "aborted", listener: () => void): void;
    addListener(event: "error", listener: (err: Error) => void): void;
    once(event: "data", listener: (chunk: any) => void): void;
    once(event: "end" | "close" | "aborted", listener: () => void): void;
    once(event: "error", listener: (err: Error) => void): void;
  }
  export interface ServerResponse {
    readonly headersSent: boolean;
    readonly writableEnded: boolean;
    readonly finished: boolean;
    readonly writableFinished: boolean;
    readonly writableCorked: number;
    readonly req: IncomingMessage;
    readonly socket: Socket | null;
    readonly connection: Socket | null;
    sendDate: boolean;
    strictContentLength: boolean;
    /* Node's writable head properties: the implicit head reads them. */
    statusCode: number;
    statusMessage: string | undefined;
    /* The value keeps its type: getHeader answers the number, string or
     * array that was set. */
    setHeader(name: string, value: number | string | readonly string[]): void;
    appendHeader(name: string, value: string | readonly string[]): void;
    getHeader(name: string): number | string | string[] | undefined;
    getHeaderNames(): string[];
    getRawHeaderNames(): string[];
    getHeaders(): OutgoingHttpHeaders;
    hasHeader(name: string): boolean;
    removeHeader(name: string): void;
    /* Both overloads answer the response (`return this` chaining); the
     * headers argument also takes Node's flat [name, value, ...] array. */
    writeHead(statusCode: number, headers?: OutgoingHttpHeaders | string[]): ServerResponse;
    writeHead(
      statusCode: number,
      statusMessage: string,
      headers?: OutgoingHttpHeaders | string[],
    ): ServerResponse;
    writeContinue(callback?: () => void): void;
    writeProcessing(callback?: () => void): void;
    writeEarlyHints(hints: Record<string, string | string[]>, callback?: () => void): void;
    write(data: string | Uint8Array): void;
    flushHeaders(): void;
    cork(): void;
    uncork(): void;
    addTrailers(headers: OutgoingHttpHeaders | ReadonlyArray<[string, string]>): void;
    setTimeout(msecs: number, callback?: () => void): this;
    /* end's callback forms fire once the body went out (the 'finish'
     * emit, deferred past the handler's synchronous tail). */
    end(data?: string | Uint8Array, callback?: () => void): void;
    end(callback: () => void): void;
    destroy(): void;
    on(event: "close" | "finish", listener: () => void): void;
    /* addListener IS on (Node aliases them) — the suite spells both. */
    addListener(event: "close" | "finish", listener: () => void): void;
    once(event: "close" | "finish", listener: () => void): void;
  }
  /* The CLIENT slice (http.request/http.get): the options-object form
   * with hostname/host, port, path, method, timeout, and headers; the
   * callback receives the response as an IncomingMessage (statusCode,
   * headers, body via on("data"/"end")). */
  export interface RequestOptions {
    hostname?: string;
    host?: string;
    port?: number;
    path?: string;
    method?: string;
    timeout?: number;
    headers?: OutgoingHttpHeaders;
    /* The caller's own dialer (the proxy's loopback dial): invoked once,
     * synchronously; its socket carries the exchange. */
    createConnection?: () => Socket;
    /* agent: false is a one-shot dial with Connection: close — exactly
     * the compiled client's model; null/undefined are the default; an
     * Agent VALUE threads through (getName-keyed maxSockets accounting
     * over one-dial-per-request connections). */
    agent?: Agent | boolean | null;
    /* The options-record stance: Node ignores an options record's
     * unknown keys, so every key typechecks here — the option WALK in
     * the lowering decides per key (lower, fence by name, or drop
     * undocumented keys exactly like Node). */
    [option: string]: unknown;
  }
  /* The Agent lowers to a checked-dynamic HANDLE: option parsing at the
   * literal construction site, getName, destroy, the sockets/requests/
   * freeSockets snapshots, and REAL maxSockets accounting (over-limit
   * requests defer their dial and queue). keepAlive: true throws the
   * named pooling fence — this client dials one connection per request
   * and closes it with the response, so freeSockets is always
   * empty. */
  export interface AgentOptions {
    keepAlive?: boolean;
    keepAliveMsecs?: number;
    maxSockets?: number;
    maxFreeSockets?: number;
    maxTotalSockets?: number;
    scheduling?: string;
    timeout?: number;
    port?: number;
    [option: string]: unknown;
  }
  export class Agent {
    constructor(options?: AgentOptions);
    destroy(): void;
    /* Node's exact key shape: host:port:localAddress[:family][:socketPath]. */
    getName(options?: {
      host?: string;
      port?: number;
      localAddress?: string;
      family?: number;
      socketPath?: string;
      [option: string]: unknown;
    }): string;
    maxSockets: number;
    maxFreeSockets: number;
    keepAliveMsecs: number;
    readonly keepAlive: boolean;
    readonly protocol: string;
    /* Settable — a portless request through this agent dials it (Node's
     * option merge). */
    defaultPort: number;
    readonly totalSocketCount: number;
    readonly sockets: { [key: string]: unknown[] };
    readonly freeSockets: { [key: string]: unknown[] };
    readonly requests: { [key: string]: unknown[] };
  }
  export const globalAgent: Agent;
  export interface ClientRequest {
    readonly destroyed: boolean;
    readonly aborted: boolean;
    readonly socket: Socket;
    readonly connection: Socket;
    readonly writableCorked: number;
    readonly method: string;
    readonly path: string;
    readonly host: string;
    readonly protocol: string;
    readonly headersSent: boolean;
    readonly writableEnded: boolean;
    readonly writableFinished: boolean;
    readonly finished: boolean;
    readonly reusedSocket: boolean;
    setHeader(name: string, value: string): void;
    getHeader(name: string): string | undefined;
    hasHeader(name: string): boolean;
    removeHeader(name: string): void;
    getHeaderNames(): string[];
    getRawHeaderNames(): string[];
    getHeaders(): OutgoingHttpHeaders;
    flushHeaders(): void;
    addTrailers(headers: OutgoingHttpHeaders | ReadonlyArray<[string, string]>): void;
    cork(): void;
    uncork(): void;
    setNoDelay(noDelay?: boolean): void;
    setSocketKeepAlive(enable?: boolean, initialDelay?: number): void;
    setTimeout(timeout: number, callback?: () => void): this;
    write(data: string | Uint8Array): void;
    end(data?: string | Uint8Array): void;
    destroy(): void;
    abort(): void;
    on(event: "response", listener: (res: IncomingMessage) => void): void;
    on(event: "socket", listener: (socket: Socket) => void): void;
    on(
      event: "upgrade",
      listener: (res: IncomingMessage, socket: Socket, head: Buffer) => void,
    ): void;
    on(event: "timeout" | "close" | "finish" | "abort", listener: () => void): void;
    on(event: "error", listener: (err: Error) => void): void;
    /* addListener IS on (Node aliases them) — the suite spells both. */
    addListener(event: "response", listener: (res: IncomingMessage) => void): void;
    addListener(event: "socket", listener: (socket: Socket) => void): void;
    addListener(
      event: "upgrade",
      listener: (res: IncomingMessage, socket: Socket, head: Buffer) => void,
    ): void;
    addListener(event: "timeout" | "close" | "finish" | "abort", listener: () => void): void;
    addListener(event: "error", listener: (err: Error) => void): void;
    once(event: "response", listener: (res: IncomingMessage) => void): void;
    once(event: "socket", listener: (socket: Socket) => void): void;
    once(
      event: "upgrade",
      listener: (res: IncomingMessage, socket: Socket, head: Buffer) => void,
    ): void;
    once(event: "timeout" | "close" | "finish" | "abort", listener: () => void): void;
    once(event: "error", listener: (err: Error) => void): void;
  }
  export function createServer(
    requestListener?: (req: IncomingMessage, res: ServerResponse) => void,
  ): Server;
  export function createServer(
    options: ServerOptions,
    requestListener?: (req: IncomingMessage, res: ServerResponse) => void,
  ): Server;
  /* One signature with a UNION first parameter rather than Node's two
   * overloads: `const requestFn = tls ? https.request : http.request`
   * (the portless isProxyRunning shape) unions two function types, and
   * resolving a call on that union collapses each constituent to a
   * single signature — with an overload SET on both sides the options
   * literal ends up checked against URL, in either declaration order.
   * A union parameter has nothing to collapse. The lowering dispatches
   * on the argument's own type, so it reads the same either way.
   *
   * `target` is a URL string or URL object (the spelling a from-scratch
   * client reaches for first — dialed directly, with a non-http scheme
   * an ERR_INVALID_PROTOCOL at runtime rather than a type error), or
   * the options record. */
  export function request(
    target: RequestOptions | string | URL,
    callback?: (res: IncomingMessage) => void,
  ): ClientRequest;
  export function get(
    target: RequestOptions | string | URL,
    callback?: (res: IncomingMessage) => void,
  ): ClientRequest;
  export function validateHeaderName(name: string, label?: string): void;
  export function validateHeaderValue(name: string, value: unknown): void;
}
declare module "node:http" {
  export * from "http";
}

/* node:tls — the TLS server slice (scr_tls.c over scr_net.c with the
 * vendored mbedTLS; linked only into using binaries).
 * createServer({ cert, key }, handler) returns a net.Server; the handler
 * is Node's 'secureConnection' — it fires post-handshake with a socket
 * that behaves exactly like a net socket (write/end/destroy/pipe and the
 * data/end/close/error events are the same lowered surface). cert/key
 * are PEM strings or Buffers. Handshake failures tear the socket down
 * without emitting an event, Node's default for 'tlsClientError' with no listener. */
declare module "tls" {
  import { Server, Socket } from "net";
  export { Server };
  export interface TlsOptions {
    /* Optional in the DECLARATION only (real Node programs build these
     * literals with every TLS knob): the lowering still requires both —
     * a literal without them fences at the call site. */
    cert?: string | Uint8Array;
    key?: string | Uint8Array;
    /* The options-record stance (see http.RequestOptions): every key
     * typechecks; the option walk fences documented-but-unlowered keys
     * by name and drops undocumented ones like Node. */
    [option: string]: unknown;
  }
  export function createServer(
    options: TlsOptions,
    secureConnectionListener?: (socket: TLSSocket) => void,
  ): Server;
  /** TLSSocket — post-handshake it IS a net socket to every lowered
   * member (the mapping collapses it onto the socket kind; the
   * secureConnect/session events ride the shared socket declarations).
   * The TLS extras: authorized/authorizationError answer Node's verify
   * split — authorizationError is the verify-failure CODE STRING
   * (DEPTH_ZERO_SELF_SIGNED_CERT, ...), or null. */
  export interface TLSSocket extends Socket {
    authorized: boolean;
    authorizationError: string | null;
    /* null before the handshake, then the negotiated protocol or false */
    readonly alpnProtocol: string | false | null;
    /* "TLSv1.2" or "TLSv1.3"; null before the handshake and after close */
    getProtocol(): string | null;
    /* OpenSSL's suite name, the IANA name and the suite's version */
    getCipher(): CipherNameAndProtocol;
  }
  export interface CipherNameAndProtocol {
    name: string;
    standardName: string;
    version: string;
  }
  export const DEFAULT_MIN_VERSION: string;
  export const DEFAULT_MAX_VERSION: string;
  /** tls.connect options — the RUNTIME options record (members read at
   * runtime; port/host/rejectUnauthorized/ca/servername are the
   * honestly-implemented set, every other documented member throws the
   * runtime fence — the options-record stance's divergence-66 shape). */
  export interface ConnectionOptions {
    port?: number;
    host?: string;
    rejectUnauthorized?: boolean;
    ca?: string | Uint8Array | ReadonlyArray<string | Uint8Array>;
    servername?: string;
    [option: string]: unknown;
  }
  export function connect(
    options: ConnectionOptions,
    secureConnectListener?: () => void,
  ): TLSSocket;
  export function connect(
    port: number,
    options?: ConnectionOptions,
    secureConnectListener?: () => void,
  ): TLSSocket;
  export function connect(
    port: number,
    host?: string,
    options?: ConnectionOptions,
    secureConnectListener?: () => void,
  ): TLSSocket;
  /** An opaque parsed cert/key pair — what an SNI callback answers with
   * (the value is a runtime handle; the members are runtime-internal). */
  export interface SecureContext {}
  export function createSecureContext(options: TlsOptions): SecureContext;
  /** The CA-store introspection surface (scr_tls_ca.c): per-type cached
   * PEM string arrays. The host bundle stands in for Node's compiled-in
   * Mozilla roots ('bundled', and rootCertificates) AND the platform
   * store ('system') — the Windows certificate stores or POSIX bundle probe;
   * 'extra' reads NODE_EXTRA_CA_CERTS. An unknown type string throws
   * Node's ERR_INVALID_ARG_VALUE TypeError. */
  export function getCACertificates(type?: string): string[];
  export const rootCertificates: readonly string[];
  /** Replaces the 'default' set (deduped) and the trust anchors the TLS
   * client verifies against; a certificate-free non-empty array throws
   * Node's ERR_CRYPTO_OPERATION_FAILED Error. */
  export function setDefaultCACertificates(certs: readonly string[]): void;
}
declare module "node:tls" {
  export * from "tls";
}

/* node:https — http over the TLS transport (scr_tls.c).
 * createServer({ cert, key }, handler) is the http server behind a
 * handshake; request/get are the http client with port 443 default and
 * the local-CA knobs: `ca` (PEM string/Buffer) replaces the trust
 * anchors, rejectUnauthorized: false disables verification (the
 * self-signed probe shape). With neither, /etc/ssl/cert.pem stands in
 * for Node's bundled roots. */
declare module "https" {
  import { Server } from "http";
  import { Agent, ClientRequest, IncomingMessage, ServerResponse } from "http";
  export { Agent, Server };
  export interface ServerOptions {
    cert: string | Uint8Array;
    key: string | Uint8Array;
    /* The options-record stance (see http.RequestOptions). */
    [option: string]: unknown;
  }
  export interface RequestOptions {
    hostname?: string;
    host?: string;
    port?: number;
    path?: string;
    method?: string;
    timeout?: number;
    headers?: { [name: string]: string };
    rejectUnauthorized?: boolean;
    ca?: string | Uint8Array;
    agent?: Agent | boolean | null;
    /* The options-record stance (see http.RequestOptions). */
    [option: string]: unknown;
  }
  export function createServer(
    options: ServerOptions,
    requestListener: (req: IncomingMessage, res: ServerResponse) => void,
  ): Server;
  /* One signature with a union first parameter, for the request-fn
   * ternary's sake (see the http block). A URL target takes no options,
   * which means Node's defaults — the certificate is verified against
   * the default trust anchors. */
  export function request(
    target: RequestOptions | string | URL,
    callback?: (res: IncomingMessage) => void,
  ): ClientRequest;
  export function get(
    target: RequestOptions | string | URL,
    callback?: (res: IncomingMessage) => void,
  ): ClientRequest;
}
declare module "node:https" {
  export * from "https";
}

/* node:http2 — the compatibility surface: allowHTTP1 servers negotiate
 * h2 or HTTP/1.1 and expose the shared request/response API. HTTP/2
 * requests retain their backing stream; server session failures surface
 * through sessionError. */
declare module "http2" {
  import { Socket } from "net";
  export interface Http2Stream {
    on(event: "error" | "close", listener: (err: Error) => void): void;
    once(event: "error" | "close", listener: (err: Error) => void): void;
    destroy(): void;
  }
  export interface Http2ServerRequest {
    readonly url: string;
    readonly method: string;
    readonly statusCode: number | undefined;
    readonly socket: Socket;
    readonly headers: { [name: string]: string | undefined };
    readonly stream: Http2Stream;
    /* The h2 compat request's version triple ("2.0" over real h2 streams;
     * the allowHTTP1 lowering's HTTP/1.1 connections answer 1.x). */
    readonly httpVersion: string;
    readonly httpVersionMajor: number;
    readonly httpVersionMinor: number;
    readonly aborted: boolean;
    readonly complete: boolean;
    resume(): void;
    destroy(): void;
    setEncoding(encoding: string): void;
    pipe(destination: Socket | import("http").ClientRequest): void;
    on(event: "data", listener: (chunk: Buffer) => void): void;
    on(event: "end" | "close" | "aborted", listener: () => void): void;
    on(event: "error", listener: (err: Error) => void): void;
    /* addListener IS on (Node aliases them) — and the compat req IS the
     * http.IncomingMessage surface, so the alias mirrors here too. */
    addListener(event: "data", listener: (chunk: Buffer) => void): void;
    addListener(event: "end" | "close" | "aborted", listener: () => void): void;
    addListener(event: "error", listener: (err: Error) => void): void;
    once(event: "data", listener: (chunk: Buffer) => void): void;
    once(event: "end" | "close" | "aborted", listener: () => void): void;
    once(event: "error", listener: (err: Error) => void): void;
  }
  export interface Http2ServerResponse {
    readonly headersSent: boolean;
    readonly writableEnded: boolean;
    readonly writableCorked: number;
    /* The same lowered surface as http.ServerResponse — the allowHTTP1
     * lowering serves every connection as HTTP/1.1, where the compat
     * response IS this parser's response handle. */
    statusCode: number;
    statusMessage: string;
    setHeader(name: string, value: string | number): void;
    getHeader(name: string): string | undefined;
    getHeaderNames(): string[];
    getRawHeaderNames(): string[];
    getHeaders(): import("http").OutgoingHttpHeaders;
    hasHeader(name: string): boolean;
    removeHeader(name: string): void;
    writeHead(
      statusCode: number,
      headers?: import("http").OutgoingHttpHeaders | string[],
    ): Http2ServerResponse;
    writeHead(
      statusCode: number,
      statusMessage: string,
      headers?: import("http").OutgoingHttpHeaders | string[],
    ): Http2ServerResponse;
    writeContinue(): void;
    writeEarlyHints(hints: Record<string, string | string[]>): void;
    write(data: string | Uint8Array): void;
    flushHeaders(): void;
    cork(): void;
    uncork(): void;
    addTrailers(
      headers: import("http").OutgoingHttpHeaders | ReadonlyArray<[string, string]>,
    ): void;
    end(data?: string | Uint8Array, callback?: () => void): void;
    end(callback: () => void): void;
    destroy(): void;
    on(event: "close", listener: () => void): void;
    /* addListener IS on (Node aliases them) — and the compat res IS the
     * http.ServerResponse surface (assignability into ServerResponse
     * unions — IncomingMessage.pipe's destination — needs the alias). */
    addListener(event: "close", listener: () => void): void;
    once(event: "close", listener: () => void): void;
  }
  export interface Http2SecureServer {
    listen(port: number, callback?: () => void): void;
    close(callback?: () => void): void;
    /* The bound AddressInfo (Node answers null before listen — this
     * surface answers the record with port 0 there, the serverPort
     * stance). */
    address(): import("node:dgram").AddressInfo;
    emit(event: "connection", socket: Socket): void;
    on(event: "connection", listener: (socket: Socket) => void): void;
    on(
      event: "request",
      listener: (req: Http2ServerRequest, res: Http2ServerResponse) => void,
    ): void;
    on(event: "error", listener: (err: Error) => void): void;
    on(event: "close", listener: () => void): void;
    on(event: "sessionError", listener: (err: Error, session: ServerHttp2Session) => void): void;
    /* The ALPN=h2 server's surface (createSecureServer WITHOUT
     * allowHTTP1 — the real h2-over-TLS stack): per-stream and
     * per-session listeners, exactly the h2c server's. */
    on(
      event: "stream",
      listener: (stream: ServerHttp2Stream, headers: IncomingHttpHeaders, flags: number) => void,
    ): void;
    on(event: "session", listener: (session: ServerHttp2Session) => void): void;
    once(
      event: "stream",
      listener: (stream: ServerHttp2Stream, headers: IncomingHttpHeaders, flags: number) => void,
    ): void;
    once(event: "session", listener: (session: ServerHttp2Session) => void): void;
    /* HTTP CONNECT (and, in Node, the h2 extended CONNECT — which the
     * allowHTTP1 lowering never sees): the second argument is the raw
     * socket on HTTP/1.1 connections; narrow with instanceof. */
    on(
      event: "connect",
      listener: (
        req: Http2ServerRequest | import("http").IncomingMessage,
        resOrSocket: Http2ServerResponse | Socket,
      ) => void,
    ): void;
    once(event: "connection", listener: (socket: Socket) => void): void;
    once(
      event: "request",
      listener: (req: Http2ServerRequest, res: Http2ServerResponse) => void,
    ): void;
    once(event: "error", listener: (err: Error) => void): void;
    once(event: "close", listener: () => void): void;
  }
  export interface SecureServerOptions {
    allowHTTP1?: boolean;
    cert?: string | Uint8Array;
    key?: string | Uint8Array;
    SNICallback?: (
      servername: string,
      cb: (err: Error | null, ctx?: import("tls").SecureContext) => void,
    ) => void;
    /* The options-record stance (see http.RequestOptions): h2 session-
     * tuning knobs are accepted as literals and ignored (no h2 session
     * ever exists under the allowHTTP1 lowering); other documented keys
     * fence by name; undocumented keys drop like Node. */
    [option: string]: unknown;
  }
  /* The full Node v24 constants table (240 members), literal-typed so
   * computed header keys ([HTTP2_HEADER_PATH]: value) stay literal keys.
   * Every ACCESS bakes as its literal at lowering; the object itself
   * never materializes (bare http2.constants value uses fence). */
  export interface Http2Constants {
    readonly NGHTTP2_ERR_FRAME_SIZE_ERROR: -522;
    readonly NGHTTP2_SESSION_SERVER: 0;
    readonly NGHTTP2_SESSION_CLIENT: 1;
    readonly NGHTTP2_STREAM_STATE_IDLE: 1;
    readonly NGHTTP2_STREAM_STATE_OPEN: 2;
    readonly NGHTTP2_STREAM_STATE_RESERVED_LOCAL: 3;
    readonly NGHTTP2_STREAM_STATE_RESERVED_REMOTE: 4;
    readonly NGHTTP2_STREAM_STATE_HALF_CLOSED_LOCAL: 5;
    readonly NGHTTP2_STREAM_STATE_HALF_CLOSED_REMOTE: 6;
    readonly NGHTTP2_STREAM_STATE_CLOSED: 7;
    readonly NGHTTP2_FLAG_NONE: 0;
    readonly NGHTTP2_FLAG_END_STREAM: 1;
    readonly NGHTTP2_FLAG_END_HEADERS: 4;
    readonly NGHTTP2_FLAG_ACK: 1;
    readonly NGHTTP2_FLAG_PADDED: 8;
    readonly NGHTTP2_FLAG_PRIORITY: 32;
    readonly DEFAULT_SETTINGS_HEADER_TABLE_SIZE: 4096;
    readonly DEFAULT_SETTINGS_ENABLE_PUSH: 1;
    readonly DEFAULT_SETTINGS_MAX_CONCURRENT_STREAMS: 4294967295;
    readonly DEFAULT_SETTINGS_INITIAL_WINDOW_SIZE: 65535;
    readonly DEFAULT_SETTINGS_MAX_FRAME_SIZE: 16384;
    readonly DEFAULT_SETTINGS_MAX_HEADER_LIST_SIZE: 65535;
    readonly DEFAULT_SETTINGS_ENABLE_CONNECT_PROTOCOL: 0;
    readonly MAX_MAX_FRAME_SIZE: 16777215;
    readonly MIN_MAX_FRAME_SIZE: 16384;
    readonly MAX_INITIAL_WINDOW_SIZE: 2147483647;
    readonly NGHTTP2_SETTINGS_HEADER_TABLE_SIZE: 1;
    readonly NGHTTP2_SETTINGS_ENABLE_PUSH: 2;
    readonly NGHTTP2_SETTINGS_MAX_CONCURRENT_STREAMS: 3;
    readonly NGHTTP2_SETTINGS_INITIAL_WINDOW_SIZE: 4;
    readonly NGHTTP2_SETTINGS_MAX_FRAME_SIZE: 5;
    readonly NGHTTP2_SETTINGS_MAX_HEADER_LIST_SIZE: 6;
    readonly NGHTTP2_SETTINGS_ENABLE_CONNECT_PROTOCOL: 8;
    readonly PADDING_STRATEGY_NONE: 0;
    readonly PADDING_STRATEGY_ALIGNED: 1;
    readonly PADDING_STRATEGY_MAX: 2;
    readonly PADDING_STRATEGY_CALLBACK: 1;
    readonly NGHTTP2_NO_ERROR: 0;
    readonly NGHTTP2_PROTOCOL_ERROR: 1;
    readonly NGHTTP2_INTERNAL_ERROR: 2;
    readonly NGHTTP2_FLOW_CONTROL_ERROR: 3;
    readonly NGHTTP2_SETTINGS_TIMEOUT: 4;
    readonly NGHTTP2_STREAM_CLOSED: 5;
    readonly NGHTTP2_FRAME_SIZE_ERROR: 6;
    readonly NGHTTP2_REFUSED_STREAM: 7;
    readonly NGHTTP2_CANCEL: 8;
    readonly NGHTTP2_COMPRESSION_ERROR: 9;
    readonly NGHTTP2_CONNECT_ERROR: 10;
    readonly NGHTTP2_ENHANCE_YOUR_CALM: 11;
    readonly NGHTTP2_INADEQUATE_SECURITY: 12;
    readonly NGHTTP2_HTTP_1_1_REQUIRED: 13;
    readonly NGHTTP2_DEFAULT_WEIGHT: 16;
    readonly HTTP2_HEADER_STATUS: ":status";
    readonly HTTP2_HEADER_METHOD: ":method";
    readonly HTTP2_HEADER_AUTHORITY: ":authority";
    readonly HTTP2_HEADER_SCHEME: ":scheme";
    readonly HTTP2_HEADER_PATH: ":path";
    readonly HTTP2_HEADER_PROTOCOL: ":protocol";
    readonly HTTP2_HEADER_ACCEPT_ENCODING: "accept-encoding";
    readonly HTTP2_HEADER_ACCEPT_LANGUAGE: "accept-language";
    readonly HTTP2_HEADER_ACCEPT_RANGES: "accept-ranges";
    readonly HTTP2_HEADER_ACCEPT: "accept";
    readonly HTTP2_HEADER_ACCESS_CONTROL_ALLOW_CREDENTIALS: "access-control-allow-credentials";
    readonly HTTP2_HEADER_ACCESS_CONTROL_ALLOW_HEADERS: "access-control-allow-headers";
    readonly HTTP2_HEADER_ACCESS_CONTROL_ALLOW_METHODS: "access-control-allow-methods";
    readonly HTTP2_HEADER_ACCESS_CONTROL_ALLOW_ORIGIN: "access-control-allow-origin";
    readonly HTTP2_HEADER_ACCESS_CONTROL_EXPOSE_HEADERS: "access-control-expose-headers";
    readonly HTTP2_HEADER_ACCESS_CONTROL_REQUEST_HEADERS: "access-control-request-headers";
    readonly HTTP2_HEADER_ACCESS_CONTROL_REQUEST_METHOD: "access-control-request-method";
    readonly HTTP2_HEADER_AGE: "age";
    readonly HTTP2_HEADER_AUTHORIZATION: "authorization";
    readonly HTTP2_HEADER_CACHE_CONTROL: "cache-control";
    readonly HTTP2_HEADER_CONNECTION: "connection";
    readonly HTTP2_HEADER_CONTENT_DISPOSITION: "content-disposition";
    readonly HTTP2_HEADER_CONTENT_ENCODING: "content-encoding";
    readonly HTTP2_HEADER_CONTENT_LENGTH: "content-length";
    readonly HTTP2_HEADER_CONTENT_TYPE: "content-type";
    readonly HTTP2_HEADER_COOKIE: "cookie";
    readonly HTTP2_HEADER_DATE: "date";
    readonly HTTP2_HEADER_ETAG: "etag";
    readonly HTTP2_HEADER_FORWARDED: "forwarded";
    readonly HTTP2_HEADER_HOST: "host";
    readonly HTTP2_HEADER_IF_MODIFIED_SINCE: "if-modified-since";
    readonly HTTP2_HEADER_IF_NONE_MATCH: "if-none-match";
    readonly HTTP2_HEADER_IF_RANGE: "if-range";
    readonly HTTP2_HEADER_LAST_MODIFIED: "last-modified";
    readonly HTTP2_HEADER_LINK: "link";
    readonly HTTP2_HEADER_LOCATION: "location";
    readonly HTTP2_HEADER_RANGE: "range";
    readonly HTTP2_HEADER_REFERER: "referer";
    readonly HTTP2_HEADER_SERVER: "server";
    readonly HTTP2_HEADER_SET_COOKIE: "set-cookie";
    readonly HTTP2_HEADER_STRICT_TRANSPORT_SECURITY: "strict-transport-security";
    readonly HTTP2_HEADER_TRANSFER_ENCODING: "transfer-encoding";
    readonly HTTP2_HEADER_TE: "te";
    readonly HTTP2_HEADER_UPGRADE_INSECURE_REQUESTS: "upgrade-insecure-requests";
    readonly HTTP2_HEADER_UPGRADE: "upgrade";
    readonly HTTP2_HEADER_USER_AGENT: "user-agent";
    readonly HTTP2_HEADER_VARY: "vary";
    readonly HTTP2_HEADER_X_CONTENT_TYPE_OPTIONS: "x-content-type-options";
    readonly HTTP2_HEADER_X_FRAME_OPTIONS: "x-frame-options";
    readonly HTTP2_HEADER_KEEP_ALIVE: "keep-alive";
    readonly HTTP2_HEADER_PROXY_CONNECTION: "proxy-connection";
    readonly HTTP2_HEADER_X_XSS_PROTECTION: "x-xss-protection";
    readonly HTTP2_HEADER_ALT_SVC: "alt-svc";
    readonly HTTP2_HEADER_CONTENT_SECURITY_POLICY: "content-security-policy";
    readonly HTTP2_HEADER_EARLY_DATA: "early-data";
    readonly HTTP2_HEADER_EXPECT_CT: "expect-ct";
    readonly HTTP2_HEADER_ORIGIN: "origin";
    readonly HTTP2_HEADER_PURPOSE: "purpose";
    readonly HTTP2_HEADER_TIMING_ALLOW_ORIGIN: "timing-allow-origin";
    readonly HTTP2_HEADER_X_FORWARDED_FOR: "x-forwarded-for";
    readonly HTTP2_HEADER_PRIORITY: "priority";
    readonly HTTP2_HEADER_ACCEPT_CHARSET: "accept-charset";
    readonly HTTP2_HEADER_ACCESS_CONTROL_MAX_AGE: "access-control-max-age";
    readonly HTTP2_HEADER_ALLOW: "allow";
    readonly HTTP2_HEADER_CONTENT_LANGUAGE: "content-language";
    readonly HTTP2_HEADER_CONTENT_LOCATION: "content-location";
    readonly HTTP2_HEADER_CONTENT_MD5: "content-md5";
    readonly HTTP2_HEADER_CONTENT_RANGE: "content-range";
    readonly HTTP2_HEADER_DNT: "dnt";
    readonly HTTP2_HEADER_EXPECT: "expect";
    readonly HTTP2_HEADER_EXPIRES: "expires";
    readonly HTTP2_HEADER_FROM: "from";
    readonly HTTP2_HEADER_IF_MATCH: "if-match";
    readonly HTTP2_HEADER_IF_UNMODIFIED_SINCE: "if-unmodified-since";
    readonly HTTP2_HEADER_MAX_FORWARDS: "max-forwards";
    readonly HTTP2_HEADER_PREFER: "prefer";
    readonly HTTP2_HEADER_PROXY_AUTHENTICATE: "proxy-authenticate";
    readonly HTTP2_HEADER_PROXY_AUTHORIZATION: "proxy-authorization";
    readonly HTTP2_HEADER_REFRESH: "refresh";
    readonly HTTP2_HEADER_RETRY_AFTER: "retry-after";
    readonly HTTP2_HEADER_TRAILER: "trailer";
    readonly HTTP2_HEADER_TK: "tk";
    readonly HTTP2_HEADER_VIA: "via";
    readonly HTTP2_HEADER_WARNING: "warning";
    readonly HTTP2_HEADER_WWW_AUTHENTICATE: "www-authenticate";
    readonly HTTP2_HEADER_HTTP2_SETTINGS: "http2-settings";
    readonly HTTP2_METHOD_ACL: "ACL";
    readonly HTTP2_METHOD_BASELINE_CONTROL: "BASELINE-CONTROL";
    readonly HTTP2_METHOD_BIND: "BIND";
    readonly HTTP2_METHOD_CHECKIN: "CHECKIN";
    readonly HTTP2_METHOD_CHECKOUT: "CHECKOUT";
    readonly HTTP2_METHOD_CONNECT: "CONNECT";
    readonly HTTP2_METHOD_COPY: "COPY";
    readonly HTTP2_METHOD_DELETE: "DELETE";
    readonly HTTP2_METHOD_GET: "GET";
    readonly HTTP2_METHOD_HEAD: "HEAD";
    readonly HTTP2_METHOD_LABEL: "LABEL";
    readonly HTTP2_METHOD_LINK: "LINK";
    readonly HTTP2_METHOD_LOCK: "LOCK";
    readonly HTTP2_METHOD_MERGE: "MERGE";
    readonly HTTP2_METHOD_MKACTIVITY: "MKACTIVITY";
    readonly HTTP2_METHOD_MKCALENDAR: "MKCALENDAR";
    readonly HTTP2_METHOD_MKCOL: "MKCOL";
    readonly HTTP2_METHOD_MKREDIRECTREF: "MKREDIRECTREF";
    readonly HTTP2_METHOD_MKWORKSPACE: "MKWORKSPACE";
    readonly HTTP2_METHOD_MOVE: "MOVE";
    readonly HTTP2_METHOD_OPTIONS: "OPTIONS";
    readonly HTTP2_METHOD_ORDERPATCH: "ORDERPATCH";
    readonly HTTP2_METHOD_PATCH: "PATCH";
    readonly HTTP2_METHOD_POST: "POST";
    readonly HTTP2_METHOD_PRI: "PRI";
    readonly HTTP2_METHOD_PROPFIND: "PROPFIND";
    readonly HTTP2_METHOD_PROPPATCH: "PROPPATCH";
    readonly HTTP2_METHOD_PUT: "PUT";
    readonly HTTP2_METHOD_REBIND: "REBIND";
    readonly HTTP2_METHOD_REPORT: "REPORT";
    readonly HTTP2_METHOD_SEARCH: "SEARCH";
    readonly HTTP2_METHOD_TRACE: "TRACE";
    readonly HTTP2_METHOD_UNBIND: "UNBIND";
    readonly HTTP2_METHOD_UNCHECKOUT: "UNCHECKOUT";
    readonly HTTP2_METHOD_UNLINK: "UNLINK";
    readonly HTTP2_METHOD_UNLOCK: "UNLOCK";
    readonly HTTP2_METHOD_UPDATE: "UPDATE";
    readonly HTTP2_METHOD_UPDATEREDIRECTREF: "UPDATEREDIRECTREF";
    readonly HTTP2_METHOD_VERSION_CONTROL: "VERSION-CONTROL";
    readonly HTTP_STATUS_CONTINUE: 100;
    readonly HTTP_STATUS_SWITCHING_PROTOCOLS: 101;
    readonly HTTP_STATUS_PROCESSING: 102;
    readonly HTTP_STATUS_EARLY_HINTS: 103;
    readonly HTTP_STATUS_OK: 200;
    readonly HTTP_STATUS_CREATED: 201;
    readonly HTTP_STATUS_ACCEPTED: 202;
    readonly HTTP_STATUS_NON_AUTHORITATIVE_INFORMATION: 203;
    readonly HTTP_STATUS_NO_CONTENT: 204;
    readonly HTTP_STATUS_RESET_CONTENT: 205;
    readonly HTTP_STATUS_PARTIAL_CONTENT: 206;
    readonly HTTP_STATUS_MULTI_STATUS: 207;
    readonly HTTP_STATUS_ALREADY_REPORTED: 208;
    readonly HTTP_STATUS_IM_USED: 226;
    readonly HTTP_STATUS_MULTIPLE_CHOICES: 300;
    readonly HTTP_STATUS_MOVED_PERMANENTLY: 301;
    readonly HTTP_STATUS_FOUND: 302;
    readonly HTTP_STATUS_SEE_OTHER: 303;
    readonly HTTP_STATUS_NOT_MODIFIED: 304;
    readonly HTTP_STATUS_USE_PROXY: 305;
    readonly HTTP_STATUS_TEMPORARY_REDIRECT: 307;
    readonly HTTP_STATUS_PERMANENT_REDIRECT: 308;
    readonly HTTP_STATUS_BAD_REQUEST: 400;
    readonly HTTP_STATUS_UNAUTHORIZED: 401;
    readonly HTTP_STATUS_PAYMENT_REQUIRED: 402;
    readonly HTTP_STATUS_FORBIDDEN: 403;
    readonly HTTP_STATUS_NOT_FOUND: 404;
    readonly HTTP_STATUS_METHOD_NOT_ALLOWED: 405;
    readonly HTTP_STATUS_NOT_ACCEPTABLE: 406;
    readonly HTTP_STATUS_PROXY_AUTHENTICATION_REQUIRED: 407;
    readonly HTTP_STATUS_REQUEST_TIMEOUT: 408;
    readonly HTTP_STATUS_CONFLICT: 409;
    readonly HTTP_STATUS_GONE: 410;
    readonly HTTP_STATUS_LENGTH_REQUIRED: 411;
    readonly HTTP_STATUS_PRECONDITION_FAILED: 412;
    readonly HTTP_STATUS_PAYLOAD_TOO_LARGE: 413;
    readonly HTTP_STATUS_URI_TOO_LONG: 414;
    readonly HTTP_STATUS_UNSUPPORTED_MEDIA_TYPE: 415;
    readonly HTTP_STATUS_RANGE_NOT_SATISFIABLE: 416;
    readonly HTTP_STATUS_EXPECTATION_FAILED: 417;
    readonly HTTP_STATUS_TEAPOT: 418;
    readonly HTTP_STATUS_MISDIRECTED_REQUEST: 421;
    readonly HTTP_STATUS_UNPROCESSABLE_ENTITY: 422;
    readonly HTTP_STATUS_LOCKED: 423;
    readonly HTTP_STATUS_FAILED_DEPENDENCY: 424;
    readonly HTTP_STATUS_TOO_EARLY: 425;
    readonly HTTP_STATUS_UPGRADE_REQUIRED: 426;
    readonly HTTP_STATUS_PRECONDITION_REQUIRED: 428;
    readonly HTTP_STATUS_TOO_MANY_REQUESTS: 429;
    readonly HTTP_STATUS_REQUEST_HEADER_FIELDS_TOO_LARGE: 431;
    readonly HTTP_STATUS_UNAVAILABLE_FOR_LEGAL_REASONS: 451;
    readonly HTTP_STATUS_INTERNAL_SERVER_ERROR: 500;
    readonly HTTP_STATUS_NOT_IMPLEMENTED: 501;
    readonly HTTP_STATUS_BAD_GATEWAY: 502;
    readonly HTTP_STATUS_SERVICE_UNAVAILABLE: 503;
    readonly HTTP_STATUS_GATEWAY_TIMEOUT: 504;
    readonly HTTP_STATUS_HTTP_VERSION_NOT_SUPPORTED: 505;
    readonly HTTP_STATUS_VARIANT_ALSO_NEGOTIATES: 506;
    readonly HTTP_STATUS_INSUFFICIENT_STORAGE: 507;
    readonly HTTP_STATUS_LOOP_DETECTED: 508;
    readonly HTTP_STATUS_BANDWIDTH_LIMIT_EXCEEDED: 509;
    readonly HTTP_STATUS_NOT_EXTENDED: 510;
    readonly HTTP_STATUS_NETWORK_AUTHENTICATION_REQUIRED: 511;
  }
  export const constants: Http2Constants;
  /* The eager handler is the first COMPAT 'request' listener — Node's
   * route on either flavor (the allowHTTP1 server's HTTP/1.1 handles,
   * the ALPN=h2 server's compat handles over streams). */
  export function createSecureServer(
    options: SecureServerOptions,
    onRequestHandler?: (
      req: import("http").IncomingMessage,
      res: import("http").ServerResponse,
    ) => void,
  ): Http2SecureServer;

  /* ── the REAL h2c surface (scr_http2.c: frame codec + HPACK over the
   * net loop) — createServer/connect and the session/stream handles the
   * Node suite's http2 family exercises. Headers cross as the canonical
   * header record (the IncomingHttpHeaders index-signature shape); the
   * response :status reads back as a number. Members declared here
   * without a lowering fence by name at their use sites. */

  /** The http2 module's own header shapes: pure index-signature records
   * (the HEADER-FAMILY canonicalization — string[] arm included). */
  export interface IncomingHttpHeaders {
    [name: string]: number | string | string[] | undefined;
  }
  export interface OutgoingHttpHeaders {
    [name: string]: number | string | string[] | undefined;
  }

  export interface Http2Session {
    close(callback?: () => void): void;
    destroy(): void;
    readonly closed: boolean;
    readonly destroyed: boolean;
    readonly encrypted: boolean;
    readonly type: number;
    readonly alpnProtocol: string;
    readonly socket: import("net").Socket;
    readonly pendingSettingsAck: boolean;
    ref(): void;
    unref(): void;
    setTimeout(msecs: number, callback?: () => void): void;
    ping(callback: (err: Error | null, duration: number, payload: Uint8Array) => void): boolean;
    /* The settings surface rides the checked-dynamic machinery (records
     * cross as dyn values — the suite's mustCall listeners are dyn). */
    settings(settings?: any, callback?: any): void;
    readonly localSettings: any;
    readonly remoteSettings: any;
    goaway(code?: number, lastStreamID?: number, opaqueData?: Uint8Array): void;
    on(event: "close" | "timeout", listener: () => void): void;
    on(event: "error", listener: (err: Error) => void): void;
    on(
      event: "connect",
      listener: (session: Http2Session, socket: import("net").Socket) => void,
    ): void;
    on(
      event: "stream",
      listener: (stream: ServerHttp2Stream, headers: IncomingHttpHeaders, flags: number) => void,
    ): void;
    on(
      event: "goaway",
      listener: (errorCode: number, lastStreamID: number, opaqueData?: Uint8Array) => void,
    ): void;
    on(event: "localSettings" | "remoteSettings", listener: (settings: any) => void): void;
    on(event: "frameError", listener: (type: number, code: number, id: number) => void): void;
    on(event: "ping", listener: (payload: Uint8Array) => void): void;
    once(event: "close" | "timeout", listener: () => void): void;
    once(event: "error", listener: (err: Error) => void): void;
    once(
      event: "connect",
      listener: (session: Http2Session, socket: import("net").Socket) => void,
    ): void;
    once(
      event: "stream",
      listener: (stream: ServerHttp2Stream, headers: IncomingHttpHeaders, flags: number) => void,
    ): void;
    once(
      event: "goaway",
      listener: (errorCode: number, lastStreamID: number, opaqueData?: Uint8Array) => void,
    ): void;
    once(event: "localSettings" | "remoteSettings", listener: (settings: any) => void): void;
  }

  export interface ClientHttp2Session extends Http2Session {
    request(
      headers?: OutgoingHttpHeaders,
      options?: {
        endStream?: boolean;
        exclusive?: boolean;
        parent?: number;
        weight?: number;
        waitForTrailers?: boolean;
      },
    ): ClientHttp2Stream;
  }

  export interface ServerHttp2Session extends Http2Session {
    altsvc(alt: string, originOrStream: number | string): void;
    origin(...origins: string[]): void;
  }

  /** The shared Http2Stream core (both roles). 'data' chunks are Buffers
   * (strings once setEncoding('utf8') is in force — the IncomingMessage
   * chunk:any stance keeps both working). */
  interface Http2StreamCore {
    readonly id: number | undefined;
    readonly rstCode: number;
    readonly closed: boolean;
    readonly destroyed: boolean;
    readonly pending: boolean;
    readonly aborted: boolean;
    readonly session: Http2Session;
    readonly sentHeaders: OutgoingHttpHeaders;
    readonly state: Record<string, number>;
    write(chunk: string | Uint8Array, callback?: (err?: Error | null) => void): boolean;
    end(data?: string | Uint8Array, callback?: () => void): void;
    end(callback: () => void): void;
    close(code?: number, callback?: () => void): void;
    destroy(error?: Error): void;
    setEncoding(encoding: string): this;
    resume(): void;
    pause(): void;
    setTimeout(msecs: number, callback?: () => void): void;
    priority(options: Record<string, number | boolean>): void;
    sendTrailers(headers: OutgoingHttpHeaders): void;
  }

  export interface ServerHttp2Stream extends Http2StreamCore {
    on(event: "data", listener: (chunk: any) => void): void;
    on(
      event:
        | "end"
        | "close"
        | "aborted"
        | "ready"
        | "timeout"
        | "drain"
        | "finish"
        | "wantTrailers",
      listener: () => void,
    ): void;
    on(event: "error", listener: (err: Error) => void): void;
    on(event: "frameError", listener: (type: number, code: number, id: number) => void): void;
    on(event: "trailers", listener: (trailers: IncomingHttpHeaders, flags: number) => void): void;
    once(event: "data", listener: (chunk: any) => void): void;
    once(
      event:
        | "end"
        | "close"
        | "aborted"
        | "ready"
        | "timeout"
        | "drain"
        | "finish"
        | "wantTrailers",
      listener: () => void,
    ): void;
    once(event: "error", listener: (err: Error) => void): void;
    once(event: "trailers", listener: (trailers: IncomingHttpHeaders, flags: number) => void): void;
    respond(
      headers?: OutgoingHttpHeaders,
      options?: { endStream?: boolean; waitForTrailers?: boolean },
    ): void;
    respondWithFile(
      path: string,
      headers?: OutgoingHttpHeaders,
      options?: Record<string, unknown>,
    ): void;
    respondWithFD(
      fd: number,
      headers?: OutgoingHttpHeaders,
      options?: Record<string, unknown>,
    ): void;
    pushStream(
      headers: OutgoingHttpHeaders,
      callback: (
        err: Error | null,
        pushStream: ServerHttp2Stream,
        headers: OutgoingHttpHeaders,
      ) => void,
    ): void;
    readonly headersSent: boolean;
    readonly pushAllowed: boolean;
    additionalHeaders(headers: OutgoingHttpHeaders): void;
  }

  export interface ClientHttp2Stream extends Http2StreamCore {
    on(event: "response", listener: (headers: IncomingHttpHeaders, flags: number) => void): void;
    on(event: "push", listener: (headers: IncomingHttpHeaders, flags: number) => void): void;
    on(event: "headers", listener: (headers: IncomingHttpHeaders, flags: number) => void): void;
    on(event: "data", listener: (chunk: any) => void): void;
    on(
      event:
        | "end"
        | "close"
        | "aborted"
        | "ready"
        | "timeout"
        | "drain"
        | "finish"
        | "wantTrailers",
      listener: () => void,
    ): void;
    on(event: "error", listener: (err: Error) => void): void;
    on(event: "frameError", listener: (type: number, code: number, id: number) => void): void;
    on(event: "trailers", listener: (trailers: IncomingHttpHeaders, flags: number) => void): void;
    once(event: "response", listener: (headers: IncomingHttpHeaders, flags: number) => void): void;
    once(event: "push", listener: (headers: IncomingHttpHeaders, flags: number) => void): void;
    once(event: "data", listener: (chunk: any) => void): void;
    once(
      event:
        | "end"
        | "close"
        | "aborted"
        | "ready"
        | "timeout"
        | "drain"
        | "finish"
        | "wantTrailers",
      listener: () => void,
    ): void;
    once(event: "error", listener: (err: Error) => void): void;
  }

  export interface Http2Server {
    listen(port?: number, callback?: () => void): void;
    listen(port: number, host: string, callback?: () => void): void;
    close(callback?: () => void): void;
    address(): import("node:dgram").AddressInfo;
    setTimeout(msecs?: number, callback?: () => void): void;
    ref(): void;
    unref(): void;
    on(
      event: "stream",
      listener: (stream: ServerHttp2Stream, headers: IncomingHttpHeaders, flags: number) => void,
    ): void;
    on(event: "session", listener: (session: ServerHttp2Session) => void): void;
    on(
      event: "request",
      listener: (req: Http2ServerRequest, res: Http2ServerResponse) => void,
    ): void;
    on(event: "error", listener: (err: Error) => void): void;
    on(event: "close" | "listening" | "timeout", listener: () => void): void;
    on(event: "connection", listener: (socket: import("net").Socket) => void): void;
    on(event: "sessionError", listener: (err: Error, session: ServerHttp2Session) => void): void;
    once(
      event: "stream",
      listener: (stream: ServerHttp2Stream, headers: IncomingHttpHeaders, flags: number) => void,
    ): void;
    once(event: "session", listener: (session: ServerHttp2Session) => void): void;
    once(
      event: "request",
      listener: (req: Http2ServerRequest, res: Http2ServerResponse) => void,
    ): void;
    once(event: "error", listener: (err: Error) => void): void;
    once(event: "close" | "listening" | "timeout", listener: () => void): void;
  }

  export interface ServerOptions {
    [option: string]: unknown;
  }

  export function createServer(
    onRequestHandler?: (req: Http2ServerRequest, res: Http2ServerResponse) => void,
  ): Http2Server;
  export function createServer(
    options: ServerOptions,
    onRequestHandler?: (req: Http2ServerRequest, res: Http2ServerResponse) => void,
  ): Http2Server;

  export function connect(
    authority: string,
    listener?: (session: ClientHttp2Session, socket: import("net").Socket) => void,
  ): ClientHttp2Session;
  export function connect(
    authority: string,
    options: Record<string, unknown>,
    listener?: (session: ClientHttp2Session, socket: import("net").Socket) => void,
  ): ClientHttp2Session;

  export function getDefaultSettings(): any;
  export function getPackedSettings(settings: Record<string, number | boolean>): Uint8Array;
  export const sensitiveHeaders: unique symbol;
}
declare module "node:http2" {
  export * from "http2";
}

/* node:dgram — UDP sockets over the event loop (scr_dgram.c, linked only
 * into using binaries). createSocket takes "udp4" or the
 * { type: "udp4", reuseAddr? } literal; bind/connect bind NOW and defer
 * 'listening'/'connect' to the next loop turn; send takes one string or
 * Buffer datagram with an explicit port + address (the connected-send
 * and callback forms have no lowering); address() returns the real
 * {address, family, port} record and THROWS "Not running" before bind,
 * like Node. The socket options throw Node's errors (EBADF before bind);
 * add/dropMembership before bind is refused at run time (SC2020). 'error'
 * with no listener exits 1 (the unhandled EventEmitter 'error' behavior). */
declare module "dgram" {
  export interface AddressInfo {
    address: string;
    family: string;
    port: number;
  }
  export interface RemoteInfo {
    address: string;
    family: string;
    port: number;
    size: number;
  }
  export interface Socket {
    bind(port: number, address?: string, callback?: () => void): void;
    connect(port: number, address?: string, callback?: () => void): void;
    send(msg: string | Uint8Array, port: number, address: string): void;
    address(): AddressInfo;
    close(callback?: () => void): void;
    disconnect(): void;
    unref(): void;
    ref(): void;
    setBroadcast(flag: boolean): void;
    setTTL(ttl: number): number;
    setMulticastTTL(ttl: number): number;
    setMulticastLoopback(flag: boolean): boolean;
    setMulticastInterface(multicastInterface: string): void;
    addMembership(multicastAddress: string, multicastInterface?: string): void;
    dropMembership(multicastAddress: string, multicastInterface?: string): void;
    getRecvBufferSize(): number;
    getSendBufferSize(): number;
    setRecvBufferSize(size: number): void;
    setSendBufferSize(size: number): void;
    getSendQueueSize(): number;
    getSendQueueCount(): number;
    on(event: "message", listener: (msg: Buffer, rinfo: RemoteInfo) => void): void;
    on(event: "listening" | "close" | "connect", listener: () => void): void;
    on(event: "error", listener: (err: Error) => void): void;
    once(event: "message", listener: (msg: Buffer, rinfo: RemoteInfo) => void): void;
    once(event: "listening" | "close" | "connect", listener: () => void): void;
    once(event: "error", listener: (err: Error) => void): void;
  }
  export function createSocket(type: "udp4"): Socket;
  export function createSocket(options: { type: "udp4"; reuseAddr?: boolean }): Socket;
}
declare module "node:dgram" {
  export * from "dgram";
}

/* node:dns — the lookup slice (scr_dgram.c hosts it; getaddrinfo runs AT
 * CALL TIME and the callback defers to the next loop turn — SEMANTICS.md
 * documents the blocking divergence). Only the { family: 4 } options
 * form lowers; failures deliver Node's error shape ("getaddrinfo
 * ENOTFOUND <hostname>") as the callback's Error argument, with "" for
 * the address where Node passes undefined. */
declare module "dns" {
  export interface LookupAddress {
    address: string;
    family: number;
  }
  export interface LookupOptions {
    family?: number | "IPv4" | "IPv6";
    hints?: number;
    all?: boolean;
    order?: "ipv4first" | "ipv6first" | "verbatim";
    verbatim?: boolean;
  }
  export interface LookupOneOptions extends LookupOptions {
    all?: false;
  }
  export interface LookupAllOptions extends LookupOptions {
    all: true;
  }
  /* The callback comes with the other lookup deliveries (literal
   * addresses on the next tick); the options follow lib/dns.js. */
  export function lookup(
    hostname: string,
    callback: (err: NodeJS.ErrnoException | null, address: string, family: number) => void,
  ): void;
  export function lookup(
    hostname: string,
    family: number,
    callback: (err: NodeJS.ErrnoException | null, address: string, family: number) => void,
  ): void;
  export function lookup(
    hostname: string,
    options: LookupOneOptions,
    callback: (err: NodeJS.ErrnoException | null, address: string, family: number) => void,
  ): void;
  export function lookup(
    hostname: string,
    options: LookupAllOptions,
    callback: (err: NodeJS.ErrnoException | null, addresses: LookupAddress[]) => void,
  ): void;
  /* getnameinfo with NI_NAMEREQD: the host's name and the port's service
   * name (the number when it has none). */
  export function lookupService(
    address: string,
    port: number,
    callback: (err: NodeJS.ErrnoException | null, hostname: string, service: string) => void,
  ): void;
  /* The nameservers /etc/resolv.conf lists. */
  export function getServers(): string[];
  export function getDefaultResultOrder(): "ipv4first" | "ipv6first" | "verbatim";
  export function setDefaultResultOrder(order: "ipv4first" | "ipv6first" | "verbatim"): void;
}
declare module "node:dns" {
  export * from "dns";
}

/* node:worker_threads — native workers use statically compiled entry points.
 * Lowering and runtime diagnostics define the supported options and methods. */
declare module "worker_threads" {
  export const isMainThread: boolean;
  export const isInternalThread: boolean;
  export const threadId: number;
  export interface WorkerOptions {
    workerData?: unknown;
    transferList?: readonly unknown[];
    argv?: readonly unknown[];
    name?: string;
    [option: string]: unknown;
  }
  export class Worker {
    constructor(filename: string | URL, options?: WorkerOptions);
    readonly threadId: number;
    on(event: "online", listener: () => void): this;
    on(event: "message", listener: (value: any) => void): this;
    on(event: "error", listener: (error: Error) => void): this;
    on(event: "exit", listener: (code: number) => 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;
    addListener(event: string, listener: (...args: any[]) => void): this;
    removeListener(event: string, listener: (...args: any[]) => void): this;
    prependListener(event: string, listener: (...args: any[]) => void): this;
    prependOnceListener(event: string, listener: (...args: any[]) => void): this;
    postMessage(value: unknown, transferList?: readonly unknown[]): void;
    ref(): void;
    unref(): void;
    terminate(): Promise<number>;
    removeAllListeners(event?: string): this;
    listenerCount(event: string, listener?: (...args: any[]) => void): number;
  }
  export class MessagePort {
    on(event: "message", listener: (value: any) => void): this;
    on(event: "close", listener: () => 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;
    addListener(event: string, listener: (...args: any[]) => void): this;
    removeListener(event: string, listener: (...args: any[]) => void): this;
    prependListener(event: string, listener: (...args: any[]) => void): this;
    prependOnceListener(event: string, listener: (...args: any[]) => void): this;
    postMessage(value: unknown, transferList?: readonly unknown[]): void;
    start(): void;
    close(callback?: () => void): void;
    ref(): void;
    unref(): void;
    hasRef(): boolean;
    removeAllListeners(event?: string): this;
    listenerCount(event: string, listener?: (...args: any[]) => void): number;
  }
  export const parentPort: MessagePort | null;
  export const workerData: any;
}
declare module "node:worker_threads" {
  export * from "worker_threads";
}

/* node:buffer — the module spelling of the Buffer/atob/btoa globals.
 * Buffer re-exports the GLOBAL declaration, so an imported binding
 * resolves to the same symbol the lowerings already answer for (and
 * third-party .d.ts files that `import { Buffer } from "node:buffer"` —
 * file-entry-cache in a typed-JS source graph — typecheck). */
declare module "buffer" {
  export function isAscii(input: ArrayBuffer | ArrayBufferView): boolean;
  export function isUtf8(input: ArrayBuffer | ArrayBufferView): boolean;
  export function transcode(source: Uint8Array, fromEncoding: string, toEncoding: string): Buffer;
  export function atob(data: string): string;
  export function btoa(data: string): string;
  export const kMaxLength: number;
  export const kStringMaxLength: number;
  export const Buffer: BufferConstructor;
  export type Blob = globalThis.Blob;
  export type File = globalThis.File;
  export const Blob: typeof globalThis.Blob;
  export const File: typeof globalThis.File;
}
declare module "node:buffer" {
  export * from "buffer";
}

/* node:cluster — the primary-probe slice. A compiled binary never runs
 * as a cluster worker (cluster forks the node binary itself — the
 * mechanism is na for compiled programs), so isPrimary lowers to `true`
 * and isWorker to `false`; everything else is undeclared. */
declare module "cluster" {
  const cluster: {
    readonly isPrimary: boolean;
    readonly isMaster: boolean;
    readonly isWorker: boolean;
  };
  export = cluster;
}
declare module "node:cluster" {
  import cluster = require("cluster");
  export = cluster;
}

/* node:tty — the fd probe (the same isatty(3) behind process.*.isTTY)
 * and the supported structural view of a process output stream. */
declare module "tty" {
  export interface WriteStream {
    write(data: string | Uint8Array, callback?: (error?: Error | null) => void): boolean;
    write(
      data: string | Uint8Array,
      encoding: BufferEncoding,
      callback?: (error?: Error | null) => void,
    ): boolean;
    readonly isTTY: boolean;
    readonly columns: number;
    readonly rows: number;
    getWindowSize(): [number, number];
  }
  export function isatty(fd: number): boolean;
}
declare module "node:tty" {
  export * from "tty";
}

/* node:async_hooks — declared surface without lowering: async-hook
 * instrumentation is guarded behind env flags in harness code; a reached
 * use fences at its site. */
declare module "async_hooks" {
  /* AsyncLocalStorage: fiber-carried context snapshots — run/getStore/
   * exit/enterWith/disable lower onto the runtime's active-slot machinery
   * (als.* libCalls); values cross as dyn values. */
  export class AsyncLocalStorage<T = any> {
    constructor();
    run<R>(store: T, callback: (...args: any[]) => R, ...args: any[]): R;
    exit<R>(callback: (...args: any[]) => R, ...args: any[]): R;
    getStore(): T | undefined;
    enterWith(store: T): void;
    disable(): void;
  }
  export interface AsyncHook {
    enable(): AsyncHook;
    disable(): AsyncHook;
  }
  export function createHook(callbacks: {
    init?: (asyncId: number, type: string, triggerAsyncId: number, resource: unknown) => void;
    before?: (asyncId: number) => void;
    after?: (asyncId: number) => void;
    destroy?: (asyncId: number) => void;
  }): AsyncHook;
  export function executionAsyncId(): number;
  export function triggerAsyncId(): number;
}
declare module "node:async_hooks" {
  export * from "async_hooks";
}
/* node:events — the EventEmitter class (the module object IS the class,
 * like Node's `module.exports = EventEmitter`). Listener/emit signatures
 * mirror @types/node's untyped `...args: any[]` surface; the compiler's
 * lowering unifies each event name's argument tuple program-wide and
 * checks annotated listener parameters against it (unannotated non-empty
 * parameter lists have no static types and fence at the registration). */
declare module "events" {
  class EventEmitter {
    constructor();
    static defaultMaxListeners: number;
    /* Listeners registered under this symbol observe 'error' emits first
     * (an emit with no 'error' listener still throws). */
    static readonly errorMonitor: unique symbol;
    static addAbortListener(signal: AbortSignal, listener: (event: Event) => void): Disposable;
    on(eventName: string | symbol, listener: (...args: any[]) => void): this;
    addListener(eventName: string | symbol, listener: (...args: any[]) => void): this;
    once(eventName: string | symbol, listener: (...args: any[]) => void): this;
    prependListener(eventName: string | symbol, listener: (...args: any[]) => void): this;
    prependOnceListener(eventName: string | symbol, listener: (...args: any[]) => void): this;
    off(eventName: string | symbol, listener: (...args: any[]) => void): this;
    removeListener(eventName: string | symbol, listener: (...args: any[]) => void): this;
    removeAllListeners(eventName?: string | symbol): this;
    emit(eventName: string | symbol, ...args: any[]): boolean;
    listenerCount(eventName: string | symbol, listener?: (...args: any[]) => void): number;
    /* Declared as zero-parameter closures so the RESULT is statically
     * consumable (.length, indexing, identity): the lowering only admits
     * these calls for events whose argument tuple is empty — a listener
     * pulled from the array is then safely callable too. Events with
     * arguments fence (their element type would lie). */
    listeners(eventName: string): Array<() => void>;
    rawListeners(eventName: string): Array<() => void>;
    eventNames(): string[];
    setMaxListeners(n: number): this;
    getMaxListeners(): number;
  }
  import internal = require("node:events");
  namespace EventEmitter {
    // The class under its own name, so `import { EventEmitter }` resolves
    // (the @types/node namespace-alias pattern).
    export { internal as EventEmitter };
    // The event's arguments, as checked-dynamic values.
    export function once(
      emitter: EventEmitter,
      eventName: string,
      options?: { signal?: AbortSignal },
    ): Promise<unknown[]>;
  }
  export = EventEmitter;
}
declare module "node:events" {
  import events = require("events");
  export = events;
}

/* node:stream — the static stream classes (runtime-provided, the
 * EventEmitter-hierarchy precedent). Phase 1 is the OPTIONS-OBJECT
 * constructor surface: `new Readable({ read() {} })`, `new Writable({
 * write(chunk, enc, cb) {} })`, Duplex/Transform/PassThrough, push/read,
 * flowing vs paused, write/end backpressure + 'drain', pipe/unpipe, and
 * destroy — with Node's event orderings. Chunks are BYTES (Buffer), with
 * utf8 strings converted at push/write like Node; objectMode and
 * setEncoding are declared so uses fence at their sites with their own
 * words. `class My extends Readable` (the _read override form) is a
 * separate feature and fences at the class declaration. The runtime-fired
 * events carry per-class FORCED argument tuples ('data' is one Buffer,
 * 'error' one Error, 'pipe'/'unpipe' one Readable, the rest empty) — the
 * overloads below hand tsc the same contract so unannotated listener
 * parameters contextually type in .js sources. */
declare module "stream" {
  import { EventEmitter } from "events";

  interface ReadableOptions {
    highWaterMark?: number;
    encoding?: string;
    objectMode?: boolean;
    read?(this: Readable, size: number): void;
    destroy?(this: Readable, error: Error | null, callback: (error?: Error | null) => void): void;
    construct?(this: Readable, callback: (error?: Error | null) => void): void;
    autoDestroy?: boolean;
    emitClose?: boolean;
    captureRejections?: boolean;
    defaultEncoding?: string;
    signal?: AbortSignal;
  }
  interface WritableOptions {
    highWaterMark?: number;
    decodeStrings?: boolean;
    defaultEncoding?: string;
    objectMode?: boolean;
    write?(
      this: Writable,
      chunk: Buffer,
      encoding: string,
      callback: (error?: Error | null) => void,
    ): void;
    writev?(this: Writable, chunks: unknown[], callback: (error?: Error | null) => void): void;
    final?(this: Writable, callback: (error?: Error | null) => void): void;
    destroy?(this: Writable, error: Error | null, callback: (error?: Error | null) => void): void;
    construct?(this: Writable, callback: (error?: Error | null) => void): void;
    autoDestroy?: boolean;
    emitClose?: boolean;
    captureRejections?: boolean;
    signal?: AbortSignal;
  }
  interface DuplexOptions {
    highWaterMark?: number;
    readableHighWaterMark?: number;
    writableHighWaterMark?: number;
    encoding?: string;
    decodeStrings?: boolean;
    objectMode?: boolean;
    readableObjectMode?: boolean;
    writableObjectMode?: boolean;
    allowHalfOpen?: boolean;
    read?(this: Duplex, size: number): void;
    write?(
      this: Duplex,
      chunk: Buffer,
      encoding: string,
      callback: (error?: Error | null) => void,
    ): void;
    final?(this: Duplex, callback: (error?: Error | null) => void): void;
    destroy?(this: Duplex, error: Error | null, callback: (error?: Error | null) => void): void;
    construct?(this: Duplex, callback: (error?: Error | null) => void): void;
    autoDestroy?: boolean;
    emitClose?: boolean;
    captureRejections?: boolean;
    readable?: boolean;
    writable?: boolean;
    defaultEncoding?: string;
    writev?(this: Duplex, chunks: unknown[], callback: (error?: Error | null) => void): void;
    signal?: AbortSignal;
  }
  interface TransformOptions {
    highWaterMark?: number;
    readableHighWaterMark?: number;
    writableHighWaterMark?: number;
    encoding?: string;
    decodeStrings?: boolean;
    objectMode?: boolean;
    readableObjectMode?: boolean;
    writableObjectMode?: boolean;
    allowHalfOpen?: boolean;
    transform?(
      this: Transform,
      chunk: Buffer,
      encoding: string,
      callback: (error?: Error | null, data?: Buffer | string) => void,
    ): void;
    flush?(this: Transform, callback: (error?: Error | null, data?: Buffer | string) => void): void;
    destroy?(this: Transform, error: Error | null, callback: (error?: Error | null) => void): void;
    construct?(this: Transform, callback: (error?: Error | null) => void): void;
    read?(this: Transform, size: number): void;
    write?(
      this: Transform,
      chunk: Buffer,
      encoding: string,
      callback: (error?: Error | null) => void,
    ): void;
    final?(this: Transform, callback: (error?: Error | null) => void): void;
    writev?(this: Transform, chunks: unknown[], callback: (error?: Error | null) => void): void;
    autoDestroy?: boolean;
    emitClose?: boolean;
    captureRejections?: boolean;
    readable?: boolean;
    writable?: boolean;
    defaultEncoding?: string;
    signal?: AbortSignal;
  }

  /* The operators' options: concurrency and highWaterMark bound map's
   * in-flight callbacks and queued results. */
  interface ArrayOptions {
    concurrency?: number;
    highWaterMark?: number;
    signal?: AbortSignal;
  }

  class Readable extends EventEmitter {
    constructor(opts?: ReadableOptions);
    /* The underscore-method surface (@types/node declares these on the
     * classes; assigning them post-construction shadows the prototype
     * method and the machinery calls through the assignment — lowered
     * onto the option-callback slots). */
    _read(size: number): void;
    _destroy(error: Error | null, callback: (error?: Error | null) => void): void;
    [Symbol.asyncIterator](): AsyncIterableIterator<any>;
    iterator(options?: { destroyOnReturn?: boolean }): AsyncIterableIterator<any>;
    push(chunk: Buffer | string | null, encoding?: string): boolean;
    unshift(chunk: Buffer | string, encoding?: string): void;
    read(size?: number): Buffer | null;
    pause(): this;
    resume(): this;
    isPaused(): boolean;
    setEncoding(encoding: string): this;
    pipe<T extends Writable>(destination: T, options?: { end?: boolean }): T;
    unpipe(destination?: Writable): this;
    destroy(error?: Error): this;
    readonly readable: boolean;
    readonly readableEnded: boolean;
    readonly readableFlowing: boolean | null;
    readonly readableLength: number;
    readonly readableHighWaterMark: number;
    readonly readableObjectMode: boolean;
    readonly closed: boolean;
    readonly destroyed: boolean;
    readonly errored: Error | null;
    static from(iterable: unknown, options?: ReadableOptions): Readable;
    /* The Readable operators: chunks are strings or Buffers, map and
     * flatMap callbacks return strings or Buffers (flatMap: arrays of
     * them, or strings), and callbacks that declare the options argument
     * are refused. */
    map(
      fn: (data: any, options?: Pick<ArrayOptions, "signal">) => any,
      options?: ArrayOptions,
    ): Readable;
    filter(
      fn: (data: any, options?: Pick<ArrayOptions, "signal">) => boolean | Promise<boolean>,
      options?: ArrayOptions,
    ): Readable;
    forEach(
      fn: (data: any, options?: Pick<ArrayOptions, "signal">) => void | Promise<void>,
      options?: ArrayOptions,
    ): Promise<void>;
    toArray(options?: Pick<ArrayOptions, "signal">): Promise<any[]>;
    some(
      fn: (data: any, options?: Pick<ArrayOptions, "signal">) => boolean | Promise<boolean>,
      options?: ArrayOptions,
    ): Promise<boolean>;
    find(
      fn: (data: any, options?: Pick<ArrayOptions, "signal">) => boolean | Promise<boolean>,
      options?: ArrayOptions,
    ): Promise<any>;
    every(
      fn: (data: any, options?: Pick<ArrayOptions, "signal">) => boolean | Promise<boolean>,
      options?: ArrayOptions,
    ): Promise<boolean>;
    flatMap(
      fn: (data: any, options?: Pick<ArrayOptions, "signal">) => any,
      options?: ArrayOptions,
    ): Readable;
    drop(limit: number, options?: Pick<ArrayOptions, "signal">): Readable;
    take(limit: number, options?: Pick<ArrayOptions, "signal">): Readable;
    reduce<T = any>(
      fn: (previous: any, data: any, options?: Pick<ArrayOptions, "signal">) => T,
      initial?: undefined,
      options?: Pick<ArrayOptions, "signal">,
    ): Promise<T>;
    reduce<T = any>(
      fn: (previous: T, data: any, options?: Pick<ArrayOptions, "signal">) => T,
      initial: T,
      options?: Pick<ArrayOptions, "signal">,
    ): Promise<T>;
    on(event: "data", listener: (chunk: any) => void): this;
    on(event: "end" | "close" | "readable" | "pause" | "resume", listener: () => void): this;
    on(event: "error", listener: (err: Error) => void): this;
    on(event: string, listener: (...args: any[]) => void): this;
    once(event: "data", listener: (chunk: any) => void): this;
    once(event: "end" | "close" | "readable" | "pause" | "resume", listener: () => void): this;
    once(event: "error", listener: (err: Error) => void): this;
    once(event: string, listener: (...args: any[]) => void): this;
    addListener(event: "data", listener: (chunk: any) => void): this;
    addListener(
      event: "end" | "close" | "readable" | "pause" | "resume",
      listener: () => void,
    ): this;
    addListener(event: "error", listener: (err: Error) => void): this;
    addListener(event: string, listener: (...args: any[]) => void): this;
    prependListener(event: "data", listener: (chunk: any) => void): this;
    prependListener(
      event: "end" | "close" | "readable" | "pause" | "resume",
      listener: () => void,
    ): this;
    prependListener(event: "error", listener: (err: Error) => void): this;
    prependListener(event: string, listener: (...args: any[]) => void): this;
    prependOnceListener(event: "data", listener: (chunk: any) => void): this;
    prependOnceListener(
      event: "end" | "close" | "readable" | "pause" | "resume",
      listener: () => void,
    ): this;
    prependOnceListener(event: "error", listener: (err: Error) => void): this;
    prependOnceListener(event: string, listener: (...args: any[]) => void): this;
    off(event: "data", listener: (chunk: any) => void): this;
    off(event: "end" | "close" | "readable" | "pause" | "resume", listener: () => void): this;
    off(event: "error", listener: (err: Error) => void): this;
    off(event: string, listener: (...args: any[]) => void): this;
    removeListener(event: "data", listener: (chunk: any) => void): this;
    removeListener(
      event: "end" | "close" | "readable" | "pause" | "resume",
      listener: () => void,
    ): this;
    removeListener(event: "error", listener: (err: Error) => void): this;
    removeListener(event: string, listener: (...args: any[]) => void): this;
  }

  class Writable extends EventEmitter {
    constructor(opts?: WritableOptions);
    /* The underscore-method surface (see Readable). */
    _write(chunk: any, encoding: string, callback: (error?: Error | null) => void): void;
    _writev(
      chunks: Array<{ chunk: any; encoding: string }>,
      callback: (error?: Error | null) => void,
    ): void;
    _final(callback: (error?: Error | null) => void): void;
    _destroy(error: Error | null, callback: (error?: Error | null) => void): void;
    write(chunk: Buffer | string, callback?: (error?: Error | null) => void): boolean;
    write(
      chunk: Buffer | string,
      encoding: string,
      callback?: (error?: Error | null) => void,
    ): boolean;
    end(callback?: () => void): this;
    end(chunk: Buffer | string, callback?: () => void): this;
    end(chunk: Buffer | string, encoding: string, callback?: () => void): this;
    cork(): void;
    uncork(): void;
    setDefaultEncoding(encoding: string): this;
    destroy(error?: Error): this;
    readonly writable: boolean;
    readonly writableEnded: boolean;
    readonly writableFinished: boolean;
    readonly writableLength: number;
    readonly writableHighWaterMark: number;
    readonly writableObjectMode: boolean;
    readonly writableNeedDrain: boolean;
    readonly writableCorked: number;
    readonly closed: boolean;
    readonly destroyed: boolean;
    readonly errored: Error | null;
    on(event: "drain" | "finish" | "close", listener: () => void): this;
    on(event: "error", listener: (err: Error) => void): this;
    on(event: "pipe" | "unpipe", listener: (src: Readable) => void): this;
    on(event: string, listener: (...args: any[]) => void): this;
    once(event: "drain" | "finish" | "close", listener: () => void): this;
    once(event: "error", listener: (err: Error) => void): this;
    once(event: "pipe" | "unpipe", listener: (src: Readable) => void): this;
    once(event: string, listener: (...args: any[]) => void): this;
    addListener(event: "drain" | "finish" | "close", listener: () => void): this;
    addListener(event: "error", listener: (err: Error) => void): this;
    addListener(event: "pipe" | "unpipe", listener: (src: Readable) => void): this;
    addListener(event: string, listener: (...args: any[]) => void): this;
    prependListener(event: "drain" | "finish" | "close", listener: () => void): this;
    prependListener(event: "error", listener: (err: Error) => void): this;
    prependListener(event: "pipe" | "unpipe", listener: (src: Readable) => void): this;
    prependListener(event: string, listener: (...args: any[]) => void): this;
    prependOnceListener(event: "drain" | "finish" | "close", listener: () => void): this;
    prependOnceListener(event: "error", listener: (err: Error) => void): this;
    prependOnceListener(event: "pipe" | "unpipe", listener: (src: Readable) => void): this;
    prependOnceListener(event: string, listener: (...args: any[]) => void): this;
    off(event: "drain" | "finish" | "close", listener: () => void): this;
    off(event: "error", listener: (err: Error) => void): this;
    off(event: "pipe" | "unpipe", listener: (src: Readable) => void): this;
    off(event: string, listener: (...args: any[]) => void): this;
    removeListener(event: "drain" | "finish" | "close", listener: () => void): this;
    removeListener(event: "error", listener: (err: Error) => void): this;
    removeListener(event: "pipe" | "unpipe", listener: (src: Readable) => void): this;
    removeListener(event: string, listener: (...args: any[]) => void): this;
  }

  /* Duplex is Readable + Writable in one object. TS single inheritance
   * mirrors @types/node: extends Readable, the writable half declared
   * again. The lowering treats both halves as first-class. */
  class Duplex extends Readable {
    constructor(opts?: DuplexOptions);
    /* The underscore-method surface (see Readable). */
    _write(chunk: any, encoding: string, callback: (error?: Error | null) => void): void;
    _writev(
      chunks: Array<{ chunk: any; encoding: string }>,
      callback: (error?: Error | null) => void,
    ): void;
    _final(callback: (error?: Error | null) => void): void;
    write(chunk: Buffer | string, callback?: (error?: Error | null) => void): boolean;
    write(
      chunk: Buffer | string,
      encoding: string,
      callback?: (error?: Error | null) => void,
    ): boolean;
    end(callback?: () => void): this;
    end(chunk: Buffer | string, callback?: () => void): this;
    end(chunk: Buffer | string, encoding: string, callback?: () => void): this;
    cork(): void;
    uncork(): void;
    setDefaultEncoding(encoding: string): this;
    readonly writable: boolean;
    readonly writableEnded: boolean;
    readonly writableFinished: boolean;
    readonly writableLength: number;
    readonly writableHighWaterMark: number;
    readonly writableObjectMode: boolean;
    readonly writableNeedDrain: boolean;
    readonly writableCorked: number;
    readonly allowHalfOpen: boolean;
    on(event: "data", listener: (chunk: any) => void): this;
    on(
      event: "end" | "close" | "readable" | "pause" | "resume" | "drain" | "finish",
      listener: () => void,
    ): this;
    on(event: "error", listener: (err: Error) => void): this;
    on(event: "pipe" | "unpipe", listener: (src: Readable) => void): this;
    on(event: string, listener: (...args: any[]) => void): this;
    once(event: "data", listener: (chunk: any) => void): this;
    once(
      event: "end" | "close" | "readable" | "pause" | "resume" | "drain" | "finish",
      listener: () => void,
    ): this;
    once(event: "error", listener: (err: Error) => void): this;
    once(event: "pipe" | "unpipe", listener: (src: Readable) => void): this;
    once(event: string, listener: (...args: any[]) => void): this;
    addListener(event: "data", listener: (chunk: any) => void): this;
    addListener(
      event: "end" | "close" | "readable" | "pause" | "resume" | "drain" | "finish",
      listener: () => void,
    ): this;
    addListener(event: "error", listener: (err: Error) => void): this;
    addListener(event: "pipe" | "unpipe", listener: (src: Readable) => void): this;
    addListener(event: string, listener: (...args: any[]) => void): this;
    prependListener(event: "data", listener: (chunk: any) => void): this;
    prependListener(
      event: "end" | "close" | "readable" | "pause" | "resume" | "drain" | "finish",
      listener: () => void,
    ): this;
    prependListener(event: "error", listener: (err: Error) => void): this;
    prependListener(event: "pipe" | "unpipe", listener: (src: Readable) => void): this;
    prependListener(event: string, listener: (...args: any[]) => void): this;
    prependOnceListener(event: "data", listener: (chunk: any) => void): this;
    prependOnceListener(
      event: "end" | "close" | "readable" | "pause" | "resume" | "drain" | "finish",
      listener: () => void,
    ): this;
    prependOnceListener(event: "error", listener: (err: Error) => void): this;
    prependOnceListener(event: "pipe" | "unpipe", listener: (src: Readable) => void): this;
    prependOnceListener(event: string, listener: (...args: any[]) => void): this;
    off(event: "data", listener: (chunk: any) => void): this;
    off(
      event: "end" | "close" | "readable" | "pause" | "resume" | "drain" | "finish",
      listener: () => void,
    ): this;
    off(event: "error", listener: (err: Error) => void): this;
    off(event: "pipe" | "unpipe", listener: (src: Readable) => void): this;
    off(event: string, listener: (...args: any[]) => void): this;
    removeListener(event: "data", listener: (chunk: any) => void): this;
    removeListener(
      event: "end" | "close" | "readable" | "pause" | "resume" | "drain" | "finish",
      listener: () => void,
    ): this;
    removeListener(event: "error", listener: (err: Error) => void): this;
    removeListener(event: "pipe" | "unpipe", listener: (src: Readable) => void): this;
    removeListener(event: string, listener: (...args: any[]) => void): this;
  }

  class Transform extends Duplex {
    constructor(opts?: TransformOptions);
    /* The underscore-method surface (see Readable). */
    _transform(
      chunk: any,
      encoding: string,
      callback: (error?: Error | null, data?: Buffer | string) => void,
    ): void;
    _flush(callback: (error?: Error | null, data?: Buffer | string) => void): void;
  }
  class PassThrough extends Transform {
    constructor(opts?: TransformOptions);
  }

  /* addAbortSignal(signal, stream): the stream, destroyed with an
   * AbortError (cause: signal.reason) when the signal aborts. */
  function addAbortSignal<T extends Readable | Writable>(signal: AbortSignal, stream: T): T;
  /* Declared so requires typecheck; each fences at its use site. */
  function pipeline(...streams: unknown[]): unknown;
  /* compose(...streams): a Duplex that writes to the first stream and
   * reads from the last, with the streams running as a pipeline. */
  function compose(...streams: Array<Readable | Writable>): Duplex;
  /* finished's options: readable/writable choose which ends count,
   * error: false ignores 'error' events, signal aborts the wait. */
  interface FinishedOptions {
    readable?: boolean;
    writable?: boolean;
    error?: boolean;
    signal?: AbortSignal;
  }
  function finished(stream: unknown, callback: (err?: Error | null) => void): () => void;
  function finished(
    stream: unknown,
    options: FinishedOptions | null,
    callback: (err?: Error | null) => void,
  ): () => void;
  /* Folds to the TARGET platform's default at compile time (win32 16384,
   * else 65536 — Node's own state.js split); literal argument only. */
  function getDefaultHighWaterMark(objectMode: boolean): number;
  /* The promise pipeline's result: a last stage that is an async
   * function resolves the promise with its value. */
  type PipelinePromise<T extends unknown[]> = T extends [
    ...unknown[],
    (...args: any[]) => Promise<infer P>,
  ]
    ? Promise<P>
    : Promise<void>;
  namespace promises {
    function pipeline<T extends unknown[]>(...streams: T): PipelinePromise<T>;
    function finished(
      stream: unknown,
      options?: FinishedOptions & { cleanup?: boolean },
    ): Promise<void>;
  }
  class Stream extends EventEmitter {}

  export {
    Readable,
    Writable,
    Duplex,
    Transform,
    PassThrough,
    Stream,
    addAbortSignal,
    pipeline,
    compose,
    finished,
    getDefaultHighWaterMark,
    promises,
  };
  export type {
    ReadableOptions,
    WritableOptions,
    DuplexOptions,
    TransformOptions,
    FinishedOptions,
  };
}
declare module "node:stream" {
  import stream = require("stream");
  export = stream;
}
declare module "stream/promises" {
  /* The promise forms of finished/pipeline: a void promise the stream's
   * terminal point settles (rejected with the error, or
   * ERR_STREAM_PREMATURE_CLOSE on an early close). Stream arguments are
   * the lowered surface — iterables/generators/functions fence per site.
   * pipeline's trailing { signal, end } object and finished's options
   * (readable, writable, error, cleanup, signal) are supported. A last
   * stage that is an async function resolves the promise with its value. */
  function pipeline<T extends unknown[]>(
    ...streams: T
  ): T extends [...unknown[], (...args: any[]) => Promise<infer P>] ? Promise<P> : Promise<void>;
  function finished(
    stream: unknown,
    options?: {
      readable?: boolean;
      writable?: boolean;
      error?: boolean;
      cleanup?: boolean;
      signal?: AbortSignal;
    } | null,
  ): Promise<void>;
  export { pipeline, finished };
}
declare module "node:stream/promises" {
  import streamPromises = require("stream/promises");
  export = streamPromises;
}
declare module "stream/consumers" {
  /* The promise consumers over a readable: accumulate every chunk and
   * settle — text (the utf8 decode), json (the text through JSON.parse:
   * `unknown`, validated with a checked cast; malformed input rejects
   * with the parse's SyntaxError), buffer (the concatenated bytes;
   * string chunks contribute their utf8 bytes, Node's Blob rule).
   * Stream errors reject; an early close rejects with
   * ERR_STREAM_PREMATURE_CLOSE. arrayBuffer answers an ArrayBuffer over
   * the bytes; blob fences per site. */
  function text(stream: unknown): Promise<string>;
  function json(stream: unknown): Promise<unknown>;
  function buffer(stream: unknown): Promise<Buffer>;
  function arrayBuffer(stream: unknown): Promise<ArrayBuffer>;
  function blob(stream: unknown): Promise<unknown>;
  export { arrayBuffer, blob, buffer, json, text };
}
declare module "node:stream/consumers" {
  import streamConsumers = require("stream/consumers");
  export = streamConsumers;
}
interface ErrorConstructor {
  stackTraceLimit: number;
}