2021-09-29 18:17:34 +02:00
2022-04-10 02:18:16 +02:00
/* NOTE: Do not edit directly! This file is generated using `npm run update-types` in https://github.com/Steve-Mcl/monaco-editor-esm-i18n */
2021-09-29 18:17:34 +02:00
declare module 'process' {
2023-03-03 11:55:06 +01:00
import * as tty from 'node:tty' ;
import { Worker } from 'node:worker_threads' ;
2021-09-29 18:17:34 +02:00
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 { }
2023-03-03 11:55:06 +01:00
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 ;
}
2021-09-29 18:17:34 +02:00
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 ;
module s : string ;
openssl : string ;
}
2023-03-03 11:55:06 +01:00
type Platform = 'aix' | 'android' | 'darwin' | 'freebsd' | 'haiku' | 'linux' | 'openbsd' | 'sunos' | 'win32' | 'cygwin' | 'netbsd' ;
2021-09-29 18:17:34 +02:00
type Signals =
2023-03-03 11:55:06 +01:00
| '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' ;
2021-09-29 18:17:34 +02:00
type UncaughtExceptionOrigin = 'uncaughtException' | 'unhandledRejection' ;
type MultipleResolveType = 'resolve' | 'reject' ;
type BeforeExitListener = ( code : number ) = > void ;
type DisconnectListener = ( ) = > void ;
type ExitListener = ( code : number ) = > void ;
2023-03-03 11:55:06 +01:00
type RejectionHandledListener = ( promise : Promise < unknown > ) = > void ;
2021-09-29 18:17:34 +02:00
type UncaughtExceptionListener = ( error : Error , origin : UncaughtExceptionOrigin ) = > void ;
2023-03-03 11:55:06 +01:00
/ * *
* 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 the the value is an Error .
* /
type UnhandledRejectionListener = ( reason : unknown , promise : Promise < unknown > ) = > void ;
2021-09-29 18:17:34 +02:00
type WarningListener = ( warning : Error ) = > void ;
2023-03-03 11:55:06 +01:00
type MessageListener = ( message : unknown , sendHandle : unknown ) = > void ;
2021-09-29 18:17:34 +02:00
type SignalsListener = ( signal : Signals ) = > void ;
2023-03-03 11:55:06 +01:00
type MultipleResolveListener = ( type : MultipleResolveType , promise : Promise < unknown > , value : unknown ) = > void ;
type WorkerListener = ( worker : Worker ) = > void ;
2021-09-29 18:17:34 +02:00
interface Socket extends ReadWriteStream {
isTTY? : true | undefined ;
}
// Alias for compatibility
2023-03-03 11:55:06 +01:00
interface ProcessEnv extends Dict < string > {
/ * *
* Can be used to change the default timezone at runtime
* /
TZ? : string ;
}
2021-09-29 18:17:34 +02:00
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 .
2022-04-10 02:18:16 +02:00
* @default false
2021-09-29 18:17:34 +02:00
* /
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 ;
}
2023-03-03 11:55:06 +01:00
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 ;
} ;
}
2021-09-29 18:17:34 +02:00
interface Process extends EventEmitter {
/ * *
2023-03-03 11:55:06 +01:00
* 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 'process' ;
*
* stdin . pipe ( stdout ) ;
* ` ` `
*
* ` process.stdout ` differs from other Node . js streams in important ways . See ` note on process I/O ` for more information .
2021-09-29 18:17:34 +02:00
* /
stdout : WriteStream & {
fd : 1 ;
} ;
/ * *
2023-03-03 11:55:06 +01:00
* 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 .
2021-09-29 18:17:34 +02:00
* /
stderr : WriteStream & {
fd : 2 ;
} ;
2023-03-03 11:55:06 +01:00
/ * *
* 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 .
* /
2021-09-29 18:17:34 +02:00
stdin : ReadStream & {
fd : 0 ;
} ;
openStdin ( ) : Socket ;
2023-03-03 11:55:06 +01:00
/ * *
* 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 'process' ;
*
* // print process.argv
* argv . forEach ( ( val , index ) = > {
* console . log ( ` ${ index } : ${ val } ` ) ;
* } ) ;
* ` ` `
*
* Launching the Node . js process as :
*
* ` ` ` console
* $ node process - args . js one two = three four
* ` ` `
*
* Would generate the output :
*
* ` ` ` text
* 0 : / u s r / l o c a l / b i n / n o d e
* 1 : / U s e r s / m j r / w o r k / n o d e / p r o c e s s - a r g s . j s
* 2 : one
* 3 : two = three
* 4 : four
* ` ` `
* @since v0 . 1.27
* /
2021-09-29 18:17:34 +02:00
argv : string [ ] ;
2023-03-03 11:55:06 +01:00
/ * *
* 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
* /
2021-09-29 18:17:34 +02:00
argv0 : string ;
2023-03-03 11:55:06 +01:00
/ * *
* 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 .
*
* ` ` ` console
* $ 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
* /
2021-09-29 18:17:34 +02:00
execArgv : string [ ] ;
2023-03-03 11:55:06 +01:00
/ * *
* 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
* /
2021-09-29 18:17:34 +02:00
execPath : string ;
2023-03-03 11:55:06 +01:00
/ * *
* 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
* /
2021-09-29 18:17:34 +02:00
abort ( ) : never ;
2023-03-03 11:55:06 +01:00
/ * *
* 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 '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
* /
2021-09-29 18:17:34 +02:00
chdir ( directory : string ) : void ;
2023-03-03 11:55:06 +01:00
/ * *
* The ` process.cwd() ` method returns the current working directory of the Node . js
* process .
*
* ` ` ` js
* import { cwd } from 'process' ;
*
* console . log ( ` Current directory: ${ cwd ( ) } ` ) ;
* ` ` `
* @since v0 . 1.8
* /
2021-09-29 18:17:34 +02:00
cwd ( ) : string ;
2023-03-03 11:55:06 +01:00
/ * *
* The port used by the Node . js debugger when enabled .
*
* ` ` ` js
* import process from 'process' ;
*
* process . debugPort = 5858 ;
* ` ` `
* @since v0 . 7.2
* /
2021-09-29 18:17:34 +02:00
debugPort : number ;
2023-03-03 11:55:06 +01:00
/ * *
* 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 '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 '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 :
*
* ` ` ` console
* $ node - e 'process.env.foo = "bar"' & # x26 ; & # x26 ; echo $foo
* ` ` `
*
* While the following will :
*
* ` ` ` js
* import { env } from '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 '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 '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 '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 .
* @since v0 . 1.27
* /
2021-09-29 18:17:34 +02:00
env : ProcessEnv ;
2023-03-03 11:55:06 +01:00
/ * *
* 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 '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 '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 '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 .
* /
2021-09-29 18:17:34 +02:00
exit ( code? : number ) : never ;
2023-03-03 11:55:06 +01:00
/ * *
* 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
* /
2021-09-29 18:17:34 +02:00
exitCode? : number | undefined ;
2023-03-03 11:55:06 +01:00
/ * *
* 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
* /
2021-09-29 18:17:34 +02:00
getgid ( ) : number ;
2023-03-03 11:55:06 +01:00
/ * *
* 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 & # x26 ; & # x26 ; 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
* /
2021-09-29 18:17:34 +02:00
setgid ( id : number | string ) : void ;
2023-03-03 11:55:06 +01:00
/ * *
* 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
* /
2021-09-29 18:17:34 +02:00
getuid ( ) : number ;
2023-03-03 11:55:06 +01:00
/ * *
* 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 & # x26 ; & # x26 ; 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
* /
2021-09-29 18:17:34 +02:00
setuid ( id : number | string ) : void ;
2023-03-03 11:55:06 +01:00
/ * *
* 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
* /
2021-09-29 18:17:34 +02:00
geteuid ( ) : number ;
2023-03-03 11:55:06 +01:00
/ * *
* 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 & # x26 ; & # x26 ; 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
* /
2021-09-29 18:17:34 +02:00
seteuid ( id : number | string ) : void ;
2023-03-03 11:55:06 +01:00
/ * *
* 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
* /
2021-09-29 18:17:34 +02:00
getegid ( ) : number ;
2023-03-03 11:55:06 +01:00
/ * *
* 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 & # x26 ; & # x26 ; 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
* /
2021-09-29 18:17:34 +02:00
setegid ( id : number | string ) : void ;
2023-03-03 11:55:06 +01:00
/ * *
* 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
* /
2021-09-29 18:17:34 +02:00
getgroups ( ) : number [ ] ;
2023-03-03 11:55:06 +01:00
/ * *
* 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 & # x26 ; & # x26 ; 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
* /
2021-09-29 18:17:34 +02:00
setgroups ( groups : ReadonlyArray < string | number > ) : void ;
2023-03-03 11:55:06 +01:00
/ * *
* 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
* /
2021-09-29 18:17:34 +02:00
setUncaughtExceptionCaptureCallback ( cb : ( ( err : Error ) = > void ) | null ) : void ;
2023-03-03 11:55:06 +01:00
/ * *
* Indicates whether a callback has been set using { @link setUncaughtExceptionCaptureCallback } .
* @since v9 . 3.0
* /
2021-09-29 18:17:34 +02:00
hasUncaughtExceptionCaptureCallback ( ) : boolean ;
2023-03-03 11:55:06 +01:00
/ * *
* The ` process.version ` property contains the Node . js version string .
*
* ` ` ` js
* import { version } from '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 module s that were compiled against a different module ABI version .
*
* ` ` ` js
* import { versions } from 'process' ;
*
* console . log ( versions ) ;
* ` ` `
*
* Will generate an object similar to :
*
* ` ` ` console
* { node : '11.13.0' ,
* v8 : '7.0.276.38-node.18' ,
* uv : '1.27.0' ,
* zlib : '1.2.11' ,
* brotli : '1.0.7' ,
* ares : '1.15.0' ,
* module s : '67' ,
* nghttp2 : '1.34.0' ,
* napi : '4' ,
* llhttp : '1.1.1' ,
* openssl : '1.1.1b' ,
* cldr : '34.0' ,
* icu : '63.1' ,
* tz : '2018e' ,
* unicode : '11.0' }
* ` ` `
* @since v0 . 2.0
* /
readonly versions : ProcessVersions ;
/ * *
* The ` process.config ` property returns an ` 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_dtrace : 'false' ,
* node_use_openssl : 'true' ,
* node_shared_openssl : 'false' ,
* strict_aliasing : 'true' ,
* target_arch : 'x64' ,
* v8_use_snapshot : 1
* }
* }
* ` ` `
*
* The ` process.config ` property is * * not * * read - only and there are existing
* module s in the ecosystem that are known to extend , modify , or entirely replace
* the value of ` process.config ` .
*
* Modifying the ` process.config ` property , or any child - property of the ` process.config ` object has been deprecated . The ` process.config ` will be made
* read - only in a future release .
* @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 '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 .
* /
2021-09-29 18:17:34 +02:00
kill ( pid : number , signal? : string | number ) : true ;
2023-03-03 11:55:06 +01:00
/ * *
* The ` process.pid ` property returns the PID of the process .
*
* ` ` ` js
* import { pid } from '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 '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
* /
2021-09-29 18:17:34 +02:00
title : string ;
2023-03-03 11:55:06 +01:00
/ * *
* The operating system CPU architecture for which the Node . js binary was compiled .
* Possible values are : ` 'arm' ` , ` 'arm64' ` , ` 'ia32' ` , ` 'mips' ` , ` 'mipsel' ` , ` 'ppc' ` , ` 'ppc64' ` , ` 's390' ` , ` 's390x' ` , ` 'x32' ` , and ` 'x64' ` .
*
* ` ` ` js
* import { arch } from 'process' ;
*
* console . log ( ` This processor architecture is ${ arch } ` ) ;
* ` ` `
* @since v0 . 5.0
* /
readonly arch : string ;
/ * *
* The ` process.platform ` property returns a string identifying the operating
* system platform on which the Node . js process is running .
*
* Currently possible values are :
*
* * ` 'aix' `
* * ` 'darwin' `
* * ` 'freebsd' `
* * ` 'linux' `
* * ` 'openbsd' `
* * ` 'sunos' `
* * ` 'win32' `
*
* ` ` ` js
* import { platform } from '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
* module s 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 .
* /
2021-09-29 18:17:34 +02:00
mainModule? : Module | undefined ;
2023-03-03 11:55:06 +01:00
memoryUsage : MemoryUsageFn ;
/ * *
* 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 '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() `
* /
2021-09-29 18:17:34 +02:00
cpuUsage ( previousValue? : CpuUsage ) : CpuUsage ;
2023-03-03 11:55:06 +01:00
/ * *
* ` 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 '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 '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 '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 `
* /
2021-09-29 18:17:34 +02:00
nextTick ( callback : Function , . . . args : any [ ] ) : void ;
2023-03-03 11:55:06 +01:00
/ * *
* 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 : 'Erbium' ,
* sourceUrl : 'https://nodejs.org/download/release/v12.18.1/node-v12.18.1.tar.gz' ,
* headersUrl : 'https://nodejs.org/download/release/v12.18.1/node-v12.18.1-headers.tar.gz' ,
* libUrl : 'https://nodejs.org/download/release/v12.18.1/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 ;
2021-09-29 18:17:34 +02:00
features : {
inspector : boolean ;
debug : boolean ;
uv : boolean ;
ipv6 : boolean ;
tls_alpn : boolean ;
tls_sni : boolean ;
tls_ocsp : boolean ;
tls : boolean ;
} ;
/ * *
2023-03-03 11:55:06 +01:00
* ` 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 .
2021-09-29 18:17:34 +02:00
* /
umask ( ) : number ;
/ * *
* Can only be set if not in worker thread .
* /
umask ( mask : string | number ) : number ;
2023-03-03 11:55:06 +01:00
/ * *
* 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
* /
2021-09-29 18:17:34 +02:00
uptime ( ) : number ;
hrtime : HRTime ;
2023-03-03 11:55:06 +01:00
/ * *
* 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
* /
2021-09-29 18:17:34 +02:00
disconnect ( ) : void ;
2023-03-03 11:55:06 +01:00
/ * *
* 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
* /
2021-09-29 18:17:34 +02:00
connected : boolean ;
/ * *
* The ` process.allowedNodeEnvironmentFlags ` property is a special ,
2023-03-03 11:55:06 +01:00
* 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 '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
2021-09-29 18:17:34 +02:00
* /
allowedNodeEnvironmentFlags : ReadonlySet < string > ;
/ * *
2023-03-03 11:55:06 +01:00
* ` 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
2021-09-29 18:17:34 +02:00
* /
report? : ProcessReport | undefined ;
2023-03-03 11:55:06 +01:00
/ * *
* ` ` ` js
* import { resourceUsage } from '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 ] .
* /
2021-09-29 18:17:34 +02:00
resourceUsage ( ) : ResourceUsage ;
2023-03-03 11:55:06 +01:00
/ * *
* 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
* /
2021-09-29 18:17:34 +02:00
traceDeprecation : boolean ;
/* EventEmitter */
2023-03-03 11:55:06 +01:00
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 ;
2021-09-29 18:17:34 +02:00
addListener ( event : Signals , listener : SignalsListener ) : this ;
2023-03-03 11:55:06 +01:00
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 ;
2021-09-29 18:17:34 +02:00
emit ( event : Signals , signal : Signals ) : boolean ;
2023-03-03 11:55:06 +01:00
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 ;
2021-09-29 18:17:34 +02:00
on ( event : Signals , listener : SignalsListener ) : this ;
2023-03-03 11:55:06 +01:00
on ( event : 'multipleResolves' , listener : MultipleResolveListener ) : this ;
on ( event : 'worker' , listener : WorkerListener ) : this ;
2021-09-29 18:17:34 +02:00
on ( event : string | symbol , listener : ( . . . args : any [ ] ) = > void ) : this ;
2023-03-03 11:55:06 +01:00
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 ;
2021-09-29 18:17:34 +02:00
once ( event : Signals , listener : SignalsListener ) : this ;
2023-03-03 11:55:06 +01:00
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 ;
2021-09-29 18:17:34 +02:00
prependListener ( event : Signals , listener : SignalsListener ) : this ;
2023-03-03 11:55:06 +01:00
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 ;
2021-09-29 18:17:34 +02:00
prependOnceListener ( event : Signals , listener : SignalsListener ) : this ;
2023-03-03 11:55:06 +01:00
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 [ ] ;
2021-09-29 18:17:34 +02:00
listeners ( event : Signals ) : SignalsListener [ ] ;
2023-03-03 11:55:06 +01:00
listeners ( event : 'multipleResolves' ) : MultipleResolveListener [ ] ;
listeners ( event : 'worker' ) : WorkerListener [ ] ;
2021-09-29 18:17:34 +02:00
}
}
}
export = process ;
}
2022-04-10 02:18:16 +02:00
declare module 'node:process' {
import process = require ( 'process' ) ;
export = process ;
}