@rio-cloud/cdk-v2-constructs 8.2.0 → 8.2.1-alpha.0

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

@@ -1,6 +1,123 @@
 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");
+        "assert/strict": typeof import("assert/strict");
+        "node:assert/strict": typeof import("node:assert/strict");
+        "async_hooks": typeof import("async_hooks");
+        "node:async_hooks": typeof import("node:async_hooks");
+        "buffer": typeof import("buffer");
+        "node:buffer": typeof import("node:buffer");
+        "child_process": typeof import("child_process");
+        "node:child_process": typeof import("node:child_process");
+        "cluster": typeof import("cluster");
+        "node:cluster": typeof import("node:cluster");
+        "console": typeof import("console");
+        "node:console": typeof import("node:console");
+        "constants": typeof import("constants");
+        "node:constants": typeof import("node:constants");
+        "crypto": typeof import("crypto");
+        "node:crypto": typeof import("node:crypto");
+        "dgram": typeof import("dgram");
+        "node:dgram": typeof import("node:dgram");
+        "diagnostics_channel": typeof import("diagnostics_channel");
+        "node:diagnostics_channel": typeof import("node:diagnostics_channel");
+        "dns": typeof import("dns");
+        "node:dns": typeof import("node:dns");
+        "dns/promises": typeof import("dns/promises");
+        "node:dns/promises": typeof import("node:dns/promises");
+        "domain": typeof import("domain");
+        "node:domain": typeof import("node:domain");
+        "events": typeof import("events");
+        "node:events": typeof import("node:events");
+        "fs": typeof import("fs");
+        "node:fs": typeof import("node:fs");
+        "fs/promises": typeof import("fs/promises");
+        "node:fs/promises": typeof import("node:fs/promises");
+        "http": typeof import("http");
+        "node:http": typeof import("node:http");
+        "http2": typeof import("http2");
+        "node:http2": typeof import("node:http2");
+        "https": typeof import("https");
+        "node:https": typeof import("node:https");
+        "inspector": typeof import("inspector");
+        "node:inspector": typeof import("node:inspector");
+        "inspector/promises": typeof import("inspector/promises");
+        "node:inspector/promises": typeof import("node:inspector/promises");
+        "module": typeof import("module");
+        "node:module": typeof import("node:module");
+        "net": typeof import("net");
+        "node:net": typeof import("node:net");
+        "os": typeof import("os");
+        "node:os": typeof import("node:os");
+        "path": typeof import("path");
+        "node:path": typeof import("node:path");
+        "path/posix": typeof import("path/posix");
+        "node:path/posix": typeof import("node:path/posix");
+        "path/win32": typeof import("path/win32");
+        "node:path/win32": typeof import("node:path/win32");
+        "perf_hooks": typeof import("perf_hooks");
+        "node:perf_hooks": typeof import("node:perf_hooks");
+        "process": typeof import("process");
+        "node:process": typeof import("node:process");
+        "punycode": typeof import("punycode");
+        "node:punycode": typeof import("node:punycode");
+        "querystring": typeof import("querystring");
+        "node:querystring": typeof import("node:querystring");
+        "readline": typeof import("readline");
+        "node:readline": typeof import("node:readline");
+        "readline/promises": typeof import("readline/promises");
+        "node:readline/promises": typeof import("node:readline/promises");
+        "repl": typeof import("repl");
+        "node:repl": typeof import("node:repl");
+        "node:sea": typeof import("node:sea");
+        "node:sqlite": typeof import("node:sqlite");
+        "stream": typeof import("stream");
+        "node:stream": typeof import("node:stream");
+        "stream/consumers": typeof import("stream/consumers");
+        "node:stream/consumers": typeof import("node:stream/consumers");
+        "stream/promises": typeof import("stream/promises");
+        "node:stream/promises": typeof import("node:stream/promises");
+        "stream/web": typeof import("stream/web");
+        "node:stream/web": typeof import("node:stream/web");
+        "string_decoder": typeof import("string_decoder");
+        "node:string_decoder": typeof import("node:string_decoder");
+        "node:test": typeof import("node:test");
+        "node:test/reporters": typeof import("node:test/reporters");
+        "timers": typeof import("timers");
+        "node:timers": typeof import("node:timers");
+        "timers/promises": typeof import("timers/promises");
+        "node:timers/promises": typeof import("node:timers/promises");
+        "tls": typeof import("tls");
+        "node:tls": typeof import("node:tls");
+        "trace_events": typeof import("trace_events");
+        "node:trace_events": typeof import("node:trace_events");
+        "tty": typeof import("tty");
+        "node:tty": typeof import("node:tty");
+        "url": typeof import("url");
+        "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");
+        "node:v8": typeof import("node:v8");
+        "vm": typeof import("vm");
+        "node:vm": typeof import("node:vm");
+        "wasi": typeof import("wasi");
+        "node:wasi": typeof import("node:wasi");
+        "worker_threads": typeof import("worker_threads");
+        "node:worker_threads": typeof import("node:worker_threads");
+        "zlib": typeof import("zlib");
+        "node:zlib": typeof import("node:zlib");
+    }
     global {
         var process: NodeJS.Process;
         namespace NodeJS {
@@ -21,10 +138,25 @@ declare module "process" {
                 rss(): number;
             }
             interface MemoryUsage {
+                /**
+                 * Resident Set Size, is the amount of space occupied in the main memory device (that is a subset of the total allocated memory) for the
+                 * process, including all C++ and JavaScript objects and code.
+                 */
                 rss: number;
+                /**
+                 * Refers to V8's memory usage.
+                 */
                 heapTotal: number;
+                /**
+                 * Refers to V8's memory usage.
+                 */
                 heapUsed: number;
                 external: number;
+                /**
+                 * Refers to memory allocated for `ArrayBuffer`s and `SharedArrayBuffer`s, including all Node.js Buffers. This is also included
+                 * in the external value. When Node.js is used as an embedded library, this value may be `0` because allocations for `ArrayBuffer`s
+                 * may not be tracked in that case.
+                 */
                 arrayBuffers: number;
             }
             interface CpuUsage {
@@ -38,6 +170,84 @@ declare module "process" {
                 libUrl?: string | undefined;
                 lts?: string | undefined;
             }
+            interface ProcessFeatures {
+                /**
+                 * A boolean value that is `true` if the current Node.js build is caching builtin modules.
+                 * @since v12.0.0
+                 */
+                readonly cached_builtins: boolean;
+                /**
+                 * A boolean value that is `true` if the current Node.js build is a debug build.
+                 * @since v0.5.5
+                 */
+                readonly debug: boolean;
+                /**
+                 * A boolean value that is `true` if the current Node.js build includes the inspector.
+                 * @since v11.10.0
+                 */
+                readonly inspector: boolean;
+                /**
+                 * A boolean value that is `true` if the current Node.js build includes support for IPv6.
+                 *
+                 * Since all Node.js builds have IPv6 support, this value is always `true`.
+                 * @since v0.5.3
+                 * @deprecated This property is always true, and any checks based on it are redundant.
+                 */
+                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-v24.x/api/modules.md#loading-ecmascript-modules-using-require).
+                 * @since v22.10.0
+                 */
+                readonly require_module: boolean;
+                /**
+                 * A boolean value that is `true` if the current Node.js build includes support for TLS.
+                 * @since v0.5.3
+                 */
+                readonly tls: boolean;
+                /**
+                 * A boolean value that is `true` if the current Node.js build includes support for ALPN in TLS.
+                 *
+                 * In Node.js 11.0.0 and later versions, the OpenSSL dependencies feature unconditional ALPN support.
+                 * This value is therefore identical to that of `process.features.tls`.
+                 * @since v4.8.0
+                 * @deprecated Use `process.features.tls` instead.
+                 */
+                readonly tls_alpn: boolean;
+                /**
+                 * A boolean value that is `true` if the current Node.js build includes support for OCSP in TLS.
+                 *
+                 * In Node.js 11.0.0 and later versions, the OpenSSL dependencies feature unconditional OCSP support.
+                 * This value is therefore identical to that of `process.features.tls`.
+                 * @since v0.11.13
+                 * @deprecated Use `process.features.tls` instead.
+                 */
+                readonly tls_ocsp: boolean;
+                /**
+                 * A boolean value that is `true` if the current Node.js build includes support for SNI in TLS.
+                 *
+                 * In Node.js 11.0.0 and later versions, the OpenSSL dependencies feature unconditional SNI support.
+                 * This value is therefore identical to that of `process.features.tls`.
+                 * @since v0.5.3
+                 * @deprecated Use `process.features.tls` instead.
+                 */
+                readonly tls_sni: boolean;
+                /**
+                 * 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-strip-types`.
+                 * @since v22.10.0
+                 */
+                readonly typescript: "strip" | "transform" | false;
+                /**
+                 * A boolean value that is `true` if the current Node.js build includes support for libuv.
+                 *
+                 * Since it's not possible to build Node.js without libuv, this value is always `true`.
+                 * @since v0.5.3
+                 * @deprecated This property is always true, and any checks based on it are redundant.
+                 */
+                readonly uv: boolean;
+            }
             interface ProcessVersions extends Dict<string> {
                 http_parser: string;
                 node: string;
@@ -64,12 +274,11 @@ declare module "process" {
                 | "arm"
                 | "arm64"
                 | "ia32"
+                | "loong64"
                 | "mips"
                 | "mipsel"
-                | "ppc"
                 | "ppc64"
                 | "riscv64"
-                | "s390"
                 | "s390x"
                 | "x64";
             type Signals =
@@ -123,7 +332,7 @@ declare module "process" {
              */
             type UnhandledRejectionListener = (reason: unknown, promise: Promise<unknown>) => void;
             type WarningListener = (warning: Error) => void;
-            type MessageListener = (message: unknown, sendHandle: unknown) => void;
+            type MessageListener = (message: unknown, sendHandle: SendHandle) => void;
             type SignalsListener = (signal: Signals) => void;
             type MultipleResolveListener = (
                 type: MultipleResolveType,
@@ -135,35 +344,112 @@ declare module "process" {
                 isTTY?: true | undefined;
             }
             // Alias for compatibility
-            interface ProcessEnv extends Dict<string> {
+            interface ProcessEnv extends Dict<string> {}
+            interface HRTime {
                 /**
-                 * Can be used to change the default timezone at runtime
+                 * This is the legacy version of {@link process.hrtime.bigint()}
+                 * before bigint was introduced in JavaScript.
+                 *
+                 * The `process.hrtime()` method returns the current high-resolution real time in a `[seconds, nanoseconds]` tuple `Array`,
+                 * where `nanoseconds` is the remaining part of the real time that can't be represented in second precision.
+                 *
+                 * `time` is an optional parameter that must be the result of a previous `process.hrtime()` call to diff with the current time.
+                 * If the parameter passed in is not a tuple `Array`, a TypeError will be thrown.
+                 * Passing in a user-defined array instead of the result of a previous call to `process.hrtime()` will lead to undefined behavior.
+                 *
+                 * These times are relative to an arbitrary time in the past,
+                 * and not related to the time of day and therefore not subject to clock drift.
+                 * The primary use is for measuring performance between intervals:
+                 * ```js
+                 * const { hrtime } = require('node:process');
+                 * const NS_PER_SEC = 1e9;
+                 * const time = hrtime();
+                 * // [ 1800216, 25 ]
+                 *
+                 * setTimeout(() => {
+                 *   const diff = hrtime(time);
+                 *   // [ 1, 552 ]
+                 *
+                 *   console.log(`Benchmark took ${diff[0] * NS_PER_SEC + diff[1]} nanoseconds`);
+                 *   // Benchmark took 1000000552 nanoseconds
+                 * }, 1000);
+                 * ```
+                 * @since 0.7.6
+                 * @legacy Use {@link process.hrtime.bigint()} instead.
+                 * @param time The result of a previous call to `process.hrtime()`
                  */
-                TZ?: string;
-            }
-            interface HRTime {
                 (time?: [number, number]): [number, number];
+                /**
+                 * The `bigint` version of the {@link process.hrtime()} method returning the current high-resolution real time in nanoseconds as a `bigint`.
+                 *
+                 * Unlike {@link process.hrtime()}, it does not support an additional time argument since the difference can just be computed directly by subtraction of the two `bigint`s.
+                 * ```js
+                 * import { hrtime } from 'node:process';
+                 *
+                 * const start = hrtime.bigint();
+                 * // 191051479007711n
+                 *
+                 * setTimeout(() => {
+                 *   const end = hrtime.bigint();
+                 *   // 191052633396993n
+                 *
+                 *   console.log(`Benchmark took ${end - start} nanoseconds`);
+                 *   // Benchmark took 1154389282 nanoseconds
+                 * }, 1000);
+                 * ```
+                 * @since v10.7.0
+                 */
                 bigint(): bigint;
             }
+            interface ProcessPermission {
+                /**
+                 * Verifies that the process is able to access the given scope and reference.
+                 * If no reference is provided, a global scope is assumed, for instance, `process.permission.has('fs.read')`
+                 * will check if the process has ALL file system read permissions.
+                 *
+                 * The reference has a meaning based on the provided scope. For example, the reference when the scope is File System means files and folders.
+                 *
+                 * The available scopes are:
+                 *
+                 * * `fs` - All File System
+                 * * `fs.read` - File System read operations
+                 * * `fs.write` - File System write operations
+                 * * `child` - Child process spawning operations
+                 * * `worker` - Worker thread spawning operation
+                 *
+                 * ```js
+                 * // Check if the process has permission to read the README file
+                 * process.permission.has('fs.read', './README.md');
+                 * // Check if the process has read permission operations
+                 * process.permission.has('fs.read');
+                 * ```
+                 * @since v20.0.0
+                 */
+                has(scope: string, reference?: string): boolean;
+            }
             interface ProcessReport {
+                /**
+                 * Write reports in a compact format, single-line JSON, more easily consumable by log processing systems
+                 * than the default multi-line format designed for human consumption.
+                 * @since v13.12.0, v12.17.0
+                 */
+                compact: boolean;
                 /**
                  * Directory where the report is written.
+                 * The default value is the empty string, indicating that reports are written to the current
                  * working directory of the Node.js process.
-                 * @default '' indicating that reports are written to the current
                  */
                 directory: string;
                 /**
-                 * Filename where the report is written.
-                 * The default value is the empty string.
-                 * @default '' the output filename will be comprised of a timestamp,
-                 * PID, and sequence number.
+                 * Filename where the report is written. If set to the empty string, the output filename will be comprised
+                 * of a timestamp, PID, and sequence number. The default value is the empty string.
                  */
                 filename: string;
                 /**
-                 * Returns a JSON-formatted diagnostic report for the running process.
-                 * The report's JavaScript stack trace is taken from err, if present.
+                 * Returns a JavaScript Object representation of a diagnostic report for the running process.
+                 * The report's JavaScript stack trace is taken from `err`, if present.
                  */
-                getReport(err?: Error): string;
+                getReport(err?: Error): object;
                 /**
                  * If true, a diagnostic report is generated on fatal errors,
                  * such as out of memory errors or failed C++ assertions.
@@ -181,6 +467,11 @@ declare module "process" {
                  * @default false
                  */
                 reportOnUncaughtException: boolean;
+                /**
+                 * If true, a diagnostic report is generated without the environment variables.
+                 * @default false
+                 */
+                excludeEnv: boolean;
                 /**
                  * The signal used to trigger the creation of a diagnostic report.
                  * @default 'SIGUSR2'
@@ -189,18 +480,19 @@ declare module "process" {
                 /**
                  * Writes a diagnostic report to a file. If filename is not provided, the default filename
                  * includes the date, time, PID, and a sequence number.
-                 * The report's JavaScript stack trace is taken from err, if present.
+                 * The report's JavaScript stack trace is taken from `err`, if present.
                  *
+                 * If the value of filename is set to `'stdout'` or `'stderr'`, the report is written
+                 * to the stdout or stderr of the process respectively.
                  * @param fileName Name of the file where the report is written.
                  * This should be a relative path, that will be appended to the directory specified in
                  * `process.report.directory`, or the current working directory of the Node.js process,
                  * if unspecified.
-                 * @param error A custom error used for reporting the JavaScript stack.
+                 * @param err A custom error used for reporting the JavaScript stack.
                  * @return Filename of the generated report.
                  */
-                writeReport(fileName?: string): string;
-                writeReport(error?: Error): string;
                 writeReport(fileName?: string, err?: Error): string;
+                writeReport(err?: Error): string;
             }
             interface ResourceUsage {
                 fsRead: number;
@@ -306,18 +598,18 @@ declare module "process" {
                  * For more information see `Stream compatibility`.
                  *
                  * In "old" streams mode the `stdin` stream is paused by default, so one
-                 * must call `process.stdin.resume()` to read from it. Note also that calling`process.stdin.resume()` itself would switch stream to "old" mode.
+                 * must call `process.stdin.resume()` to read from it. Note also that calling `process.stdin.resume()` itself would switch stream to "old" mode.
                  */
                 stdin: ReadStream & {
                     fd: 0;
                 };
-                openStdin(): Socket;
                 /**
                  * The `process.argv` property returns an array containing the command-line
                  * 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. The remaining elements will be any additional command-line
+                 * file being executed. If a [program entry point](https://nodejs.org/docs/latest-v24.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
                  * arguments.
                  *
                  * For example, assuming the following script for `process-args.js`:
@@ -371,13 +663,13 @@ declare module "process" {
                  * the same execution environment as the parent.
                  *
                  * ```bash
-                 * node --harmony script.js --version
+                 * node --icu-data-dir=./foo --require ./bar.js script.js --version
                  * ```
                  *
                  * Results in `process.execArgv`:
                  *
                  * ```js
-                 * ['--harmony']
+                 * ["--icu-data-dir=./foo", "--require", "./bar.js"]
                  * ```
                  *
                  * And `process.argv`:
@@ -453,6 +745,32 @@ declare module "process" {
                  * @since v0.7.2
                  */
                 debugPort: number;
+                /**
+                 * The `process.dlopen()` method allows dynamically loading shared objects. It is primarily used by `require()` to load C++ Addons, and
+                 * 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-v24.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
+                 * are then accessible via `module.exports`.
+                 *
+                 * The example below shows how to load a C++ Addon, named `local.node`, that exports a `foo` function. All the symbols are loaded before the call returns, by passing the `RTLD_NOW` constant.
+                 * In this example the constant is assumed to be available.
+                 *
+                 * ```js
+                 * import { dlopen } from 'node:process';
+                 * import { constants } from 'node:os';
+                 * import { fileURLToPath } from 'node:url';
+                 *
+                 * const module = { exports: {} };
+                 * dlopen(module, fileURLToPath(new URL('local.node', import.meta.url)),
+                 *        constants.dlopen.RTLD_NOW);
+                 * module.exports.foo();
+                 * ```
+                 */
+                dlopen(module: object, filename: string, flags?: number): void;
                 /**
                  * The `process.emitWarning()` method can be used to emit custom or application
                  * specific process warnings. These can be listened for by adding a handler to the `'warning'` event.
@@ -460,17 +778,27 @@ declare module "process" {
                  * ```js
                  * import { emitWarning } from 'node:process';
                  *
-                 * // Emit a warning with a code and additional detail.
-                 * emitWarning('Something happened!', {
-                 *   code: 'MY_WARNING',
-                 *   detail: 'This is some additional information',
-                 * });
-                 * // Emits:
-                 * // (node:56338) [MY_WARNING] Warning: Something happened!
-                 * // This is some additional information
+                 * // Emit a warning using a string.
+                 * emitWarning('Something happened!');
+                 * // Emits: (node: 56338) Warning: Something happened!
+                 * ```
+                 *
+                 * ```js
+                 * import { emitWarning } from 'node:process';
+                 *
+                 * // Emit a warning using a string and a type.
+                 * emitWarning('Something Happened!', 'CustomWarning');
+                 * // Emits: (node:56338) CustomWarning: Something Happened!
                  * ```
                  *
-                 * In this example, an `Error` object is generated internally by`process.emitWarning()` and passed through to the `'warning'` handler.
+                 * ```js
+                 * import { emitWarning } from 'node:process';
+                 *
+                 * emitWarning('Something happened!', 'CustomWarning', 'WARN001');
+                 * // Emits: (node:56338) [WARN001] CustomWarning: Something happened!
+                 * ```js
+                 *
+                 * In each of the previous examples, an `Error` object is generated internally by `process.emitWarning()` and passed through to the `'warning'` handler.
                  *
                  * ```js
                  * import process from 'node:process';
@@ -484,7 +812,30 @@ declare module "process" {
                  * });
                  * ```
                  *
-                 * If `warning` is passed as an `Error` object, the `options` argument is ignored.
+                 * If `warning` is passed as an `Error` object, it will be passed through to the `'warning'` event handler
+                 * unmodified (and the optional `type`, `code` and `ctor` arguments will be ignored):
+                 *
+                 * ```js
+                 * import { emitWarning } from 'node:process';
+                 *
+                 * // Emit a warning using an Error object.
+                 * const myWarning = new Error('Something happened!');
+                 * // Use the Error name property to specify the type name
+                 * myWarning.name = 'CustomWarning';
+                 * myWarning.code = 'WARN001';
+                 *
+                 * emitWarning(myWarning);
+                 * // Emits: (node:56338) [WARN001] CustomWarning: Something happened!
+                 * ```
+                 *
+                 * A `TypeError` is thrown if `warning` is anything other than a string or `Error` object.
+                 *
+                 * While process warnings use `Error` objects, the process warning mechanism is not a replacement for normal error handling mechanisms.
+                 *
+                 * The following additional handling is implemented if the warning `type` is `'DeprecationWarning'`:
+                 * * If the `--throw-deprecation` command-line flag is used, the deprecation warning is thrown as an exception rather than being emitted as an event.
+                 * * If the `--no-deprecation` command-line flag is used, the deprecation warning is suppressed.
+                 * * If the `--trace-deprecation` command-line flag is used, the deprecation warning is printed to `stderr` along with the full stack trace.
                  * @since v8.0.0
                  * @param warning The warning to emit.
                  */
@@ -572,7 +923,7 @@ declare module "process" {
                  * parent thread's `process.env`, or whatever was specified as the `env` option
                  * to the `Worker` constructor. Changes to `process.env` will not be visible
                  * across `Worker` threads, and only the main thread can make changes that
-                 * are visible to the operating system or to native add-ons. On Windows, a copy of`process.env` on a `Worker` instance operates in a case-sensitive manner
+                 * are visible to the operating system or to native add-ons. On Windows, a copy of `process.env` on a `Worker` instance operates in a case-sensitive manner
                  * unlike the main thread.
                  * @since v0.1.27
                  */
@@ -596,13 +947,13 @@ declare module "process" {
                  *
                  * Calling `process.exit()` will force the process to exit as quickly as possible
                  * even if there are still asynchronous operations pending that have not yet
-                 * completed fully, including I/O operations to `process.stdout` and`process.stderr`.
+                 * completed fully, including I/O operations to `process.stdout` and `process.stderr`.
                  *
-                 * In most situations, it is not actually necessary to call `process.exit()`explicitly. The Node.js process will exit on its own _if there is no additional_
+                 * In most situations, it is not actually necessary to call `process.exit()` explicitly. The Node.js process will exit on its own _if there is no additional_
                  * _work pending_ in the event loop. The `process.exitCode` property can be set to
                  * tell the process which exit code to use when the process exits gracefully.
                  *
-                 * For instance, the following example illustrates a _misuse_ of the`process.exit()` method that could lead to data printed to stdout being
+                 * For instance, the following example illustrates a _misuse_ of the `process.exit()` method that could lead to data printed to stdout being
                  * truncated and lost:
                  *
                  * ```js
@@ -619,7 +970,7 @@ declare module "process" {
                  * are sometimes _asynchronous_ and may occur over multiple ticks of the Node.js
                  * event loop. Calling `process.exit()`, however, forces the process to exit _before_ those additional writes to `stdout` can be performed.
                  *
-                 * Rather than calling `process.exit()` directly, the code _should_ set the`process.exitCode` and allow the process to exit naturally by avoiding
+                 * Rather than calling `process.exit()` directly, the code _should_ set the `process.exitCode` and allow the process to exit naturally by avoiding
                  * scheduling any additional work for the event loop:
                  *
                  * ```js
@@ -642,7 +993,7 @@ declare module "process" {
                  * @since v0.1.13
                  * @param [code=0] The exit code. For string type, only integer strings (e.g.,'1') are allowed.
                  */
-                exit(code?: number): never;
+                exit(code?: number | string | null): never;
                 /**
                  * A number which will be the process exit code, when the process either
                  * exits gracefully, or is exited via {@link exit} without specifying
@@ -650,15 +1001,74 @@ declare module "process" {
                  *
                  * Specifying a code to {@link exit} will override any
                  * previous setting of `process.exitCode`.
+                 * @default undefined
                  * @since v0.11.8
                  */
-                exitCode?: number | undefined;
+                exitCode: number | string | null | undefined;
+                finalization: {
+                    /**
+                     * This function registers a callback to be called when the process emits the `exit` event if the `ref` object was not garbage collected.
+                     * If the object `ref` was garbage collected before the `exit` event is emitted, the callback will be removed from the finalization registry, and it will not be called on process exit.
+                     *
+                     * Inside the callback you can release the resources allocated by the `ref` object.
+                     * Be aware that all limitations applied to the `beforeExit` event are also applied to the callback function,
+                     * this means that there is a possibility that the callback will not be called under special circumstances.
+                     *
+                     * The idea of ​​this function is to help you free up resources when the starts process exiting, but also let the object be garbage collected if it is no longer being used.
+                     * @param ref The reference to the resource that is being tracked.
+                     * @param callback The callback function to be called when the resource is finalized.
+                     * @since v22.5.0
+                     * @experimental
+                     */
+                    register<T extends object>(ref: T, callback: (ref: T, event: "exit") => void): void;
+                    /**
+                     * This function behaves exactly like the `register`, except that the callback will be called when the process emits the `beforeExit` event if `ref` object was not garbage collected.
+                     *
+                     * Be aware that all limitations applied to the `beforeExit` event are also applied to the callback function, this means that there is a possibility that the callback will not be called under special circumstances.
+                     * @param ref The reference to the resource that is being tracked.
+                     * @param callback The callback function to be called when the resource is finalized.
+                     * @since v22.5.0
+                     * @experimental
+                     */
+                    registerBeforeExit<T extends object>(ref: T, callback: (ref: T, event: "beforeExit") => void): void;
+                    /**
+                     * This function remove the register of the object from the finalization registry, so the callback will not be called anymore.
+                     * @param ref The reference to the resource that was registered previously.
+                     * @since v22.5.0
+                     * @experimental
+                     */
+                    unregister(ref: object): void;
+                };
+                /**
+                 * The `process.getActiveResourcesInfo()` method returns an array of strings containing
+                 * the types of the active resources that are currently keeping the event loop alive.
+                 *
+                 * ```js
+                 * import { getActiveResourcesInfo } from 'node:process';
+                 * import { setTimeout } from 'node:timers';
+
+                 * console.log('Before:', getActiveResourcesInfo());
+                 * setTimeout(() => {}, 1000);
+                 * console.log('After:', getActiveResourcesInfo());
+                 * // Prints:
+                 * //   Before: [ 'TTYWrap', 'TTYWrap', 'TTYWrap' ]
+                 * //   After: [ 'TTYWrap', 'TTYWrap', 'TTYWrap', 'Timeout' ]
+                 * ```
+                 * @since v17.3.0, v16.14.0
+                 */
+                getActiveResourcesInfo(): string[];
+                /**
+                 * Provides a way to load built-in modules in a globally available function.
+                 * @param id ID of the built-in module being requested.
+                 */
+                getBuiltinModule<ID extends keyof BuiltInModule>(id: ID): BuiltInModule[ID];
+                getBuiltinModule(id: string): object | undefined;
                 /**
                  * The `process.getgid()` method returns the numerical group identity of the
                  * process. (See [`getgid(2)`](http://man7.org/linux/man-pages/man2/getgid.2.html).)
                  *
                  * ```js
-                 * import process from 'process';
+                 * import process from 'node:process';
                  *
                  * if (process.getgid) {
                  *   console.log(`Current gid: ${process.getgid()}`);
@@ -677,7 +1087,7 @@ declare module "process" {
                  * associated numeric ID.
                  *
                  * ```js
-                 * import process from 'process';
+                 * import process from 'node:process';
                  *
                  * if (process.getgid &#x26;&#x26; process.setgid) {
                  *   console.log(`Current gid: ${process.getgid()}`);
@@ -702,7 +1112,7 @@ declare module "process" {
                  * (See [`getuid(2)`](http://man7.org/linux/man-pages/man2/getuid.2.html).)
                  *
                  * ```js
-                 * import process from 'process';
+                 * import process from 'node:process';
                  *
                  * if (process.getuid) {
                  *   console.log(`Current uid: ${process.getuid()}`);
@@ -721,7 +1131,7 @@ declare module "process" {
                  * numeric ID.
                  *
                  * ```js
-                 * import process from 'process';
+                 * import process from 'node:process';
                  *
                  * if (process.getuid &#x26;&#x26; process.setuid) {
                  *   console.log(`Current uid: ${process.getuid()}`);
@@ -745,7 +1155,7 @@ declare module "process" {
                  * the process. (See [`geteuid(2)`](http://man7.org/linux/man-pages/man2/geteuid.2.html).)
                  *
                  * ```js
-                 * import process from 'process';
+                 * import process from 'node:process';
                  *
                  * if (process.geteuid) {
                  *   console.log(`Current uid: ${process.geteuid()}`);
@@ -764,7 +1174,7 @@ declare module "process" {
                  * associated numeric ID.
                  *
                  * ```js
-                 * import process from 'process';
+                 * import process from 'node:process';
                  *
                  * if (process.geteuid &#x26;&#x26; process.seteuid) {
                  *   console.log(`Current uid: ${process.geteuid()}`);
@@ -789,7 +1199,7 @@ declare module "process" {
                  * of the Node.js process. (See [`getegid(2)`](http://man7.org/linux/man-pages/man2/getegid.2.html).)
                  *
                  * ```js
-                 * import process from 'process';
+                 * import process from 'node:process';
                  *
                  * if (process.getegid) {
                  *   console.log(`Current gid: ${process.getegid()}`);
@@ -808,7 +1218,7 @@ declare module "process" {
                  * the associated a numeric ID.
                  *
                  * ```js
-                 * import process from 'process';
+                 * import process from 'node:process';
                  *
                  * if (process.getegid &#x26;&#x26; process.setegid) {
                  *   console.log(`Current gid: ${process.getegid()}`);
@@ -834,7 +1244,7 @@ declare module "process" {
                  * Node.js ensures it always is.
                  *
                  * ```js
-                 * import process from 'process';
+                 * import process from 'node:process';
                  *
                  * if (process.getgroups) {
                  *   console.log(process.getgroups()); // [ 16, 21, 297 ]
@@ -854,7 +1264,7 @@ declare module "process" {
                  * The `groups` array can contain numeric group IDs, group names, or both.
                  *
                  * ```js
-                 * import process from 'process';
+                 * import process from 'node:process';
                  *
                  * if (process.getgroups &#x26;&#x26; process.setgroups) {
                  *   try {
@@ -883,7 +1293,7 @@ declare module "process" {
                  * not abort. Actions configured to take place on exceptions such as report
                  * generations will be affected too
                  *
-                 * To unset the capture function,`process.setUncaughtExceptionCaptureCallback(null)` may be used. Calling this
+                 * To unset the capture function, `process.setUncaughtExceptionCaptureCallback(null)` may be used. Calling this
                  * method with a non-`null` argument while another capture function is set will
                  * throw an error.
                  *
@@ -902,6 +1312,18 @@ declare module "process" {
                  * @experimental
                  */
                 readonly sourceMapsEnabled: boolean;
+                /**
+                 * This function enables or disables the [Source Map v3](https://sourcemaps.info/spec.html) support for
+                 * stack traces.
+                 *
+                 * It provides same features as launching Node.js process with commandline options `--enable-source-maps`.
+                 *
+                 * Only source maps in JavaScript files that are loaded after source maps has been
+                 * enabled will be parsed and loaded.
+                 * @since v16.6.0, v14.18.0
+                 * @experimental
+                 */
+                setSourceMapsEnabled(value: boolean): void;
                 /**
                  * The `process.version` property contains the Node.js version string.
                  *
@@ -1032,6 +1454,21 @@ declare module "process" {
                  * @param [signal='SIGTERM'] The signal to send, either as a string or number.
                  */
                 kill(pid: number, signal?: string | number): true;
+                /**
+                 * Loads the environment configuration from a `.env` file into `process.env`. If
+                 * the file is not found, error will be thrown.
+                 *
+                 * To load a specific .env file by specifying its path, use the following code:
+                 *
+                 * ```js
+                 * import { loadEnvFile } from 'node:process';
+                 *
+                 * loadEnvFile('./development.env')
+                 * ```
+                 * @since v20.12.0
+                 * @param path The path to the .env file
+                 */
+                loadEnvFile(path?: PathLike): void;
                 /**
                  * The `process.pid` property returns the PID of the process.
                  *
@@ -1055,6 +1492,18 @@ declare module "process" {
                  * @since v9.2.0, v8.10.0, v6.13.0
                  */
                 readonly ppid: number;
+                /**
+                 * The `process.threadCpuUsage()` method returns the user and system CPU time usage of
+                 * the current worker thread, in an object with properties `user` and `system`, whose
+                 * values are microsecond values (millionth of a second).
+                 *
+                 * 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
+                 * @param previousValue A previous return value from calling
+                 * `process.threadCpuUsage()`
+                 */
+                threadCpuUsage(previousValue?: CpuUsage): CpuUsage;
                 /**
                  * The `process.title` property returns the current process title (i.e. returns
                  * the current value of `ps`). Assigning a new value to `process.title` modifies
@@ -1063,8 +1512,8 @@ declare module "process" {
                  * When a new value is assigned, different platforms will impose different maximum
                  * length restrictions on the title. Usually such restrictions are quite limited.
                  * For instance, on Linux and macOS, `process.title` is limited to the size of the
-                 * binary name plus the length of the command-line arguments because setting the`process.title` overwrites the `argv` memory of the process. Node.js v0.8
-                 * allowed for longer process title strings by also overwriting the `environ`memory but that was potentially insecure and confusing in some (rather obscure)
+                 * binary name plus the length of the command-line arguments because setting the `process.title` overwrites the `argv` memory of the process. Node.js v0.8
+                 * allowed for longer process title strings by also overwriting the `environ` memory but that was potentially insecure and confusing in some (rather obscure)
                  * cases.
                  *
                  * Assigning a value to `process.title` might not result in an accurate label
@@ -1075,7 +1524,8 @@ declare module "process" {
                 title: string;
                 /**
                  * The operating system CPU architecture for which the Node.js binary was compiled.
-                 * Possible values are: `'arm'`, `'arm64'`, `'ia32'`, `'mips'`,`'mipsel'`, `'ppc'`,`'ppc64'`, `'riscv64'`, `'s390'`, `'s390x'`, and `'x64'`.
+                 * Possible values are: `'arm'`, `'arm64'`, `'ia32'`, `'loong64'`, `'mips'`,
+                 * `'mipsel'`, `'ppc64'`, `'riscv64'`, `'s390x'`, and `'x64'`.
                  *
                  * ```js
                  * import { arch } from 'node:process';
@@ -1121,19 +1571,24 @@ declare module "process" {
                  * @since v0.1.17
                  * @deprecated Since v14.0.0 - Use `main` instead.
                  */
-                mainModule?: Module | undefined;
+                mainModule?: Module;
                 memoryUsage: MemoryUsageFn;
                 /**
                  * Gets the amount of memory available to the process (in bytes) based on
                  * limits imposed by the OS. If there is no such constraint, or the constraint
-                 * is unknown, `undefined` is returned.
+                 * is unknown, `0` is returned.
                  *
                  * See [`uv_get_constrained_memory`](https://docs.libuv.org/en/v1.x/misc.html#c.uv_get_constrained_memory) for more
                  * information.
                  * @since v19.6.0, v18.15.0
-                 * @experimental
                  */
-                constrainedMemory(): number | undefined;
+                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-v24.x/api/process.html#processavailablememory) for more information.
+                 * @since v20.13.0
+                 */
+                availableMemory(): number;
                 /**
                  * The `process.cpuUsage()` method returns the user and system CPU time usage of
                  * the current process, in an object with properties `user` and `system`, whose
@@ -1250,6 +1705,19 @@ declare module "process" {
                  * @param args Additional arguments to pass when invoking the `callback`
                  */
                 nextTick(callback: Function, ...args: any[]): void;
+                /**
+                 * The process.noDeprecation property indicates whether the --no-deprecation flag is set on the current Node.js process.
+                 * See the documentation for the ['warning' event](https://nodejs.org/docs/latest/api/process.html#event-warning) and the [emitWarning()](https://nodejs.org/docs/latest/api/process.html#processemitwarningwarning-type-code-ctor) method for more information about this flag's behavior.
+                 */
+                noDeprecation?: boolean;
+                /**
+                 * This API is available through the [--permission](https://nodejs.org/api/cli.html#--permission) flag.
+                 *
+                 * `process.permission` is an object whose methods are used to manage permissions for the current process.
+                 * Additional documentation is available in the [Permission Model](https://nodejs.org/api/permissions.html#permission-model).
+                 * @since v20.0.0
+                 */
+                permission: ProcessPermission;
                 /**
                  * The `process.release` property returns an `Object` containing metadata related
                  * to the current release, including URLs for the source tarball and headers-only
@@ -1267,26 +1735,35 @@ declare module "process" {
                  * }
                  * ```
                  *
-                 * In custom builds from non-release versions of the source tree, only the`name` property may be present. The additional properties should not be
+                 * In custom builds from non-release versions of the source tree, only the `name` property may be present. The additional properties should not be
                  * relied upon to exist.
                  * @since v3.0.0
                  */
                 readonly release: ProcessRelease;
-                features: {
-                    inspector: boolean;
-                    debug: boolean;
-                    uv: boolean;
-                    ipv6: boolean;
-                    tls_alpn: boolean;
-                    tls_sni: boolean;
-                    tls_ocsp: boolean;
-                    tls: boolean;
-                };
+                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.
                  * @since v0.1.19
-                 * @deprecated Calling `process.umask()` with no argument causes the process-wide umask to be written twice. This introduces a race condition between threads, and is a potential   *
+                 * @deprecated Calling `process.umask()` with no argument causes the process-wide umask to be written twice. This introduces a race condition between threads, and is a potential
                  * security vulnerability. There is no safe, cross-platform alternative API.
                  */
                 umask(): number;
@@ -1304,6 +1781,12 @@ declare module "process" {
                  */
                 uptime(): number;
                 hrtime: HRTime;
+                /**
+                 * If the Node.js process was spawned with an IPC channel, the process.channel property is a reference to the IPC channel.
+                 * If no IPC channel exists, this property is undefined.
+                 * @since v7.1.0
+                 */
+                channel?: Control;
                 /**
                  * If Node.js is spawned with an IPC channel, the `process.send()` method can be
                  * used to send messages to the parent process. Messages will be received as a `'message'` event on the parent's `ChildProcess` object.
@@ -1313,16 +1796,23 @@ declare module "process" {
                  * The message goes through serialization and parsing. The resulting message might
                  * not be the same as what is originally sent.
                  * @since v0.5.9
-                 * @param options used to parameterize the sending of certain types of handles.`options` supports the following properties:
+                 * @param options used to parameterize the sending of certain types of handles. `options` supports the following properties:
                  */
                 send?(
                     message: any,
-                    sendHandle?: any,
-                    options?: {
-                        swallowErrors?: boolean | undefined;
-                    },
+                    sendHandle?: SendHandle,
+                    options?: MessageOptions,
                     callback?: (error: Error | null) => void,
                 ): boolean;
+                send?(
+                    message: any,
+                    sendHandle: SendHandle,
+                    callback?: (error: Error | null) => void,
+                ): boolean;
+                send?(
+                    message: any,
+                    callback: (error: Error | null) => void,
+                ): boolean;
                 /**
                  * If the Node.js process is spawned with an IPC channel (see the `Child Process` and `Cluster` documentation), the `process.disconnect()` method will close the
                  * IPC channel to the parent process, allowing the child process to exit gracefully
@@ -1330,13 +1820,13 @@ declare module "process" {
                  *
                  * The effect of calling `process.disconnect()` is the same as calling `ChildProcess.disconnect()` from the parent process.
                  *
-                 * If the Node.js process was not spawned with an IPC channel,`process.disconnect()` will be `undefined`.
+                 * If the Node.js process was not spawned with an IPC channel, `process.disconnect()` will be `undefined`.
                  * @since v0.7.2
                  */
                 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.
+                 * 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.
                  *
                  * Once `process.connected` is `false`, it is no longer possible to send messages
                  * over the IPC channel using `process.send()`.
@@ -1347,11 +1837,11 @@ declare module "process" {
                  * The `process.allowedNodeEnvironmentFlags` property is a special,
                  * read-only `Set` of flags allowable within the `NODE_OPTIONS` environment variable.
                  *
-                 * `process.allowedNodeEnvironmentFlags` extends `Set`, but overrides`Set.prototype.has` to recognize several different possible flag
+                 * `process.allowedNodeEnvironmentFlags` extends `Set`, but overrides `Set.prototype.has` to recognize several different possible flag
                  * representations. `process.allowedNodeEnvironmentFlags.has()` will
                  * return `true` in the following cases:
                  *
-                 * * Flags may omit leading single (`-`) or double (`--`) dashes; e.g.,`inspect-brk` for `--inspect-brk`, or `r` for `-r`.
+                 * * Flags may omit leading single (`-`) or double (`--`) dashes; e.g., `inspect-brk` for `--inspect-brk`, or `r` for `-r`.
                  * * Flags passed through to V8 (as listed in `--v8-options`) may replace
                  * one or more _non-leading_ dashes for an underscore, or vice-versa;
                  * e.g., `--perf_basic_prof`, `--perf-basic-prof`, `--perf_basic-prof`,
@@ -1386,11 +1876,11 @@ declare module "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`.
+                 * `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-v24.x/api/report.html).
                  * @since v11.8.0
                  */
-                report?: ProcessReport | undefined;
+                report: ProcessReport;
                 /**
                  * ```js
                  * import { resourceUsage } from 'node:process';
@@ -1423,12 +1913,85 @@ declare module "process" {
                  */
                 resourceUsage(): ResourceUsage;
                 /**
-                 * The `process.traceDeprecation` property indicates whether the`--trace-deprecation` flag is set on the current Node.js process. See the
+                 * The initial value of `process.throwDeprecation` indicates whether the `--throw-deprecation` flag is set on the current Node.js process. `process.throwDeprecation`
+                 * is mutable, so whether or not deprecation warnings result in errors may be altered at runtime. See the documentation for the 'warning' event and the emitWarning()
+                 * method for more information.
+                 *
+                 * ```bash
+                 * $ node --throw-deprecation -p "process.throwDeprecation"
+                 * true
+                 * $ node -p "process.throwDeprecation"
+                 * undefined
+                 * $ node
+                 * > process.emitWarning('test', 'DeprecationWarning');
+                 * undefined
+                 * > (node:26598) DeprecationWarning: test
+                 * > process.throwDeprecation = true;
+                 * true
+                 * > process.emitWarning('test', 'DeprecationWarning');
+                 * Thrown:
+                 * [DeprecationWarning: test] { name: 'DeprecationWarning' }
+                 * ```
+                 * @since v0.9.12
+                 */
+                throwDeprecation: boolean;
+                /**
+                 * The `process.traceDeprecation` property indicates whether the `--trace-deprecation` flag is set on the current Node.js process. See the
                  * documentation for the `'warning' event` and the `emitWarning() method` for more information about this
                  * flag's behavior.
                  * @since v0.8.0
                  */
                 traceDeprecation: boolean;
+                /**
+                 * An object is "refable" if it implements the Node.js "Refable protocol".
+                 * Specifically, this means that the object implements the `Symbol.for('nodejs.ref')`
+                 * and `Symbol.for('nodejs.unref')` methods. "Ref'd" objects will keep the Node.js
+                 * event loop alive, while "unref'd" objects will not. Historically, this was
+                 * implemented by using `ref()` and `unref()` methods directly on the objects.
+                 * This pattern, however, is being deprecated in favor of the "Refable protocol"
+                 * in order to better support Web Platform API types whose APIs cannot be modified
+                 * to add `ref()` and `unref()` methods but still need to support that behavior.
+                 * @since v22.14.0
+                 * @experimental
+                 * @param maybeRefable An object that may be "refable".
+                 */
+                ref(maybeRefable: any): void;
+                /**
+                 * An object is "unrefable" if it implements the Node.js "Refable protocol".
+                 * Specifically, this means that the object implements the `Symbol.for('nodejs.ref')`
+                 * and `Symbol.for('nodejs.unref')` methods. "Ref'd" objects will keep the Node.js
+                 * event loop alive, while "unref'd" objects will not. Historically, this was
+                 * implemented by using `ref()` and `unref()` methods directly on the objects.
+                 * This pattern, however, is being deprecated in favor of the "Refable protocol"
+                 * in order to better support Web Platform API types whose APIs cannot be modified
+                 * to add `ref()` and `unref()` methods but still need to support that behavior.
+                 * @since v22.14.0
+                 * @experimental
+                 * @param maybeRefable An object that may be "unref'd".
+                 */
+                unref(maybeRefable: any): void;
+                /**
+                 * Replaces the current process with a new process.
+                 *
+                 * This is achieved by using the `execve` POSIX function and therefore no memory or other
+                 * resources from the current process are preserved, except for the standard input,
+                 * standard output and standard error file descriptor.
+                 *
+                 * 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.
+                 *
+                 * This function will never return, unless an error occurred.
+                 *
+                 * This function is not available on Windows or IBM i.
+                 * @since v22.15.0
+                 * @experimental
+                 * @param file The name or path of the executable file to run.
+                 * @param args List of string arguments. No argument can contain a null-byte (`\u0000`).
+                 * @param env Environment key-value pairs.
+                 * No key or value can contain a null-byte (`\u0000`).
+                 * **Default:** `process.env`.
+                 */
+                execve?(file: string, args?: readonly string[], env?: ProcessEnv): never;
                 /* EventEmitter */
                 addListener(event: "beforeExit", listener: BeforeExitListener): this;
                 addListener(event: "disconnect", listener: DisconnectListener): this;
@@ -1439,6 +2002,7 @@ declare module "process" {
                 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;
@@ -1450,7 +2014,8 @@ declare module "process" {
                 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: unknown): this;
+                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",
@@ -1471,6 +2036,7 @@ declare module "process" {
                 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;
@@ -1484,6 +2050,7 @@ declare module "process" {
                 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;
@@ -1494,6 +2061,7 @@ declare module "process" {
                 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;
@@ -1506,6 +2074,7 @@ declare module "process" {
                 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;
@@ -1518,6 +2087,7 @@ declare module "process" {
                 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[];