@types/node 18.17.17 → 18.17.19

node v18.17/https.d.ts

@@ -3,17 +3,19 @@
  * separate module.
  * @see [source](https://github.com/nodejs/node/blob/v18.0.0/lib/https.js)
  */
-declare module 'node:https' {
-    import { Duplex } from 'node:stream';
-    import * as tls from 'node:tls';
-    import * as http from 'node:http';
-    import { URL } from 'node:url';
+declare module "https" {
+    import { Duplex } from "node:stream";
+    import * as tls from "node:tls";
+    import * as http from "node:http";
+    import { URL } from "node: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
@@ -58,13 +60,13 @@ declare module 'node:https' {
          */
         closeIdleConnections(): void;
         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,
@@ -72,74 +74,74 @@ declare module 'node: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: "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',
+            event: "checkContinue",
             req: InstanceType<Request>,
             res: InstanceType<Response> & { req: InstanceType<Request> },
         ): boolean;
         emit(
-            event: 'checkExpectation',
+            event: "checkExpectation",
             req: InstanceType<Request>,
             res: InstanceType<Response> & { req: InstanceType<Request> },
         ): boolean;
-        emit(event: 'clientError', err: Error, socket: Duplex): boolean;
-        emit(event: 'connect', req: InstanceType<Request>, socket: Duplex, head: Buffer): boolean;
+        emit(event: "clientError", err: Error, socket: Duplex): boolean;
+        emit(event: "connect", req: InstanceType<Request>, socket: Duplex, head: Buffer): boolean;
         emit(
-            event: 'request',
+            event: "request",
             req: InstanceType<Request>,
             res: InstanceType<Response> & { req: InstanceType<Request> },
         ): boolean;
-        emit(event: 'upgrade', req: InstanceType<Request>, socket: Duplex, head: Buffer): 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,
@@ -147,29 +149,29 @@ declare module 'node: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,
@@ -177,29 +179,29 @@ declare module 'node: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,
@@ -207,35 +209,35 @@ declare module 'node: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,
@@ -243,25 +245,25 @@ declare module 'node: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;
     }
@@ -537,6 +539,6 @@ declare module 'node:https' {
     ): http.ClientRequest;
     let globalAgent: Agent;
 }
-declare module 'https' {
-    export * from 'node:https';
+declare module "node:https" {
+    export * from "https";
 }

node v18.17/inspector.d.ts

@@ -16,7 +16,7 @@
  * ```
  * @see [source](https://github.com/nodejs/node/blob/v18.0.0/lib/inspector.js)
  */
-declare module 'node:inspector' {
+declare module 'inspector' {
     import EventEmitter = require('node:events');
     interface InspectorNotification<T> {
         method: string;
@@ -2734,7 +2734,7 @@ declare module 'node:inspector' {
 /**
  * The inspector module provides an API for interacting with the V8 inspector.
  */
-declare module 'inspector' {
-    import inspector = require('node:inspector');
+declare module 'node:inspector' {
+    import inspector = require('inspector');
     export = inspector;
 }

node v18.17/module.d.ts

@@ -1,9 +1,9 @@
 /**
  * @since v0.3.7
  */
-declare module 'node:module' {
-    import { URL } from 'node:url';
-    import { MessagePort } from 'node:worker_threads';
+declare module "module" {
+    import { URL } from "node:url";
+    import { MessagePort } from "node:worker_threads";
     namespace Module {
         /**
          * The `module.syncBuiltinESMExports()` method updates all the live bindings for
@@ -82,7 +82,7 @@ declare module 'node:module' {
         interface ImportAssertions extends NodeJS.Dict<string> {
             type?: string | undefined;
         }
-        type ModuleFormat = 'builtin' | 'commonjs' | 'json' | 'module' | 'wasm';
+        type ModuleFormat = "builtin" | "commonjs" | "json" | "module" | "wasm";
         type ModuleSource = string | ArrayBuffer | NodeJS.TypedArray;
         interface GlobalPreloadContext {
             port: MessagePort;
@@ -140,7 +140,10 @@ declare module 'node:module' {
         type ResolveHook = (
             specifier: string,
             context: ResolveHookContext,
-            nextResolve: (specifier: string, context?: ResolveHookContext) => ResolveFnOutput | Promise<ResolveFnOutput>
+            nextResolve: (
+                specifier: string,
+                context?: ResolveHookContext,
+            ) => ResolveFnOutput | Promise<ResolveFnOutput>,
         ) => ResolveFnOutput | Promise<ResolveFnOutput>;
         interface LoadHookContext {
             /**
@@ -179,7 +182,7 @@ declare module 'node:module' {
         type LoadHook = (
             url: string,
             context: LoadHookContext,
-            nextLoad: (url: string, context?: LoadHookContext) => LoadFnOutput | Promise<LoadFnOutput>
+            nextLoad: (url: string, context?: LoadHookContext) => LoadFnOutput | Promise<LoadFnOutput>,
         ) => LoadFnOutput | Promise<LoadFnOutput>;
     }
     interface Module extends NodeModule {}
@@ -212,7 +215,7 @@ declare module 'node:module' {
     }
     export = Module;
 }
-declare module 'module' {
-    import module = require('node:module');
+declare module "node:module" {
+    import module = require("module");
     export = module;
 }