node-red-contrib-tak-registration 0.11.1 → 0.11.5

package/node_modules/@types/node/ts4.8/https.d.ts

@@ -3,17 +3,19 @@
  * separate module.
  * @see [source](https://github.com/nodejs/node/blob/v20.2.0/lib/https.js)
  */
-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';
+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,125 +60,218 @@ declare module 'https' {
          */
         closeIdleConnections(): void;
         addListener(event: string, listener: (...args: any[]) => void): this;
-        addListener(event: 'keylog', listener: (line: Buffer, tlsSocket: tls.TLSSocket) => void): this;
-        addListener(event: 'newSession', listener: (sessionId: Buffer, sessionData: Buffer, callback: (err: Error, resp: Buffer) => 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, 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: 'connect', listener: (req: InstanceType<Request>, socket: Duplex, head: Buffer) => void): this;
-        addListener(event: 'request', listener: http.RequestListener<Request, Response>): this;
-        addListener(event: 'upgrade', listener: (req: InstanceType<Request>, socket: Duplex, head: Buffer) => void): this;
+        addListener(event: "keylog", listener: (line: Buffer, tlsSocket: tls.TLSSocket) => void): this;
+        addListener(
+            event: "newSession",
+            listener: (sessionId: Buffer, sessionData: Buffer, callback: (err: Error, resp: Buffer) => 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, 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: "connect",
+            listener: (req: InstanceType<Request>, socket: Duplex, head: Buffer) => void,
+        ): this;
+        addListener(event: "request", listener: http.RequestListener<Request, Response>): this;
+        addListener(
+            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: 'newSession', sessionId: Buffer, sessionData: Buffer, callback: (err: Error, resp: Buffer) => 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, 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: "keylog", line: Buffer, tlsSocket: tls.TLSSocket): boolean;
         emit(
-            event: 'checkContinue',
+            event: "newSession",
+            sessionId: Buffer,
+            sessionData: Buffer,
+            callback: (err: Error, resp: Buffer) => 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, 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> & {
                 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: 'newSession', listener: (sessionId: Buffer, sessionData: Buffer, callback: (err: Error, resp: Buffer) => 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, 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: "keylog", listener: (line: Buffer, tlsSocket: tls.TLSSocket) => void): this;
+        on(
+            event: "newSession",
+            listener: (sessionId: Buffer, sessionData: Buffer, callback: (err: Error, resp: Buffer) => 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, 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;
         once(event: string, listener: (...args: any[]) => void): this;
-        once(event: 'keylog', listener: (line: Buffer, tlsSocket: tls.TLSSocket) => void): this;
-        once(event: 'newSession', listener: (sessionId: Buffer, sessionData: Buffer, callback: (err: Error, resp: Buffer) => 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, 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: "keylog", listener: (line: Buffer, tlsSocket: tls.TLSSocket) => void): this;
+        once(
+            event: "newSession",
+            listener: (sessionId: Buffer, sessionData: Buffer, callback: (err: Error, resp: Buffer) => 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, 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;
         prependListener(event: string, listener: (...args: any[]) => void): this;
-        prependListener(event: 'keylog', listener: (line: Buffer, tlsSocket: tls.TLSSocket) => void): this;
-        prependListener(event: 'newSession', listener: (sessionId: Buffer, sessionData: Buffer, callback: (err: Error, resp: Buffer) => 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, 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: 'connect', listener: (req: InstanceType<Request>, socket: Duplex, head: Buffer) => void): this;
-        prependListener(event: 'request', listener: http.RequestListener<Request, Response>): this;
-        prependListener(event: 'upgrade', listener: (req: InstanceType<Request>, socket: Duplex, head: Buffer) => void): this;
+        prependListener(event: "keylog", listener: (line: Buffer, tlsSocket: tls.TLSSocket) => void): this;
+        prependListener(
+            event: "newSession",
+            listener: (sessionId: Buffer, sessionData: Buffer, callback: (err: Error, resp: Buffer) => 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, 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: "connect",
+            listener: (req: InstanceType<Request>, socket: Duplex, head: Buffer) => void,
+        ): this;
+        prependListener(event: "request", listener: http.RequestListener<Request, Response>): this;
+        prependListener(
+            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: 'newSession', listener: (sessionId: Buffer, sessionData: Buffer, callback: (err: Error, resp: Buffer) => 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, 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: 'connect', listener: (req: InstanceType<Request>, socket: Duplex, head: Buffer) => void): this;
-        prependOnceListener(event: 'request', listener: http.RequestListener<Request, Response>): this;
-        prependOnceListener(event: 'upgrade', listener: (req: InstanceType<Request>, socket: Duplex, head: Buffer) => void): this;
+        prependOnceListener(event: "keylog", listener: (line: Buffer, tlsSocket: tls.TLSSocket) => void): this;
+        prependOnceListener(
+            event: "newSession",
+            listener: (sessionId: Buffer, sessionData: Buffer, callback: (err: Error, resp: Buffer) => 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, 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: "connect",
+            listener: (req: InstanceType<Request>, socket: Duplex, head: Buffer) => void,
+        ): this;
+        prependOnceListener(event: "request", listener: http.RequestListener<Request, Response>): this;
+        prependOnceListener(
+            event: "upgrade",
+            listener: (req: InstanceType<Request>, socket: Duplex, head: Buffer) => void,
+        ): this;
     }
     /**
      * ```js
@@ -406,8 +501,15 @@ declare module 'https' {
      * @since v0.3.6
      * @param options Accepts all `options` from `request`, with some differences in default values:
      */
-    function request(options: RequestOptions | string | URL, callback?: (res: http.IncomingMessage) => void): http.ClientRequest;
-    function request(url: string | URL, options: RequestOptions, callback?: (res: http.IncomingMessage) => void): http.ClientRequest;
+    function request(
+        options: RequestOptions | string | URL,
+        callback?: (res: http.IncomingMessage) => void,
+    ): http.ClientRequest;
+    function request(
+        url: string | URL,
+        options: RequestOptions,
+        callback?: (res: http.IncomingMessage) => void,
+    ): http.ClientRequest;
     /**
      * Like `http.get()` but for HTTPS.
      *
@@ -432,10 +534,17 @@ declare module 'https' {
      * @since v0.3.6
      * @param options Accepts the same `options` as {@link request}, with the `method` always set to `GET`.
      */
-    function get(options: RequestOptions | string | URL, callback?: (res: http.IncomingMessage) => void): http.ClientRequest;
-    function get(url: string | URL, options: RequestOptions, callback?: (res: http.IncomingMessage) => void): http.ClientRequest;
+    function get(
+        options: RequestOptions | string | URL,
+        callback?: (res: http.IncomingMessage) => void,
+    ): http.ClientRequest;
+    function get(
+        url: string | URL,
+        options: RequestOptions,
+        callback?: (res: http.IncomingMessage) => void,
+    ): http.ClientRequest;
     let globalAgent: Agent;
 }
-declare module 'node:https' {
-    export * from 'https';
+declare module "node:https" {
+    export * from "https";
 }

package/node_modules/@types/node/ts4.8/inspector.d.ts

@@ -1,4 +1,3 @@
-// eslint-disable-next-line @definitelytyped/dt-header
 // Type definitions for inspector
 
 // These definitions are auto-generated.

package/node_modules/@types/node/ts4.8/module.d.ts

@@ -1,9 +1,10 @@
 /**
  * @since v0.3.7
+ * @experimental
  */
-declare module '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
@@ -64,6 +65,24 @@ declare module 'module' {
             originalLine: number;
             originalColumn: number;
         }
+        interface SourceOrigin {
+            /**
+             * The name of the range in the source map, if one was provided
+             */
+            name?: string;
+            /**
+             * The file name of the original source, as reported in the SourceMap
+             */
+            fileName: string;
+            /**
+             * The 1-indexed lineNumber of the corresponding call site in the original source
+             */
+            lineNumber: number;
+            /**
+             * The 1-indexed columnNumber of the corresponding call site in the original source
+             */
+            columnNumber: number;
+        }
         /**
          * @since v13.7.0, v12.17.0
          */
@@ -92,11 +111,23 @@ declare module 'module' {
              * @param columnOffset The zero-indexed column number offset in the generated source
              */
             findEntry(lineOffset: number, columnOffset: number): SourceMapping;
+            /**
+             * Given a 1-indexed `lineNumber` and `columnNumber` from a call site in the generated source,
+             * find the corresponding call site location in the original source.
+             *
+             * If the `lineNumber` and `columnNumber` provided are not found in any source map,
+             * then an empty object is returned.
+             * @param lineNumber The 1-indexed line number of the call site in the generated source
+             * @param columnNumber The 1-indexed column number of the call site in the generated source
+             */
+            findOrigin(lineNumber: number, columnNumber: number): SourceOrigin | {};
         }
-        interface ImportAssertions extends NodeJS.Dict<string> {
+        /** @deprecated Use `ImportAttributes` instead */
+        interface ImportAssertions extends ImportAttributes {}
+        interface ImportAttributes 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;
@@ -113,22 +144,26 @@ declare module 'module' {
          */
         type GlobalPreloadHook = (context: GlobalPreloadContext) => string;
         /**
-         * The `initialize` hook provides a way to define a custom function that runs in the loader's thread
-         * when the loader is initialized. Initialization happens when the loader is registered via `register`
-         * or registered via the `--experimental-loader` command line option.
+         * The `initialize` hook provides a way to define a custom function that runs in the hooks thread
+         * when the hooks module is initialized. Initialization happens when the hooks module is registered via `register`.
          *
-         * This hook can send and receive data from a `register` invocation, including ports and other transferrable objects.
+         * This hook can receive data from a `register` invocation, including ports and other transferrable objects.
+         * The return value of `initialize` can be a `Promise`, in which case it will be awaited before the main application thread execution resumes.
          */
-        type InitializeHook<Data = any, ReturnType = any> = (data: Data) => ReturnType;
+        type InitializeHook<Data = any> = (data: Data) => void | Promise<void>;
         interface ResolveHookContext {
             /**
              * Export conditions of the relevant `package.json`
              */
             conditions: string[];
+            /**
+             * @deprecated Use `importAttributes` instead
+             */
+            importAssertions: ImportAttributes;
             /**
              *  An object whose key-value pairs represent the assertions for the module to import
              */
-            importAssertions: ImportAssertions;
+            importAttributes: ImportAttributes;
             /**
              * The module importing this one, or undefined if this is the Node.js entry point
              */
@@ -140,9 +175,13 @@ declare module 'module' {
              */
             format?: ModuleFormat | null | undefined;
             /**
-             * The import assertions to use when caching the module (optional; if excluded the input will be used)
+             * @deprecated Use `importAttributes` instead
+             */
+            importAssertions?: ImportAttributes | undefined;
+            /**
+             * The import attributes to use when caching the module (optional; if excluded the input will be used)
              */
-            importAssertions?: ImportAssertions | undefined;
+            importAttributes?: ImportAttributes | undefined;
             /**
              * A signal that this hook intends to terminate the chain of `resolve` hooks.
              * @default false
@@ -165,7 +204,10 @@ declare module '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 {
             /**
@@ -176,10 +218,14 @@ declare module 'module' {
              * The format optionally supplied by the `resolve` hook chain
              */
             format: ModuleFormat;
+            /**
+             * @deprecated Use `importAttributes` instead
+             */
+            importAssertions: ImportAttributes;
             /**
              *  An object whose key-value pairs represent the assertions for the module to import
              */
-            importAssertions: ImportAssertions;
+            importAttributes: ImportAttributes;
         }
         interface LoadFnOutput {
             format: ModuleFormat;
@@ -204,11 +250,11 @@ declare module '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 RegisterOptions<Data> {
-        parentURL: string;
+        parentURL: string | URL;
         data?: Data | undefined;
         transferList?: any[] | undefined;
     }
@@ -220,8 +266,12 @@ declare module 'module' {
         static builtinModules: string[];
         static isBuiltin(moduleName: string): boolean;
         static Module: typeof Module;
-        static register<Data = any, ReturnType = any>(specifier: string, parentURL?: string, options?: RegisterOptions<Data>): ReturnType;
-        static register<Data = any, ReturnType = any>(specifier: string, options?: RegisterOptions<Data>): ReturnType;
+        static register<Data = any>(
+            specifier: string | URL,
+            parentURL?: string | URL,
+            options?: RegisterOptions<Data>,
+        ): void;
+        static register<Data = any>(specifier: string | URL, options?: RegisterOptions<Data>): void;
         constructor(id: string, parent?: Module);
     }
     global {
@@ -231,27 +281,21 @@ declare module 'module' {
              * Provides a module-relative resolution function scoped to each module, returning
              * the URL string.
              *
-             * @param specified The module specifier to resolve relative to the current module.
-             * @returns The absolute (`file:`) URL string for the resolved module.
-             */
-            resolve(specified: string): string;
-            /**
-             * This feature is only available with the `--experimental-import-meta-resolve`
+             * Second `parent` parameter is only used when the `--experimental-import-meta-resolve`
              * command flag enabled.
              *
-             * Provides a module-relative resolution function scoped to each module, returning
-             * the URL string.
+             * @since v20.6.0
              *
-             * @param specified The module specifier to resolve relative to `parent`.
+             * @param specifier The module specifier to resolve relative to `parent`.
              * @param parent The absolute parent module URL to resolve from.
              * @returns The absolute (`file:`) URL string for the resolved module.
              */
-            resolve(specified: string, parent: string | URL): string;
+            resolve(specifier: string, parent?: string | URL | undefined): string;
         }
     }
     export = Module;
 }
-declare module 'node:module' {
-    import module = require('module');
+declare module "node:module" {
+    import module = require("module");
     export = module;
 }