@types/node 14.18.62 → 14.18.63

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

@@ -1,16 +1,18 @@
-declare module 'https' {
-    import { Duplex } from 'stream';
-    import * as tls from 'tls';
-    import * as http from 'http';
-    import { URL } from 'url';
+declare module "https" {
+    import { Duplex } from "stream";
+    import * as tls from "tls";
+    import * as http from "http";
+    import { URL } from "url";
 
     type ServerOptions<
         Request extends typeof http.IncomingMessage = typeof http.IncomingMessage,
         Response extends typeof http.ServerResponse = typeof http.ServerResponse,
     > = tls.SecureContextOptions & tls.TlsOptions & http.ServerOptions<Request, Response>;
 
-    type RequestOptions = http.RequestOptions &
-        tls.SecureContextOptions & {
+    type RequestOptions =
+        & http.RequestOptions
+        & tls.SecureContextOptions
+        & {
             checkServerIdentity?: typeof tls.checkServerIdentity | undefined;
             rejectUnauthorized?: boolean | undefined; // Defaults to true
             servername?: string | undefined; // SNI TLS Extension
@@ -40,13 +42,13 @@ declare module 'https' {
             requestListener?: http.RequestListener<Request, Response>,
         );
         addListener(event: string, listener: (...args: any[]) => void): this;
-        addListener(event: 'keylog', listener: (line: Buffer, tlsSocket: tls.TLSSocket) => void): this;
+        addListener(event: "keylog", listener: (line: Buffer, tlsSocket: tls.TLSSocket) => void): this;
         addListener(
-            event: 'newSession',
+            event: "newSession",
             listener: (sessionId: Buffer, sessionData: Buffer, callback: (err: Error, resp: Buffer) => void) => void,
         ): this;
         addListener(
-            event: 'OCSPRequest',
+            event: "OCSPRequest",
             listener: (
                 certificate: Buffer,
                 issuer: Buffer,
@@ -54,62 +56,62 @@ declare module 'https' {
             ) => void,
         ): this;
         addListener(
-            event: 'resumeSession',
+            event: "resumeSession",
             listener: (sessionId: Buffer, callback: (err: Error, sessionData: Buffer) => void) => void,
         ): this;
-        addListener(event: 'secureConnection', listener: (tlsSocket: tls.TLSSocket) => void): this;
-        addListener(event: 'tlsClientError', listener: (err: Error, tlsSocket: tls.TLSSocket) => void): this;
-        addListener(event: 'close', listener: () => void): this;
-        addListener(event: 'connection', listener: (socket: Duplex) => void): this;
-        addListener(event: 'error', listener: (err: Error) => void): this;
-        addListener(event: 'listening', listener: () => void): this;
-        addListener(event: 'checkContinue', listener: http.RequestListener<Request, Response>): this;
-        addListener(event: 'checkExpectation', listener: http.RequestListener<Request, Response>): this;
-        addListener(event: 'clientError', listener: (err: Error, socket: Duplex) => void): this;
+        addListener(event: "secureConnection", listener: (tlsSocket: tls.TLSSocket) => void): this;
+        addListener(event: "tlsClientError", listener: (err: Error, tlsSocket: tls.TLSSocket) => void): this;
+        addListener(event: "close", listener: () => void): this;
+        addListener(event: "connection", listener: (socket: Duplex) => void): this;
+        addListener(event: "error", listener: (err: Error) => void): this;
+        addListener(event: "listening", listener: () => void): this;
+        addListener(event: "checkContinue", listener: http.RequestListener<Request, Response>): this;
+        addListener(event: "checkExpectation", listener: http.RequestListener<Request, Response>): this;
+        addListener(event: "clientError", listener: (err: Error, socket: Duplex) => void): this;
         addListener(
-            event: 'connect',
+            event: "connect",
             listener: (req: InstanceType<Request>, socket: Duplex, head: Buffer) => void,
         ): this;
-        addListener(event: 'request', listener: http.RequestListener<Request, Response>): this;
+        addListener(event: "request", listener: http.RequestListener<Request, Response>): this;
         addListener(
-            event: 'upgrade',
+            event: "upgrade",
             listener: (req: InstanceType<Request>, socket: Duplex, head: Buffer) => void,
         ): this;
         emit(event: string, ...args: any[]): boolean;
-        emit(event: 'keylog', line: Buffer, tlsSocket: tls.TLSSocket): boolean;
+        emit(event: "keylog", line: Buffer, tlsSocket: tls.TLSSocket): boolean;
         emit(
-            event: 'newSession',
+            event: "newSession",
             sessionId: Buffer,
             sessionData: Buffer,
             callback: (err: Error, resp: Buffer) => void,
         ): boolean;
         emit(
-            event: 'OCSPRequest',
+            event: "OCSPRequest",
             certificate: Buffer,
             issuer: Buffer,
             callback: (err: Error | null, resp: Buffer) => void,
         ): boolean;
-        emit(event: 'resumeSession', sessionId: Buffer, callback: (err: Error, sessionData: Buffer) => void): boolean;
-        emit(event: 'secureConnection', tlsSocket: tls.TLSSocket): boolean;
-        emit(event: 'tlsClientError', err: Error, tlsSocket: tls.TLSSocket): boolean;
-        emit(event: 'close'): boolean;
-        emit(event: 'connection', socket: Duplex): boolean;
-        emit(event: 'error', err: Error): boolean;
-        emit(event: 'listening'): boolean;
-        emit(event: 'checkContinue', req: InstanceType<Request>, res: InstanceType<Response>): boolean;
-        emit(event: 'checkExpectation', req: InstanceType<Request>, res: InstanceType<Response>): boolean;
-        emit(event: 'clientError', err: Error, socket: Duplex): boolean;
-        emit(event: 'connect', req: InstanceType<Request>, socket: Duplex, head: Buffer): boolean;
-        emit(event: 'request', req: InstanceType<Request>, res: InstanceType<Response>): boolean;
-        emit(event: 'upgrade', req: InstanceType<Request>, socket: Duplex, head: Buffer): boolean;
+        emit(event: "resumeSession", sessionId: Buffer, callback: (err: Error, sessionData: Buffer) => void): boolean;
+        emit(event: "secureConnection", tlsSocket: tls.TLSSocket): boolean;
+        emit(event: "tlsClientError", err: Error, tlsSocket: tls.TLSSocket): boolean;
+        emit(event: "close"): boolean;
+        emit(event: "connection", socket: Duplex): boolean;
+        emit(event: "error", err: Error): boolean;
+        emit(event: "listening"): boolean;
+        emit(event: "checkContinue", req: InstanceType<Request>, res: InstanceType<Response>): boolean;
+        emit(event: "checkExpectation", req: InstanceType<Request>, res: InstanceType<Response>): boolean;
+        emit(event: "clientError", err: Error, socket: Duplex): boolean;
+        emit(event: "connect", req: InstanceType<Request>, socket: Duplex, head: Buffer): boolean;
+        emit(event: "request", req: InstanceType<Request>, res: InstanceType<Response>): boolean;
+        emit(event: "upgrade", req: InstanceType<Request>, socket: Duplex, head: Buffer): boolean;
         on(event: string, listener: (...args: any[]) => void): this;
-        on(event: 'keylog', listener: (line: Buffer, tlsSocket: tls.TLSSocket) => void): this;
+        on(event: "keylog", listener: (line: Buffer, tlsSocket: tls.TLSSocket) => void): this;
         on(
-            event: 'newSession',
+            event: "newSession",
             listener: (sessionId: Buffer, sessionData: Buffer, callback: (err: Error, resp: Buffer) => void) => void,
         ): this;
         on(
-            event: 'OCSPRequest',
+            event: "OCSPRequest",
             listener: (
                 certificate: Buffer,
                 issuer: Buffer,
@@ -117,29 +119,29 @@ declare module 'https' {
             ) => void,
         ): this;
         on(
-            event: 'resumeSession',
+            event: "resumeSession",
             listener: (sessionId: Buffer, callback: (err: Error, sessionData: Buffer) => void) => void,
         ): this;
-        on(event: 'secureConnection', listener: (tlsSocket: tls.TLSSocket) => void): this;
-        on(event: 'tlsClientError', listener: (err: Error, tlsSocket: tls.TLSSocket) => void): this;
-        on(event: 'close', listener: () => void): this;
-        on(event: 'connection', listener: (socket: Duplex) => void): this;
-        on(event: 'error', listener: (err: Error) => void): this;
-        on(event: 'listening', listener: () => void): this;
-        on(event: 'checkContinue', listener: http.RequestListener<Request, Response>): this;
-        on(event: 'checkExpectation', listener: http.RequestListener<Request, Response>): this;
-        on(event: 'clientError', listener: (err: Error, socket: Duplex) => void): this;
-        on(event: 'connect', listener: (req: InstanceType<Request>, socket: Duplex, head: Buffer) => void): this;
-        on(event: 'request', listener: http.RequestListener<Request, Response>): this;
-        on(event: 'upgrade', listener: (req: InstanceType<Request>, socket: Duplex, head: Buffer) => void): this;
+        on(event: "secureConnection", listener: (tlsSocket: tls.TLSSocket) => void): this;
+        on(event: "tlsClientError", listener: (err: Error, tlsSocket: tls.TLSSocket) => void): this;
+        on(event: "close", listener: () => void): this;
+        on(event: "connection", listener: (socket: Duplex) => void): this;
+        on(event: "error", listener: (err: Error) => void): this;
+        on(event: "listening", listener: () => void): this;
+        on(event: "checkContinue", listener: http.RequestListener<Request, Response>): this;
+        on(event: "checkExpectation", listener: http.RequestListener<Request, Response>): this;
+        on(event: "clientError", listener: (err: Error, socket: Duplex) => void): this;
+        on(event: "connect", listener: (req: InstanceType<Request>, socket: Duplex, head: Buffer) => void): this;
+        on(event: "request", listener: http.RequestListener<Request, Response>): this;
+        on(event: "upgrade", listener: (req: InstanceType<Request>, socket: Duplex, head: Buffer) => void): this;
         once(event: string, listener: (...args: any[]) => void): this;
-        once(event: 'keylog', listener: (line: Buffer, tlsSocket: tls.TLSSocket) => void): this;
+        once(event: "keylog", listener: (line: Buffer, tlsSocket: tls.TLSSocket) => void): this;
         once(
-            event: 'newSession',
+            event: "newSession",
             listener: (sessionId: Buffer, sessionData: Buffer, callback: (err: Error, resp: Buffer) => void) => void,
         ): this;
         once(
-            event: 'OCSPRequest',
+            event: "OCSPRequest",
             listener: (
                 certificate: Buffer,
                 issuer: Buffer,
@@ -147,29 +149,29 @@ declare module 'https' {
             ) => void,
         ): this;
         once(
-            event: 'resumeSession',
+            event: "resumeSession",
             listener: (sessionId: Buffer, callback: (err: Error, sessionData: Buffer) => void) => void,
         ): this;
-        once(event: 'secureConnection', listener: (tlsSocket: tls.TLSSocket) => void): this;
-        once(event: 'tlsClientError', listener: (err: Error, tlsSocket: tls.TLSSocket) => void): this;
-        once(event: 'close', listener: () => void): this;
-        once(event: 'connection', listener: (socket: Duplex) => void): this;
-        once(event: 'error', listener: (err: Error) => void): this;
-        once(event: 'listening', listener: () => void): this;
-        once(event: 'checkContinue', listener: http.RequestListener<Request, Response>): this;
-        once(event: 'checkExpectation', listener: http.RequestListener<Request, Response>): this;
-        once(event: 'clientError', listener: (err: Error, socket: Duplex) => void): this;
-        once(event: 'connect', listener: (req: InstanceType<Request>, socket: Duplex, head: Buffer) => void): this;
-        once(event: 'request', listener: http.RequestListener<Request, Response>): this;
-        once(event: 'upgrade', listener: (req: InstanceType<Request>, socket: Duplex, head: Buffer) => void): this;
+        once(event: "secureConnection", listener: (tlsSocket: tls.TLSSocket) => void): this;
+        once(event: "tlsClientError", listener: (err: Error, tlsSocket: tls.TLSSocket) => void): this;
+        once(event: "close", listener: () => void): this;
+        once(event: "connection", listener: (socket: Duplex) => void): this;
+        once(event: "error", listener: (err: Error) => void): this;
+        once(event: "listening", listener: () => void): this;
+        once(event: "checkContinue", listener: http.RequestListener<Request, Response>): this;
+        once(event: "checkExpectation", listener: http.RequestListener<Request, Response>): this;
+        once(event: "clientError", listener: (err: Error, socket: Duplex) => void): this;
+        once(event: "connect", listener: (req: InstanceType<Request>, socket: Duplex, head: Buffer) => void): this;
+        once(event: "request", listener: http.RequestListener<Request, Response>): this;
+        once(event: "upgrade", listener: (req: InstanceType<Request>, socket: Duplex, head: Buffer) => void): this;
         prependListener(event: string, listener: (...args: any[]) => void): this;
-        prependListener(event: 'keylog', listener: (line: Buffer, tlsSocket: tls.TLSSocket) => void): this;
+        prependListener(event: "keylog", listener: (line: Buffer, tlsSocket: tls.TLSSocket) => void): this;
         prependListener(
-            event: 'newSession',
+            event: "newSession",
             listener: (sessionId: Buffer, sessionData: Buffer, callback: (err: Error, resp: Buffer) => void) => void,
         ): this;
         prependListener(
-            event: 'OCSPRequest',
+            event: "OCSPRequest",
             listener: (
                 certificate: Buffer,
                 issuer: Buffer,
@@ -177,35 +179,35 @@ declare module 'https' {
             ) => void,
         ): this;
         prependListener(
-            event: 'resumeSession',
+            event: "resumeSession",
             listener: (sessionId: Buffer, callback: (err: Error, sessionData: Buffer) => void) => void,
         ): this;
-        prependListener(event: 'secureConnection', listener: (tlsSocket: tls.TLSSocket) => void): this;
-        prependListener(event: 'tlsClientError', listener: (err: Error, tlsSocket: tls.TLSSocket) => void): this;
-        prependListener(event: 'close', listener: () => void): this;
-        prependListener(event: 'connection', listener: (socket: Duplex) => void): this;
-        prependListener(event: 'error', listener: (err: Error) => void): this;
-        prependListener(event: 'listening', listener: () => void): this;
-        prependListener(event: 'checkContinue', listener: http.RequestListener<Request, Response>): this;
-        prependListener(event: 'checkExpectation', listener: http.RequestListener<Request, Response>): this;
-        prependListener(event: 'clientError', listener: (err: Error, socket: Duplex) => void): this;
+        prependListener(event: "secureConnection", listener: (tlsSocket: tls.TLSSocket) => void): this;
+        prependListener(event: "tlsClientError", listener: (err: Error, tlsSocket: tls.TLSSocket) => void): this;
+        prependListener(event: "close", listener: () => void): this;
+        prependListener(event: "connection", listener: (socket: Duplex) => void): this;
+        prependListener(event: "error", listener: (err: Error) => void): this;
+        prependListener(event: "listening", listener: () => void): this;
+        prependListener(event: "checkContinue", listener: http.RequestListener<Request, Response>): this;
+        prependListener(event: "checkExpectation", listener: http.RequestListener<Request, Response>): this;
+        prependListener(event: "clientError", listener: (err: Error, socket: Duplex) => void): this;
         prependListener(
-            event: 'connect',
+            event: "connect",
             listener: (req: InstanceType<Request>, socket: Duplex, head: Buffer) => void,
         ): this;
-        prependListener(event: 'request', listener: http.RequestListener<Request, Response>): this;
+        prependListener(event: "request", listener: http.RequestListener<Request, Response>): this;
         prependListener(
-            event: 'upgrade',
+            event: "upgrade",
             listener: (req: InstanceType<Request>, socket: Duplex, head: Buffer) => void,
         ): this;
         prependOnceListener(event: string, listener: (...args: any[]) => void): this;
-        prependOnceListener(event: 'keylog', listener: (line: Buffer, tlsSocket: tls.TLSSocket) => void): this;
+        prependOnceListener(event: "keylog", listener: (line: Buffer, tlsSocket: tls.TLSSocket) => void): this;
         prependOnceListener(
-            event: 'newSession',
+            event: "newSession",
             listener: (sessionId: Buffer, sessionData: Buffer, callback: (err: Error, resp: Buffer) => void) => void,
         ): this;
         prependOnceListener(
-            event: 'OCSPRequest',
+            event: "OCSPRequest",
             listener: (
                 certificate: Buffer,
                 issuer: Buffer,
@@ -213,25 +215,25 @@ declare module 'https' {
             ) => void,
         ): this;
         prependOnceListener(
-            event: 'resumeSession',
+            event: "resumeSession",
             listener: (sessionId: Buffer, callback: (err: Error, sessionData: Buffer) => void) => void,
         ): this;
-        prependOnceListener(event: 'secureConnection', listener: (tlsSocket: tls.TLSSocket) => void): this;
-        prependOnceListener(event: 'tlsClientError', listener: (err: Error, tlsSocket: tls.TLSSocket) => void): this;
-        prependOnceListener(event: 'close', listener: () => void): this;
-        prependOnceListener(event: 'connection', listener: (socket: Duplex) => void): this;
-        prependOnceListener(event: 'error', listener: (err: Error) => void): this;
-        prependOnceListener(event: 'listening', listener: () => void): this;
-        prependOnceListener(event: 'checkContinue', listener: http.RequestListener<Request, Response>): this;
-        prependOnceListener(event: 'checkExpectation', listener: http.RequestListener<Request, Response>): this;
-        prependOnceListener(event: 'clientError', listener: (err: Error, socket: Duplex) => void): this;
+        prependOnceListener(event: "secureConnection", listener: (tlsSocket: tls.TLSSocket) => void): this;
+        prependOnceListener(event: "tlsClientError", listener: (err: Error, tlsSocket: tls.TLSSocket) => void): this;
+        prependOnceListener(event: "close", listener: () => void): this;
+        prependOnceListener(event: "connection", listener: (socket: Duplex) => void): this;
+        prependOnceListener(event: "error", listener: (err: Error) => void): this;
+        prependOnceListener(event: "listening", listener: () => void): this;
+        prependOnceListener(event: "checkContinue", listener: http.RequestListener<Request, Response>): this;
+        prependOnceListener(event: "checkExpectation", listener: http.RequestListener<Request, Response>): this;
+        prependOnceListener(event: "clientError", listener: (err: Error, socket: Duplex) => void): this;
         prependOnceListener(
-            event: 'connect',
+            event: "connect",
             listener: (req: InstanceType<Request>, socket: Duplex, head: Buffer) => void,
         ): this;
-        prependOnceListener(event: 'request', listener: http.RequestListener<Request, Response>): this;
+        prependOnceListener(event: "request", listener: http.RequestListener<Request, Response>): this;
         prependOnceListener(
-            event: 'upgrade',
+            event: "upgrade",
             listener: (req: InstanceType<Request>, socket: Duplex, head: Buffer) => void,
         ): this;
     }
@@ -267,6 +269,6 @@ declare module 'https' {
     ): http.ClientRequest;
     let globalAgent: Agent;
 }
-declare module 'node:https' {
-    export * from 'https';
+declare module "node:https" {
+    export * from "https";
 }

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

@@ -1,5 +1,5 @@
-declare module 'module' {
-    import { URL } from 'url';
+declare module "module" {
+    import { URL } from "url";
     namespace Module {
         /**
          * Updates all the live bindings for builtin ES Modules to match the properties of the CommonJS exports.
@@ -50,7 +50,7 @@ declare module 'module' {
     }
     export = Module;
 }
-declare module 'node:module' {
-    import module = require('module');
+declare module "node:module" {
+    import module = require("module");
     export = module;
 }

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

@@ -1,7 +1,7 @@
-declare module 'net' {
-    import * as stream from 'stream';
-    import EventEmitter = require('events');
-    import * as dns from 'dns';
+declare module "net" {
+    import * as stream from "stream";
+    import EventEmitter = require("events");
+    import * as dns from "dns";
 
     type LookupFunction = (
         hostname: string,
@@ -56,7 +56,7 @@ declare module 'net' {
     }
 
     type SocketConnectOpts = TcpSocketConnectOpts | IpcSocketConnectOpts;
-    type SocketReadyState = 'opening' | 'open' | 'readOnly' | 'writeOnly' | 'closed';
+    type SocketReadyState = "opening" | "open" | "readOnly" | "writeOnly" | "closed";
 
     class Socket extends stream.Duplex {
         constructor(options?: SocketConstructorOpts);
@@ -127,7 +127,10 @@ declare module 'net' {
         addListener(event: "drain", listener: () => void): this;
         addListener(event: "end", listener: () => void): this;
         addListener(event: "error", listener: (err: Error) => void): this;
-        addListener(event: "lookup", listener: (err: Error, address: string, family: string | number, host: string) => void): this;
+        addListener(
+            event: "lookup",
+            listener: (err: Error, address: string, family: string | number, host: string) => void,
+        ): this;
         addListener(event: "ready", listener: () => void): this;
         addListener(event: "timeout", listener: () => void): this;
 
@@ -149,7 +152,10 @@ declare module 'net' {
         on(event: "drain", listener: () => void): this;
         on(event: "end", listener: () => void): this;
         on(event: "error", listener: (err: Error) => void): this;
-        on(event: "lookup", listener: (err: Error, address: string, family: string | number, host: string) => void): this;
+        on(
+            event: "lookup",
+            listener: (err: Error, address: string, family: string | number, host: string) => void,
+        ): this;
         on(event: "ready", listener: () => void): this;
         on(event: "timeout", listener: () => void): this;
 
@@ -160,7 +166,10 @@ declare module 'net' {
         once(event: "drain", listener: () => void): this;
         once(event: "end", listener: () => void): this;
         once(event: "error", listener: (err: Error) => void): this;
-        once(event: "lookup", listener: (err: Error, address: string, family: string | number, host: string) => void): this;
+        once(
+            event: "lookup",
+            listener: (err: Error, address: string, family: string | number, host: string) => void,
+        ): this;
         once(event: "ready", listener: () => void): this;
         once(event: "timeout", listener: () => void): this;
 
@@ -171,7 +180,10 @@ declare module 'net' {
         prependListener(event: "drain", listener: () => void): this;
         prependListener(event: "end", listener: () => void): this;
         prependListener(event: "error", listener: (err: Error) => void): this;
-        prependListener(event: "lookup", listener: (err: Error, address: string, family: string | number, host: string) => void): this;
+        prependListener(
+            event: "lookup",
+            listener: (err: Error, address: string, family: string | number, host: string) => void,
+        ): this;
         prependListener(event: "ready", listener: () => void): this;
         prependListener(event: "timeout", listener: () => void): this;
 
@@ -182,7 +194,10 @@ declare module 'net' {
         prependOnceListener(event: "drain", listener: () => void): this;
         prependOnceListener(event: "end", listener: () => void): this;
         prependOnceListener(event: "error", listener: (err: Error) => void): this;
-        prependOnceListener(event: "lookup", listener: (err: Error, address: string, family: string | number, host: string) => void): this;
+        prependOnceListener(
+            event: "lookup",
+            listener: (err: Error, address: string, family: string | number, host: string) => void,
+        ): this;
         prependOnceListener(event: "ready", listener: () => void): this;
         prependOnceListener(event: "timeout", listener: () => void): this;
     }
@@ -304,6 +319,6 @@ declare module 'net' {
     function isIPv4(input: string): boolean;
     function isIPv6(input: string): boolean;
 }
-declare module 'node:net' {
-    export * from 'net';
+declare module "node:net" {
+    export * from "net";
 }

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

@@ -1,4 +1,4 @@
-declare module 'os' {
+declare module "os" {
     interface CpuInfo {
         model: string;
         speed: number;
@@ -49,7 +49,7 @@ declare module 'os' {
     function release(): string;
     function networkInterfaces(): NodeJS.Dict<NetworkInterfaceInfo[]>;
     function homedir(): string;
-    function userInfo(options: { encoding: 'buffer' }): UserInfo<Buffer>;
+    function userInfo(options: { encoding: "buffer" }): UserInfo<Buffer>;
     function userInfo(options?: { encoding: BufferEncoding }): UserInfo<string>;
 
     type SignalConstants = {
@@ -238,6 +238,6 @@ declare module 'os' {
      */
     function setPriority(pid: number, priority: number): void;
 }
-declare module 'node:os' {
-    export * from 'os';
+declare module "node:os" {
+    export * from "os";
 }

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

@@ -1,4 +1,4 @@
-declare module 'path' {
+declare module "path" {
     namespace path {
         /**
          * A parsed path object generated by path.parse() or consumed by path.format().
@@ -122,11 +122,11 @@ declare module 'path' {
             /**
              * The platform-specific file separator. '\\' or '/'.
              */
-            readonly sep: '\\' | '/';
+            readonly sep: "\\" | "/";
             /**
              * The platform-specific file delimiter. ';' or ':'.
              */
-            readonly delimiter: ';' | ':';
+            readonly delimiter: ";" | ":";
             /**
              * Returns an object from a path string - the opposite of format().
              *
@@ -162,7 +162,7 @@ declare module 'path' {
     const path: path.PlatformPath;
     export = path;
 }
-declare module 'node:path' {
-    import path = require('path');
+declare module "node:path" {
+    import path = require("path");
     export = path;
 }

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

@@ -1,7 +1,7 @@
-declare module 'perf_hooks' {
-    import { AsyncResource } from 'async_hooks';
+declare module "perf_hooks" {
+    import { AsyncResource } from "async_hooks";
 
-    type EntryType = 'node' | 'mark' | 'measure' | 'gc' | 'function' | 'http2' | 'http';
+    type EntryType = "node" | "mark" | "measure" | "gc" | "function" | "http2" | "http";
 
     interface PerformanceEntry {
         /**
@@ -269,6 +269,6 @@ declare module 'perf_hooks' {
 
     function monitorEventLoopDelay(options?: EventLoopMonitorOptions): EventLoopDelayMonitor;
 }
-declare module 'node:perf_hooks' {
-    export * from 'perf_hooks';
+declare module "node:perf_hooks" {
+    export * from "perf_hooks";
 }

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

@@ -1,5 +1,5 @@
-declare module 'process' {
-    import * as tty from 'tty';
+declare module "process" {
+    import * as tty from "tty";
 
     global {
         var process: NodeJS.Process;
@@ -43,25 +43,59 @@ declare module 'process' {
                 openssl: string;
             }
 
-            type Platform = 'aix'
-                | 'android'
-                | 'darwin'
-                | 'freebsd'
-                | 'linux'
-                | 'openbsd'
-                | 'sunos'
-                | 'win32'
-                | 'cygwin'
-                | 'netbsd';
+            type Platform =
+                | "aix"
+                | "android"
+                | "darwin"
+                | "freebsd"
+                | "linux"
+                | "openbsd"
+                | "sunos"
+                | "win32"
+                | "cygwin"
+                | "netbsd";
 
             type Signals =
-                "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";
-
-            type UncaughtExceptionOrigin = 'uncaughtException' | 'unhandledRejection';
-            type MultipleResolveType = 'resolve' | 'reject';
+                | "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";
+
+            type UncaughtExceptionOrigin = "uncaughtException" | "unhandledRejection";
+            type MultipleResolveType = "resolve" | "reject";
 
             type BeforeExitListener = (code: number) => void;
             type DisconnectListener = () => void;
@@ -278,7 +312,12 @@ declare module 'process' {
                 domain: Domain;
 
                 // Worker
-                send?(message: any, sendHandle?: any, options?: { swallowErrors?: boolean | undefined}, callback?: (error: Error | null) => void): boolean;
+                send?(
+                    message: any,
+                    sendHandle?: any,
+                    options?: { swallowErrors?: boolean | undefined },
+                    callback?: (error: Error | null) => void,
+                ): boolean;
                 disconnect(): void;
                 connected: boolean;
 
@@ -407,7 +446,7 @@ declare module 'process' {
 
     export = process;
 }
-declare module 'node:process' {
-    import process = require('process');
+declare module "node:process" {
+    import process = require("process");
     export = process;
 }