@psnext/slingcli 3.1.20260904-1 → 3.3.20260911-1

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

@@ -1,8 +1,9 @@
-declare module "node:process" {
+declare module "process" {
     import { Control, MessageOptions, SendHandle } from "node:child_process";
     import { PathLike } from "node:fs";
     import * as tty from "node:tty";
     import { Worker } from "node:worker_threads";
+
     interface BuiltInModule {
         "assert": typeof import("assert");
         "node:assert": typeof import("node:assert");
@@ -34,7 +35,6 @@ declare module "node:process" {
         "node:domain": typeof import("node:domain");
         "events": typeof import("events");
         "node:events": typeof import("node:events");
-        "node:ffi": typeof import("node:ffi");
         "fs": typeof import("fs");
         "node:fs": typeof import("node:fs");
         "fs/promises": typeof import("fs/promises");
@@ -69,7 +69,6 @@ declare module "node:process" {
         "node:punycode": typeof import("node:punycode");
         "querystring": typeof import("querystring");
         "node:querystring": typeof import("node:querystring");
-        "node:quic": typeof import("node:quic");
         "readline": typeof import("readline");
         "node:readline": typeof import("node:readline");
         "readline/promises": typeof import("readline/promises");
@@ -82,8 +81,6 @@ declare module "node:process" {
         "node:stream": typeof import("node:stream");
         "stream/consumers": typeof import("stream/consumers");
         "node:stream/consumers": typeof import("node:stream/consumers");
-        "stream/iter": typeof import("stream/iter");
-        "node:stream/iter": typeof import("node:stream/iter");
         "stream/promises": typeof import("stream/promises");
         "node:stream/promises": typeof import("node:stream/promises");
         "stream/web": typeof import("stream/web");
@@ -106,6 +103,8 @@ declare module "node:process" {
         "node:url": typeof import("node:url");
         "util": typeof import("util");
         "node:util": typeof import("node:util");
+        "sys": typeof import("util");
+        "node:sys": typeof import("node:util");
         "util/types": typeof import("util/types");
         "node:util/types": typeof import("node:util/types");
         "v8": typeof import("v8");
@@ -119,28 +118,8 @@ declare module "node:process" {
         "zlib": typeof import("zlib");
         "node:zlib": typeof import("node:zlib");
     }
-    type SignalsEventMap = { [S in NodeJS.Signals]: [signal: S] };
-    interface ProcessEventMap extends SignalsEventMap {
-        "beforeExit": [code: number];
-        "disconnect": [];
-        "exit": [code: number];
-        "message": [
-            message: object | boolean | number | string | null,
-            sendHandle: SendHandle | undefined,
-        ];
-        "rejectionHandled": [promise: Promise<unknown>];
-        "uncaughtException": [error: Error, origin: NodeJS.UncaughtExceptionOrigin];
-        "uncaughtExceptionMonitor": [error: Error, origin: NodeJS.UncaughtExceptionOrigin];
-        "unhandledRejection": [reason: unknown, promise: Promise<unknown>];
-        "warning": [warning: Error];
-        "worker": [worker: Worker];
-        "workerMessage": [value: any, source: number];
-    }
     global {
         var process: NodeJS.Process;
-        namespace process {
-            export { ProcessEventMap };
-        }
         namespace NodeJS {
             // this namespace merge is here because these are specifically used
             // as the type for process.stdin, process.stdout, and process.stderr.
@@ -217,7 +196,7 @@ declare module "node:process" {
                 readonly ipv6: boolean;
                 /**
                  * A boolean value that is `true` if the current Node.js build supports
-                 * [loading ECMAScript modules using `require()`](https://nodejs.org/docs/latest-v26.x/api/modules.md#loading-ecmascript-modules-using-require).
+                 * [loading ECMAScript modules using `require()`](https://nodejs.org/docs/latest-v22.x/api/modules.md#loading-ecmascript-modules-using-require).
                  * @since v22.10.0
                  */
                 readonly require_module: boolean;
@@ -254,11 +233,12 @@ declare module "node:process" {
                  */
                 readonly tls_sni: boolean;
                 /**
-                 * A value that is `"strip"` by default, and `false` if
-                 * Node.js is run with `--no-strip-types`.
+                 * A value that is `"strip"` by default,
+                 * `"transform"` if Node.js is run with `--experimental-transform-types`, and `false` if
+                 * Node.js is run with `--no-experimental-strip-types`.
                  * @since v22.10.0
                  */
-                readonly typescript: "strip" | false;
+                readonly typescript: "strip" | "transform" | false;
                 /**
                  * A boolean value that is `true` if the current Node.js build includes support for libuv.
                  *
@@ -297,8 +277,10 @@ declare module "node:process" {
                 | "loong64"
                 | "mips"
                 | "mipsel"
+                | "ppc"
                 | "ppc64"
                 | "riscv64"
+                | "s390"
                 | "s390x"
                 | "x64";
             type Signals =
@@ -340,129 +322,26 @@ declare module "node:process" {
                 | "SIGLOST"
                 | "SIGINFO";
             type UncaughtExceptionOrigin = "uncaughtException" | "unhandledRejection";
+            type MultipleResolveType = "resolve" | "reject";
+            type BeforeExitListener = (code: number) => void;
+            type DisconnectListener = () => void;
+            type ExitListener = (code: number) => void;
+            type RejectionHandledListener = (promise: Promise<unknown>) => void;
+            type UncaughtExceptionListener = (error: Error, origin: UncaughtExceptionOrigin) => void;
             /**
-             * @deprecated Global listener types will be removed in a future version.
-             * Callbacks passed directly to `process`'s EventEmitter methods
-             * have their parameter types inferred automatically.
-             *
-             * `process` event types are also available via `ProcessEventMap`:
-             *
-             * ```ts
-             * import type { ProcessEventMap } from 'node:process';
-             * const listener = (...args: ProcessEventMap['beforeExit']) => { ... };
-             * ```
-             */
-            type BeforeExitListener = (...args: ProcessEventMap["beforeExit"]) => void;
-            /**
-             * @deprecated Global listener types will be removed in a future version.
-             * Callbacks passed directly to `process`'s EventEmitter methods
-             * have their parameter types inferred automatically.
-             *
-             * `process` event types are also available via `ProcessEventMap`:
-             *
-             * ```ts
-             * import type { ProcessEventMap } from 'node:process';
-             * const listener = (...args: ProcessEventMap['disconnect']) => { ... };
-             * ```
-             */
-            type DisconnectListener = (...args: ProcessEventMap["disconnect"]) => void;
-            /**
-             * @deprecated Global listener types will be removed in a future version.
-             * Callbacks passed directly to `process`'s EventEmitter methods
-             * have their parameter types inferred automatically.
-             *
-             * `process` event types are also available via `ProcessEventMap`:
-             *
-             * ```ts
-             * import type { ProcessEventMap } from 'node:process';
-             * const listener = (...args: ProcessEventMap['exit']) => { ... };
-             * ```
-             */
-            type ExitListener = (...args: ProcessEventMap["exit"]) => void;
-            /**
-             * @deprecated Global listener types will be removed in a future version.
-             * Callbacks passed directly to `process`'s EventEmitter methods
-             * have their parameter types inferred automatically.
-             *
-             * `process` event types are also available via `ProcessEventMap`:
-             *
-             * ```ts
-             * import type { ProcessEventMap } from 'node:process';
-             * const listener = (...args: ProcessEventMap['message']) => { ... };
-             * ```
-             */
-            type MessageListener = (...args: ProcessEventMap["message"]) => void;
-            /**
-             * @deprecated Global listener types will be removed in a future version.
-             * Callbacks passed directly to `process`'s EventEmitter methods
-             * have their parameter types inferred automatically.
-             *
-             * `process` event types are also available via `ProcessEventMap`:
-             *
-             * ```ts
-             * import type { ProcessEventMap } from 'node:process';
-             * const listener = (...args: ProcessEventMap['rejectionHandled']) => { ... };
-             * ```
-             */
-            type RejectionHandledListener = (...args: ProcessEventMap["rejectionHandled"]) => void;
-            /**
-             * @deprecated Global listener types will be removed in a future version.
-             * Callbacks passed directly to `process`'s EventEmitter methods
-             * have their parameter types inferred automatically.
+             * Most of the time the unhandledRejection will be an Error, but this should not be relied upon
+             * as *anything* can be thrown/rejected, it is therefore unsafe to assume that the value is an Error.
              */
+            type UnhandledRejectionListener = (reason: unknown, promise: Promise<unknown>) => void;
+            type WarningListener = (warning: Error) => void;
+            type MessageListener = (message: unknown, sendHandle: SendHandle) => void;
             type SignalsListener = (signal: Signals) => void;
-            /**
-             * @deprecated Global listener types will be removed in a future version.
-             * Callbacks passed directly to `process`'s EventEmitter methods
-             * have their parameter types inferred automatically.
-             *
-             * `process` event types are also available via `ProcessEventMap`:
-             *
-             * ```ts
-             * import type { ProcessEventMap } from 'node:process';
-             * const listener = (...args: ProcessEventMap['uncaughtException']) => { ... };
-             * ```
-             */
-            type UncaughtExceptionListener = (...args: ProcessEventMap["uncaughtException"]) => void;
-            /**
-             * @deprecated Global listener types will be removed in a future version.
-             * Callbacks passed directly to `process`'s EventEmitter methods
-             * have their parameter types inferred automatically.
-             *
-             * `process` event types are also available via `ProcessEventMap`:
-             *
-             * ```ts
-             * import type { ProcessEventMap } from 'node:process';
-             * const listener = (...args: ProcessEventMap['unhandledRejection']) => { ... };
-             * ```
-             */
-            type UnhandledRejectionListener = (...args: ProcessEventMap["unhandledRejection"]) => void;
-            /**
-             * @deprecated Global listener types will be removed in a future version.
-             * Callbacks passed directly to `process`'s EventEmitter methods
-             * have their parameter types inferred automatically.
-             *
-             * `process` event types are also available via `ProcessEventMap`:
-             *
-             * ```ts
-             * import type { ProcessEventMap } from 'node:process';
-             * const listener = (...args: ProcessEventMap['warning']) => { ... };
-             * ```
-             */
-            type WarningListener = (...args: ProcessEventMap["warning"]) => void;
-            /**
-             * @deprecated Global listener types will be removed in a future version.
-             * Callbacks passed directly to `process`'s EventEmitter methods
-             * have their parameter types inferred automatically.
-             *
-             * `process` event types are also available via `ProcessEventMap`:
-             *
-             * ```ts
-             * import type { ProcessEventMap } from 'node:process';
-             * const listener = (...args: ProcessEventMap['worker']) => { ... };
-             * ```
-             */
-            type WorkerListener = (...args: ProcessEventMap["worker"]) => void;
+            type MultipleResolveListener = (
+                type: MultipleResolveType,
+                promise: Promise<unknown>,
+                value: unknown,
+            ) => void;
+            type WorkerListener = (worker: Worker) => void;
             interface Socket extends ReadWriteStream {
                 isTTY?: true | undefined;
             }
@@ -549,58 +428,6 @@ declare module "node:process" {
                  * @since v20.0.0
                  */
                 has(scope: string, reference?: string): boolean;
-                /**
-                 * Drops the specified permission from the current process. This operation is
-                 * **irreversible** — once a permission is dropped, it cannot be restored through
-                 * any Node.js API.
-                 *
-                 * If no reference is provided, the entire scope is dropped. For example,
-                 * `process.permission.drop('fs.read')` will revoke ALL file system read
-                 * permissions.
-                 *
-                 * When a reference is provided, only the permission for that specific resource
-                 * is dropped. For example, `process.permission.drop('fs.read', '/etc/myapp')`
-                 * will revoke read access to that directory while keeping other read
-                 * permissions intact.
-                 *
-                 * **Important:** You can only drop the exact resource that was explicitly
-                 * granted. The reference passed to `drop()` must match the original grant:
-                 *
-                 * * If a permission was granted using a wildcard (`*`), such as
-                 *   `--allow-fs-read=*`, individual paths cannot be dropped - only the entire
-                 *   scope can be dropped (by calling `drop()` without a reference).
-                 * * If a directory was granted (e.g. `--allow-fs-read=/my/folder`), you cannot
-                 *   drop access to individual files inside it. You must drop the same directory
-                 *   that was granted. Any remaining grants continue to apply.
-                 *
-                 * The available scopes are the same as [`process.permission.has()`][]:
-                 *
-                 *  `fs` - All File System (drops both read and write)
-                 * * `fs.read` - File System read operations
-                 * * `fs.write` - File System write operations
-                 * * `child` - Child process spawning operations
-                 * * `worker` - Worker thread spawning operation
-                 * * `net` - Network operations
-                 * * `inspector` - Inspector operations
-                 * * `wasi` - WASI operations
-                 * * `addon` - Native addon operations
-                 *
-                 * ```js
-                 * const fs = require('node:fs');
-                 *
-                 * // Read configuration during startup
-                 * const config = fs.readFileSync('/etc/myapp/config.json', 'utf8');
-                 *
-                 * // Drop read access to the config directory after initialization
-                 * process.permission.drop('fs.read', '/etc/myapp');
-                 *
-                 * // This will now throw ERR_ACCESS_DENIED
-                 * fs.readFileSync('/etc/myapp/config.json');
-                 * ```
-                 * @since v26.3.0
-                 * @experimental
-                 */
-                drop(scope: string, reference?: string): void;
             }
             interface ProcessReport {
                 /**
@@ -783,8 +610,7 @@ declare module "node:process" {
                  * arguments passed when the Node.js process was launched. The first element will
                  * be {@link execPath}. See `process.argv0` if access to the original value
                  * of `argv[0]` is needed. The second element will be the path to the JavaScript
-                 * file being executed. If a [program entry point](https://nodejs.org/docs/latest-v26.x/api/cli.html#program-entry-point) was provided, the second element
-                 * will be the absolute path to it. The remaining elements are additional command-line
+                 * file being executed. The remaining elements will be any additional command-line
                  * arguments.
                  *
                  * For example, assuming the following script for `process-args.js`:
@@ -843,14 +669,14 @@ declare module "node:process" {
                  *
                  * Results in `process.execArgv`:
                  *
-                 * ```json
+                 * ```js
                  * ["--icu-data-dir=./foo", "--require", "./bar.js"]
                  * ```
                  *
                  * And `process.argv`:
                  *
-                 * ```json
-                 * ["/usr/local/bin/node", "script.js", "--version"]
+                 * ```js
+                 * ['/usr/local/bin/node', 'script.js', '--version']
                  * ```
                  *
                  * Refer to `Worker constructor` for the detailed behavior of worker
@@ -862,8 +688,8 @@ declare module "node:process" {
                  * The `process.execPath` property returns the absolute pathname of the executable
                  * that started the Node.js process. Symbolic links, if any, are resolved.
                  *
-                 * ```json
-                 * "/usr/local/bin/node"
+                 * ```js
+                 * '/usr/local/bin/node'
                  * ```
                  * @since v0.1.100
                  */
@@ -876,28 +702,6 @@ declare module "node:process" {
                  * @since v0.7.0
                  */
                 abort(): never;
-                /**
-                 * The `process.addUncaughtExceptionCaptureCallback()` function adds a callback
-                 * that will be invoked when an uncaught exception occurs, receiving the exception
-                 * value as its first argument.
-                 *
-                 * Unlike `process.setUncaughtExceptionCaptureCallback()`, this function allows
-                 * multiple callbacks to be registered and does not conflict with the
-                 * [`domain`](https://nodejs.org/docs/latest-v26.x/api/domain.html) module. Callbacks are called in reverse order of registration
-                 * (most recent first). If a callback returns `true`, subsequent callbacks
-                 * and the default uncaught exception handling are skipped.
-                 *
-                 * ```js
-                 * import process from 'node:process';
-                 *
-                 * process.addUncaughtExceptionCaptureCallback((err) => {
-                 *   console.error('Caught exception:', err.message);
-                 *   return true; // Indicates exception was handled
-                 * });
-                 * ```
-                 * @since v25.9.0
-                 */
-                addUncaughtExceptionCaptureCallback(fn: (err: unknown) => boolean): void;
                 /**
                  * The `process.chdir()` method changes the current working directory of the
                  * Node.js process or throws an exception if doing so fails (for instance, if
@@ -947,7 +751,7 @@ declare module "node:process" {
                  * should not be used directly, except in special cases. In other words, `require()` should be preferred over `process.dlopen()`
                  * unless there are specific reasons such as custom dlopen flags or loading from ES modules.
                  *
-                 * The `flags` argument is an integer that allows to specify dlopen behavior. See the `[os.constants.dlopen](https://nodejs.org/docs/latest-v26.x/api/os.html#dlopen-constants)`
+                 * The `flags` argument is an integer that allows to specify dlopen behavior. See the `[os.constants.dlopen](https://nodejs.org/docs/latest-v22.x/api/os.html#dlopen-constants)`
                  * documentation for details.
                  *
                  * An important requirement when calling `process.dlopen()` is that the `module` instance must be passed. Functions exported by the C++ Addon
@@ -1046,18 +850,18 @@ declare module "node:process" {
                  *
                  * An example of this object looks like:
                  *
-                 * ```json
+                 * ```js
                  * {
-                 *   "TERM": "xterm-256color",
-                 *   "SHELL": "/usr/local/bin/bash",
-                 *   "USER": "maciej",
-                 *   "PATH": "~/.bin/:/usr/bin:/bin:/usr/sbin:/sbin:/usr/local/bin",
-                 *   "PWD": "/Users/maciej",
-                 *   "EDITOR": "vim",
-                 *   "SHLVL": "1",
-                 *   "HOME": "/Users/maciej",
-                 *   "LOGNAME": "maciej",
-                 *   "_": "/usr/local/bin/node"
+                 *   TERM: 'xterm-256color',
+                 *   SHELL: '/usr/local/bin/bash',
+                 *   USER: 'maciej',
+                 *   PATH: '~/.bin/:/usr/bin:/bin:/usr/sbin:/sbin:/usr/local/bin',
+                 *   PWD: '/Users/maciej',
+                 *   EDITOR: 'vim',
+                 *   SHLVL: '1',
+                 *   HOME: '/Users/maciej',
+                 *   LOGNAME: 'maciej',
+                 *   _: '/usr/local/bin/node'
                  * }
                  * ```
                  *
@@ -1494,11 +1298,10 @@ declare module "node:process" {
                  * method with a non-`null` argument while another capture function is set will
                  * throw an error.
                  *
-                 * To register multiple callbacks that can coexist, use
-                 * `process.addUncaughtExceptionCaptureCallback()` instead.
+                 * Using this function is mutually exclusive with using the deprecated `domain` built-in module.
                  * @since v9.3.0
                  */
-                setUncaughtExceptionCaptureCallback(cb: ((err: unknown) => void) | null): void;
+                setUncaughtExceptionCaptureCallback(cb: ((err: Error) => void) | null): void;
                 /**
                  * Indicates whether a callback has been set using {@link setUncaughtExceptionCaptureCallback}.
                  * @since v9.3.0
@@ -1551,35 +1354,30 @@ declare module "node:process" {
                  * Will generate an object similar to:
                  *
                  * ```console
-                 * { node: '26.0.0-pre',
-                 *   acorn: '8.15.0',
-                 *   ada: '3.4.1',
-                 *   amaro: '1.1.5',
-                 *   ares: '1.34.6',
-                 *   brotli: '1.2.0',
-                 *   merve: '1.0.0',
-                 *   cldr: '48.0',
-                 *   icu: '78.2',
-                 *   llhttp: '9.3.0',
-                 *   modules: '144',
-                 *   napi: '10',
-                 *   nbytes: '0.1.1',
-                 *   ncrypto: '0.0.1',
-                 *   nghttp2: '1.68.0',
-                 *   nghttp3: '',
-                 *   ngtcp2: '',
-                 *   openssl: '3.5.4',
-                 *   simdjson: '4.2.4',
-                 *   simdutf: '7.3.3',
-                 *   sqlite: '3.51.2',
-                 *   tz: '2025c',
-                 *   undici: '7.18.2',
-                 *   unicode: '17.0',
-                 *   uv: '1.51.0',
-                 *   uvwasi: '0.0.23',
-                 *   v8: '14.3.127.18-node.10',
-                 *   zlib: '1.3.1-e00f703',
-                 *   zstd: '1.5.7' }
+                 * { node: '20.2.0',
+                 *   acorn: '8.8.2',
+                 *   ada: '2.4.0',
+                 *   ares: '1.19.0',
+                 *   base64: '0.5.0',
+                 *   brotli: '1.0.9',
+                 *   cjs_module_lexer: '1.2.2',
+                 *   cldr: '43.0',
+                 *   icu: '73.1',
+                 *   llhttp: '8.1.0',
+                 *   modules: '115',
+                 *   napi: '8',
+                 *   nghttp2: '1.52.0',
+                 *   nghttp3: '0.7.0',
+                 *   ngtcp2: '0.8.1',
+                 *   openssl: '3.0.8+quic',
+                 *   simdutf: '3.2.9',
+                 *   tz: '2023c',
+                 *   undici: '5.22.0',
+                 *   unicode: '15.0',
+                 *   uv: '1.44.2',
+                 *   uvwasi: '0.0.16',
+                 *   v8: '11.3.244.8-node.9',
+                 *   zlib: '1.2.13' }
                  * ```
                  * @since v0.2.0
                  */
@@ -1592,28 +1390,29 @@ declare module "node:process" {
                  *
                  * An example of the possible output looks like:
                  *
-                 * ```json
+                 * ```js
                  * {
-                 *   "target_defaults":
-                 *    { "cflags": [],
-                 *      "default_configuration": "Release",
-                 *      "defines": [],
-                 *      "include_dirs": [],
-                 *      "libraries": [] },
-                 *   "variables":
+                 *   target_defaults:
+                 *    { cflags: [],
+                 *      default_configuration: 'Release',
+                 *      defines: [],
+                 *      include_dirs: [],
+                 *      libraries: [] },
+                 *   variables:
                  *    {
-                 *      "host_arch": "x64",
-                 *      "napi_build_version": 5,
-                 *      "node_install_npm": "true",
-                 *      "node_prefix": "",
-                 *      "node_shared_cares": "false",
-                 *      "node_shared_http_parser": "false",
-                 *      "node_shared_libuv": "false",
-                 *      "node_shared_zlib": "false",
-                 *      "node_use_openssl": "true",
-                 *      "node_shared_openssl": "false",
-                 *      "target_arch": "x64",
-                 *      "v8_use_snapshot": 1
+                 *      host_arch: 'x64',
+                 *      napi_build_version: 5,
+                 *      node_install_npm: 'true',
+                 *      node_prefix: '',
+                 *      node_shared_cares: 'false',
+                 *      node_shared_http_parser: 'false',
+                 *      node_shared_libuv: 'false',
+                 *      node_shared_zlib: 'false',
+                 *      node_use_openssl: 'true',
+                 *      node_shared_openssl: 'false',
+                 *      strict_aliasing: 'true',
+                 *      target_arch: 'x64',
+                 *      v8_use_snapshot: 1
                  *    }
                  * }
                  * ```
@@ -1701,7 +1500,7 @@ declare module "node:process" {
                  *
                  * The result of a previous call to `process.threadCpuUsage()` can be passed as the
                  * argument to the function, to get a diff reading.
-                 * @since v23.9.0
+                 * @since v22.19.0
                  * @param previousValue A previous return value from calling
                  * `process.threadCpuUsage()`
                  */
@@ -1726,8 +1525,7 @@ declare module "node:process" {
                 title: string;
                 /**
                  * The operating system CPU architecture for which the Node.js binary was compiled.
-                 * Possible values are: `'arm'`, `'arm64'`, `'ia32'`, `'loong64'`, `'mips'`,
-                 * `'mipsel'`, `'ppc64'`, `'riscv64'`, `'s390x'`, and `'x64'`.
+                 * Possible values are: `'arm'`, `'arm64'`, `'ia32'`, `'loong64'`, `'mips'`, `'mipsel'`, `'ppc'`, `'ppc64'`, `'riscv64'`, `'s390'`, `'s390x'`, and `'x64'`.
                  *
                  * ```js
                  * import { arch } from 'node:process';
@@ -1787,7 +1585,7 @@ declare module "node:process" {
                 constrainedMemory(): number;
                 /**
                  * Gets the amount of free memory that is still available to the process (in bytes).
-                 * See [`uv_get_available_memory`](https://nodejs.org/docs/latest-v26.x/api/process.html#processavailablememory) for more information.
+                 * See [`uv_get_available_memory`](https://nodejs.org/docs/latest-v22.x/api/process.html#processavailablememory) for more information.
                  * @since v20.13.0
                  */
                 availableMemory(): number;
@@ -1927,13 +1725,13 @@ declare module "node:process" {
                  *
                  * `process.release` contains the following properties:
                  *
-                 * ```json
+                 * ```js
                  * {
-                 *   "name": "node",
-                 *   "lts": "Hydrogen",
-                 *   "sourceUrl": "https://nodejs.org/download/release/v18.12.0/node-v18.12.0.tar.gz",
-                 *   "headersUrl": "https://nodejs.org/download/release/v18.12.0/node-v18.12.0-headers.tar.gz",
-                 *   "libUrl": "https://nodejs.org/download/release/v18.12.0/win-x64/node.lib"
+                 *   name: 'node',
+                 *   lts: 'Hydrogen',
+                 *   sourceUrl: 'https://nodejs.org/download/release/v18.12.0/node-v18.12.0.tar.gz',
+                 *   headersUrl: 'https://nodejs.org/download/release/v18.12.0/node-v18.12.0-headers.tar.gz',
+                 *   libUrl: 'https://nodejs.org/download/release/v18.12.0/win-x64/node.lib'
                  * }
                  * ```
                  *
@@ -1943,24 +1741,6 @@ declare module "node:process" {
                  */
                 readonly release: ProcessRelease;
                 readonly features: ProcessFeatures;
-                /**
-                 * The `process.traceProcessWarnings` property indicates whether the `--trace-warnings` flag
-                 * is set on the current Node.js process. This property allows programmatic control over the
-                 * tracing of warnings, enabling or disabling stack traces for warnings at runtime.
-                 *
-                 * ```js
-                 * // Enable trace warnings
-                 * process.traceProcessWarnings = true;
-                 *
-                 * // Emit a warning with a stack trace
-                 * process.emitWarning('Warning with stack trace');
-                 *
-                 * // Disable trace warnings
-                 * process.traceProcessWarnings = false;
-                 * ```
-                 * @since v6.10.0
-                 */
-                traceProcessWarnings: boolean;
                 /**
                  * `process.umask()` returns the Node.js process's file mode creation mask. Child
                  * processes inherit the mask from the parent process.
@@ -2025,7 +1805,7 @@ declare module "node:process" {
                  * If the Node.js process was not spawned with an IPC channel, `process.disconnect()` will be `undefined`.
                  * @since v0.7.2
                  */
-                disconnect?(): void;
+                disconnect(): void;
                 /**
                  * If the Node.js process is spawned with an IPC channel (see the `Child Process` and `Cluster` documentation), the `process.connected` property will return `true` so long as the IPC
                  * channel is connected and will return `false` after `process.disconnect()` is called.
@@ -2079,7 +1859,7 @@ declare module "node:process" {
                 allowedNodeEnvironmentFlags: ReadonlySet<string>;
                 /**
                  * `process.report` is an object whose methods are used to generate diagnostic reports for the current process.
-                 * Additional documentation is available in the [report documentation](https://nodejs.org/docs/latest-v26.x/api/report.html).
+                 * Additional documentation is available in the [report documentation](https://nodejs.org/docs/latest-v22.x/api/report.html).
                  * @since v11.8.0
                  */
                 report: ProcessReport;
@@ -2182,19 +1962,7 @@ declare module "node:process" {
                  * All other resources are discarded by the system when the processes are swapped, without triggering
                  * any exit or close events and without running any cleanup handler.
                  *
-                 * On success, all other resources are discarded by the system when the
-                 * processes are swapped, without triggering any exit or close events, without
-                 * running any JavaScript cleanup handler (for example `process.on('exit')`),
-                 * and without invoking native `AtExit` callbacks registered through the
-                 * embedder API. Callers that need to run cleanup logic should do so before
-                 * calling `process.execve()`.
-                 *
-                 * This function does not return on success. If the underlying `execve(2)`
-                 * system call fails, an `Error` is thrown whose `code` property is set to the
-                 * corresponding `errno` string (for example, `'ENOENT'` when `file` does not
-                 * exist), with `syscall` set to `'execve'` and `path` set to `file`. When
-                 * `execve(2)` fails the current process continues to run with its state
-                 * unchanged, so a caller may handle the error and take another action.
+                 * This function will never return, unless an error occurred.
                  *
                  * This function is not available on Windows or IBM i.
                  * @since v22.15.0
@@ -2206,63 +1974,111 @@ declare module "node:process" {
                  * **Default:** `process.env`.
                  */
                 execve?(file: string, args?: readonly string[], env?: ProcessEnv): never;
-                // #region InternalEventEmitter
-                addListener<E extends keyof ProcessEventMap>(
-                    eventName: E,
-                    listener: (...args: ProcessEventMap[E]) => void,
-                ): this;
-                addListener(eventName: string | symbol, listener: (...args: any[]) => void): this;
-                emit<E extends keyof ProcessEventMap>(eventName: E, ...args: ProcessEventMap[E]): boolean;
-                emit(eventName: string | symbol, ...args: any[]): boolean;
-                listenerCount<E extends keyof ProcessEventMap>(
-                    eventName: E,
-                    listener?: (...args: ProcessEventMap[E]) => void,
-                ): number;
-                listenerCount(eventName: string | symbol, listener?: (...args: any[]) => void): number;
-                listeners<E extends keyof ProcessEventMap>(eventName: E): ((...args: ProcessEventMap[E]) => void)[];
-                listeners(eventName: string | symbol): ((...args: any[]) => void)[];
-                off<E extends keyof ProcessEventMap>(
-                    eventName: E,
-                    listener: (...args: ProcessEventMap[E]) => void,
-                ): this;
-                off(eventName: string | symbol, listener: (...args: any[]) => void): this;
-                on<E extends keyof ProcessEventMap>(
-                    eventName: E,
-                    listener: (...args: ProcessEventMap[E]) => void,
-                ): this;
-                on(eventName: string | symbol, listener: (...args: any[]) => void): this;
-                once<E extends keyof ProcessEventMap>(
-                    eventName: E,
-                    listener: (...args: ProcessEventMap[E]) => void,
-                ): this;
-                once(eventName: string | symbol, listener: (...args: any[]) => void): this;
-                prependListener<E extends keyof ProcessEventMap>(
-                    eventName: E,
-                    listener: (...args: ProcessEventMap[E]) => void,
+                /* EventEmitter */
+                addListener(event: "beforeExit", listener: BeforeExitListener): this;
+                addListener(event: "disconnect", listener: DisconnectListener): this;
+                addListener(event: "exit", listener: ExitListener): this;
+                addListener(event: "rejectionHandled", listener: RejectionHandledListener): this;
+                addListener(event: "uncaughtException", listener: UncaughtExceptionListener): this;
+                addListener(event: "uncaughtExceptionMonitor", listener: UncaughtExceptionListener): this;
+                addListener(event: "unhandledRejection", listener: UnhandledRejectionListener): this;
+                addListener(event: "warning", listener: WarningListener): this;
+                addListener(event: "message", listener: MessageListener): this;
+                addListener(event: "workerMessage", listener: (value: any, source: number) => void): this;
+                addListener(event: Signals, listener: SignalsListener): this;
+                addListener(event: "multipleResolves", listener: MultipleResolveListener): this;
+                addListener(event: "worker", listener: WorkerListener): this;
+                emit(event: "beforeExit", code: number): boolean;
+                emit(event: "disconnect"): boolean;
+                emit(event: "exit", code: number): boolean;
+                emit(event: "rejectionHandled", promise: Promise<unknown>): boolean;
+                emit(event: "uncaughtException", error: Error): boolean;
+                emit(event: "uncaughtExceptionMonitor", error: Error): boolean;
+                emit(event: "unhandledRejection", reason: unknown, promise: Promise<unknown>): boolean;
+                emit(event: "warning", warning: Error): boolean;
+                emit(event: "message", message: unknown, sendHandle: SendHandle): this;
+                emit(event: "workerMessage", value: any, source: number): this;
+                emit(event: Signals, signal?: Signals): boolean;
+                emit(
+                    event: "multipleResolves",
+                    type: MultipleResolveType,
+                    promise: Promise<unknown>,
+                    value: unknown,
                 ): this;
-                prependListener(eventName: string | symbol, listener: (...args: any[]) => void): this;
-                prependOnceListener<E extends keyof ProcessEventMap>(
-                    eventName: E,
-                    listener: (...args: ProcessEventMap[E]) => void,
-                ): this;
-                prependOnceListener(eventName: string | symbol, listener: (...args: any[]) => void): this;
-                rawListeners<E extends keyof ProcessEventMap>(eventName: E): ((...args: ProcessEventMap[E]) => void)[];
-                rawListeners(eventName: string | symbol): ((...args: any[]) => void)[];
-                // eslint-disable-next-line @definitelytyped/no-unnecessary-generics
-                removeAllListeners<E extends keyof ProcessEventMap>(eventName?: E): this;
-                removeAllListeners(eventName?: string | symbol): this;
-                removeListener<E extends keyof ProcessEventMap>(
-                    eventName: E,
-                    listener: (...args: ProcessEventMap[E]) => void,
-                ): this;
-                removeListener(eventName: string | symbol, listener: (...args: any[]) => void): this;
-                // #endregion
+                emit(event: "worker", listener: WorkerListener): this;
+                on(event: "beforeExit", listener: BeforeExitListener): this;
+                on(event: "disconnect", listener: DisconnectListener): this;
+                on(event: "exit", listener: ExitListener): this;
+                on(event: "rejectionHandled", listener: RejectionHandledListener): this;
+                on(event: "uncaughtException", listener: UncaughtExceptionListener): this;
+                on(event: "uncaughtExceptionMonitor", listener: UncaughtExceptionListener): this;
+                on(event: "unhandledRejection", listener: UnhandledRejectionListener): this;
+                on(event: "warning", listener: WarningListener): this;
+                on(event: "message", listener: MessageListener): this;
+                on(event: Signals, listener: SignalsListener): this;
+                on(event: "multipleResolves", listener: MultipleResolveListener): this;
+                on(event: "worker", listener: WorkerListener): this;
+                on(event: "workerMessage", listener: (value: any, source: number) => void): this;
+                on(event: string | symbol, listener: (...args: any[]) => void): this;
+                once(event: "beforeExit", listener: BeforeExitListener): this;
+                once(event: "disconnect", listener: DisconnectListener): this;
+                once(event: "exit", listener: ExitListener): this;
+                once(event: "rejectionHandled", listener: RejectionHandledListener): this;
+                once(event: "uncaughtException", listener: UncaughtExceptionListener): this;
+                once(event: "uncaughtExceptionMonitor", listener: UncaughtExceptionListener): this;
+                once(event: "unhandledRejection", listener: UnhandledRejectionListener): this;
+                once(event: "warning", listener: WarningListener): this;
+                once(event: "message", listener: MessageListener): this;
+                once(event: Signals, listener: SignalsListener): this;
+                once(event: "multipleResolves", listener: MultipleResolveListener): this;
+                once(event: "worker", listener: WorkerListener): this;
+                once(event: "workerMessage", listener: (value: any, source: number) => void): this;
+                once(event: string | symbol, listener: (...args: any[]) => void): this;
+                prependListener(event: "beforeExit", listener: BeforeExitListener): this;
+                prependListener(event: "disconnect", listener: DisconnectListener): this;
+                prependListener(event: "exit", listener: ExitListener): this;
+                prependListener(event: "rejectionHandled", listener: RejectionHandledListener): this;
+                prependListener(event: "uncaughtException", listener: UncaughtExceptionListener): this;
+                prependListener(event: "uncaughtExceptionMonitor", listener: UncaughtExceptionListener): this;
+                prependListener(event: "unhandledRejection", listener: UnhandledRejectionListener): this;
+                prependListener(event: "warning", listener: WarningListener): this;
+                prependListener(event: "message", listener: MessageListener): this;
+                prependListener(event: "workerMessage", listener: (value: any, source: number) => void): this;
+                prependListener(event: Signals, listener: SignalsListener): this;
+                prependListener(event: "multipleResolves", listener: MultipleResolveListener): this;
+                prependListener(event: "worker", listener: WorkerListener): this;
+                prependOnceListener(event: "beforeExit", listener: BeforeExitListener): this;
+                prependOnceListener(event: "disconnect", listener: DisconnectListener): this;
+                prependOnceListener(event: "exit", listener: ExitListener): this;
+                prependOnceListener(event: "rejectionHandled", listener: RejectionHandledListener): this;
+                prependOnceListener(event: "uncaughtException", listener: UncaughtExceptionListener): this;
+                prependOnceListener(event: "uncaughtExceptionMonitor", listener: UncaughtExceptionListener): this;
+                prependOnceListener(event: "unhandledRejection", listener: UnhandledRejectionListener): this;
+                prependOnceListener(event: "warning", listener: WarningListener): this;
+                prependOnceListener(event: "message", listener: MessageListener): this;
+                prependOnceListener(event: "workerMessage", listener: (value: any, source: number) => void): this;
+                prependOnceListener(event: Signals, listener: SignalsListener): this;
+                prependOnceListener(event: "multipleResolves", listener: MultipleResolveListener): this;
+                prependOnceListener(event: "worker", listener: WorkerListener): this;
+                listeners(event: "beforeExit"): BeforeExitListener[];
+                listeners(event: "disconnect"): DisconnectListener[];
+                listeners(event: "exit"): ExitListener[];
+                listeners(event: "rejectionHandled"): RejectionHandledListener[];
+                listeners(event: "uncaughtException"): UncaughtExceptionListener[];
+                listeners(event: "uncaughtExceptionMonitor"): UncaughtExceptionListener[];
+                listeners(event: "unhandledRejection"): UnhandledRejectionListener[];
+                listeners(event: "warning"): WarningListener[];
+                listeners(event: "message"): MessageListener[];
+                listeners(event: "workerMessage"): ((value: any, source: number) => void)[];
+                listeners(event: Signals): SignalsListener[];
+                listeners(event: "multipleResolves"): MultipleResolveListener[];
+                listeners(event: "worker"): WorkerListener[];
             }
         }
     }
     export = process;
 }
-declare module "process" {
-    import process = require("node:process");
+declare module "node:process" {
+    import process = require("process");
     export = process;
 }