omegon 0.8.4 → 0.9.0

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

@@ -1,12 +1,13 @@
 /**
  * HTTPS is the HTTP protocol over TLS/SSL. In Node.js this is implemented as a
  * separate module.
- * @see [source](https://github.com/nodejs/node/blob/v25.x/lib/https.js)
+ * @see [source](https://github.com/nodejs/node/blob/v22.x/lib/https.js)
  */
-declare module "node:https" {
-    import * as http from "node:http";
+declare module "https" {
+    import { NonSharedBuffer } from "node:buffer";
     import { Duplex } from "node:stream";
     import * as tls from "node:tls";
+    import * as http from "node:http";
     import { URL } from "node:url";
     interface ServerOptions<
         Request extends typeof http.IncomingMessage = typeof http.IncomingMessage,
@@ -24,12 +25,6 @@ declare module "node:https" {
     }
     /**
      * An `Agent` object for HTTPS similar to `http.Agent`. See {@link request} for more information.
-     *
-     * Like `http.Agent`, the `createConnection(options[, callback])` method can be overridden
-     * to customize how TLS connections are established.
-     *
-     * > See `agent.createConnection()` for details on overriding this method,
-     * > including asynchronous socket creation with a callback.
      * @since v0.4.5
      */
     class Agent extends http.Agent {
@@ -41,10 +36,10 @@ declare module "node:https" {
         ): Duplex | null | undefined;
         getName(options?: RequestOptions): string;
     }
-    interface ServerEventMap<
+    interface Server<
         Request extends typeof http.IncomingMessage = typeof http.IncomingMessage,
         Response extends typeof http.ServerResponse<InstanceType<Request>> = typeof http.ServerResponse,
-    > extends http.ServerEventMap<Request, Response>, tls.ServerEventMap {}
+    > extends http.Server<Request, Response> {}
     /**
      * See `http.Server` for more information.
      * @since v0.3.4
@@ -68,66 +63,245 @@ declare module "node:https" {
          * @since v18.2.0
          */
         closeIdleConnections(): void;
-        // #region InternalEventEmitter
-        addListener<E extends keyof ServerEventMap>(
-            eventName: E,
-            listener: (...args: ServerEventMap<Request, Response>[E]) => void,
+        addListener(event: string, listener: (...args: any[]) => void): this;
+        addListener(event: "keylog", listener: (line: NonSharedBuffer, tlsSocket: tls.TLSSocket) => void): this;
+        addListener(
+            event: "newSession",
+            listener: (sessionId: NonSharedBuffer, sessionData: NonSharedBuffer, callback: () => void) => void,
+        ): this;
+        addListener(
+            event: "OCSPRequest",
+            listener: (
+                certificate: NonSharedBuffer,
+                issuer: NonSharedBuffer,
+                callback: (err: Error | null, resp: Buffer | null) => void,
+            ) => void,
+        ): this;
+        addListener(
+            event: "resumeSession",
+            listener: (
+                sessionId: NonSharedBuffer,
+                callback: (err: Error | null, sessionData: Buffer | null) => 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: NonSharedBuffer) => void,
+        ): this;
+        addListener(event: "request", listener: http.RequestListener<Request, Response>): this;
+        addListener(
+            event: "upgrade",
+            listener: (req: InstanceType<Request>, socket: Duplex, head: NonSharedBuffer) => void,
+        ): this;
+        emit(event: string, ...args: any[]): boolean;
+        emit(event: "keylog", line: NonSharedBuffer, tlsSocket: tls.TLSSocket): boolean;
+        emit(
+            event: "newSession",
+            sessionId: NonSharedBuffer,
+            sessionData: NonSharedBuffer,
+            callback: () => void,
+        ): boolean;
+        emit(
+            event: "OCSPRequest",
+            certificate: NonSharedBuffer,
+            issuer: NonSharedBuffer,
+            callback: (err: Error | null, resp: Buffer | null) => void,
+        ): boolean;
+        emit(
+            event: "resumeSession",
+            sessionId: NonSharedBuffer,
+            callback: (err: Error | null, sessionData: Buffer | null) => 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: NonSharedBuffer): boolean;
+        emit(
+            event: "request",
+            req: InstanceType<Request>,
+            res: InstanceType<Response>,
+        ): boolean;
+        emit(event: "upgrade", req: InstanceType<Request>, socket: Duplex, head: NonSharedBuffer): boolean;
+        on(event: string, listener: (...args: any[]) => void): this;
+        on(event: "keylog", listener: (line: NonSharedBuffer, tlsSocket: tls.TLSSocket) => void): this;
+        on(
+            event: "newSession",
+            listener: (sessionId: NonSharedBuffer, sessionData: NonSharedBuffer, callback: () => void) => void,
+        ): this;
+        on(
+            event: "OCSPRequest",
+            listener: (
+                certificate: NonSharedBuffer,
+                issuer: NonSharedBuffer,
+                callback: (err: Error | null, resp: Buffer | null) => void,
+            ) => void,
+        ): this;
+        on(
+            event: "resumeSession",
+            listener: (
+                sessionId: NonSharedBuffer,
+                callback: (err: Error | null, sessionData: Buffer | null) => 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: NonSharedBuffer) => void,
         ): this;
-        addListener(eventName: string | symbol, listener: (...args: any[]) => void): this;
-        emit<E extends keyof ServerEventMap>(eventName: E, ...args: ServerEventMap<Request, Response>[E]): boolean;
-        emit(eventName: string | symbol, ...args: any[]): boolean;
-        listenerCount<E extends keyof ServerEventMap>(
-            eventName: E,
-            listener?: (...args: ServerEventMap<Request, Response>[E]) => void,
-        ): number;
-        listenerCount(eventName: string | symbol, listener?: (...args: any[]) => void): number;
-        listeners<E extends keyof ServerEventMap>(
-            eventName: E,
-        ): ((...args: ServerEventMap<Request, Response>[E]) => void)[];
-        listeners(eventName: string | symbol): ((...args: any[]) => void)[];
-        off<E extends keyof ServerEventMap>(
-            eventName: E,
-            listener: (...args: ServerEventMap<Request, Response>[E]) => void,
+        on(event: "request", listener: http.RequestListener<Request, Response>): this;
+        on(
+            event: "upgrade",
+            listener: (req: InstanceType<Request>, socket: Duplex, head: NonSharedBuffer) => void,
         ): this;
-        off(eventName: string | symbol, listener: (...args: any[]) => void): this;
-        on<E extends keyof ServerEventMap>(
-            eventName: E,
-            listener: (...args: ServerEventMap<Request, Response>[E]) => void,
+        once(event: string, listener: (...args: any[]) => void): this;
+        once(event: "keylog", listener: (line: NonSharedBuffer, tlsSocket: tls.TLSSocket) => void): this;
+        once(
+            event: "newSession",
+            listener: (sessionId: NonSharedBuffer, sessionData: NonSharedBuffer, callback: () => void) => void,
         ): this;
-        on(eventName: string | symbol, listener: (...args: any[]) => void): this;
-        once<E extends keyof ServerEventMap>(
-            eventName: E,
-            listener: (...args: ServerEventMap<Request, Response>[E]) => void,
+        once(
+            event: "OCSPRequest",
+            listener: (
+                certificate: NonSharedBuffer,
+                issuer: NonSharedBuffer,
+                callback: (err: Error | null, resp: Buffer | null) => void,
+            ) => void,
         ): this;
-        once(eventName: string | symbol, listener: (...args: any[]) => void): this;
-        prependListener<E extends keyof ServerEventMap>(
-            eventName: E,
-            listener: (...args: ServerEventMap<Request, Response>[E]) => void,
+        once(
+            event: "resumeSession",
+            listener: (
+                sessionId: NonSharedBuffer,
+                callback: (err: Error | null, sessionData: Buffer | null) => void,
+            ) => void,
         ): this;
-        prependListener(eventName: string | symbol, listener: (...args: any[]) => void): this;
-        prependOnceListener<E extends keyof ServerEventMap>(
-            eventName: E,
-            listener: (...args: ServerEventMap<Request, Response>[E]) => void,
+        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: NonSharedBuffer) => void,
         ): this;
-        prependOnceListener(eventName: string | symbol, listener: (...args: any[]) => void): this;
-        rawListeners<E extends keyof ServerEventMap>(
-            eventName: E,
-        ): ((...args: ServerEventMap<Request, Response>[E]) => void)[];
-        rawListeners(eventName: string | symbol): ((...args: any[]) => void)[];
-        // eslint-disable-next-line @definitelytyped/no-unnecessary-generics
-        removeAllListeners<E extends keyof ServerEventMap>(eventName?: E): this;
-        removeAllListeners(eventName?: string | symbol): this;
-        removeListener<E extends keyof ServerEventMap>(
-            eventName: E,
-            listener: (...args: ServerEventMap<Request, Response>[E]) => void,
+        once(event: "request", listener: http.RequestListener<Request, Response>): this;
+        once(
+            event: "upgrade",
+            listener: (req: InstanceType<Request>, socket: Duplex, head: NonSharedBuffer) => void,
+        ): this;
+        prependListener(event: string, listener: (...args: any[]) => void): this;
+        prependListener(event: "keylog", listener: (line: NonSharedBuffer, tlsSocket: tls.TLSSocket) => void): this;
+        prependListener(
+            event: "newSession",
+            listener: (sessionId: NonSharedBuffer, sessionData: NonSharedBuffer, callback: () => void) => void,
+        ): this;
+        prependListener(
+            event: "OCSPRequest",
+            listener: (
+                certificate: NonSharedBuffer,
+                issuer: NonSharedBuffer,
+                callback: (err: Error | null, resp: Buffer | null) => void,
+            ) => void,
+        ): this;
+        prependListener(
+            event: "resumeSession",
+            listener: (
+                sessionId: NonSharedBuffer,
+                callback: (err: Error | null, sessionData: Buffer | null) => 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: NonSharedBuffer) => void,
+        ): this;
+        prependListener(event: "request", listener: http.RequestListener<Request, Response>): this;
+        prependListener(
+            event: "upgrade",
+            listener: (req: InstanceType<Request>, socket: Duplex, head: NonSharedBuffer) => void,
+        ): this;
+        prependOnceListener(event: string, listener: (...args: any[]) => void): this;
+        prependOnceListener(event: "keylog", listener: (line: NonSharedBuffer, tlsSocket: tls.TLSSocket) => void): this;
+        prependOnceListener(
+            event: "newSession",
+            listener: (sessionId: NonSharedBuffer, sessionData: NonSharedBuffer, callback: () => void) => void,
+        ): this;
+        prependOnceListener(
+            event: "OCSPRequest",
+            listener: (
+                certificate: NonSharedBuffer,
+                issuer: NonSharedBuffer,
+                callback: (err: Error | null, resp: Buffer | null) => void,
+            ) => void,
+        ): this;
+        prependOnceListener(
+            event: "resumeSession",
+            listener: (
+                sessionId: NonSharedBuffer,
+                callback: (err: Error | null, sessionData: Buffer | null) => 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: NonSharedBuffer) => void,
+        ): this;
+        prependOnceListener(event: "request", listener: http.RequestListener<Request, Response>): this;
+        prependOnceListener(
+            event: "upgrade",
+            listener: (req: InstanceType<Request>, socket: Duplex, head: NonSharedBuffer) => void,
         ): this;
-        removeListener(eventName: string | symbol, listener: (...args: any[]) => void): this;
-        // #endregion
     }
-    interface Server<
-        Request extends typeof http.IncomingMessage = typeof http.IncomingMessage,
-        Response extends typeof http.ServerResponse<InstanceType<Request>> = typeof http.ServerResponse,
-    > extends http.Server<Request, Response> {}
     /**
      * ```js
      * // curl -k https://localhost:8000/
@@ -400,6 +574,6 @@ declare module "node:https" {
     ): http.ClientRequest;
     let globalAgent: Agent;
 }
-declare module "https" {
-    export * from "node:https";
+declare module "node:https" {
+    export * from "https";
 }

package/node_modules/@types/node/index.d.ts

@@ -22,38 +22,26 @@
  * IN THE SOFTWARE.
  */
 
-// NOTE: These definitions support Node.js and TypeScript 5.8+.
+// NOTE: These definitions support Node.js and TypeScript 5.7+.
 
-// Reference required TypeScript libraries:
+// Reference required TypeScript libs:
 /// <reference lib="es2020" />
-/// <reference lib="esnext.disposable" />
-/// <reference lib="esnext.float16" />
 
-// Iterator definitions required for compatibility with TypeScript <5.6:
-/// <reference path="compatibility/iterators.d.ts" />
+// TypeScript backwards-compatibility definitions:
+/// <reference path="compatibility/index.d.ts" />
 
-// Definitions for Node.js modules specific to TypeScript 5.7+:
+// Definitions specific to TypeScript 5.7+:
 /// <reference path="globals.typedarray.d.ts" />
 /// <reference path="buffer.buffer.d.ts" />
 
 // Definitions for Node.js modules that are not specific to any version of TypeScript:
 /// <reference path="globals.d.ts" />
 /// <reference path="web-globals/abortcontroller.d.ts" />
-/// <reference path="web-globals/blob.d.ts" />
-/// <reference path="web-globals/console.d.ts" />
-/// <reference path="web-globals/crypto.d.ts" />
 /// <reference path="web-globals/domexception.d.ts" />
-/// <reference path="web-globals/encoding.d.ts" />
 /// <reference path="web-globals/events.d.ts" />
 /// <reference path="web-globals/fetch.d.ts" />
-/// <reference path="web-globals/importmeta.d.ts" />
-/// <reference path="web-globals/messaging.d.ts" />
 /// <reference path="web-globals/navigator.d.ts" />
-/// <reference path="web-globals/performance.d.ts" />
 /// <reference path="web-globals/storage.d.ts" />
-/// <reference path="web-globals/streams.d.ts" />
-/// <reference path="web-globals/timers.d.ts" />
-/// <reference path="web-globals/url.d.ts" />
 /// <reference path="assert.d.ts" />
 /// <reference path="assert/strict.d.ts" />
 /// <reference path="async_hooks.d.ts" />
@@ -76,30 +64,25 @@
 /// <reference path="https.d.ts" />
 /// <reference path="inspector.d.ts" />
 /// <reference path="inspector.generated.d.ts" />
-/// <reference path="inspector/promises.d.ts" />
 /// <reference path="module.d.ts" />
 /// <reference path="net.d.ts" />
 /// <reference path="os.d.ts" />
 /// <reference path="path.d.ts" />
-/// <reference path="path/posix.d.ts" />
-/// <reference path="path/win32.d.ts" />
 /// <reference path="perf_hooks.d.ts" />
 /// <reference path="process.d.ts" />
 /// <reference path="punycode.d.ts" />
 /// <reference path="querystring.d.ts" />
-/// <reference path="quic.d.ts" />
 /// <reference path="readline.d.ts" />
 /// <reference path="readline/promises.d.ts" />
 /// <reference path="repl.d.ts" />
 /// <reference path="sea.d.ts" />
 /// <reference path="sqlite.d.ts" />
 /// <reference path="stream.d.ts" />
-/// <reference path="stream/consumers.d.ts" />
 /// <reference path="stream/promises.d.ts" />
+/// <reference path="stream/consumers.d.ts" />
 /// <reference path="stream/web.d.ts" />
 /// <reference path="string_decoder.d.ts" />
 /// <reference path="test.d.ts" />
-/// <reference path="test/reporters.d.ts" />
 /// <reference path="timers.d.ts" />
 /// <reference path="timers/promises.d.ts" />
 /// <reference path="tls.d.ts" />
@@ -107,7 +90,6 @@
 /// <reference path="tty.d.ts" />
 /// <reference path="url.d.ts" />
 /// <reference path="util.d.ts" />
-/// <reference path="util/types.d.ts" />
 /// <reference path="v8.d.ts" />
 /// <reference path="vm.d.ts" />
 /// <reference path="wasi.d.ts" />

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

@@ -1,10 +1,10 @@
 /**
  * The `node:inspector` module provides an API for interacting with the V8
  * inspector.
- * @see [source](https://github.com/nodejs/node/blob/v25.x/lib/inspector.js)
+ * @see [source](https://github.com/nodejs/node/blob/v22.x/lib/inspector.js)
  */
-declare module "node:inspector" {
-    import { EventEmitter } from "node:events";
+declare module "inspector" {
+    import EventEmitter = require("node:events");
     /**
      * The `inspector.Session` is used for dispatching messages to the V8 inspector
      * back-end and receiving message responses and notifications.
@@ -39,7 +39,7 @@ declare module "node:inspector" {
      * If wait is `true`, will block until a client has connected to the inspect port
      * and flow control has been passed to the debugger client.
      *
-     * See the [security warning](https://nodejs.org/docs/latest-v25.x/api/cli.html#warning-binding-inspector-to-a-public-ipport-combination-is-insecure)
+     * See the [security warning](https://nodejs.org/docs/latest-v22.x/api/cli.html#warning-binding-inspector-to-a-public-ipport-combination-is-insecure)
      * regarding the `host` parameter usage.
      * @param port Port to listen on for inspector connections. Defaults to what was specified on the CLI.
      * @param host Host to listen on for inspector connections. Defaults to what was specified on the CLI.
@@ -125,14 +125,14 @@ declare module "node:inspector" {
          * `Network.streamResourceContent` command was not invoked for the given request yet.
          *
          * Also enables `Network.getResponseBody` command to retrieve the response data.
-         * @since v24.2.0
+         * @since v22.17.0
          */
         function dataReceived(params: DataReceivedEventDataType): void;
         /**
          * This feature is only available with the `--experimental-network-inspection` flag enabled.
          *
          * Enables `Network.getRequestPostData` command to retrieve the request data.
-         * @since v24.3.0
+         * @since v22.18.0
          */
         function dataSent(params: unknown): void;
         /**
@@ -159,30 +159,6 @@ declare module "node:inspector" {
          * @since v22.7.0
          */
         function loadingFailed(params: LoadingFailedEventDataType): void;
-        /**
-         * This feature is only available with the `--experimental-network-inspection` flag enabled.
-         *
-         * Broadcasts the `Network.webSocketCreated` event to connected frontends. This event indicates that
-         * a WebSocket connection has been initiated.
-         * @since v24.7.0
-         */
-        function webSocketCreated(params: WebSocketCreatedEventDataType): void;
-        /**
-         * This feature is only available with the `--experimental-network-inspection` flag enabled.
-         *
-         * Broadcasts the `Network.webSocketHandshakeResponseReceived` event to connected frontends.
-         * This event indicates that the WebSocket handshake response has been received.
-         * @since v24.7.0
-         */
-        function webSocketHandshakeResponseReceived(params: WebSocketHandshakeResponseReceivedEventDataType): void;
-        /**
-         * This feature is only available with the `--experimental-network-inspection` flag enabled.
-         *
-         * Broadcasts the `Network.webSocketClosed` event to connected frontends.
-         * This event indicates that a WebSocket connection has been closed.
-         * @since v24.7.0
-         */
-        function webSocketClosed(params: WebSocketClosedEventDataType): void;
     }
     namespace NetworkResources {
         /**
@@ -213,57 +189,65 @@ declare module "node:inspector" {
          * ```
          *
          * For more details, see the official CDP documentation: [Network.loadNetworkResource](https://chromedevtools.github.io/devtools-protocol/tot/Network/#method-loadNetworkResource)
-         * @since v24.5.0
+         * @since v22.19.0
          * @experimental
          */
         function put(url: string, data: string): void;
     }
-    namespace DOMStorage {
-        /**
-         * This feature is only available with the
-         * `--experimental-storage-inspection` flag enabled.
-         *
-         * Broadcasts the `DOMStorage.domStorageItemAdded` event to connected frontends.
-         * This event indicates that a new item has been added to the storage.
-         * @since v25.5.0
-         */
-        function domStorageItemAdded(params: DomStorageItemAddedEventDataType): void;
+}
+
+/**
+ * The `node:inspector` module provides an API for interacting with the V8
+ * inspector.
+ */
+declare module "node:inspector" {
+    export * from "inspector";
+}
+
+/**
+ * The `node:inspector/promises` module provides an API for interacting with the V8
+ * inspector.
+ * @see [source](https://github.com/nodejs/node/blob/v22.x/lib/inspector/promises.js)
+ * @since v19.0.0
+ */
+declare module "inspector/promises" {
+    import EventEmitter = require("node:events");
+    export { close, console, NetworkResources, open, url, waitForDebugger } from "inspector";
+    /**
+     * The `inspector.Session` is used for dispatching messages to the V8 inspector
+     * back-end and receiving message responses and notifications.
+     * @since v19.0.0
+     */
+    export class Session extends EventEmitter {
         /**
-         * This feature is only available with the
-         * `--experimental-storage-inspection` flag enabled.
-         *
-         * Broadcasts the `DOMStorage.domStorageItemRemoved` event to connected frontends.
-         * This event indicates that an item has been removed from the storage.
-         * @since v25.5.0
+         * Create a new instance of the inspector.Session class.
+         * The inspector session needs to be connected through `session.connect()` before the messages can be dispatched to the inspector backend.
          */
-        function domStorageItemRemoved(params: DomStorageItemRemovedEventDataType): void;
+        constructor();
         /**
-         * This feature is only available with the
-         * `--experimental-storage-inspection` flag enabled.
-
-         * Broadcasts the `DOMStorage.domStorageItemUpdated` event to connected frontends.
-         * This event indicates that a storage item has been updated.
-         * @since v25.5.0
+         * Connects a session to the inspector back-end.
          */
-        function domStorageItemUpdated(params: DomStorageItemUpdatedEventDataType): void;
+        connect(): void;
         /**
-         * This feature is only available with the
-         * `--experimental-storage-inspection` flag enabled.
-         *
-         * Broadcasts the `DOMStorage.domStorageItemsCleared` event to connected
-         * frontends. This event indicates that all items have been cleared from the
-         * storage.
-         * @since v25.5.0
+         * Connects a session to the inspector back-end.
+         * An exception will be thrown if this API was not called on a Worker thread.
+         * @since v12.11.0
          */
-        function domStorageItemsCleared(params: DomStorageItemsClearedEventDataType): void;
+        connectToMainThread(): void;
         /**
-         * This feature is only available with the
-         * `--experimental-storage-inspection` flag enabled.
-         * @since v25.5.0
+         * Immediately close the session. All pending message callbacks will be called with an error.
+         * `session.connect()` will need to be called to be able to send messages again.
+         * Reconnected session will lose all inspector state, such as enabled agents or configured breakpoints.
          */
-        function registerStorage(params: unknown): void;
+        disconnect(): void;
     }
 }
-declare module "inspector" {
-    export * from "node:inspector";
+
+/**
+ * The `node:inspector/promises` module provides an API for interacting with the V8
+ * inspector.
+ * @since v19.0.0
+ */
+declare module "node:inspector/promises" {
+    export * from "inspector/promises";
 }