@code-yeongyu/senpi 2026.6.3 → 2026.6.6-3

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

@@ -1,9 +1,8 @@
-declare module "process" {
+declare module "node: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");
@@ -69,6 +68,7 @@ declare module "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");
@@ -103,8 +103,6 @@ declare module "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");
@@ -118,8 +116,28 @@ declare module "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.
@@ -196,7 +214,7 @@ declare module "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-v22.x/api/modules.md#loading-ecmascript-modules-using-require).
+                 * [loading ECMAScript modules using `require()`](https://nodejs.org/docs/latest-v25.x/api/modules.md#loading-ecmascript-modules-using-require).
                  * @since v22.10.0
                  */
                 readonly require_module: boolean;
@@ -235,7 +253,7 @@ declare module "process" {
                 /**
                  * 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`.
+                 * Node.js is run with `--no-strip-types`.
                  * @since v22.10.0
                  */
                 readonly typescript: "strip" | "transform" | false;
@@ -277,10 +295,8 @@ declare module "process" {
                 | "loong64"
                 | "mips"
                 | "mipsel"
-                | "ppc"
                 | "ppc64"
                 | "riscv64"
-                | "s390"
                 | "s390x"
                 | "x64";
             type Signals =
@@ -322,26 +338,129 @@ declare module "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;
             /**
-             * 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.
+             * @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.
              */
-            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;
-            type MultipleResolveListener = (
-                type: MultipleResolveType,
-                promise: Promise<unknown>,
-                value: unknown,
-            ) => void;
-            type WorkerListener = (worker: Worker) => 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;
             interface Socket extends ReadWriteStream {
                 isTTY?: true | undefined;
             }
@@ -610,7 +729,8 @@ declare module "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. The remaining elements will be any additional command-line
+                 * file being executed. If a [program entry point](https://nodejs.org/docs/latest-v25.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`:
@@ -702,6 +822,28 @@ declare module "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-v25.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
@@ -751,7 +893,7 @@ declare module "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-v22.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-v25.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
@@ -1298,9 +1440,11 @@ declare module "process" {
                  * method with a non-`null` argument while another capture function is set will
                  * throw an error.
                  *
-                 * Using this function is mutually exclusive with using the deprecated `domain` built-in module.
+                 * To register multiple callbacks that can coexist, use
+                 * `process.addUncaughtExceptionCaptureCallback()` instead.
                  * @since v9.3.0
                  */
+                // TODO: callback parameter should be `unknown`
                 setUncaughtExceptionCaptureCallback(cb: ((err: Error) => void) | null): void;
                 /**
                  * Indicates whether a callback has been set using {@link setUncaughtExceptionCaptureCallback}.
@@ -1354,30 +1498,35 @@ declare module "process" {
                  * Will generate an object similar to:
                  *
                  * ```console
-                 * { 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' }
+                 * { 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' }
                  * ```
                  * @since v0.2.0
                  */
@@ -1500,7 +1649,7 @@ declare module "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 v22.19.0
+                 * @since v23.9.0
                  * @param previousValue A previous return value from calling
                  * `process.threadCpuUsage()`
                  */
@@ -1525,7 +1674,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'`, `'loong64'`, `'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';
@@ -1585,7 +1735,7 @@ declare module "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-v22.x/api/process.html#processavailablememory) for more information.
+                 * See [`uv_get_available_memory`](https://nodejs.org/docs/latest-v25.x/api/process.html#processavailablememory) for more information.
                  * @since v20.13.0
                  */
                 availableMemory(): number;
@@ -1741,6 +1891,24 @@ declare module "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.
@@ -1805,7 +1973,7 @@ declare module "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.
@@ -1859,7 +2027,7 @@ 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](https://nodejs.org/docs/latest-v22.x/api/report.html).
+                 * Additional documentation is available in the [report documentation](https://nodejs.org/docs/latest-v25.x/api/report.html).
                  * @since v11.8.0
                  */
                 report: ProcessReport;
@@ -1974,111 +2142,63 @@ declare module "process" {
                  * **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;
-                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,
+                // #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;
-                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[];
+                once(eventName: string | symbol, listener: (...args: any[]) => void): this;
+                prependListener<E extends keyof ProcessEventMap>(
+                    eventName: E,
+                    listener: (...args: ProcessEventMap[E]) => void,
+                ): 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
             }
         }
     }
     export = process;
 }
-declare module "node:process" {
-    import process = require("process");
+declare module "process" {
+    import process = require("node:process");
     export = process;
 }

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

@@ -1,32 +1,4 @@
-/**
- * **The version of the punycode module bundled in Node.js is being deprecated. **In a future major version of Node.js this module will be removed. Users
- * currently depending on the `punycode` module should switch to using the
- * userland-provided [Punycode.js](https://github.com/bestiejs/punycode.js) module instead. For punycode-based URL
- * encoding, see `url.domainToASCII` or, more generally, the `WHATWG URL API`.
- *
- * The `punycode` module is a bundled version of the [Punycode.js](https://github.com/bestiejs/punycode.js) module. It
- * can be accessed using:
- *
- * ```js
- * import punycode from 'node:punycode';
- * ```
- *
- * [Punycode](https://tools.ietf.org/html/rfc3492) is a character encoding scheme defined by RFC 3492 that is
- * primarily intended for use in Internationalized Domain Names. Because host
- * names in URLs are limited to ASCII characters only, Domain Names that contain
- * non-ASCII characters must be converted into ASCII using the Punycode scheme.
- * For instance, the Japanese character that translates into the English word, `'example'` is `'例'`. The Internationalized Domain Name, `'例.com'` (equivalent
- * to `'example.com'`) is represented by Punycode as the ASCII string `'xn--fsq.com'`.
- *
- * The `punycode` module provides a simple implementation of the Punycode standard.
- *
- * The `punycode` module is a third-party dependency used by Node.js and
- * made available to developers as a convenience. Fixes or other modifications to
- * the module must be directed to the [Punycode.js](https://github.com/bestiejs/punycode.js) project.
- * @deprecated Since v7.0.0 - Deprecated
- * @see [source](https://github.com/nodejs/node/blob/v22.x/lib/punycode.js)
- */
-declare module "punycode" {
+declare module "node:punycode" {
     /**
      * The `punycode.decode()` method converts a [Punycode](https://tools.ietf.org/html/rfc3492) string of ASCII-only
      * characters to the equivalent string of Unicode codepoints.
@@ -112,6 +84,6 @@ declare module "punycode" {
      */
     const version: string;
 }
-declare module "node:punycode" {
-    export * from "punycode";
+declare module "punycode" {
+    export * from "node:punycode";
 }