@node-red/editor-client 3.0.2 → 3.1.0-beta.2

package/public/types/node/os.d.ts

@@ -1,6 +1,15 @@
 
 /* NOTE: Do not edit directly! This file is generated using `npm run update-types` in https://github.com/Steve-Mcl/monaco-editor-esm-i18n */
 
+/**
+ * The `os` module provides operating system-related utility methods and
+ * properties. It can be accessed using:
+ *
+ * ```js
+ * const os = require('os');
+ * ```
+ * @see [source](https://github.com/nodejs/node/blob/v16.9.0/lib/os.js)
+ */
 declare module 'os' {
     interface CpuInfo {
         model: string;
@@ -13,7 +22,6 @@ declare module 'os' {
             irq: number;
         };
     }
-
     interface NetworkInterfaceBase {
         address: string;
         netmask: string;
@@ -21,16 +29,13 @@ declare module 'os' {
         internal: boolean;
         cidr: string | null;
     }
-
     interface NetworkInterfaceInfoIPv4 extends NetworkInterfaceBase {
-        family: "IPv4";
+        family: 'IPv4';
     }
-
     interface NetworkInterfaceInfoIPv6 extends NetworkInterfaceBase {
-        family: "IPv6";
+        family: 'IPv6';
         scopeid: number;
     }
-
     interface UserInfo<T> {
         username: T;
         uid: number;
@@ -38,26 +43,197 @@ declare module 'os' {
         shell: T;
         homedir: T;
     }
-
     type NetworkInterfaceInfo = NetworkInterfaceInfoIPv4 | NetworkInterfaceInfoIPv6;
-
+    /**
+     * Returns the host name of the operating system as a string.
+     * @since v0.3.3
+     */
     function hostname(): string;
+    /**
+     * Returns an array containing the 1, 5, and 15 minute load averages.
+     *
+     * The load average is a measure of system activity calculated by the operating
+     * system and expressed as a fractional number.
+     *
+     * The load average is a Unix-specific concept. On Windows, the return value is
+     * always `[0, 0, 0]`.
+     * @since v0.3.3
+     */
     function loadavg(): number[];
+    /**
+     * Returns the system uptime in number of seconds.
+     * @since v0.3.3
+     */
     function uptime(): number;
+    /**
+     * Returns the amount of free system memory in bytes as an integer.
+     * @since v0.3.3
+     */
     function freemem(): number;
+    /**
+     * Returns the total amount of system memory in bytes as an integer.
+     * @since v0.3.3
+     */
     function totalmem(): number;
+    /**
+     * Returns an array of objects containing information about each logical CPU core.
+     *
+     * The properties included on each object include:
+     *
+     * ```js
+     * [
+     *   {
+     *     model: 'Intel(R) Core(TM) i7 CPU         860  @ 2.80GHz',
+     *     speed: 2926,
+     *     times: {
+     *       user: 252020,
+     *       nice: 0,
+     *       sys: 30340,
+     *       idle: 1070356870,
+     *       irq: 0
+     *     }
+     *   },
+     *   {
+     *     model: 'Intel(R) Core(TM) i7 CPU         860  @ 2.80GHz',
+     *     speed: 2926,
+     *     times: {
+     *       user: 306960,
+     *       nice: 0,
+     *       sys: 26980,
+     *       idle: 1071569080,
+     *       irq: 0
+     *     }
+     *   },
+     *   {
+     *     model: 'Intel(R) Core(TM) i7 CPU         860  @ 2.80GHz',
+     *     speed: 2926,
+     *     times: {
+     *       user: 248450,
+     *       nice: 0,
+     *       sys: 21750,
+     *       idle: 1070919370,
+     *       irq: 0
+     *     }
+     *   },
+     *   {
+     *     model: 'Intel(R) Core(TM) i7 CPU         860  @ 2.80GHz',
+     *     speed: 2926,
+     *     times: {
+     *       user: 256880,
+     *       nice: 0,
+     *       sys: 19430,
+     *       idle: 1070905480,
+     *       irq: 20
+     *     }
+     *   },
+     * ]
+     * ```
+     *
+     * `nice` values are POSIX-only. On Windows, the `nice` values of all processors
+     * are always 0.
+     * @since v0.3.3
+     */
     function cpus(): CpuInfo[];
+    /**
+     * Returns the operating system name as returned by [`uname(3)`](https://linux.die.net/man/3/uname). For example, it
+     * returns `'Linux'` on Linux, `'Darwin'` on macOS, and `'Windows_NT'` on Windows.
+     *
+     * See [https://en.wikipedia.org/wiki/Uname#Examples](https://en.wikipedia.org/wiki/Uname#Examples) for additional information
+     * about the output of running [`uname(3)`](https://linux.die.net/man/3/uname) on various operating systems.
+     * @since v0.3.3
+     */
     function type(): string;
+    /**
+     * Returns the operating system as a string.
+     *
+     * On POSIX systems, the operating system release is determined by calling [`uname(3)`](https://linux.die.net/man/3/uname). On Windows, `GetVersionExW()` is used. See
+     * [https://en.wikipedia.org/wiki/Uname#Examples](https://en.wikipedia.org/wiki/Uname#Examples) for more information.
+     * @since v0.3.3
+     */
     function release(): string;
+    /**
+     * Returns an object containing network interfaces that have been assigned a
+     * network address.
+     *
+     * Each key on the returned object identifies a network interface. The associated
+     * value is an array of objects that each describe an assigned network address.
+     *
+     * The properties available on the assigned network address object include:
+     *
+     * ```js
+     * {
+     *   lo: [
+     *     {
+     *       address: '127.0.0.1',
+     *       netmask: '255.0.0.0',
+     *       family: 'IPv4',
+     *       mac: '00:00:00:00:00:00',
+     *       internal: true,
+     *       cidr: '127.0.0.1/8'
+     *     },
+     *     {
+     *       address: '::1',
+     *       netmask: 'ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff',
+     *       family: 'IPv6',
+     *       mac: '00:00:00:00:00:00',
+     *       scopeid: 0,
+     *       internal: true,
+     *       cidr: '::1/128'
+     *     }
+     *   ],
+     *   eth0: [
+     *     {
+     *       address: '192.168.1.108',
+     *       netmask: '255.255.255.0',
+     *       family: 'IPv4',
+     *       mac: '01:02:03:0a:0b:0c',
+     *       internal: false,
+     *       cidr: '192.168.1.108/24'
+     *     },
+     *     {
+     *       address: 'fe80::a00:27ff:fe4e:66a1',
+     *       netmask: 'ffff:ffff:ffff:ffff::',
+     *       family: 'IPv6',
+     *       mac: '01:02:03:0a:0b:0c',
+     *       scopeid: 1,
+     *       internal: false,
+     *       cidr: 'fe80::a00:27ff:fe4e:66a1/64'
+     *     }
+     *   ]
+     * }
+     * ```
+     * @since v0.6.0
+     */
     function networkInterfaces(): NodeJS.Dict<NetworkInterfaceInfo[]>;
+    /**
+     * Returns the string path of the current user's home directory.
+     *
+     * On POSIX, it uses the `$HOME` environment variable if defined. Otherwise it
+     * uses the [effective UID](https://en.wikipedia.org/wiki/User_identifier#Effective_user_ID) to look up the user's home directory.
+     *
+     * On Windows, it uses the `USERPROFILE` environment variable if defined.
+     * Otherwise it uses the path to the profile directory of the current user.
+     * @since v2.3.0
+     */
     function homedir(): string;
+    /**
+     * Returns information about the currently effective user. On POSIX platforms,
+     * this is typically a subset of the password file. The returned object includes
+     * the `username`, `uid`, `gid`, `shell`, and `homedir`. On Windows, the `uid` and`gid` fields are `-1`, and `shell` is `null`.
+     *
+     * The value of `homedir` returned by `os.userInfo()` is provided by the operating
+     * system. This differs from the result of `os.homedir()`, which queries
+     * environment variables for the home directory before falling back to the
+     * operating system response.
+     *
+     * Throws a `SystemError` if a user has no `username` or `homedir`.
+     * @since v6.0.0
+     */
     function userInfo(options: { encoding: 'buffer' }): UserInfo<Buffer>;
     function userInfo(options?: { encoding: BufferEncoding }): UserInfo<string>;
-
     type SignalConstants = {
         [key in NodeJS.Signals]: number;
     };
-
     namespace constants {
         const UV_UDP_REUSEADDR: number;
         namespace signals {}
@@ -210,34 +386,71 @@ declare module 'os' {
             const PRIORITY_HIGHEST: number;
         }
     }
-
+    const devNull: string;
+    const EOL: string;
+    /**
+     * Returns 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'`.
+     *
+     * The return value is equivalent to `process.arch`.
+     * @since v0.5.0
+     */
     function arch(): string;
     /**
      * Returns a string identifying the kernel version.
-     * On POSIX systems, the operating system release is determined by calling
-     * [uname(3)][]. On Windows, `pRtlGetVersion` is used, and if it is not available,
-     * `GetVersionExW()` will be used. See
-     * https://en.wikipedia.org/wiki/Uname#Examples for more information.
+     *
+     * On POSIX systems, the operating system release is determined by calling [`uname(3)`](https://linux.die.net/man/3/uname). On Windows, `RtlGetVersion()` is used, and if it is not
+     * available, `GetVersionExW()` will be used. See [https://en.wikipedia.org/wiki/Uname#Examples](https://en.wikipedia.org/wiki/Uname#Examples) for more information.
+     * @since v13.11.0, v12.17.0
      */
     function version(): string;
+    /**
+     * Returns a string identifying the operating system platform. The value is set
+     * at compile time. Possible values are `'aix'`, `'darwin'`, `'freebsd'`,`'linux'`, `'openbsd'`, `'sunos'`, and `'win32'`.
+     *
+     * The return value is equivalent to `process.platform`.
+     *
+     * The value `'android'` may also be returned if Node.js is built on the Android
+     * operating system. [Android support is experimental](https://github.com/nodejs/node/blob/HEAD/BUILDING.md#androidandroid-based-devices-eg-firefox-os).
+     * @since v0.5.0
+     */
     function platform(): NodeJS.Platform;
+    /**
+     * Returns the operating system's default directory for temporary files as a
+     * string.
+     * @since v0.9.9
+     */
     function tmpdir(): string;
-    const EOL: string;
-    function endianness(): "BE" | "LE";
     /**
-     * Gets the priority of a process.
-     * Defaults to current process.
+     * Returns a string identifying the endianness of the CPU for which the Node.js
+     * binary was compiled.
+     *
+     * Possible values are `'BE'` for big endian and `'LE'` for little endian.
+     * @since v0.9.4
      */
-    function getPriority(pid?: number): number;
+    function endianness(): 'BE' | 'LE';
     /**
-     * Sets the priority of the current process.
-     * @param priority Must be in range of -20 to 19
+     * Returns the scheduling priority for the process specified by `pid`. If `pid` is
+     * not provided or is `0`, the priority of the current process is returned.
+     * @since v10.10.0
+     * @param [pid=0] The process ID to retrieve scheduling priority for.
      */
-    function setPriority(priority: number): void;
+    function getPriority(pid?: number): number;
     /**
-     * Sets the priority of the process specified process.
-     * @param priority Must be in range of -20 to 19
+     * Attempts to set the scheduling priority for the process specified by `pid`. If`pid` is not provided or is `0`, the process ID of the current process is used.
+     *
+     * The `priority` input must be an integer between `-20` (high priority) and `19`(low priority). Due to differences between Unix priority levels and Windows
+     * priority classes, `priority` is mapped to one of six priority constants in`os.constants.priority`. When retrieving a process priority level, this range
+     * mapping may cause the return value to be slightly different on Windows. To avoid
+     * confusion, set `priority` to one of the priority constants.
+     *
+     * On Windows, setting priority to `PRIORITY_HIGHEST` requires elevated user
+     * privileges. Otherwise the set priority will be silently reduced to`PRIORITY_HIGH`.
+     * @since v10.10.0
+     * @param [pid=0] The process ID to set scheduling priority for.
+     * @param priority The scheduling priority to assign to the process.
      */
+    function setPriority(priority: number): void;
     function setPriority(pid: number, priority: number): void;
 }
 declare module 'node:os' {

package/public/types/node/path.d.ts

@@ -1,6 +1,23 @@
 
 /* NOTE: Do not edit directly! This file is generated using `npm run update-types` in https://github.com/Steve-Mcl/monaco-editor-esm-i18n */
 
+declare module 'path/posix' {
+    import path = require('path');
+    export = path;
+}
+declare module 'path/win32' {
+    import path = require('path');
+    export = path;
+}
+/**
+ * The `path` module provides utilities for working with file and directory paths.
+ * It can be accessed using:
+ *
+ * ```js
+ * const path = require('path');
+ * ```
+ * @see [source](https://github.com/nodejs/node/blob/v16.9.0/lib/path.js)
+ */
 declare module 'path' {
     namespace path {
         /**
@@ -28,7 +45,6 @@ declare module 'path' {
              */
             name: string;
         }
-
         interface FormatInputPathObject {
             /**
              * The root of the path such as '/' or 'c:\'
@@ -51,24 +67,24 @@ declare module 'path' {
              */
             name?: string | undefined;
         }
-
         interface PlatformPath {
             /**
              * Normalize a string path, reducing '..' and '.' parts.
              * When multiple slashes are found, they're replaced by a single one; when the path contains a trailing slash, it is preserved. On Windows backslashes are used.
              *
-             * @param p string path to normalize.
+             * @param path string path to normalize.
+             * @throws {TypeError} if `path` is not a string.
              */
-            normalize(p: string): string;
+            normalize(path: string): string;
             /**
              * Join all arguments together and normalize the resulting path.
-             * Arguments must be strings. In v0.8, non-string arguments were silently ignored. In v0.10 and up, an exception is thrown.
              *
              * @param paths paths to join.
+             * @throws {TypeError} if any of the path segments is not a string.
              */
             join(...paths: string[]): string;
             /**
-             * The right-most parameter is considered {to}.  Other parameters are considered an array of {from}.
+             * The right-most parameter is considered {to}. Other parameters are considered an array of {from}.
              *
              * Starting from leftmost {from} parameter, resolves {to} to an absolute path.
              *
@@ -77,61 +93,71 @@ declare module 'path' {
              * the current working directory is used as well. The resulting path is normalized,
              * and trailing slashes are removed unless the path gets resolved to the root directory.
              *
-             * @param pathSegments string paths to join.  Non-string arguments are ignored.
+             * @param paths string paths to join.
+             * @throws {TypeError} if any of the arguments is not a string.
              */
-            resolve(...pathSegments: string[]): string;
+            resolve(...paths: string[]): string;
             /**
              * Determines whether {path} is an absolute path. An absolute path will always resolve to the same location, regardless of the working directory.
              *
+             * If the given {path} is a zero-length string, `false` will be returned.
+             *
              * @param path path to test.
+             * @throws {TypeError} if `path` is not a string.
              */
-            isAbsolute(p: string): boolean;
+            isAbsolute(path: string): boolean;
             /**
-             * Solve the relative path from {from} to {to}.
+             * Solve the relative path from {from} to {to} based on the current working directory.
              * At times we have two absolute paths, and we need to derive the relative path from one to the other. This is actually the reverse transform of path.resolve.
+             *
+             * @throws {TypeError} if either `from` or `to` is not a string.
              */
             relative(from: string, to: string): string;
             /**
              * Return the directory name of a path. Similar to the Unix dirname command.
              *
-             * @param p the path to evaluate.
+             * @param path the path to evaluate.
+             * @throws {TypeError} if `path` is not a string.
              */
-            dirname(p: string): string;
+            dirname(path: string): string;
             /**
              * Return the last portion of a path. Similar to the Unix basename command.
              * Often used to extract the file name from a fully qualified path.
              *
-             * @param p the path to evaluate.
+             * @param path the path to evaluate.
              * @param ext optionally, an extension to remove from the result.
+             * @throws {TypeError} if `path` is not a string or if `ext` is given and is not a string.
              */
-            basename(p: string, ext?: string): string;
+            basename(path: string, ext?: string): string;
             /**
              * Return the extension of the path, from the last '.' to end of string in the last portion of the path.
-             * If there is no '.' in the last portion of the path or the first character of it is '.', then it returns an empty string
+             * If there is no '.' in the last portion of the path or the first character of it is '.', then it returns an empty string.
              *
-             * @param p the path to evaluate.
+             * @param path the path to evaluate.
+             * @throws {TypeError} if `path` is not a string.
              */
-            extname(p: string): string;
+            extname(path: string): string;
             /**
              * The platform-specific file separator. '\\' or '/'.
              */
-            readonly sep: string;
+            readonly sep: '\\' | '/';
             /**
              * The platform-specific file delimiter. ';' or ':'.
              */
-            readonly delimiter: string;
+            readonly delimiter: ';' | ':';
             /**
              * Returns an object from a path string - the opposite of format().
              *
-             * @param pathString path to evaluate.
+             * @param path path to evaluate.
+             * @throws {TypeError} if `path` is not a string.
              */
-            parse(p: string): ParsedPath;
+            parse(path: string): ParsedPath;
             /**
              * Returns a path string from an object - the opposite of parse().
              *
-             * @param pathString path to evaluate.
+             * @param pathObject path to evaluate.
              */
-            format(pP: FormatInputPathObject): string;
+            format(pathObject: FormatInputPathObject): string;
             /**
              * On Windows systems only, returns an equivalent namespace-prefixed path for the given path.
              * If path is not a string, path will be returned without modifications.
@@ -158,3 +184,11 @@ declare module 'node:path' {
     import path = require('path');
     export = path;
 }
+declare module 'node:path/posix' {
+    import path = require('path/posix');
+    export = path;
+}
+declare module 'node:path/win32' {
+    import path = require('path/win32');
+    export = path;
+}