node-red-contrib-tak-registration
Version:
A Node-RED node to register to TAK and to help wrap files as datapackages to send to TAK
1,049 lines (1,048 loc) • 87.3 kB
TypeScript
declare module "process" {
import * as net from "node:net";
import * as os from "node:os";
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 {
/**
* Resident Set Size, is the amount of space occupied in the main memory device (that is a subset of the total allocated memory) for the
* process, including all C++ and JavaScript objects and code.
*/
rss: number;
/**
* Refers to V8's memory usage.
*/
heapTotal: number;
/**
* Refers to V8's memory usage.
*/
heapUsed: number;
external: number;
/**
* Refers to memory allocated for `ArrayBuffer`s and `SharedArrayBuffer`s, including all Node.js Buffers. This is also included
* in the external value. When Node.js is used as an embedded library, this value may be `0` because allocations for `ArrayBuffer`s
* may not be tracked in that case.
*/
arrayBuffers: number;
}
interface CpuUsage {
user: number;
system: number;
}
interface ProcessRelease {
name: string;
sourceUrl?: string | undefined;
headersUrl?: string | undefined;
libUrl?: string | undefined;
lts?: string | undefined;
}
interface ProcessVersions extends Dict<string> {
http_parser: string;
node: string;
v8: string;
ares: string;
uv: string;
zlib: string;
modules: string;
openssl: string;
}
type Platform =
| "aix"
| "android"
| "darwin"
| "freebsd"
| "haiku"
| "linux"
| "openbsd"
| "sunos"
| "win32"
| "cygwin"
| "netbsd";
type Architecture =
| "arm"
| "arm64"
| "ia32"
| "loong64"
| "mips"
| "mipsel"
| "ppc"
| "ppc64"
| "riscv64"
| "s390"
| "s390x"
| "x64";
type Signals =
| "SIGABRT"
| "SIGALRM"
| "SIGBUS"
| "SIGCHLD"
| "SIGCONT"
| "SIGFPE"
| "SIGHUP"
| "SIGILL"
| "SIGINT"
| "SIGIO"
| "SIGIOT"
| "SIGKILL"
| "SIGPIPE"
| "SIGPOLL"
| "SIGPROF"
| "SIGPWR"
| "SIGQUIT"
| "SIGSEGV"
| "SIGSTKFLT"
| "SIGSTOP"
| "SIGSYS"
| "SIGTERM"
| "SIGTRAP"
| "SIGTSTP"
| "SIGTTIN"
| "SIGTTOU"
| "SIGUNUSED"
| "SIGURG"
| "SIGUSR1"
| "SIGUSR2"
| "SIGVTALRM"
| "SIGWINCH"
| "SIGXCPU"
| "SIGXFSZ"
| "SIGBREAK"
| "SIGLOST"
| "SIGINFO";
type UncaughtExceptionOrigin = "uncaughtException" | "unhandledRejection";
type MultipleResolveType = "resolve" | "reject";
type BeforeExitListener = (code: number) => void;
type DisconnectListener = () => void;
type ExitListener = (code: number) => void;
type RejectionHandledListener = (promise: Promise<unknown>) => void;
type UncaughtExceptionListener = (error: Error, origin: UncaughtExceptionOrigin) => void;
/**
* Most of the time the unhandledRejection will be an Error, but this should not be relied upon
* as *anything* can be thrown/rejected, it is therefore unsafe to assume that the value is an Error.
*/
type UnhandledRejectionListener = (reason: unknown, promise: Promise<unknown>) => void;
type WarningListener = (warning: Error) => void;
type MessageListener = (message: unknown, sendHandle: unknown) => void;
type SignalsListener = (signal: Signals) => void;
type MultipleResolveListener = (
type: MultipleResolveType,
promise: Promise<unknown>,
value: unknown,
) => void;
type WorkerListener = (worker: Worker) => void;
interface Socket extends ReadWriteStream {
isTTY?: true | undefined;
}
// Alias for compatibility
interface ProcessEnv extends Dict<string> {
/**
* Can be used to change the default timezone at runtime
*/
TZ?: string;
}
interface HRTime {
(time?: [number, number]): [number, number];
/**
* The `bigint` version of the `{@link hrtime()}` method returning the current high-resolution real time in nanoseconds as a `bigint`.
*
* Unlike `{@link hrtime()}`, it does not support an additional time argument since the difference can just be computed directly by subtraction of the two `bigint`s.
* ```js
* import { hrtime } from 'node:process';
*
* const start = hrtime.bigint();
* // 191051479007711n
*
* setTimeout(() => {
* const end = hrtime.bigint();
* // 191052633396993n
*
* console.log(`Benchmark took ${end - start} nanoseconds`);
* // Benchmark took 1154389282 nanoseconds
* }, 1000);
* ```
*/
bigint(): bigint;
}
interface ProcessPermission {
/**
* Verifies that the process is able to access the given scope and reference.
* If no reference is provided, a global scope is assumed, for instance, `process.permission.has('fs.read')`
* will check if the process has ALL file system read permissions.
*
* The reference has a meaning based on the provided scope. For example, the reference when the scope is File System means files and folders.
*
* The available scopes are:
*
* * `fs` - All File System
* * `fs.read` - File System read operations
* * `fs.write` - File System write operations
* * `child` - Child process spawning operations
* * `worker` - Worker thread spawning operation
*
* ```js
* // Check if the process has permission to read the README file
* process.permission.has('fs.read', './README.md');
* // Check if the process has read permission operations
* process.permission.has('fs.read');
* ```
* @since v20.0.0
*/
has(scope: string, reference?: string): boolean;
}
interface ProcessReport {
/**
* 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;
};
/**
* The `process.argv` property returns an array containing the command-line
* arguments passed when the Node.js process was launched. The first element will
* be {@link execPath}. See `process.argv0` if access to the original value
* of `argv[0]` is needed. The second element will be the path to the JavaScript
* file being executed. The remaining elements will be any additional command-line
* arguments.
*
* For example, assuming the following script for `process-args.js`:
*
* ```js
* import { argv } from 'node:process';
*
* // print process.argv
* argv.forEach((val, index) => {
* console.log(`${index}: ${val}`);
* });
* ```
*
* Launching the Node.js process as:
*
* ```bash
* node process-args.js one two=three four
* ```
*
* Would generate the output:
*
* ```text
* 0: /usr/local/bin/node
* 1: /Users/mjr/work/node/process-args.js
* 2: one
* 3: two=three
* 4: four
* ```
* @since v0.1.27
*/
argv: string[];
/**
* The `process.argv0` property stores a read-only copy of the original value of`argv[0]` passed when Node.js starts.
*
* ```console
* $ bash -c 'exec -a customArgv0 ./node'
* > process.argv[0]
* '/Volumes/code/external/node/out/Release/node'
* > process.argv0
* 'customArgv0'
* ```
* @since v6.4.0
*/
argv0: string;
/**
* The `process.execArgv` property returns the set of Node.js-specific command-line
* options passed when the Node.js process was launched. These options do not
* appear in the array returned by the {@link argv} property, and do not
* include the Node.js executable, the name of the script, or any options following
* the script name. These options are useful in order to spawn child processes with
* the same execution environment as the parent.
*
* ```bash
* node --icu-data-dir=./foo --require ./bar.js script.js --version
* ```
*
* Results in `process.execArgv`:
*
* ```js
* ["--icu-data-dir=./foo", "--require", "./bar.js"]
* ```
*
* And `process.argv`:
*
* ```js
* ['/usr/local/bin/node', 'script.js', '--version']
* ```
*
* Refer to `Worker constructor` for the detailed behavior of worker
* threads with this property.
* @since v0.7.7
*/
execArgv: string[];
/**
* The `process.execPath` property returns the absolute pathname of the executable
* that started the Node.js process. Symbolic links, if any, are resolved.
*
* ```js
* '/usr/local/bin/node'
* ```
* @since v0.1.100
*/
execPath: string;
/**
* The `process.abort()` method causes the Node.js process to exit immediately and
* generate a core file.
*
* This feature is not available in `Worker` threads.
* @since v0.7.0
*/
abort(): never;
/**
* The `process.chdir()` method changes the current working directory of the
* Node.js process or throws an exception if doing so fails (for instance, if
* the specified `directory` does not exist).
*
* ```js
* import { chdir, cwd } from 'node:process';
*
* console.log(`Starting directory: ${cwd()}`);
* try {
* chdir('/tmp');
* console.log(`New directory: ${cwd()}`);
* } catch (err) {
* console.error(`chdir: ${err}`);
* }
* ```
*
* This feature is not available in `Worker` threads.
* @since v0.1.17
*/
chdir(directory: string): void;
/**
* The `process.cwd()` method returns the current working directory of the Node.js
* process.
*
* ```js
* import { cwd } from 'node:process';
*
* console.log(`Current directory: ${cwd()}`);
* ```
* @since v0.1.8
*/
cwd(): string;
/**
* The port used by the Node.js debugger when enabled.
*
* ```js
* import process from 'node:process';
*
* process.debugPort = 5858;
* ```
* @since v0.7.2
*/
debugPort: number;
/**
* The `process.dlopen()` method allows dynamically loading shared objects. It is primarily used by `require()` to load C++ Addons, and
* should not be used directly, except in special cases. In other words, `require()` should be preferred over `process.dlopen()`
* unless there are specific reasons such as custom dlopen flags or loading from ES modules.
*
* The `flags` argument is an integer that allows to specify dlopen behavior. See the `[os.constants.dlopen](https://nodejs.org/docs/latest-v22.x/api/os.html#dlopen-constants)`
* documentation for details.
*
* An important requirement when calling `process.dlopen()` is that the `module` instance must be passed. Functions exported by the C++ Addon
* are then accessible via `module.exports`.
*
* The example below shows how to load a C++ Addon, named `local.node`, that exports a `foo` function. All the symbols are loaded before the call returns, by passing the `RTLD_NOW` constant.
* In this example the constant is assumed to be available.
*
* ```js
* import { dlopen } from 'node:process';
* import { constants } from 'node:os';
* import { fileURLToPath } from 'node:url';
*
* const module = { exports: {} };
* dlopen(module, fileURLToPath(new URL('local.node', import.meta.url)),
* constants.dlopen.RTLD_NOW);
* module.exports.foo();
* ```
*/
dlopen(module: object, filename: string, flags?: number): void;
/**
* The `process.emitWarning()` method can be used to emit custom or application
* specific process warnings. These can be listened for by adding a handler to the `'warning'` event.
*
* ```js
* import { emitWarning } from 'node:process';
*
* // Emit a warning using a string.
* emitWarning('Something happened!');
* // Emits: (node: 56338) Warning: Something happened!
* ```
*
* ```js
* import { emitWarning } from 'node:process';
*
* // Emit a warning using a string and a type.
* emitWarning('Something Happened!', 'CustomWarning');
* // Emits: (node:56338) CustomWarning: Something Happened!
* ```
*
* ```js
* import { emitWarning } from 'node:process';
*
* emitWarning('Something happened!', 'CustomWarning', 'WARN001');
* // Emits: (node:56338) [WARN001] CustomWarning: Something happened!
* ```js
*
* In each of the previous examples, an `Error` object is generated internally by `process.emitWarning()` and passed through to the `'warning'` handler.
*
* ```js
* import process from 'node:process';
*
* process.on('warning', (warning) => {
* console.warn(warning.name); // 'Warning'
* console.warn(warning.message); // 'Something happened!'
* console.warn(warning.code); // 'MY_WARNING'
* console.warn(warning.stack); // Stack trace
* console.warn(warning.detail); // 'This is some additional information'
* });
* ```
*
* If `warning` is passed as an `Error` object, it will be passed through to the `'warning'` event handler
* unmodified (and the optional `type`, `code` and `ctor` arguments will be ignored):
*
* ```js
* import { emitWarning } from 'node:process';
*
* // Emit a warning using an Error object.
* const myWarning = new Error('Something happened!');
* // Use the Error name property to specify the type name
* myWarning.name = 'CustomWarning';
* myWarning.code = 'WARN001';
*
* emitWarning(myWarning);
* // Emits: (node:56338) [WARN001] CustomWarning: Something happened!
* ```
*
* A `TypeError` is thrown if `warning` is anything other than a string or `Error` object.
*
* While process warnings use `Error` objects, the process warning mechanism is not a replacement for normal error handling mechanisms.
*
* The following additional handling is implemented if the warning `type` is `'DeprecationWarning'`:
* * If the `--throw-deprecation` command-line flag is used, the deprecation warning is thrown as an exception rather than being emitted as an event.
* * If the `--no-deprecation` command-line flag is used, the deprecation warning is suppressed.
* * If the `--trace-deprecation` command-line flag is used, the deprecation warning is printed to `stderr` along with the full stack trace.
* @since v8.0.0
* @param warning The warning to emit.
*/
emitWarning(warning: string | Error, ctor?: Function): void;
emitWarning(warning: string | Error, type?: string, ctor?: Function): void;
emitWarning(warning: string | Error, type?: string, code?: string, ctor?: Function): void;
emitWarning(warning: string | Error, options?: EmitWarningOptions): void;
/**
* The `process.env` property returns an object containing the user environment.
* See [`environ(7)`](http://man7.org/linux/man-pages/man7/environ.7.html).
*
* An example of this object looks like:
*
* ```js
* {
* TERM: 'xterm-256color',
* SHELL: '/usr/local/bin/bash',
* USER: 'maciej',
* PATH: '~/.bin/:/usr/bin:/bin:/usr/sbin:/sbin:/usr/local/bin',
* PWD: '/Users/maciej',
* EDITOR: 'vim',
* SHLVL: '1',
* HOME: '/Users/maciej',
* LOGNAME: 'maciej',
* _: '/usr/local/bin/node'
* }
* ```
*
* It is possible to modify this object, but such modifications will not be
* reflected outside the Node.js process, or (unless explicitly requested)
* to other `Worker` threads.
* In other words, the following example would not work:
*
* ```bash
* node -e 'process.env.foo = "bar"' && echo $foo
* ```
*
* While the following will:
*
* ```js
* import { env } from 'node:process';
*
* env.foo = 'bar';
* console.log(env.foo);
* ```
*
* Assigning a property on `process.env` will implicitly convert the value
* to a string. **This behavior is deprecated.** Future versions of Node.js may
* throw an error when the value is not a string, number, or boolean.
*
* ```js
* import { env } from 'node:process';
*
* env.test = null;
* console.log(env.test);
* // => 'null'
* env.test = undefined;
* console.log(env.test);
* // => 'undefined'
* ```
*
* Use `delete` to delete a property from `process.env`.
*
* ```js
* import { env } from 'node:process';
*
* env.TEST = 1;
* delete env.TEST;
* console.log(env.TEST);
* // => undefined
* ```
*
* On Windows operating systems, environment variables are case-insensitive.
*
* ```js
* import { env } from 'node:process';
*
* env.TEST = 1;
* console.log(env.test);
* // => 1
* ```
*
* Unless explicitly specified when creating a `Worker` instance,
* each `Worker` thread has its own copy of `process.env`, based on its
* parent thread's `process.env`, or whatever was specified as the `env` option
* to the `Worker` constructor. Changes to `process.env` will not be visible
* across `Worker` threads, and only the main thread can make changes that
* are visible to the operating system or to native add-ons. On Windows, a copy of `process.env` on a `Worker` instance operates in a case-sensitive manner
* unlike the main thread.
* @since v0.1.27
*/
env: ProcessEnv;
/**
* The `process.exit()` method instructs Node.js to terminate the process
* synchronously with an exit status of `code`. If `code` is omitted, exit uses
* either the 'success' code `0` or the value of `process.exitCode` if it has been
* set. Node.js will not terminate until all the `'exit'` event listeners are
* called.
*
* To exit with a 'failure' code:
*
* ```js
* import { exit } from 'node:process';
*
* exit(1);
* ```
*
* The shell that executed Node.js should see the exit code as `1`.
*
* Calling `process.exit()` will force the process to exit as quickly as possible
* even if there are still asynchronous operations pending that have not yet
* completed fully, including I/O operations to `process.stdout` and `process.stderr`.
*
* In most situations, it is not actually necessary to call `process.exit()` explicitly. The Node.js process will exit on its own _if there is no additional_
* _work pending_ in the event loop. The `process.exitCode` property can be set to
* tell the process which exit code to use when the process exits gracefully.
*
* For instance, the following example illustrates a _misuse_ of the `process.exit()` method that could lead to data printed to stdout being
* truncated and lost:
*
* ```js
* import { exit } from 'node:process';
*
* // This is an example of what *not* to do:
* if (someConditionNotMet()) {
* printUsageToStdout();
* exit(1);
* }
* ```
*
* The reason this is problematic is because writes to `process.stdout` in Node.js
* are sometimes _asynchronous_ and may occur over multiple ticks of the Node.js
* event loop. Calling `process.exit()`, however, forces the process to exit _before_ those additional writes to `stdout` can be performed.
*
* Rather than calling `process.exit()` directly, the code _should_ set the `process.exitCode` and allow the process to exit naturally by avoiding
* scheduling any additional work for the event loop:
*
* ```js
* import process from 'node:process';
*
* // How to properly set the exit code while letting
* // the process exit gracefully.
* if (someConditionNotMet()) {
* printUsageToStdout();
* process.exitCode = 1;
* }
* ```
*
* If it is necessary to terminate the Node.js process due to an error condition,
* throwing an _uncaught_ error and allowing the process to terminate accordingly
* is safer than calling `process.exit()`.
*
* In `Worker` threads, this function stops the current thread rather
* than the current process.
* @since v0.1.13
* @param [code=0] The exit code. For string type, only integer strings (e.g.,'1') are allowed.
*/
exit(code?: number | string | null | undefined): never;
/**
* A number which will be the process exit code, when the process either
* exits gracefully, or is exited via {@link exit} without specifying
* a code.
*
* Specifying a code to {@link exit} will override any
* previous setting of `process.exitCode`.
* @default undefined
* @since v0.11.8
*/
exitCode?: number | string | number | undefined;
/**
* The `process.getActiveResourcesInfo()` method returns an array of strings containing
* the types of the active resources that are currently keeping the event loop alive.
*
* ```js
* import { getActiveResourcesInfo } from 'node:process';
* import { setTimeout } from 'node:timers';
* console.log('Before:', getActiveResourcesInfo());
* setTimeout(() => {}, 1000);
* console.log('After:', getActiveResourcesInfo());
* // Prints:
* // Before: [ 'TTYWrap', 'TTYWrap', 'TTYWrap' ]
* // After: [ 'TTYWrap', 'TTYWrap', 'TTYWrap', 'Timeout' ]
* ```
* @since v17.3.0, v16.14.0
*/
getActiveResourcesInfo(): string[];
/**
* 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 'node: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 'node: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 'node: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 'node: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 'node: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 'node: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 'node: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 'node: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 'node: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 'node: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