@types/node 14.18.61 → 14.18.63

node v14.18/ts4.8/tls.d.ts

@@ -1,6 +1,6 @@
-declare module 'node:tls' {
-    import * as net from 'net';
-    import * as stream from 'stream';
+declare module "tls" {
+    import * as net from "net";
+    import * as stream from "stream";
 
     const CLIENT_RENEG_LIMIT: number;
     const CLIENT_RENEG_WINDOW: number;
@@ -266,7 +266,10 @@ declare module 'node:tls' {
          * is successfully completed.
          * @return `undefined` when socket is destroy, `false` if negotiaion can't be initiated.
          */
-        renegotiate(options: { rejectUnauthorized?: boolean | undefined, requestCert?: boolean | undefined }, callback: (err: Error | null) => void): undefined | boolean;
+        renegotiate(
+            options: { rejectUnauthorized?: boolean | undefined; requestCert?: boolean | undefined },
+            callback: (err: Error | null) => void,
+        ): undefined | boolean;
         /**
          * Set maximum TLS fragment size (default and maximum value is: 16384, minimum is: 512).
          * Smaller fragment size decreases buffering latency on the client: large fragments are buffered by
@@ -404,7 +407,6 @@ declare module 'node:tls' {
         ticketKeys?: Buffer | undefined;
 
         /**
-         *
          * @param socket
          * @param identity identity parameter sent from the client.
          * @return pre-shared key that must either be
@@ -484,7 +486,6 @@ declare module 'node:tls' {
          */
         getTicketKeys(): Buffer;
         /**
-         *
          * The server.setSecureContext() method replaces the
          * secure context of an existing server. Existing connections to the
          * server are not interrupted.
@@ -508,49 +509,120 @@ declare module 'node:tls' {
          */
         addListener(event: string, listener: (...args: any[]) => void): this;
         addListener(event: "tlsClientError", listener: (err: Error, tlsSocket: TLSSocket) => void): this;
-        addListener(event: "newSession", listener: (sessionId: Buffer, sessionData: Buffer, callback: () => void) => void): this;
-        addListener(event: "OCSPRequest", listener: (certificate: Buffer, issuer: Buffer, callback: (err: Error | null, resp: Buffer) => void) => void): this;
-        addListener(event: "resumeSession", listener: (sessionId: Buffer, callback: (err: Error | null, sessionData: Buffer | null) => void) => void): this;
+        addListener(
+            event: "newSession",
+            listener: (sessionId: Buffer, sessionData: Buffer, callback: () => void) => void,
+        ): this;
+        addListener(
+            event: "OCSPRequest",
+            listener: (
+                certificate: Buffer,
+                issuer: Buffer,
+                callback: (err: Error | null, resp: Buffer) => void,
+            ) => void,
+        ): this;
+        addListener(
+            event: "resumeSession",
+            listener: (sessionId: Buffer, callback: (err: Error | null, sessionData: Buffer | null) => void) => void,
+        ): this;
         addListener(event: "secureConnection", listener: (tlsSocket: TLSSocket) => void): this;
         addListener(event: "keylog", listener: (line: Buffer, tlsSocket: TLSSocket) => void): this;
 
         emit(event: string | symbol, ...args: any[]): boolean;
         emit(event: "tlsClientError", err: Error, tlsSocket: TLSSocket): boolean;
         emit(event: "newSession", sessionId: Buffer, sessionData: Buffer, callback: () => void): boolean;
-        emit(event: "OCSPRequest", certificate: Buffer, issuer: Buffer, callback: (err: Error | null, resp: Buffer) => void): boolean;
-        emit(event: "resumeSession", sessionId: Buffer, callback: (err: Error | null, sessionData: Buffer | null) => void): boolean;
+        emit(
+            event: "OCSPRequest",
+            certificate: Buffer,
+            issuer: Buffer,
+            callback: (err: Error | null, resp: Buffer) => void,
+        ): boolean;
+        emit(
+            event: "resumeSession",
+            sessionId: Buffer,
+            callback: (err: Error | null, sessionData: Buffer | null) => void,
+        ): boolean;
         emit(event: "secureConnection", tlsSocket: TLSSocket): boolean;
         emit(event: "keylog", line: Buffer, tlsSocket: TLSSocket): boolean;
 
         on(event: string, listener: (...args: any[]) => void): this;
         on(event: "tlsClientError", listener: (err: Error, tlsSocket: TLSSocket) => void): this;
         on(event: "newSession", listener: (sessionId: Buffer, sessionData: Buffer, callback: () => void) => void): this;
-        on(event: "OCSPRequest", listener: (certificate: Buffer, issuer: Buffer, callback: (err: Error | null, resp: Buffer) => void) => void): this;
-        on(event: "resumeSession", listener: (sessionId: Buffer, callback: (err: Error | null, sessionData: Buffer | null) => void) => void): this;
+        on(
+            event: "OCSPRequest",
+            listener: (
+                certificate: Buffer,
+                issuer: Buffer,
+                callback: (err: Error | null, resp: Buffer) => void,
+            ) => void,
+        ): this;
+        on(
+            event: "resumeSession",
+            listener: (sessionId: Buffer, callback: (err: Error | null, sessionData: Buffer | null) => void) => void,
+        ): this;
         on(event: "secureConnection", listener: (tlsSocket: TLSSocket) => void): this;
         on(event: "keylog", listener: (line: Buffer, tlsSocket: TLSSocket) => void): this;
 
         once(event: string, listener: (...args: any[]) => void): this;
         once(event: "tlsClientError", listener: (err: Error, tlsSocket: TLSSocket) => void): this;
-        once(event: "newSession", listener: (sessionId: Buffer, sessionData: Buffer, callback: () => void) => void): this;
-        once(event: "OCSPRequest", listener: (certificate: Buffer, issuer: Buffer, callback: (err: Error | null, resp: Buffer) => void) => void): this;
-        once(event: "resumeSession", listener: (sessionId: Buffer, callback: (err: Error | null, sessionData: Buffer | null) => void) => void): this;
+        once(
+            event: "newSession",
+            listener: (sessionId: Buffer, sessionData: Buffer, callback: () => void) => void,
+        ): this;
+        once(
+            event: "OCSPRequest",
+            listener: (
+                certificate: Buffer,
+                issuer: Buffer,
+                callback: (err: Error | null, resp: Buffer) => void,
+            ) => void,
+        ): this;
+        once(
+            event: "resumeSession",
+            listener: (sessionId: Buffer, callback: (err: Error | null, sessionData: Buffer | null) => void) => void,
+        ): this;
         once(event: "secureConnection", listener: (tlsSocket: TLSSocket) => void): this;
         once(event: "keylog", listener: (line: Buffer, tlsSocket: TLSSocket) => void): this;
 
         prependListener(event: string, listener: (...args: any[]) => void): this;
         prependListener(event: "tlsClientError", listener: (err: Error, tlsSocket: TLSSocket) => void): this;
-        prependListener(event: "newSession", listener: (sessionId: Buffer, sessionData: Buffer, callback: () => void) => void): this;
-        prependListener(event: "OCSPRequest", listener: (certificate: Buffer, issuer: Buffer, callback: (err: Error | null, resp: Buffer) => void) => void): this;
-        prependListener(event: "resumeSession", listener: (sessionId: Buffer, callback: (err: Error | null, sessionData: Buffer | null) => void) => void): this;
+        prependListener(
+            event: "newSession",
+            listener: (sessionId: Buffer, sessionData: Buffer, callback: () => void) => void,
+        ): this;
+        prependListener(
+            event: "OCSPRequest",
+            listener: (
+                certificate: Buffer,
+                issuer: Buffer,
+                callback: (err: Error | null, resp: Buffer) => void,
+            ) => void,
+        ): this;
+        prependListener(
+            event: "resumeSession",
+            listener: (sessionId: Buffer, callback: (err: Error | null, sessionData: Buffer | null) => void) => void,
+        ): this;
         prependListener(event: "secureConnection", listener: (tlsSocket: TLSSocket) => void): this;
         prependListener(event: "keylog", listener: (line: Buffer, tlsSocket: TLSSocket) => void): this;
 
         prependOnceListener(event: string, listener: (...args: any[]) => void): this;
         prependOnceListener(event: "tlsClientError", listener: (err: Error, tlsSocket: TLSSocket) => void): this;
-        prependOnceListener(event: "newSession", listener: (sessionId: Buffer, sessionData: Buffer, callback: () => void) => void): this;
-        prependOnceListener(event: "OCSPRequest", listener: (certificate: Buffer, issuer: Buffer, callback: (err: Error | null, resp: Buffer) => void) => void): this;
-        prependOnceListener(event: "resumeSession", listener: (sessionId: Buffer, callback: (err: Error | null, sessionData: Buffer | null) => void) => void): this;
+        prependOnceListener(
+            event: "newSession",
+            listener: (sessionId: Buffer, sessionData: Buffer, callback: () => void) => void,
+        ): this;
+        prependOnceListener(
+            event: "OCSPRequest",
+            listener: (
+                certificate: Buffer,
+                issuer: Buffer,
+                callback: (err: Error | null, resp: Buffer) => void,
+            ) => void,
+        ): this;
+        prependOnceListener(
+            event: "resumeSession",
+            listener: (sessionId: Buffer, callback: (err: Error | null, sessionData: Buffer | null) => void) => void,
+        ): this;
         prependOnceListener(event: "secureConnection", listener: (tlsSocket: TLSSocket) => void): this;
         prependOnceListener(event: "keylog", listener: (line: Buffer, tlsSocket: TLSSocket) => void): this;
     }
@@ -560,7 +632,7 @@ declare module 'node:tls' {
         cleartext: TLSSocket;
     }
 
-    type SecureVersion = 'TLSv1.3' | 'TLSv1.2' | 'TLSv1.1' | 'TLSv1';
+    type SecureVersion = "TLSv1.3" | "TLSv1.2" | "TLSv1.1" | "TLSv1";
 
     interface SecureContextOptions {
         /**
@@ -736,12 +808,22 @@ declare module 'node:tls' {
     function createServer(secureConnectionListener?: (socket: TLSSocket) => void): Server;
     function createServer(options: TlsOptions, secureConnectionListener?: (socket: TLSSocket) => void): Server;
     function connect(options: ConnectionOptions, secureConnectListener?: () => void): TLSSocket;
-    function connect(port: number, host?: string, options?: ConnectionOptions, secureConnectListener?: () => void): TLSSocket;
+    function connect(
+        port: number,
+        host?: string,
+        options?: ConnectionOptions,
+        secureConnectListener?: () => void,
+    ): TLSSocket;
     function connect(port: number, options?: ConnectionOptions, secureConnectListener?: () => void): TLSSocket;
     /**
      * @deprecated since v0.11.3 Use `tls.TLSSocket` instead.
      */
-    function createSecurePair(credentials?: SecureContext, isServer?: boolean, requestCert?: boolean, rejectUnauthorized?: boolean): SecurePair;
+    function createSecurePair(
+        credentials?: SecureContext,
+        isServer?: boolean,
+        requestCert?: boolean,
+        rejectUnauthorized?: boolean,
+    ): SecurePair;
     function createSecureContext(options?: SecureContextOptions): SecureContext;
     function getCiphers(): string[];
 
@@ -779,6 +861,6 @@ declare module 'node:tls' {
      */
     const rootCertificates: ReadonlyArray<string>;
 }
-declare module 'tls' {
-    export * from 'node:tls';
+declare module "node:tls" {
+    export * from "tls";
 }

node v14.18/ts4.8/trace_events.d.ts

@@ -1,4 +1,4 @@
-declare module 'node:trace_events' {
+declare module "trace_events" {
     /**
      * The `Tracing` object is used to enable or disable tracing for sets of
      * categories. Instances are created using the
@@ -59,6 +59,6 @@ declare module 'node:trace_events' {
      */
     function getEnabledCategories(): string | undefined;
 }
-declare module 'trace_events' {
-    export * from 'node:trace_events';
+declare module "node:trace_events" {
+    export * from "trace_events";
 }

node v14.18/ts4.8/tty.d.ts

@@ -1,5 +1,5 @@
-declare module 'node:tty' {
-    import * as net from 'net';
+declare module "tty" {
+    import * as net from "net";
 
     function isatty(fd: number): boolean;
     class ReadStream extends net.Socket {
@@ -64,6 +64,6 @@ declare module 'node:tty' {
         isTTY: boolean;
     }
 }
-declare module 'tty' {
-    export * from 'node:tty';
+declare module "node:tty" {
+    export * from "tty";
 }

node v14.18/ts4.8/url.d.ts

@@ -1,6 +1,6 @@
-declare module 'node:url' {
-    import { ClientRequestArgs } from 'node:http';
-    import { ParsedUrlQuery, ParsedUrlQueryInput } from 'querystring';
+declare module "url" {
+    import { ClientRequestArgs } from "node:http";
+    import { ParsedUrlQuery, ParsedUrlQueryInput } from "querystring";
 
     // Input to `url.format`
     interface UrlObject {
@@ -44,7 +44,11 @@ declare module 'node:url' {
     /** @deprecated since v11.0.0 - Use the WHATWG URL API. */
     function parse(urlStr: string): UrlWithStringQuery;
     /** @deprecated since v11.0.0 - Use the WHATWG URL API. */
-    function parse(urlStr: string, parseQueryString: false | undefined, slashesDenoteHost?: boolean): UrlWithStringQuery;
+    function parse(
+        urlStr: string,
+        parseQueryString: false | undefined,
+        slashesDenoteHost?: boolean,
+    ): UrlWithStringQuery;
     /** @deprecated since v11.0.0 - Use the WHATWG URL API. */
     function parse(urlStr: string, parseQueryString: true, slashesDenoteHost?: boolean): UrlWithParsedQuery;
     /** @deprecated since v11.0.0 - Use the WHATWG URL API. */
@@ -126,7 +130,14 @@ declare module 'node:url' {
     }
 
     class URLSearchParams implements Iterable<[string, string]> {
-        constructor(init?: URLSearchParams | string | Record<string, string | ReadonlyArray<string>> | Iterable<[string, string]> | ReadonlyArray<[string, string]>);
+        constructor(
+            init?:
+                | URLSearchParams
+                | string
+                | Record<string, string | ReadonlyArray<string>>
+                | Iterable<[string, string]>
+                | ReadonlyArray<[string, string]>,
+        );
         readonly size: number;
         append(name: string, value: string): void;
         delete(name: string): void;
@@ -143,7 +154,7 @@ declare module 'node:url' {
         [Symbol.iterator](): IterableIterator<[string, string]>;
     }
 
-    import { URL as _URL, URLSearchParams as _URLSearchParams } from 'url';
+    import { URL as _URL, URLSearchParams as _URLSearchParams } from "url";
     global {
         interface URLSearchParams extends _URLSearchParams {}
         interface URL extends _URL {}
@@ -158,8 +169,7 @@ declare module 'node:url' {
          */
         var URL:
             // For compatibility with "dom" and "webworker" URL declarations
-            typeof globalThis extends { onmessage: any, URL: infer URL }
-                ? URL
+            typeof globalThis extends { onmessage: any; URL: infer URL } ? URL
                 : typeof _URL;
         /**
          * `URLSearchParams` class is a global reference for `require('url').URLSearchParams`.
@@ -168,11 +178,10 @@ declare module 'node:url' {
          */
         var URLSearchParams:
             // For compatibility with "dom" and "webworker" URLSearchParams declarations
-            typeof globalThis extends { onmessage: any, URLSearchParams: infer URLSearchParams }
-                ? URLSearchParams
+            typeof globalThis extends { onmessage: any; URLSearchParams: infer URLSearchParams } ? URLSearchParams
                 : typeof _URLSearchParams;
     }
 }
-declare module 'url' {
-    export * from 'node:url';
+declare module "node:url" {
+    export * from "url";
 }

node v14.18/ts4.8/util.d.ts

@@ -1,6 +1,17 @@
-declare module 'node:util' {
-    interface InspectOptions extends NodeJS.InspectOptions { }
-    type Style = 'special' | 'number' | 'bigint' | 'boolean' | 'undefined' | 'null' | 'string' | 'symbol' | 'date' | 'regexp' | 'module';
+declare module "util" {
+    interface InspectOptions extends NodeJS.InspectOptions {}
+    type Style =
+        | "special"
+        | "number"
+        | "bigint"
+        | "boolean"
+        | "undefined"
+        | "null"
+        | "string"
+        | "symbol"
+        | "date"
+        | "regexp"
+        | "module";
     type CustomInspectFunction = (depth: number, options: InspectOptionsStylized) => string;
     interface InspectOptionsStylized extends InspectOptions {
         stylize(text: string, styleType: Style): string;
@@ -15,7 +26,7 @@ declare module 'node:util' {
     namespace inspect {
         let colors: NodeJS.Dict<[number, number]>;
         let styles: {
-            [K in Style]: string
+            [K in Style]: string;
         };
         let defaultOptions: InspectOptions;
         /**
@@ -65,29 +76,74 @@ declare module 'node:util' {
     function isDeepStrictEqual(val1: any, val2: any): boolean;
 
     function callbackify(fn: () => Promise<void>): (callback: (err: NodeJS.ErrnoException) => void) => void;
-    function callbackify<TResult>(fn: () => Promise<TResult>): (callback: (err: NodeJS.ErrnoException, result: TResult) => void) => void;
-    function callbackify<T1>(fn: (arg1: T1) => Promise<void>): (arg1: T1, callback: (err: NodeJS.ErrnoException) => void) => void;
-    function callbackify<T1, TResult>(fn: (arg1: T1) => Promise<TResult>): (arg1: T1, callback: (err: NodeJS.ErrnoException, result: TResult) => void) => void;
-    function callbackify<T1, T2>(fn: (arg1: T1, arg2: T2) => Promise<void>): (arg1: T1, arg2: T2, callback: (err: NodeJS.ErrnoException) => void) => void;
-    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;
-    function callbackify<T1, T2, T3>(fn: (arg1: T1, arg2: T2, arg3: T3) => Promise<void>): (arg1: T1, arg2: T2, arg3: T3, callback: (err: NodeJS.ErrnoException) => void) => void;
+    function callbackify<TResult>(
+        fn: () => Promise<TResult>,
+    ): (callback: (err: NodeJS.ErrnoException, result: TResult) => void) => void;
+    function callbackify<T1>(
+        fn: (arg1: T1) => Promise<void>,
+    ): (arg1: T1, callback: (err: NodeJS.ErrnoException) => void) => void;
+    function callbackify<T1, TResult>(
+        fn: (arg1: T1) => Promise<TResult>,
+    ): (arg1: T1, callback: (err: NodeJS.ErrnoException, result: TResult) => void) => void;
+    function callbackify<T1, T2>(
+        fn: (arg1: T1, arg2: T2) => Promise<void>,
+    ): (arg1: T1, arg2: T2, callback: (err: NodeJS.ErrnoException) => void) => void;
+    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;
+    function callbackify<T1, T2, T3>(
+        fn: (arg1: T1, arg2: T2, arg3: T3) => Promise<void>,
+    ): (arg1: T1, arg2: T2, arg3: T3, callback: (err: NodeJS.ErrnoException) => void) => void;
     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;
+        fn: (arg1: T1, arg2: T2, arg3: T3) => Promise<TResult>,
+    ): (arg1: T1, arg2: T2, arg3: T3, callback: (err: NodeJS.ErrnoException | null, result: TResult) => void) => void;
     function callbackify<T1, T2, T3, T4>(
-        fn: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => Promise<void>): (arg1: T1, arg2: T2, arg3: T3, arg4: T4, callback: (err: NodeJS.ErrnoException) => void) => void;
+        fn: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => Promise<void>,
+    ): (arg1: T1, arg2: T2, arg3: T3, arg4: T4, callback: (err: NodeJS.ErrnoException) => void) => void;
     function callbackify<T1, T2, T3, T4, TResult>(
-        fn: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => Promise<TResult>): (arg1: T1, arg2: T2, arg3: T3, arg4: T4, callback: (err: NodeJS.ErrnoException | null, result: TResult) => void) => void;
+        fn: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => Promise<TResult>,
+    ): (
+        arg1: T1,
+        arg2: T2,
+        arg3: T3,
+        arg4: T4,
+        callback: (err: NodeJS.ErrnoException | null, result: TResult) => void,
+    ) => void;
     function callbackify<T1, T2, T3, T4, T5>(
-        fn: (arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5) => Promise<void>): (arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, callback: (err: NodeJS.ErrnoException) => void) => void;
+        fn: (arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5) => Promise<void>,
+    ): (arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, callback: (err: NodeJS.ErrnoException) => void) => void;
     function callbackify<T1, T2, T3, T4, T5, TResult>(
         fn: (arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5) => Promise<TResult>,
-    ): (arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, callback: (err: NodeJS.ErrnoException | null, result: TResult) => void) => void;
+    ): (
+        arg1: T1,
+        arg2: T2,
+        arg3: T3,
+        arg4: T4,
+        arg5: T5,
+        callback: (err: NodeJS.ErrnoException | null, result: TResult) => void,
+    ) => void;
     function callbackify<T1, T2, T3, T4, T5, T6>(
         fn: (arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, arg6: T6) => Promise<void>,
-    ): (arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, arg6: T6, callback: (err: NodeJS.ErrnoException) => void) => void;
+    ): (
+        arg1: T1,
+        arg2: T2,
+        arg3: T3,
+        arg4: T4,
+        arg5: T5,
+        arg6: T6,
+        callback: (err: NodeJS.ErrnoException) => void,
+    ) => void;
     function callbackify<T1, T2, T3, T4, T5, T6, TResult>(
-        fn: (arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, arg6: T6) => Promise<TResult>
-    ): (arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, arg6: T6, callback: (err: NodeJS.ErrnoException | null, result: TResult) => void) => void;
+        fn: (arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, arg6: T6) => Promise<TResult>,
+    ): (
+        arg1: T1,
+        arg2: T2,
+        arg3: T3,
+        arg4: T4,
+        arg5: T5,
+        arg6: T6,
+        callback: (err: NodeJS.ErrnoException | null, result: TResult) => void,
+    ) => void;
 
     interface CustomPromisifyLegacy<TCustom extends Function> extends Function {
         __promisify__: TCustom;
@@ -102,18 +158,28 @@ declare module 'node:util' {
     function promisify<TCustom extends Function>(fn: CustomPromisify<TCustom>): TCustom;
     function promisify<TResult>(fn: (callback: (err: any, result: TResult) => void) => void): () => Promise<TResult>;
     function promisify(fn: (callback: (err?: any) => void) => void): () => Promise<void>;
-    function promisify<T1, TResult>(fn: (arg1: T1, callback: (err: any, result: TResult) => void) => void): (arg1: T1) => Promise<TResult>;
+    function promisify<T1, TResult>(
+        fn: (arg1: T1, callback: (err: any, result: TResult) => void) => void,
+    ): (arg1: T1) => Promise<TResult>;
     function promisify<T1>(fn: (arg1: T1, callback: (err?: any) => void) => void): (arg1: T1) => Promise<void>;
-    function promisify<T1, T2, TResult>(fn: (arg1: T1, arg2: T2, callback: (err: any, result: TResult) => void) => void): (arg1: T1, arg2: T2) => Promise<TResult>;
-    function promisify<T1, T2>(fn: (arg1: T1, arg2: T2, callback: (err?: any) => void) => void): (arg1: T1, arg2: T2) => Promise<void>;
-    function promisify<T1, T2, T3, TResult>(fn: (arg1: T1, arg2: T2, arg3: T3, callback: (err: any, result: TResult) => void) => void):
-        (arg1: T1, arg2: T2, arg3: T3) => Promise<TResult>;
-    function promisify<T1, T2, T3>(fn: (arg1: T1, arg2: T2, arg3: T3, callback: (err?: any) => void) => void): (arg1: T1, arg2: T2, arg3: T3) => Promise<void>;
+    function promisify<T1, T2, TResult>(
+        fn: (arg1: T1, arg2: T2, callback: (err: any, result: TResult) => void) => void,
+    ): (arg1: T1, arg2: T2) => Promise<TResult>;
+    function promisify<T1, T2>(
+        fn: (arg1: T1, arg2: T2, callback: (err?: any) => void) => void,
+    ): (arg1: T1, arg2: T2) => Promise<void>;
+    function promisify<T1, T2, T3, TResult>(
+        fn: (arg1: T1, arg2: T2, arg3: T3, callback: (err: any, result: TResult) => void) => void,
+    ): (arg1: T1, arg2: T2, arg3: T3) => Promise<TResult>;
+    function promisify<T1, T2, T3>(
+        fn: (arg1: T1, arg2: T2, arg3: T3, callback: (err?: any) => void) => void,
+    ): (arg1: T1, arg2: T2, arg3: T3) => Promise<void>;
     function promisify<T1, T2, T3, T4, TResult>(
         fn: (arg1: T1, arg2: T2, arg3: T3, arg4: T4, callback: (err: any, result: TResult) => void) => void,
     ): (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => Promise<TResult>;
-    function promisify<T1, T2, T3, T4>(fn: (arg1: T1, arg2: T2, arg3: T3, arg4: T4, callback: (err?: any) => void) => void):
-        (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => Promise<void>;
+    function promisify<T1, T2, T3, T4>(
+        fn: (arg1: T1, arg2: T2, arg3: T3, arg4: T4, callback: (err?: any) => void) => void,
+    ): (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => Promise<void>;
     function promisify<T1, T2, T3, T4, T5, TResult>(
         fn: (arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, callback: (err: any, result: TResult) => void) => void,
     ): (arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5) => Promise<TResult>;
@@ -147,10 +213,8 @@ declare module 'node:util' {
         function isInt32Array(object: any): object is Int32Array;
         function isMap<T>(
             object: T | {},
-        ): object is T extends ReadonlyMap<any, any>
-            ? unknown extends T
-                ? never
-                : ReadonlyMap<any, any>
+        ): object is T extends ReadonlyMap<any, any> ? unknown extends T ? never
+            : ReadonlyMap<any, any>
             : Map<any, any>;
         function isMapIterator(object: any): boolean;
         function isModuleNamespaceObject(value: any): boolean;
@@ -161,10 +225,8 @@ declare module 'node:util' {
         function isRegExp(object: any): object is RegExp;
         function isSet<T>(
             object: T | {},
-        ): object is T extends ReadonlySet<any>
-            ? unknown extends T
-                ? never
-                : ReadonlySet<any>
+        ): object is T extends ReadonlySet<any> ? unknown extends T ? never
+            : ReadonlySet<any>
             : Set<any>;
         function isSetIterator(object: any): boolean;
         function isSharedArrayBuffer(object: any): object is SharedArrayBuffer;
@@ -184,12 +246,12 @@ declare module 'node:util' {
         readonly fatal: boolean;
         readonly ignoreBOM: boolean;
         constructor(
-          encoding?: string,
-          options?: { fatal?: boolean | undefined; ignoreBOM?: boolean | undefined }
+            encoding?: string,
+            options?: { fatal?: boolean | undefined; ignoreBOM?: boolean | undefined },
         );
         decode(
-          input?: NodeJS.ArrayBufferView | ArrayBuffer | null,
-          options?: { stream?: boolean | undefined }
+            input?: NodeJS.ArrayBufferView | ArrayBuffer | null,
+            options?: { stream?: boolean | undefined },
         ): string;
     }
 
@@ -211,6 +273,6 @@ declare module 'node:util' {
         encodeInto(input: string, output: Uint8Array): EncodeIntoResult;
     }
 }
-declare module 'util' {
-    export * from 'node:util';
+declare module "node:util" {
+    export * from "util";
 }

node v14.18/ts4.8/v8.d.ts

@@ -1,5 +1,5 @@
-declare module 'node:v8' {
-    import { Readable } from 'stream';
+declare module "v8" {
+    import { Readable } from "stream";
 
     interface HeapSpaceInfo {
         space_name: string;
@@ -52,7 +52,6 @@ declare module 'node:v8' {
     function getHeapSnapshot(): Readable;
 
     /**
-     *
      * @param fileName The file path where the V8 heap snapshot is to be
      * saved. If not specified, a file name with the pattern
      * `'Heap-${yyyymmdd}-${hhmmss}-${pid}-${thread_id}.heapsnapshot'` will be
@@ -185,6 +184,6 @@ declare module 'node:v8' {
      */
     function deserialize(data: NodeJS.TypedArray): any;
 }
-declare module 'v8' {
-    export * from 'node:v8';
+declare module "node:v8" {
+    export * from "v8";
 }

node v14.18/ts4.8/vm.d.ts

@@ -1,5 +1,5 @@
-declare module 'node:vm' {
-    interface Context extends NodeJS.Dict<any> { }
+declare module "vm" {
+    interface Context extends NodeJS.Dict<any> {}
     interface BaseOptions {
         /**
          * Specifies the filename used in stack traces produced by this script.
@@ -45,7 +45,7 @@ declare module 'node:vm' {
         /**
          * If set to `afterEvaluate`, microtasks will be run immediately after the script has run.
          */
-        microtaskMode?: 'afterEvaluate' | undefined;
+        microtaskMode?: "afterEvaluate" | undefined;
     }
     interface CompileFunctionOptions extends BaseOptions {
         /**
@@ -98,10 +98,10 @@ declare module 'node:vm' {
         /**
          * If set to `afterEvaluate`, microtasks will be run immediately after the script has run.
          */
-        microtaskMode?: 'afterEvaluate' | undefined;
+        microtaskMode?: "afterEvaluate" | undefined;
     }
 
-    type MeasureMemoryMode = 'summary' | 'detailed';
+    type MeasureMemoryMode = "summary" | "detailed";
 
     interface MeasureMemoryOptions {
         /**
@@ -150,6 +150,6 @@ declare module 'node:vm' {
      */
     function measureMemory(options?: MeasureMemoryOptions): Promise<MemoryMeasurement>;
 }
-declare module 'vm' {
-    export * from 'node:vm';
+declare module "node:vm" {
+    export * from "vm";
 }

node v14.18/ts4.8/wasi.d.ts

@@ -1,4 +1,4 @@
-declare module 'node:wasi' {
+declare module "wasi" {
     interface WASIOptions {
         /**
          * An array of strings that the WebAssembly application will
@@ -52,7 +52,6 @@ declare module 'node:wasi' {
     class WASI {
         constructor(options?: WASIOptions);
         /**
-         *
          * Attempt to begin execution of `instance` by invoking its `_start()` export.
          * If `instance` does not contain a `_start()` export, then `start()` attempts to
          * invoke the `__wasi_unstable_reactor_start()` export. If neither of those exports
@@ -84,6 +83,6 @@ declare module 'node:wasi' {
         readonly wasiImport: NodeJS.Dict<any>; // TODO: Narrow to DOM types
     }
 }
-declare module 'wasi' {
-    export * from 'node:wasi';
+declare module "node:wasi" {
+    export * from "wasi";
 }

node v14.18/ts4.8/worker_threads.d.ts

@@ -1,9 +1,9 @@
-declare module 'node:worker_threads' {
-    import { Context } from 'vm';
-    import EventEmitter = require('events');
-    import { Readable, Writable } from 'stream';
-    import { URL } from 'url';
-    import { FileHandle } from 'fs/promises';
+declare module "worker_threads" {
+    import { Context } from "vm";
+    import EventEmitter = require("events");
+    import { Readable, Writable } from "stream";
+    import { URL } from "url";
+    import { FileHandle } from "fs/promises";
 
     const isMainThread: boolean;
     const parentPort: null | MessagePort;
@@ -236,6 +236,6 @@ declare module 'node:worker_threads' {
      */
     function receiveMessageOnPort(port: MessagePort): { message: any } | undefined;
 }
-declare module 'worker_threads' {
-    export * from 'node:worker_threads';
+declare module "node:worker_threads" {
+    export * from "worker_threads";
 }