declare module "process" { | |
import * as tty from "node:tty"; | |
import { Worker } from "node:worker_threads"; | |
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 { | |
rss: number; | |
heapTotal: number; | |
heapUsed: number; | |
external: number; | |
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 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" | |
| "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 { | |
(time?: [number, number]): [number, number]; | |
bigint(): bigint; | |
} | |
interface ProcessReport { | |
/** | |
* Directory where the report is written. | |
* 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: string; | |
/** | |
* Returns a JSON-formatted diagnostic report for the running process. | |
* The report's JavaScript stack trace is taken from err, if present. | |
*/ | |
getReport(err?: Error): string; | |
/** | |
* 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. | |
* | |
* @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. | |
* @return Filename of the generated report. | |
*/ | |
writeReport(fileName?: string): string; | |
writeReport(error?: Error): string; | |
writeReport(fileName?: string, 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; | |
}; | |
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 | |
* 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 --harmony script.js --version | |
* ``` | |
* | |
* Results in `process.execArgv`: | |
* | |
* ```js | |
* ['--harmony'] | |
* ``` | |
* | |
* 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.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 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 | |
* ``` | |
* | |
* In this example, 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, the `options` argument is ignored. | |
* @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): 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`. | |
* @since v0.11.8 | |
*/ | |
exitCode?: number | 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'; | |
* | |
* if (process.getgid) { | |
* console.log(`Current gid: ${process.getgid()}`); | |
* } | |
* ``` | |
* | |
* This function is only available on POSIX platforms (i.e. not Windows or | |
* Android). | |
* @since v0.1.31 | |
*/ | |
getgid?: () => number; | |
/** | |
* The `process.setgid()` method sets the group identity of the process. (See [`setgid(2)`](http://man7.org/linux/man-pages/man2/setgid.2.html).) The `id` can be passed as either a | |
* numeric ID or a group name | |
* string. If a group name is specified, this method blocks while resolving the | |
* associated numeric ID. | |
* | |
* ```js | |
* import process from 'process'; | |
* | |
* if (process.getgid && process.setgid) { | |
* console.log(`Current gid: ${process.getgid()}`); | |
* try { | |
* process.setgid(501); | |
* console.log(`New gid: ${process.getgid()}`); | |
* } catch (err) { | |
* console.log(`Failed to set gid: ${err}`); | |
* } | |
* } | |
* ``` | |
* | |
* This function is only available on POSIX platforms (i.e. not Windows or | |
* Android). | |
* This feature is not available in `Worker` threads. | |
* @since v0.1.31 | |
* @param id The group name or ID | |
*/ | |
setgid?: (id: number | string) => void; | |
/** | |
* The `process.getuid()` method returns the numeric user identity of the process. | |
* (See [`getuid(2)`](http://man7.org/linux/man-pages/man2/getuid.2.html).) | |
* | |
* ```js | |
* import process from 'process'; | |
* | |
* if (process.getuid) { | |
* console.log(`Current uid: ${process.getuid()}`); | |
* } | |
* ``` | |
* | |
* This function is only available on POSIX platforms (i.e. not Windows or | |
* Android). | |
* @since v0.1.28 | |
*/ | |
getuid?: () => number; | |
/** | |
* The `process.setuid(id)` method sets the user identity of the process. (See [`setuid(2)`](http://man7.org/linux/man-pages/man2/setuid.2.html).) The `id` can be passed as either a | |
* numeric ID or a username string. | |
* If a username is specified, the method blocks while resolving the associated | |
* numeric ID. | |
* | |
* ```js | |
* import process from 'process'; | |
* | |
* if (process.getuid && process.setuid) { | |
* console.log(`Current uid: ${process.getuid()}`); | |
* try { | |
* process.setuid(501); | |
* console.log(`New uid: ${process.getuid()}`); | |
* } catch (err) { | |
* console.log(`Failed to set uid: ${err}`); | |
* } | |
* } | |
* ``` | |
* | |
* This function is only available on POSIX platforms (i.e. not Windows or | |
* Android). | |
* This feature is not available in `Worker` threads. | |
* @since v0.1.28 | |
*/ | |
setuid?: (id: number | string) => void; | |
/** | |
* The `process.geteuid()` method returns the numerical effective user identity of | |
* the process. (See [`geteuid(2)`](http://man7.org/linux/man-pages/man2/geteuid.2.html).) | |
* | |
* ```js | |
* import process from 'process'; | |
* | |
* if (process.geteuid) { | |
* console.log(`Current uid: ${process.geteuid()}`); | |
* } | |
* ``` | |
* | |
* This function is only available on POSIX platforms (i.e. not Windows or | |
* Android). | |
* @since v2.0.0 | |
*/ | |
geteuid?: () => number; | |
/** | |
* The `process.seteuid()` method sets the effective user identity of the process. | |
* (See [`seteuid(2)`](http://man7.org/linux/man-pages/man2/seteuid.2.html).) The `id` can be passed as either a numeric ID or a username | |
* string. If a username is specified, the method blocks while resolving the | |
* associated numeric ID. | |
* | |
* ```js | |
* import process from 'process'; | |
* | |
* if (process.geteuid && process.seteuid) { | |
* console.log(`Current uid: ${process.geteuid()}`); | |
* try { | |
* process.seteuid(501); | |
* console.log(`New uid: ${process.geteuid()}`); | |
* } catch (err) { | |
* console.log(`Failed to set uid: ${err}`); | |
* } | |
* } | |
* ``` | |
* | |
* This function is only available on POSIX platforms (i.e. not Windows or | |
* Android). | |
* This feature is not available in `Worker` threads. | |
* @since v2.0.0 | |
* @param id A user name or ID | |
*/ | |
seteuid?: (id: number | string) => void; | |
/** | |
* The `process.getegid()` method returns the numerical effective group identity | |
* of the Node.js process. (See [`getegid(2)`](http://man7.org/linux/man-pages/man2/getegid.2.html).) | |
* | |
* ```js | |
* import process from 'process'; | |
* | |
* if (process.getegid) { | |
* console.log(`Current gid: ${process.getegid()}`); | |
* } | |
* ``` | |
* | |
* This function is only available on POSIX platforms (i.e. not Windows or | |
* Android). | |
* @since v2.0.0 | |
*/ | |
getegid?: () => number; | |
/** | |
* The `process.setegid()` method sets the effective group identity of the process. | |
* (See [`setegid(2)`](http://man7.org/linux/man-pages/man2/setegid.2.html).) The `id` can be passed as either a numeric ID or a group | |
* name string. If a group name is specified, this method blocks while resolving | |
* the associated a numeric ID. | |
* | |
* ```js | |
* import process from 'process'; | |
* | |
* if (process.getegid && process.setegid) { | |
* console.log(`Current gid: ${process.getegid()}`); | |
* try { | |
* process.setegid(501); | |
* console.log(`New gid: ${process.getegid()}`); | |
* } catch (err) { | |
* console.log(`Failed to set gid: ${err}`); | |
* } | |
* } | |
* ``` | |
* | |
* This function is only available on POSIX platforms (i.e. not Windows or | |
* Android). | |
* This feature is not available in `Worker` threads. | |
* @since v2.0.0 | |
* @param id A group name or ID | |
*/ | |
setegid?: (id: number | string) => void; | |
/** | |
* The `process.getgroups()` method returns an array with the supplementary group | |
* IDs. POSIX leaves it unspecified if the effective group ID is included but | |
* Node.js ensures it always is. | |
* | |
* ```js | |
* import process from 'process'; | |
* | |
* if (process.getgroups) { | |
* console.log(process.getgroups()); // [ 16, 21, 297 ] | |
* } | |
* ``` | |
* | |
* This function is only available on POSIX platforms (i.e. not Windows or | |
* Android). | |
* @since v0.9.4 | |
*/ | |
getgroups?: () => number[]; | |
/** | |
* The `process.setgroups()` method sets the supplementary group IDs for the | |
* Node.js process. This is a privileged operation that requires the Node.js | |
* process to have `root` or the `CAP_SETGID` capability. | |
* | |
* The `groups` array can contain numeric group IDs, group names, or both. | |
* | |
* ```js | |
* import process from 'process'; | |
* | |
* if (process.getgroups && process.setgroups) { | |
* try { | |
* process.setgroups([501]); | |
* console.log(process.getgroups()); // new groups | |
* } catch (err) { | |
* console.log(`Failed to set groups: ${err}`); | |
* } | |
* } | |
* ``` | |
* | |
* This function is only available on POSIX platforms (i.e. not Windows or | |
* Android). | |
* This feature is not available in `Worker` threads. | |
* @since v0.9.4 | |
*/ | |
setgroups?: (groups: ReadonlyArray<string | number>) => void; | |
/** | |
* The `process.setUncaughtExceptionCaptureCallback()` function sets a function | |
* that will be invoked when an uncaught exception occurs, which will receive the | |
* exception value itself as its first argument. | |
* | |
* If such a function is set, the `'uncaughtException'` event will | |
* not be emitted. If `--abort-on-uncaught-exception` was passed from the | |
* command line or set through `v8.setFlagsFromString()`, the process will | |
* 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 | |
* 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. | |
* @since v9.3.0 | |
*/ | |
setUncaughtExceptionCaptureCallback(cb: ((err: Error) => void) | null): void; | |
/** | |
* Indicates whether a callback has been set using {@link setUncaughtExceptionCaptureCallback}. | |
* @since v9.3.0 | |
*/ | |
hasUncaughtExceptionCaptureCallback(): boolean; | |
/** | |
* The `process.sourceMapsEnabled` property returns whether the [Source Map v3](https://sourcemaps.info/spec.html) support for stack traces is enabled. | |
* @since v20.7.0 | |
* @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. | |
* | |
* ```js | |
* import { version } from 'node:process'; | |
* | |
* console.log(`Version: ${version}`); | |
* // Version: v14.8.0 | |
* ``` | |
* | |
* To get the version string without the prepended _v_, use`process.versions.node`. | |
* @since v0.1.3 | |
*/ | |
readonly version: string; | |
/** | |
* The `process.versions` property returns an object listing the version strings of | |
* Node.js and its dependencies. `process.versions.modules` indicates the current | |
* ABI version, which is increased whenever a C++ API changes. Node.js will refuse | |
* to load modules that were compiled against a different module ABI version. | |
* | |
* ```js | |
* import { versions } from 'node:process'; | |
* | |
* console.log(versions); | |
* ``` | |
* | |
* 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' } | |
* ``` | |
* @since v0.2.0 | |
*/ | |
readonly versions: ProcessVersions; | |
/** | |
* The `process.config` property returns a frozen `Object` containing the | |
* JavaScript representation of the configure options used to compile the current | |
* Node.js executable. This is the same as the `config.gypi` file that was produced | |
* when running the `./configure` script. | |
* | |
* An example of the possible output looks like: | |
* | |
* ```js | |
* { | |
* target_defaults: | |
* { cflags: [], | |
* default_configuration: 'Release', | |
* defines: [], | |
* include_dirs: [], | |
* libraries: [] }, | |
* variables: | |
* { | |
* host_arch: 'x64', | |
* napi_build_version: 5, | |
* node_install_npm: 'true', | |
* node_prefix: '', | |
* node_shared_cares: 'false', | |
* node_shared_http_parser: 'false', | |
* node_shared_libuv: 'false', | |
* node_shared_zlib: 'false', | |
* node_use_openssl: 'true', | |
* node_shared_openssl: 'false', | |
* strict_aliasing: 'true', | |
* target_arch: 'x64', | |
* v8_use_snapshot: 1 | |
* } | |
* } | |
* ``` | |
* @since v0.7.7 | |
*/ | |
readonly config: ProcessConfig; | |
/** | |
* The `process.kill()` method sends the `signal` to the process identified by`pid`. | |
* | |
* Signal names are strings such as `'SIGINT'` or `'SIGHUP'`. See `Signal Events` and [`kill(2)`](http://man7.org/linux/man-pages/man2/kill.2.html) for more information. | |
* | |
* This method will throw an error if the target `pid` does not exist. As a special | |
* case, a signal of `0` can be used to test for the existence of a process. | |
* Windows platforms will throw an error if the `pid` is used to kill a process | |
* group. | |
* | |
* Even though the name of this function is `process.kill()`, it is really just a | |
* signal sender, like the `kill` system call. The signal sent may do something | |
* other than kill the target process. | |
* | |
* ```js | |
* import process, { kill } from 'node:process'; | |
* | |
* process.on('SIGHUP', () => { | |
* console.log('Got SIGHUP signal.'); | |
* }); | |
* | |
* setTimeout(() => { | |
* console.log('Exiting.'); | |
* process.exit(0); | |
* }, 100); | |
* | |
* kill(process.pid, 'SIGHUP'); | |
* ``` | |
* | |
* When `SIGUSR1` is received by a Node.js process, Node.js will start the | |
* debugger. See `Signal Events`. | |
* @since v0.0.6 | |
* @param pid A process ID | |
* @param [signal='SIGTERM'] The signal to send, either as a string or number. | |
*/ | |
kill(pid: number, signal?: string | number): true; | |
/** | |
* The `process.pid` property returns the PID of the process. | |
* | |
* ```js | |
* import { pid } from 'node:process'; | |
* | |
* console.log(`This process is pid ${pid}`); | |
* ``` | |
* @since v0.1.15 | |
*/ | |
readonly pid: number; | |
/** | |
* The `process.ppid` property returns the PID of the parent of the | |
* current process. | |
* | |
* ```js | |
* import { ppid } from 'node:process'; | |
* | |
* console.log(`The parent process is pid ${ppid}`); | |
* ``` | |
* @since v9.2.0, v8.10.0, v6.13.0 | |
*/ | |
readonly ppid: number; | |
/** | |
* 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 | |
* the current value of `ps`. | |
* | |
* 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) | |
* cases. | |
* | |
* Assigning a value to `process.title` might not result in an accurate label | |
* within process manager applications such as macOS Activity Monitor or Windows | |
* Services Manager. | |
* @since v0.1.104 | |
*/ | |
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'`. | |
* | |
* ```js | |
* import { arch } from 'node:process'; | |
* | |
* console.log(`This processor architecture is ${arch}`); | |
* ``` | |
* @since v0.5.0 | |
*/ | |
readonly arch: Architecture; | |
/** | |
* The `process.platform` property returns a string identifying the operating | |
* system platform for which the Node.js binary was compiled. | |
* | |
* Currently possible values are: | |
* | |
* * `'aix'` | |
* * `'darwin'` | |
* * `'freebsd'` | |
* * `'linux'` | |
* * `'openbsd'` | |
* * `'sunos'` | |
* * `'win32'` | |
* | |
* ```js | |
* import { platform } from 'node:process'; | |
* | |
* console.log(`This platform is ${platform}`); | |
* ``` | |
* | |
* The value `'android'` may also be returned if the Node.js is built on the | |
* Android operating system. However, Android support in Node.js [is experimental](https://github.com/nodejs/node/blob/HEAD/BUILDING.md#androidandroid-based-devices-eg-firefox-os). | |
* @since v0.1.16 | |
*/ | |
readonly platform: Platform; | |
/** | |
* The `process.mainModule` property provides an alternative way of retrieving `require.main`. The difference is that if the main module changes at | |
* runtime, `require.main` may still refer to the original main module in | |
* modules that were required before the change occurred. Generally, it's | |
* safe to assume that the two refer to the same module. | |
* | |
* As with `require.main`, `process.mainModule` will be `undefined` if there | |
* is no entry script. | |
* @since v0.1.17 | |
* @deprecated Since v14.0.0 - Use `main` instead. | |
*/ | |
mainModule?: Module | undefined; | |
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. | |
* | |
* 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; | |
/** | |
* 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 | |
* values are microsecond values (millionth of a second). These values measure time | |
* spent in user and system code respectively, and may end up being greater than | |
* actual elapsed time if multiple CPU cores are performing work for this process. | |
* | |
* The result of a previous call to `process.cpuUsage()` can be passed as the | |
* argument to the function, to get a diff reading. | |
* | |
* ```js | |
* import { cpuUsage } from 'node:process'; | |
* | |
* const startUsage = cpuUsage(); | |
* // { user: 38579, system: 6986 } | |
* | |
* // spin the CPU for 500 milliseconds | |
* const now = Date.now(); | |
* while (Date.now() - now < 500); | |
* | |
* console.log(cpuUsage(startUsage)); | |
* // { user: 514883, system: 11226 } | |
* ``` | |
* @since v6.1.0 | |
* @param previousValue A previous return value from calling `process.cpuUsage()` | |
*/ | |
cpuUsage(previousValue?: CpuUsage): CpuUsage; | |
/** | |
* `process.nextTick()` adds `callback` to the "next tick queue". This queue is | |
* fully drained after the current operation on the JavaScript stack runs to | |
* completion and before the event loop is allowed to continue. It's possible to | |
* create an infinite loop if one were to recursively call `process.nextTick()`. | |
* See the [Event Loop](https://nodejs.org/en/docs/guides/event-loop-timers-and-nexttick/#process-nexttick) guide for more background. | |
* | |
* ```js | |
* import { nextTick } from 'node:process'; | |
* | |
* console.log('start'); | |
* nextTick(() => { | |
* console.log('nextTick callback'); | |
* }); | |
* console.log('scheduled'); | |
* // Output: | |
* // start | |
* // scheduled | |
* // nextTick callback | |
* ``` | |
* | |
* This is important when developing APIs in order to give users the opportunity | |
* to assign event handlers _after_ an object has been constructed but before any | |
* I/O has occurred: | |
* | |
* ```js | |
* import { nextTick } from 'node:process'; | |
* | |
* function MyThing(options) { | |
* this.setupOptions(options); | |
* | |
* nextTick(() => { | |
* this.startDoingStuff(); | |
* }); | |
* } | |
* | |
* const thing = new MyThing(); | |
* thing.getReadyForStuff(); | |
* | |
* // thing.startDoingStuff() gets called now, not before. | |
* ``` | |
* | |
* It is very important for APIs to be either 100% synchronous or 100% | |
* asynchronous. Consider this example: | |
* | |
* ```js | |
* // WARNING! DO NOT USE! BAD UNSAFE HAZARD! | |
* function maybeSync(arg, cb) { | |
* if (arg) { | |
* cb(); | |
* return; | |
* } | |
* | |
* fs.stat('file', cb); | |
* } | |
* ``` | |
* | |
* This API is hazardous because in the following case: | |
* | |
* ```js | |
* const maybeTrue = Math.random() > 0.5; | |
* | |
* maybeSync(maybeTrue, () => { | |
* foo(); | |
* }); | |
* | |
* bar(); | |
* ``` | |
* | |
* It is not clear whether `foo()` or `bar()` will be called first. | |
* | |
* The following approach is much better: | |
* | |
* ```js | |
* import { nextTick } from 'node:process'; | |
* | |
* function definitelyAsync(arg, cb) { | |
* if (arg) { | |
* nextTick(cb); | |
* return; | |
* } | |
* | |
* fs.stat('file', cb); | |
* } | |
* ``` | |
* @since v0.1.26 | |
* @param args Additional arguments to pass when invoking the `callback` | |
*/ | |
nextTick(callback: Function, ...args: any[]): void; | |
/** | |
* The `process.release` property returns an `Object` containing metadata related | |
* to the current release, including URLs for the source tarball and headers-only | |
* tarball. | |
* | |
* `process.release` contains the following properties: | |
* | |
* ```js | |
* { | |
* name: 'node', | |
* lts: 'Hydrogen', | |
* sourceUrl: 'https://nodejs.org/download/release/v18.12.0/node-v18.12.0.tar.gz', | |
* headersUrl: 'https://nodejs.org/download/release/v18.12.0/node-v18.12.0-headers.tar.gz', | |
* libUrl: 'https://nodejs.org/download/release/v18.12.0/win-x64/node.lib' | |
* } | |
* ``` | |
* | |
* 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; | |
}; | |
/** | |
* `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 * | |
* security vulnerability. There is no safe, cross-platform alternative API. | |
*/ | |
umask(): number; | |
/** | |
* Can only be set if not in worker thread. | |
*/ | |
umask(mask: string | number): number; | |
/** | |
* The `process.uptime()` method returns the number of seconds the current Node.js | |
* process has been running. | |
* | |
* The return value includes fractions of a second. Use `Math.floor()` to get whole | |
* seconds. | |
* @since v0.5.0 | |
*/ | |
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?: { | |
/** | |
* This method makes the IPC channel keep the event loop of the process running if .unref() has been called before. | |
* @since v7.1.0 | |
*/ | |
ref(): void; | |
/** | |
* This method makes the IPC channel not keep the event loop of the process running, and lets it finish even while the channel is open. | |
* @since v7.1.0 | |
*/ | |
unref(): void; | |
}; | |
/** | |
* 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. | |
* | |
* If Node.js was not spawned with an IPC channel, `process.send` will be `undefined`. | |
* | |
* 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: | |
*/ | |
send?( | |
message: any, | |
sendHandle?: any, | |
options?: { | |
swallowErrors?: boolean | undefined; | |
}, | |
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 | |
* once there are no other connections keeping it alive. | |
* | |
* 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`. | |
* @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. | |
* | |
* Once `process.connected` is `false`, it is no longer possible to send messages | |
* over the IPC channel using `process.send()`. | |
* @since v0.7.2 | |
*/ | |
connected: boolean; | |
/** | |
* 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 | |
* 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 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`, | |
* etc. | |
* * Flags may contain one or more equals (`=`) characters; all | |
* characters after and including the first equals will be ignored; | |
* e.g., `--stack-trace-limit=100`. | |
* * Flags _must_ be allowable within `NODE_OPTIONS`. | |
* | |
* When iterating over `process.allowedNodeEnvironmentFlags`, flags will | |
* appear only _once_; each will begin with one or more dashes. Flags | |
* passed through to V8 will contain underscores instead of non-leading | |
* dashes: | |
* | |
* ```js | |
* import { allowedNodeEnvironmentFlags } from 'node:process'; | |
* | |
* allowedNodeEnvironmentFlags.forEach((flag) => { | |
* // -r | |
* // --inspect-brk | |
* // --abort_on_uncaught_exception | |
* // ... | |
* }); | |
* ``` | |
* | |
* The methods `add()`, `clear()`, and `delete()` of`process.allowedNodeEnvironmentFlags` do nothing, and will fail | |
* silently. | |
* | |
* If Node.js was compiled _without_ `NODE_OPTIONS` support (shown in {@link config}), `process.allowedNodeEnvironmentFlags` will | |
* contain what _would have_ been allowable. | |
* @since v10.10.0 | |
*/ | |
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`. | |
* @since v11.8.0 | |
*/ | |
report?: ProcessReport | undefined; | |
/** | |
* ```js | |
* import { resourceUsage } from 'node:process'; | |
* | |
* console.log(resourceUsage()); | |
* /* | |
* Will output: | |
* { | |
* userCPUTime: 82872, | |
* systemCPUTime: 4143, | |
* maxRSS: 33164, | |
* sharedMemorySize: 0, | |
* unsharedDataSize: 0, | |
* unsharedStackSize: 0, | |
* minorPageFault: 2469, | |
* majorPageFault: 0, | |
* swappedOut: 0, | |
* fsRead: 0, | |
* fsWrite: 8, | |
* ipcSent: 0, | |
* ipcReceived: 0, | |
* signalsCount: 0, | |
* voluntaryContextSwitches: 79, | |
* involuntaryContextSwitches: 1 | |
* } | |
* | |
* ``` | |
* @since v12.6.0 | |
* @return the resource usage for the current process. All of these values come from the `uv_getrusage` call which returns a [`uv_rusage_t` struct][uv_rusage_t]. | |
*/ | |
resourceUsage(): ResourceUsage; | |
/** | |
* 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; | |
/* 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: 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: unknown): this; | |
emit(event: Signals, signal?: Signals): boolean; | |
emit( | |
event: "multipleResolves", | |
type: MultipleResolveType, | |
promise: Promise<unknown>, | |
value: unknown, | |
): 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: 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: 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: 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: 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: Signals): SignalsListener[]; | |
listeners(event: "multipleResolves"): MultipleResolveListener[]; | |
listeners(event: "worker"): WorkerListener[]; | |
} | |
} | |
} | |
export = process; | |
} | |
declare module "node:process" { | |
import process = require("process"); | |
export = process; | |
} | |