@types/node

declare module "process" { 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 { // this namespace merge is here because these are specifically used // as the type for process.stdin, process.stdout, and process.stderr. // they can't live in tty.d.ts because we need to disambiguate the imported name. interface ReadStream extends tty.ReadStream {} interface WriteStream extends tty.WriteStream {} interface MemoryUsageFn { /** * The `process.memoryUsage()` method iterate over each page to gather informations about memory * usage which can be slow depending on the program memory allocations. */ (): MemoryUsage; /** * method returns an integer representing the Resident Set Size (RSS) in bytes. */ 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 { user: number; system: number; } interface ProcessRelease { name: string; sourceUrl?: string | undefined; headersUrl?: string | undefined; 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-v22.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"` if Node.js is run with `--experimental-strip-types`, * `"transform"` if Node.js is run with `--experimental-transform-types`, and `false` otherwise. * @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; v8: string; ares: string; uv: string; zlib: string; modules: string; openssl: string; } type Platform = | "aix" | "android" | "darwin" | "freebsd" | "haiku" | "linux" | "openbsd" | "sunos" | "win32" | "cygwin" | "netbsd"; type Architecture = | "arm" | "arm64" | "ia32" | "loong64" | "mips" | "mipsel" | "ppc" | "ppc64" | "riscv64" | "s390" | "s390x" | "x64"; type Signals = | "SIGABRT" | "SIGALRM" | "SIGBUS" | "SIGCHLD" | "SIGCONT" | "SIGFPE" | "SIGHUP" | "SIGILL" | "SIGINT" | "SIGIO" | "SIGIOT" | "SIGKILL" | "SIGPIPE" | "SIGPOLL" | "SIGPROF" | "SIGPWR" | "SIGQUIT" | "SIGSEGV" | "SIGSTKFLT" | "SIGSTOP" | "SIGSYS" | "SIGTERM" | "SIGTRAP" | "SIGTSTP" | "SIGTTIN" | "SIGTTOU" | "SIGUNUSED" | "SIGURG" | "SIGUSR1" | "SIGUSR2" | "SIGVTALRM" | "SIGWINCH" | "SIGXCPU" | "SIGXFSZ" | "SIGBREAK" | "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. */ type UnhandledRejectionListener = (reason: unknown, promise: Promise<unknown>) => void; type WarningListener = (warning: Error) => void; type MessageListener = (message: unknown, sendHandle: unknown) => void; type SignalsListener = (signal: Signals) => void; type MultipleResolveListener = ( type: MultipleResolveType, promise: Promise<unknown>, value: unknown, ) => void; type WorkerListener = (worker: Worker) => void; interface Socket extends ReadWriteStream { isTTY?: true | undefined; } // Alias for compatibility interface ProcessEnv extends Dict<string> { /** * Can be used to change the default timezone at runtime */ TZ?: string; } interface HRTime { /** * 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()` */ (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. */ directory: string; /** * 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 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): object; /** * If true, a diagnostic report is generated on fatal errors, * such as out of memory errors or failed C++ assertions. * @default false */ reportOnFatalError: boolean; /** * If true, a diagnostic report is generated when the process * receives the signal specified by process.report.signal. * @default false */ reportOnSignal: boolean; /** * If true, a diagnostic report is generated on uncaught exception. * @default false */ reportOnUncaughtException: boolean; /** * The signal used to trigger the creation of a diagnostic report. * @default 'SIGUSR2' */ signal: Signals; /** * 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. * * 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 err A custom error used for reporting the JavaScript stack. * @return Filename of the generated report. */ writeReport(fileName?: string, err?: Error): string; writeReport(err?: Error): string; } interface ResourceUsage { fsRead: number; fsWrite: number; involuntaryContextSwitches: number; ipcReceived: number; ipcSent: number; majorPageFault: number; maxRSS: number; minorPageFault: number; sharedMemorySize: number; signalsCount: number; swappedOut: number; systemCPUTime: number; unsharedDataSize: number; unsharedStackSize: number; userCPUTime: number; voluntaryContextSwitches: number; } interface EmitWarningOptions { /** * When `warning` is a `string`, `type` is the name to use for the _type_ of warning being emitted. * * @default 'Warning' */ type?: string | undefined; /** * A unique identifier for the warning instance being emitted. */ code?: string | undefined; /** * When `warning` is a `string`, `ctor` is an optional function used to limit the generated stack trace. * * @default process.emitWarning */ ctor?: Function | undefined; /** * Additional text to include with the error. */ detail?: string | undefined; } interface ProcessConfig { readonly target_defaults: { readonly cflags: any[]; readonly default_configuration: string; readonly defines: string[]; readonly include_dirs: string[]; readonly libraries: string[]; }; readonly variables: { readonly clang: number; readonly host_arch: string; readonly node_install_npm: boolean; readonly node_install_waf: boolean; readonly node_prefix: string; readonly node_shared_openssl: boolean; readonly node_shared_v8: boolean; readonly node_shared_zlib: boolean; readonly node_use_dtrace: boolean; readonly node_use_etw: boolean; readonly node_use_openssl: boolean; readonly target_arch: string; readonly v8_no_strict_aliasing: number; readonly v8_use_snapshot: boolean; readonly visibility: string; }; } interface Process extends EventEmitter { /** * The `process.stdout` property returns a stream connected to`stdout` (fd `1`). It is a `net.Socket` (which is a `Duplex` stream) unless fd `1` refers to a file, in which case it is * a `Writable` stream. * * For example, to copy `process.stdin` to `process.stdout`: * * ```js * import { stdin, stdout } from 'node:process'; * * stdin.pipe(stdout); * ``` * * `process.stdout` differs from other Node.js streams in important ways. See `note on process I/O` for more information. */ stdout: WriteStream & { fd: 1; }; /** * The `process.stderr` property returns a stream connected to`stderr` (fd `2`). It is a `net.Socket` (which is a `Duplex` stream) unless fd `2` refers to a file, in which case it is * a `Writable` stream. * * `process.stderr` differs from other Node.js streams in important ways. See `note on process I/O` for more information. */ stderr: WriteStream & { fd: 2; }; /** * The `process.stdin` property returns a stream connected to`stdin` (fd `0`). It is a `net.Socket` (which is a `Duplex` stream) unless fd `0` refers to a file, in which case it is * a `Readable` stream. * * For details of how to read from `stdin` see `readable.read()`. * * As a `Duplex` stream, `process.stdin` can also be used in "old" mode that * is compatible with scripts written for Node.js prior to v0.10\. * 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. */ stdin: ReadStream & { fd: 0; }; /** * 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 * arguments. * * For example, assuming the following script for `process-args.js`: * * ```js * import { argv } from 'node:process'; * * // print process.argv * argv.forEach((val, index) => { * console.log(`${index}: ${val}`); * }); * ``` * * Launching the Node.js process as: * * ```bash * node process-args.js one two=three four * ``` * * Would generate the output: * * ```text * 0: /usr/local/bin/node * 1: /Users/mjr/work/node/process-args.js * 2: one * 3: two=three * 4: four * ``` * @since v0.1.27 */ argv: string[]; /** * The `process.argv0` property stores a read-only copy of the original value of`argv[0]` passed when Node.js starts. * * ```console * $ bash -c 'exec -a customArgv0 ./node' * > process.argv[0] * '/Volumes/code/external/node/out/Release/node' * > process.argv0 * 'customArgv0' * ``` * @since v6.4.0 */ argv0: string; /** * The `process.execArgv` property returns the set of Node.js-specific command-line * options passed when the Node.js process was launched. These options do not * appear in the array returned by the {@link argv} property, and do not * include the Node.js executable, the name of the script, or any options following * the script name. These options are useful in order to spawn child processes with * the same execution environment as the parent. * * ```bash * node --icu-data-dir=./foo --require ./bar.js script.js --version * ``` * * Results in `process.execArgv`: * * ```js * ["--icu-data-dir=./foo", "--require", "./bar.js"] * ``` * * And `process.argv`: * * ```js * ['/usr/local/bin/node', 'script.js', '--version'] * ``` * * Refer to `Worker constructor` for the detailed behavior of worker * threads with this property. * @since v0.7.7 */ execArgv: string[]; /** * The `process.execPath` property returns the absolute pathname of the executable * that started the Node.js process. Symbolic links, if any, are resolved. * * ```js * '/usr/local/bin/node' * ``` * @since v0.1.100 */ execPath: string; /** * The `process.abort()` method causes the Node.js process to exit immediately and * generate a core file. * * This feature is not available in `Worker` threads. * @since v0.7.0 */ abort(): never; /** * 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 * the specified `directory` does not exist). * * ```js * import { chdir, cwd } from 'node:process'; * * console.log(`Starting directory: ${cwd()}`); * try { * chdir('/tmp'); * console.log(`New directory: ${cwd()}`); * } catch (err) { * console.error(`chdir: ${err}`); * } * ``` * * This feature is not available in `Worker` threads. * @since v0.1.17 */ chdir(directory: string): void; /** * The `process.cwd()` method returns the current working directory of the Node.js * process. * * ```js * import { cwd } from 'node:process'; * * console.log(`Current directory: ${cwd()}`); * ``` * @since v0.1.8 */ cwd(): string; /** * The port used by the Node.js debugger when enabled. * * ```js * import process from 'node:process'; * * process.debugPort = 5858; * ``` * @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-v22.x/api/os.html#dlopen-constants)` * documentation for details. * * An important requirement when calling `process.dlopen()` is that the `module` instance must be passed. Functions exported by the C++ Addon * 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. * * ```js * import { emitWarning } from 'node:process'; * * // 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! * ``` * * ```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'; * * process.on('warning', (warning) => { * console.warn(warning.name); // 'Warning' * console.warn(warning.message); // 'Something happened!' * console.warn(warning.code); // 'MY_WARNING' * console.warn(warning.stack); // Stack trace * console.warn(warning.detail); // 'This is some additional information' * }); * ``` * * 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. */ emitWarning(warning: string | Error, ctor?: Function): void; emitWarning(warning: string | Error, type?: string, ctor?: Function): void; emitWarning(warning: string | Error, type?: string, code?: string, ctor?: Function): void; emitWarning(warning: string | Error, options?: EmitWarningOptions): void; /** * The `process.env` property returns an object containing the user environment. * See [`environ(7)`](http://man7.org/linux/man-pages/man7/environ.7.html). * * An example of this object looks like: * * ```js * { * TERM: 'xterm-256color', * SHELL: '/usr/local/bin/bash', * USER: 'maciej', * PATH: '~/.bin/:/usr/bin:/bin:/usr/sbin:/sbin:/usr/local/bin', * PWD: '/Users/maciej', * EDITOR: 'vim', * SHLVL: '1', * HOME: '/Users/maciej', * LOGNAME: 'maciej', * _: '/usr/local/bin/node' * } * ``` * * It is possible to modify this object, but such modifications will not be * reflected outside the Node.js process, or (unless explicitly requested) * to other `Worker` threads. * In other words, the following example would not work: * * ```bash * node -e 'process.env.foo = "bar"' && echo $foo * ``` * * While the following will: * * ```js * import { env } from 'node:process'; * * env.foo = 'bar'; * console.log(env.foo); * ``` * * Assigning a property on `process.env` will implicitly convert the value * to a string. **This behavior is deprecated.** Future versions of Node.js may * throw an error when the value is not a string, number, or boolean. * * ```js * import { env } from 'node:process'; * * env.test = null; * console.log(env.test); * // => 'null' * env.test = undefined; * console.log(env.test); * // => 'undefined' * ``` * * Use `delete` to delete a property from `process.env`. * * ```js * import { env } from 'node:process'; * * env.TEST = 1; * delete env.TEST; * console.log(env.TEST); * // => undefined * ``` * * On Windows operating systems, environment variables are case-insensitive. * * ```js * import { env } from 'node:process'; * * env.TEST = 1; * console.log(env.test); * // => 1 * ``` * * Unless explicitly specified when creating a `Worker` instance, * each `Worker` thread has its own copy of `process.env`, based on its * 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 * unlike the main thread. * @since v0.1.27 */ env: ProcessEnv; /** * The `process.exit()` method instructs Node.js to terminate the process * synchronously with an exit status of `code`. If `code` is omitted, exit uses * either the 'success' code `0` or the value of `process.exitCode` if it has been * set. Node.js will not terminate until all the `'exit'` event listeners are * called. * * To exit with a 'failure' code: * * ```js * import { exit } from 'node:process'; * * exit(1); * ``` * * The shell that executed Node.js should see the exit code as `1`. * * 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`. * * 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 * truncated and lost: * * ```js * import { exit } from 'node:process'; * * // This is an example of what *not* to do: * if (someConditionNotMet()) { * printUsageToStdout(); * exit(1); * } * ``` * * The reason this is problematic is because writes to `process.stdout` in Node.js * 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 * scheduling any additional work for the event loop: * * ```js * import process from 'node:process'; * * // How to properly set the exit code while letting * // the process exit gracefully. * if (someConditionNotMet()) { * printUsageToStdout(); * process.exitCode = 1; * } * ``` * * If it is necessary to terminate the Node.js process due to an error condition, * throwing an _uncaught_ error and allowing the process to terminate accordingly * is safer than calling `process.exit()`. * * In `Worker` threads, this function stops the current thread rather * than the current 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 | string | null | undefined): never; /** * A number which will be the process exit code, when the process either * exits gracefully, or is exited via {@link exit} without specifying * a code. * * Specifying a code to {@link exit} will override any * previous setting of `process.exitCode`. * @default undefined * @since v0.11.8 */ exitCode?: number | string | number | 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