@scriptc/compiler 0.4.5 → 0.4.6

package/ambient/node-fallback/test.d.ts

@@ -0,0 +1,236 @@
+/// <reference path="./assert.d.ts" />
+
+/* 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 = (s: SuiteContext) => void;
+  type HookFn = (c: TestContext | SuiteContext) => void | Promise<void>;
+  /* The describe/suite callback's context, and the before/after hook
+   * context of a suite. */
+  interface SuiteContext {
+    readonly name: string;
+    readonly fullName: string;
+    readonly filePath: string | undefined;
+    readonly attempt: number;
+    readonly passed: boolean;
+    diagnostic(message: string): 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 filePath: string | undefined;
+    readonly attempt: number;
+    readonly passed: boolean;
+    readonly workerId: number | undefined;
+    readonly tags: readonly string[];
+    readonly assert: TestContextAssert;
+    readonly mock: MockTracker;
+    test(name?: string, fn?: TestFn): Promise<void>;
+    test(name?: string, options?: TestOptions, fn?: TestFn): Promise<void>;
+    test(options?: TestOptions, fn?: TestFn): Promise<void>;
+    test(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 AssertSnapshotOptions {
+    readonly serializers?: ReadonlyArray<(value: any) => any> | undefined;
+  }
+  interface TestContextAssert {
+    snapshot(value: any, options?: AssertSnapshotOptions): void;
+    fileSnapshot(value: any, path: string, options?: AssertSnapshotOptions): void;
+    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;
+  }
+  /* The name, options and function are each optional, as in Node: a test
+   * without a name takes the function's name, or "<anonymous>". */
+  function test(name?: string, fn?: TestFn): Promise<void>;
+  function test(name?: string, options?: TestOptions, fn?: TestFn): Promise<void>;
+  function test(options?: TestOptions, fn?: TestFn): Promise<void>;
+  function test(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 skip(options?: TestOptions, fn?: TestFn): Promise<void>;
+    function skip(fn?: TestFn): Promise<void>;
+    function todo(name?: string, fn?: TestFn): Promise<void>;
+    function todo(name?: string, options?: TestOptions, fn?: TestFn): Promise<void>;
+    function todo(options?: TestOptions, fn?: TestFn): Promise<void>;
+    function todo(fn?: TestFn): Promise<void>;
+    function only(name?: string, fn?: TestFn): Promise<void>;
+    function only(name?: string, options?: TestOptions, fn?: TestFn): Promise<void>;
+    function only(options?: TestOptions, fn?: TestFn): Promise<void>;
+    function only(fn?: TestFn): Promise<void>;
+  }
+  const it: typeof test;
+  function describe(name?: string, fn?: SuiteFn): void;
+  function describe(name?: string, options?: TestOptions, fn?: SuiteFn): void;
+  function describe(options?: TestOptions, fn?: SuiteFn): void;
+  function describe(fn?: SuiteFn): void;
+  namespace describe {
+    function skip(name?: string, fn?: SuiteFn): void;
+    function skip(name?: string, options?: TestOptions, fn?: SuiteFn): void;
+    function skip(options?: TestOptions, fn?: SuiteFn): void;
+    function skip(fn?: SuiteFn): void;
+    function todo(name?: string, fn?: SuiteFn): void;
+    function todo(name?: string, options?: TestOptions, fn?: SuiteFn): void;
+    function todo(options?: TestOptions, fn?: SuiteFn): void;
+    function todo(fn?: SuiteFn): void;
+    function only(name?: string, fn?: SuiteFn): void;
+    function only(name?: string, options?: TestOptions, fn?: SuiteFn): void;
+    function only(options?: TestOptions, fn?: SuiteFn): void;
+    function only(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, mock.method and their t.mock
+   * twins, the tracker's restoreAll and reset, and 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 MockFunctionOptions {
+    times?: number;
+  }
+  type FunctionPropertyNames<T> = {
+    [K in keyof T]: T[K] extends Function ? K : never;
+  }[keyof T];
+  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, MethodName extends FunctionPropertyNames<MockedObject>>(
+      object: MockedObject,
+      methodName: MethodName,
+      options?: MockFunctionOptions,
+    ): MockedObject[MethodName] extends Function ? Mock<MockedObject[MethodName]> : never;
+    method<
+      MockedObject extends object,
+      MethodName extends FunctionPropertyNames<MockedObject>,
+      Implementation extends Function,
+    >(
+      object: MockedObject,
+      methodName: MethodName,
+      implementation: Implementation,
+      options?: MockFunctionOptions,
+    ): MockedObject[MethodName] extends Function
+      ? Mock<MockedObject[MethodName] | Implementation>
+      : never;
+    reset(): void;
+    restoreAll(): void;
+    readonly timers: MockTimers;
+  }
+  interface MockTimersOptions {
+    apis: ReadonlyArray<"setInterval" | "setTimeout" | "setImmediate" | "Date">;
+    now?: number | Date | undefined;
+  }
+  interface MockTimers {
+    enable(options?: MockTimersOptions): void;
+    setTime(milliseconds?: number): void;
+    reset(): void;
+    tick(milliseconds?: number): void;
+    runAll(): void;
+    [Symbol.dispose](): void;
+  }
+  const mock: MockTracker;
+  /* The context of the test, suite or hook running in the current async
+   * context; undefined outside one. */
+  function getTestContext(): TestContext | SuiteContext | undefined;
+  /* 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,
+    getTestContext,
+    run,
+    snapshot,
+    TestContext,
+    SuiteContext,
+    TestOptions,
+    Mock,
+    MockFunctionContext,
+    MockFunctionCall,
+    MockTracker,
+    MockTimers,
+    MockTimersOptions,
+  };
+  export default test;
+}

package/ambient/node-fallback/timers-promises.d.ts

@@ -0,0 +1,31 @@
+/* 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, options?: TimerOptions): Promise<void>;
+    yield(): Promise<void>;
+  };
+}
+
+declare module "timers/promises" {
+  export * from "node:timers/promises";
+}

package/ambient/node-fallback/timers.d.ts

@@ -0,0 +1,28 @@
+/* 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";
+}

package/ambient/node-fallback/tls.d.ts

@@ -0,0 +1,169 @@
+/// <reference path="./crypto.d.ts" />
+/// <reference path="./net.d.ts" />
+
+/* 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 as NetServer, Socket } from "net";
+  /** tls.Server: a net server whose connections handshake first. */
+  export interface Server extends NetServer {
+    /* serve `context` to clients whose SNI name matches `hostname` ('*'
+     * matches within one label); the newest match wins */
+    addContext(hostname: string, context: TlsOptions | SecureContext): void;
+    /* new connections serve a context made from `options` */
+    setSecureContext(options: TlsOptions): void;
+  }
+  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 {
+    readonly encrypted: true;
+    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;
+    /* whether the handshake resumed a cached session */
+    isSessionReused(): boolean;
+    /* the peer's certificate: {} before the handshake or without one,
+     * null once the socket is destroyed; detailed adds issuerCertificate */
+    getPeerCertificate(detailed: true): DetailedPeerCertificate;
+    getPeerCertificate(detailed?: false): PeerCertificate;
+    getPeerCertificate(detailed?: boolean): PeerCertificate | DetailedPeerCertificate;
+    /* the certificate this socket serves, the same way */
+    getCertificate(): PeerCertificate | object | null;
+    /* a new X509Certificate on each call, or undefined without one */
+    getPeerX509Certificate(): import("crypto").X509Certificate | undefined;
+    getX509Certificate(): import("crypto").X509Certificate | undefined;
+  }
+  /* A certificate as getPeerCertificate() and X509Certificate's
+   * toLegacyObject() answer it: subject and issuer map attribute short
+   * names to values, infoAccess its "<method> - <type>" keys to values. */
+  export interface PeerCertificate {
+    subject: { [attribute: string]: string | string[] };
+    issuer: { [attribute: string]: string | string[] };
+    subjectaltname?: string;
+    infoAccess?: { [key: string]: string[] };
+    ca: boolean;
+    modulus?: string;
+    exponent?: string;
+    pubkey?: Buffer;
+    bits?: number;
+    valid_from: string;
+    valid_to: string;
+    fingerprint: string;
+    fingerprint256: string;
+    fingerprint512: string;
+    ext_key_usage?: string[];
+    serialNumber: string;
+    raw: Buffer;
+    asn1Curve?: string;
+    nistCurve?: string;
+  }
+  /* getPeerCertificate(true): each certificate links to its issuer; a
+   * self-issued root is its own issuerCertificate */
+  export interface DetailedPeerCertificate extends PeerCertificate {
+    issuerCertificate: DetailedPeerCertificate;
+  }
+
+  /** new tls.TLSSocket(socket, options): the server-mode wrap of an open
+   * socket (a server connection or an http CONNECT socket). The options
+   * record reads at runtime; isServer, cert, key, secureContext,
+   * ALPNProtocols, minVersion and maxVersion are implemented. */
+  export interface TLSSocketOptions {
+    isServer?: boolean;
+    cert?: string | Uint8Array;
+    key?: string | Uint8Array;
+    secureContext?: SecureContext;
+    ALPNProtocols?: string[] | Uint8Array;
+    minVersion?: string;
+    maxVersion?: string;
+    [option: string]: unknown;
+  }
+  export const TLSSocket: new (socket: Socket, options: TLSSocketOptions) => TLSSocket;
+  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/socket/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;
+    /* an open socket to run the client handshake over */
+    socket?: Socket;
+    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 {}
+  /* @types/node's name for createSecureContext's options */
+  export type SecureContextOptions = TlsOptions;
+  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";
+}

package/ambient/node-fallback/url.d.ts

@@ -0,0 +1,95 @@
+/// <reference path="./querystring.d.ts" />
+
+/* 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, the domain pair
+ * converts a hostname to and from its Punycode form, and urlToHttpOptions
+ * builds http.request options from a URL. */
+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;
+  /** urlToHttpOptions's null-prototype request options. */
+  export interface UrlHttpOptions {
+    protocol: string;
+    hostname: string;
+    hash: string;
+    search: string;
+    pathname: string;
+    path: string;
+    href: string;
+    port?: number;
+    auth?: string;
+  }
+  export function urlToHttpOptions(url: URL): UrlHttpOptions;
+}
+
+declare module "node:url" {
+  export * from "url";
+}

package/ambient/node-fallback/util-types.d.ts

@@ -0,0 +1,50 @@
+/* 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 isFloat16Array(value: unknown): value is Float16Array;
+  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;
+  export function isDate(value: unknown): value is Date;
+  export function isSharedArrayBuffer(value: unknown): value is SharedArrayBuffer;
+  export function isMapIterator(value: unknown): boolean;
+  export function isSetIterator(value: unknown): boolean;
+  export function isKeyObject(value: unknown): boolean;
+  export function isNumberObject(value: unknown): boolean;
+  export function isStringObject(value: unknown): boolean;
+  export function isBooleanObject(value: unknown): boolean;
+  export function isBigIntObject(value: unknown): boolean;
+  export function isSymbolObject(value: unknown): boolean;
+  export function isBoxedPrimitive(value: unknown): boolean;
+  export function isBigInt64Array(value: unknown): value is BigInt64Array;
+  export function isBigUint64Array(value: unknown): value is BigUint64Array;
+  export function isCryptoKey(value: unknown): boolean;
+  export function isExternal(value: unknown): boolean;
+}
+
+declare module "node:util/types" {
+  export * from "util/types";
+}