@types/node 18.11.5 → 20.2.5

node/ts4.8/util.d.ts

@@ -1,33 +1,49 @@
 /**
- * The `util` module supports the needs of Node.js internal APIs. Many of the
+ * The `node:util` module supports the needs of Node.js internal APIs. Many of the
  * utilities are useful for application and module developers as well. To access
  * it:
  *
  * ```js
- * const util = require('util');
+ * const util = require('node:util');
  * ```
- * @see [source](https://github.com/nodejs/node/blob/v18.0.0/lib/util.js)
+ * @see [source](https://github.com/nodejs/node/blob/v20.2.0/lib/util.js)
  */
 declare module 'util' {
     import * as types from 'node:util/types';
     export interface InspectOptions {
         /**
-         * If set to `true`, getters are going to be
-         * inspected as well. If set to `'get'` only getters without setter are going
-         * to be inspected. If set to `'set'` only getters having a corresponding
-         * setter are going to be inspected. This might cause side effects depending on
-         * the getter function.
-         * @default `false`
+         * If `true`, object's non-enumerable symbols and properties are included in the formatted result.
+         * `WeakMap` and `WeakSet` entries are also included as well as user defined prototype properties (excluding method properties).
+         * @default false
          */
-        getters?: 'get' | 'set' | boolean | undefined;
         showHidden?: boolean | undefined;
         /**
+         * Specifies the number of times to recurse while formatting object.
+         * This is useful for inspecting large objects.
+         * To recurse up to the maximum call stack size pass `Infinity` or `null`.
          * @default 2
          */
         depth?: number | null | undefined;
+        /**
+         * If `true`, the output is styled with ANSI color codes. Colors are customizable.
+         */
         colors?: boolean | undefined;
+        /**
+         * If `false`, `[util.inspect.custom](depth, opts, inspect)` functions are not invoked.
+         * @default true
+         */
         customInspect?: boolean | undefined;
+        /**
+         * If `true`, `Proxy` inspection includes the target and handler objects.
+         * @default false
+         */
         showProxy?: boolean | undefined;
+        /**
+         * Specifies the maximum number of `Array`, `TypedArray`, `WeakMap`, and `WeakSet` elements
+         * to include when formatting. Set to `null` or `Infinity` to show all elements.
+         * Set to `0` or negative to show no elements.
+         * @default 100
+         */
         maxArrayLength?: number | null | undefined;
         /**
          * Specifies the maximum number of characters to
@@ -36,6 +52,12 @@ declare module 'util' {
          * @default 10000
          */
         maxStringLength?: number | null | undefined;
+        /**
+         * The length at which input values are split across multiple lines.
+         * Set to `Infinity` to format the input as a single line
+         * (in combination with `compact` set to `true` or any number >= `1`).
+         * @default 80
+         */
         breakLength?: number | undefined;
         /**
          * Setting this to `false` causes each object key
@@ -45,13 +67,33 @@ declare module 'util' {
          * `breakLength`. Short array elements are also grouped together. Note that no
          * text will be reduced below 16 characters, no matter the `breakLength` size.
          * For more information, see the example below.
-         * @default `true`
+         * @default true
          */
         compact?: boolean | number | undefined;
+        /**
+         * If set to `true` or a function, all properties of an object, and `Set` and `Map`
+         * entries are sorted in the resulting string.
+         * If set to `true` the default sort is used.
+         * If set to a function, it is used as a compare function.
+         */
         sorted?: boolean | ((a: string, b: string) => number) | undefined;
+        /**
+         * If set to `true`, getters are going to be
+         * inspected as well. If set to `'get'` only getters without setter are going
+         * to be inspected. If set to `'set'` only getters having a corresponding
+         * setter are going to be inspected. This might cause side effects depending on
+         * the getter function.
+         * @default false
+         */
+        getters?: 'get' | 'set' | boolean | undefined;
+        /**
+         * If set to `true`, an underscore is used to separate every three digits in all bigints and numbers.
+         * @default false
+         */
+        numericSeparator?: boolean | undefined;
     }
     export type Style = 'special' | 'number' | 'bigint' | 'boolean' | 'undefined' | 'null' | 'string' | 'symbol' | 'date' | 'regexp' | 'module';
-    export type CustomInspectFunction = (depth: number, options: InspectOptionsStylized) => string;
+    export type CustomInspectFunction = (depth: number, options: InspectOptionsStylized) => any; // TODO: , inspect: inspect
     export interface InspectOptionsStylized extends InspectOptions {
         stylize(text: string, styleType: Style): string;
     }
@@ -147,7 +189,7 @@ declare module 'util' {
      * timestamp.
      *
      * ```js
-     * const util = require('util');
+     * const util = require('node:util');
      *
      * util.log('Timestamped message.');
      * ```
@@ -166,12 +208,12 @@ declare module 'util' {
      * Creates and returns an `AbortController` instance whose `AbortSignal` is marked
      * as transferable and can be used with `structuredClone()` or `postMessage()`.
      * @since v18.11.0
+     * @experimental
      * @returns A transferable AbortController
      */
     export function transferableAbortController(): AbortController;
     /**
-     * Marks the given {AbortSignal} as transferable so that it can be used with
-     * `structuredClone()` and `postMessage()`.
+     * Marks the given `AbortSignal` as transferable so that it can be used with`structuredClone()` and `postMessage()`.
      *
      * ```js
      * const signal = transferableAbortSignal(AbortSignal.timeout(100));
@@ -179,10 +221,35 @@ declare module 'util' {
      * channel.port2.postMessage(signal, [signal]);
      * ```
      * @since v18.11.0
+     * @experimental
      * @param signal The AbortSignal
      * @returns The same AbortSignal
      */
     export function transferableAbortSignal(signal: AbortSignal): AbortSignal;
+    /**
+     * Listens to abort event on the provided `signal` and
+     * returns a promise that is fulfilled when the `signal` is
+     * aborted. If the passed `resource` is garbage collected before the `signal` is
+     * aborted, the returned promise shall remain pending indefinitely.
+     *
+     * ```js
+     * import { aborted } from 'node:util';
+     *
+     * const dependent = obtainSomethingAbortable();
+     *
+     * aborted(dependent.signal, dependent).then(() => {
+     *   // Do something when dependent is aborted.
+     * });
+     *
+     * dependent.on('event', () => {
+     *   dependent.abort();
+     * });
+     * ```
+     * @since v19.7.0
+     * @experimental
+     * @param resource Any non-null entity, reference to which is held weakly.
+     */
+    export function aborted(signal: AbortSignal, resource: any): Promise<void>;
     /**
      * The `util.inspect()` method returns a string representation of `object` that is
      * intended for debugging. The output of `util.inspect` may change at any time
@@ -209,7 +276,7 @@ declare module 'util' {
      * Circular references point to their anchor by using a reference index:
      *
      * ```js
-     * const { inspect } = require('util');
+     * const { inspect } = require('node:util');
      *
      * const obj = {};
      * obj.a = [obj];
@@ -227,7 +294,7 @@ declare module 'util' {
      * The following example inspects all properties of the `util` object:
      *
      * ```js
-     * const util = require('util');
+     * const util = require('node:util');
      *
      * console.log(util.inspect(util, { showHidden: true, depth: null }));
      * ```
@@ -235,7 +302,7 @@ declare module 'util' {
      * The following example highlights the effect of the `compact` option:
      *
      * ```js
-     * const util = require('util');
+     * const util = require('node:util');
      *
      * const o = {
      *   a: [1, 2, [[
@@ -243,7 +310,7 @@ declare module 'util' {
      *       'eiusmod \ntempor incididunt ut labore et dolore magna aliqua.',
      *     'test',
      *     'foo']], 4],
-     *   b: new Map([['za', 1], ['zb', 'test']])
+     *   b: new Map([['za', 1], ['zb', 'test']]),
      * };
      * console.log(util.inspect(o, { compact: true, depth: 5, breakLength: 80 }));
      *
@@ -292,7 +359,7 @@ declare module 'util' {
      * with no remaining strong references may be garbage collected at any time.
      *
      * ```js
-     * const { inspect } = require('util');
+     * const { inspect } = require('node:util');
      *
      * const obj = { a: 1 };
      * const obj2 = { b: 2 };
@@ -306,13 +373,13 @@ declare module 'util' {
      * impact the result of `util.inspect()`.
      *
      * ```js
-     * const { inspect } = require('util');
-     * const assert = require('assert');
+     * const { inspect } = require('node:util');
+     * const assert = require('node:assert');
      *
      * const o1 = {
      *   b: [2, 3, 1],
      *   a: '`a` comes before `b`',
-     *   c: new Set([2, 3, 1])
+     *   c: new Set([2, 3, 1]),
      * };
      * console.log(inspect(o1, { sorted: true }));
      * // { a: '`a` comes before `b`', b: [ 2, 3, 1 ], c: Set(3) { 1, 2, 3 } }
@@ -322,11 +389,11 @@ declare module 'util' {
      * const o2 = {
      *   c: new Set([2, 1, 3]),
      *   a: '`a` comes before `b`',
-     *   b: [2, 3, 1]
+     *   b: [2, 3, 1],
      * };
      * assert.strict.equal(
      *   inspect(o1, { sorted: true }),
-     *   inspect(o2, { sorted: true })
+     *   inspect(o2, { sorted: true }),
      * );
      * ```
      *
@@ -334,7 +401,7 @@ declare module 'util' {
      * numbers.
      *
      * ```js
-     * const { inspect } = require('util');
+     * const { inspect } = require('node:util');
      *
      * const thousand = 1_000;
      * const million = 1_000_000;
@@ -346,7 +413,7 @@ declare module 'util' {
      * ```
      *
      * `util.inspect()` is a synchronous method intended for debugging. Its maximum
-     * output length is approximately 128 MB. Inputs that result in longer output will
+     * output length is approximately 128 MiB. Inputs that result in longer output will
      * be truncated.
      * @since v0.3.0
      * @param object Any JavaScript primitive or `Object`.
@@ -375,7 +442,7 @@ declare module 'util' {
      * Returns `true` if the given `object` is an `Array`. Otherwise, returns `false`.
      *
      * ```js
-     * const util = require('util');
+     * const util = require('node:util');
      *
      * util.isArray([]);
      * // Returns: true
@@ -392,7 +459,7 @@ declare module 'util' {
      * Returns `true` if the given `object` is a `RegExp`. Otherwise, returns `false`.
      *
      * ```js
-     * const util = require('util');
+     * const util = require('node:util');
      *
      * util.isRegExp(/some regexp/);
      * // Returns: true
@@ -409,7 +476,7 @@ declare module 'util' {
      * Returns `true` if the given `object` is a `Date`. Otherwise, returns `false`.
      *
      * ```js
-     * const util = require('util');
+     * const util = require('node:util');
      *
      * util.isDate(new Date());
      * // Returns: true
@@ -426,7 +493,7 @@ declare module 'util' {
      * Returns `true` if the given `object` is an `Error`. Otherwise, returns`false`.
      *
      * ```js
-     * const util = require('util');
+     * const util = require('node:util');
      *
      * util.isError(new Error());
      * // Returns: true
@@ -440,7 +507,7 @@ declare module 'util' {
      * possible to obtain an incorrect result when the `object` argument manipulates`@@toStringTag`.
      *
      * ```js
-     * const util = require('util');
+     * const util = require('node:util');
      * const obj = { name: 'Error', message: 'an error occurred' };
      *
      * util.isError(obj);
@@ -465,8 +532,8 @@ declare module 'util' {
      * through the `constructor.super_` property.
      *
      * ```js
-     * const util = require('util');
-     * const EventEmitter = require('events');
+     * const util = require('node:util');
+     * const EventEmitter = require('node:events');
      *
      * function MyStream() {
      *   EventEmitter.call(this);
@@ -492,7 +559,7 @@ declare module 'util' {
      * ES6 example using `class` and `extends`:
      *
      * ```js
-     * const EventEmitter = require('events');
+     * const EventEmitter = require('node:events');
      *
      * class MyStream extends EventEmitter {
      *   write(data) {
@@ -508,7 +575,7 @@ declare module 'util' {
      * stream.write('With ES6');
      * ```
      * @since v0.3.0
-     * @deprecated Legacy: Use ES2015 class syntax and `extends` keyword instead.
+     * @legacy Use ES2015 class syntax and `extends` keyword instead.
      */
     export function inherits(constructor: unknown, superConstructor: unknown): void;
     export type DebugLoggerFunction = (msg: string, ...param: unknown[]) => void;
@@ -521,7 +588,7 @@ declare module 'util' {
      * environment variable, then the returned function operates similar to `console.error()`. If not, then the returned function is a no-op.
      *
      * ```js
-     * const util = require('util');
+     * const util = require('node:util');
      * const debuglog = util.debuglog('foo');
      *
      * debuglog('hello from foo [%d]', 123);
@@ -540,7 +607,7 @@ declare module 'util' {
      * The `section` supports wildcard also:
      *
      * ```js
-     * const util = require('util');
+     * const util = require('node:util');
      * const debuglog = util.debuglog('foo-bar');
      *
      * debuglog('hi there, it\'s foo-bar [%d]', 2333);
@@ -560,7 +627,7 @@ declare module 'util' {
      * unnecessary wrapping.
      *
      * ```js
-     * const util = require('util');
+     * const util = require('node:util');
      * let debuglog = util.debuglog('internals', (debug) => {
      *   // Replace with a logging function that optimizes out
      *   // testing if the section is enabled
@@ -578,7 +645,7 @@ declare module 'util' {
      * Returns `true` if the given `object` is a `Boolean`. Otherwise, returns `false`.
      *
      * ```js
-     * const util = require('util');
+     * const util = require('node:util');
      *
      * util.isBoolean(1);
      * // Returns: false
@@ -595,7 +662,7 @@ declare module 'util' {
      * Returns `true` if the given `object` is a `Buffer`. Otherwise, returns `false`.
      *
      * ```js
-     * const util = require('util');
+     * const util = require('node:util');
      *
      * util.isBuffer({ length: 0 });
      * // Returns: false
@@ -612,7 +679,7 @@ declare module 'util' {
      * Returns `true` if the given `object` is a `Function`. Otherwise, returns`false`.
      *
      * ```js
-     * const util = require('util');
+     * const util = require('node:util');
      *
      * function Foo() {}
      * const Bar = () => {};
@@ -632,7 +699,7 @@ declare module 'util' {
      * Returns `true` if the given `object` is strictly `null`. Otherwise, returns`false`.
      *
      * ```js
-     * const util = require('util');
+     * const util = require('node:util');
      *
      * util.isNull(0);
      * // Returns: false
@@ -650,7 +717,7 @@ declare module 'util' {
      * returns `false`.
      *
      * ```js
-     * const util = require('util');
+     * const util = require('node:util');
      *
      * util.isNullOrUndefined(0);
      * // Returns: false
@@ -667,7 +734,7 @@ declare module 'util' {
      * Returns `true` if the given `object` is a `Number`. Otherwise, returns `false`.
      *
      * ```js
-     * const util = require('util');
+     * const util = require('node:util');
      *
      * util.isNumber(false);
      * // Returns: false
@@ -687,7 +754,7 @@ declare module 'util' {
      * Otherwise, returns `false`.
      *
      * ```js
-     * const util = require('util');
+     * const util = require('node:util');
      *
      * util.isObject(5);
      * // Returns: false
@@ -699,14 +766,14 @@ declare module 'util' {
      * // Returns: false
      * ```
      * @since v0.11.5
-     * @deprecated Since v4.0.0 - Deprecated: Use `value !== null && typeof value === 'object'` instead.
+     * @deprecated Since v4.0.0 - Use `value !== null && typeof value === 'object'` instead.
      */
     export function isObject(object: unknown): boolean;
     /**
      * Returns `true` if the given `object` is a primitive type. Otherwise, returns`false`.
      *
      * ```js
-     * const util = require('util');
+     * const util = require('node:util');
      *
      * util.isPrimitive(5);
      * // Returns: true
@@ -735,7 +802,7 @@ declare module 'util' {
      * Returns `true` if the given `object` is a `string`. Otherwise, returns `false`.
      *
      * ```js
-     * const util = require('util');
+     * const util = require('node:util');
      *
      * util.isString('');
      * // Returns: true
@@ -754,7 +821,7 @@ declare module 'util' {
      * Returns `true` if the given `object` is a `Symbol`. Otherwise, returns `false`.
      *
      * ```js
-     * const util = require('util');
+     * const util = require('node:util');
      *
      * util.isSymbol(5);
      * // Returns: false
@@ -771,7 +838,7 @@ declare module 'util' {
      * Returns `true` if the given `object` is `undefined`. Otherwise, returns `false`.
      *
      * ```js
-     * const util = require('util');
+     * const util = require('node:util');
      *
      * const foo = undefined;
      * util.isUndefined(5);
@@ -790,7 +857,7 @@ declare module 'util' {
      * such a way that it is marked as deprecated.
      *
      * ```js
-     * const util = require('util');
+     * const util = require('node:util');
      *
      * exports.obsoleteFunction = util.deprecate(() => {
      *   // Do something here.
@@ -806,7 +873,7 @@ declare module 'util' {
      * the warning will be emitted only once for that `code`.
      *
      * ```js
-     * const util = require('util');
+     * const util = require('node:util');
      *
      * const fn1 = util.deprecate(someFunction, someMessage, 'DEP0001');
      * const fn2 = util.deprecate(someOtherFunction, someOtherMessage, 'DEP0001');
@@ -860,7 +927,7 @@ declare module 'util' {
      * first argument will be the rejection reason (or `null` if the `Promise`resolved), and the second argument will be the resolved value.
      *
      * ```js
-     * const util = require('util');
+     * const util = require('node:util');
      *
      * async function fn() {
      *   return 'hello world';
@@ -899,7 +966,7 @@ declare module 'util' {
      * });
      * ```
      * @since v8.2.0
-     * @param original An `async` function
+     * @param fn An `async` function
      * @return a callback style function
      */
     export function callbackify(fn: () => Promise<void>): (callback: (err: NodeJS.ErrnoException) => void) => void;
@@ -943,8 +1010,8 @@ declare module 'util' {
      * that returns promises.
      *
      * ```js
-     * const util = require('util');
-     * const fs = require('fs');
+     * const util = require('node:util');
+     * const fs = require('node:fs');
      *
      * const stat = util.promisify(fs.stat);
      * stat('.').then((stats) => {
@@ -957,8 +1024,8 @@ declare module 'util' {
      * Or, equivalently using `async function`s:
      *
      * ```js
-     * const util = require('util');
-     * const fs = require('fs');
+     * const util = require('node:util');
+     * const fs = require('node:fs');
      *
      * const stat = util.promisify(fs.stat);
      *
@@ -979,7 +1046,7 @@ declare module 'util' {
      * work as expected unless handled specially:
      *
      * ```js
-     * const util = require('util');
+     * const util = require('node:util');
      *
      * class Foo {
      *   constructor() {
@@ -1068,7 +1135,7 @@ declare module 'util' {
          * internally and emitted after the next call to `textDecoder.decode()`.
          *
          * If `textDecoder.fatal` is `true`, decoding errors that occur will result in a`TypeError` being thrown.
-         * @param input An `ArrayBuffer`, `DataView` or `TypedArray` instance containing the encoded data.
+         * @param input An `ArrayBuffer`, `DataView`, or `TypedArray` instance containing the encoded data.
          */
         decode(
             input?: NodeJS.ArrayBufferView | ArrayBuffer | null,
@@ -1128,7 +1195,6 @@ declare module 'util' {
          */
         encodeInto(src: string, dest: Uint8Array): EncodeIntoResult;
     }
-
     import { TextDecoder as _TextDecoder, TextEncoder as _TextEncoder } from 'util';
     global {
         /**
@@ -1136,19 +1202,18 @@ declare module 'util' {
          * https://nodejs.org/api/globals.html#textdecoder
          * @since v11.0.0
          */
-         var TextDecoder: typeof globalThis extends {
+        var TextDecoder: typeof globalThis extends {
             onmessage: any;
             TextDecoder: infer TextDecoder;
         }
             ? TextDecoder
             : typeof _TextDecoder;
-
         /**
          * `TextEncoder` class is a global reference for `require('util').TextEncoder`
          * https://nodejs.org/api/globals.html#textencoder
          * @since v11.0.0
          */
-         var TextEncoder: typeof globalThis extends {
+        var TextEncoder: typeof globalThis extends {
             onmessage: any;
             TextEncoder: infer TextEncoder;
         }
@@ -1158,70 +1223,87 @@ declare module 'util' {
 
     //// parseArgs
     /**
-     * Provides a high-level API for command-line argument parsing. Takes a
-     * specification for the expected arguments and returns a structured object
-     * with the parsed values and positionals.
-     *
-     * `config` provides arguments for parsing and configures the parser. It
-     * supports the following properties:
-     *
-     *   - `args` The array of argument strings. **Default:** `process.argv` with
-     *     `execPath` and `filename` removed.
-     *   - `options` Arguments known to the parser. Keys of `options` are the long
-     *     names of options and values are objects accepting the following properties:
-     *
-     *     - `type` Type of argument, which must be either `boolean` (for options
-     *        which do not take values) or `string` (for options which do).
-     *     - `multiple` Whether this option can be provided multiple
-     *       times. If `true`, all values will be collected in an array. If
-     *       `false`, values for the option are last-wins. **Default:** `false`.
-     *     - `short` A single character alias for the option.
-     *     - `default` The default option value when it is not set by args. It
-     *       must be of the same type as the `type` property. When `multiple`
-     *       is `true`, it must be an array.
-     *
-     *   - `strict`: Whether an error should be thrown when unknown arguments
-     *     are encountered, or when arguments are passed that do not match the
-     *     `type` configured in `options`. **Default:** `true`.
-     *   - `allowPositionals`: Whether this command accepts positional arguments.
-     *     **Default:** `false` if `strict` is `true`, otherwise `true`.
-     *   - `tokens`: Whether tokens {boolean} Return the parsed tokens. This is useful
-     *     for extending the built-in behavior, from adding additional checks through
-     *     to reprocessing the tokens in different ways.
-     *     **Default:** `false`.
-     *
-     * @returns The parsed command line arguments:
-     *
-     *   - `values` A mapping of parsed option names with their string
-     *     or boolean values.
-     *   - `positionals` Positional arguments.
-     *   - `tokens` Detailed parse information (only if `tokens` was specified).
-     *
-     */
-    export function parseArgs<T extends ParseArgsConfig>(config: T): ParsedResults<T>;
-
+     * Provides a higher level API for command-line argument parsing than interacting
+     * with `process.argv` directly. Takes a specification for the expected arguments
+     * and returns a structured object with the parsed options and positionals.
+     *
+     * ```js
+     * import { parseArgs } from 'node:util';
+     * const args = ['-f', '--bar', 'b'];
+     * const options = {
+     *   foo: {
+     *     type: 'boolean',
+     *     short: 'f',
+     *   },
+     *   bar: {
+     *     type: 'string',
+     *   },
+     * };
+     * const {
+     *   values,
+     *   positionals,
+     * } = parseArgs({ args, options });
+     * console.log(values, positionals);
+     * // Prints: [Object: null prototype] { foo: true, bar: 'b' } []
+     * ```
+     * @since v18.3.0, v16.17.0
+     * @param config Used to provide arguments for parsing and to configure the parser. `config` supports the following properties:
+     * @return The parsed command line arguments:
+     */
+    export function parseArgs<T extends ParseArgsConfig>(config?: T): ParsedResults<T>;
     interface ParseArgsOptionConfig {
+        /**
+         * Type of argument.
+         */
         type: 'string' | 'boolean';
-        short?: string;
-        multiple?: boolean;
         /**
+         * Whether this option can be provided multiple times.
+         * If `true`, all values will be collected in an array.
+         * If `false`, values for the option are last-wins.
+         * @default false.
+         */
+        multiple?: boolean | undefined;
+        /**
+         * A single character alias for the option.
+         */
+        short?: string | undefined;
+        /**
+         * The default option value when it is not set by args.
+         * It must be of the same type as the the `type` property.
+         * When `multiple` is `true`, it must be an array.
          * @since v18.11.0
          */
-        default?: string | boolean | string[] | boolean[];
+        default?: string | boolean | string[] | boolean[] | undefined;
     }
-
     interface ParseArgsOptionsConfig {
         [longOption: string]: ParseArgsOptionConfig;
     }
-
     export interface ParseArgsConfig {
-        strict?: boolean;
-        allowPositionals?: boolean;
-        tokens?: boolean;
-        options?: ParseArgsOptionsConfig;
-        args?: string[];
+        /**
+         * Array of argument strings.
+         */
+        args?: string[] | undefined;
+        /**
+         * Used to describe arguments known to the parser.
+         */
+        options?: ParseArgsOptionsConfig | undefined;
+        /**
+         * Should an error be thrown when unknown arguments are encountered,
+         * or when arguments are passed that do not match the `type` configured in `options`.
+         * @default true
+         */
+        strict?: boolean | undefined;
+        /**
+         * Whether this command accepts positional arguments.
+         */
+        allowPositionals?: boolean | undefined;
+        /**
+         * Return the parsed tokens. This is useful for extending the built-in behavior,
+         * from adding additional checks through to reprocessing the tokens in different ways.
+         * @default false
+         */
+        tokens?: boolean | undefined;
     }
-
     /*
     IfDefaultsTrue and IfDefaultsFalse are helpers to handle default values for missing boolean properties.
     TypeScript does not have exact types for objects: https://github.com/microsoft/TypeScript/issues/12936
@@ -1345,11 +1427,103 @@ declare module 'util' {
     // So we can't rely on the `"not definitely present" implies "definitely not present"` assumption mentioned above.
     type ParsedResults<T extends ParseArgsConfig> = ParseArgsConfig extends T
         ? {
-              values: { [longOption: string]: undefined | string | boolean | Array<string | boolean> };
+              values: {
+                  [longOption: string]: undefined | string | boolean | Array<string | boolean>;
+              };
               positionals: string[];
               tokens?: Token[];
           }
         : PreciseParsedResults<T>;
+
+    /**
+     * An implementation of [the MIMEType class](https://bmeck.github.io/node-proposal-mime-api/).
+     *
+     * In accordance with browser conventions, all properties of `MIMEType` objects
+     * are implemented as getters and setters on the class prototype, rather than as
+     * data properties on the object itself.
+     *
+     * A MIME string is a structured string containing multiple meaningful
+     * components. When parsed, a `MIMEType` object is returned containing
+     * properties for each of these components.
+     * @since v19.1.0, v18.13.0
+     * @experimental
+     */
+    export class MIMEType {
+        /**
+         * Creates a new MIMEType object by parsing the input.
+         *
+         * A `TypeError` will be thrown if the `input` is not a valid MIME.
+         * Note that an effort will be made to coerce the given values into strings.
+         * @param input The input MIME to parse.
+         */
+        constructor(input: string | { toString: () => string });
+
+        /**
+         * Gets and sets the type portion of the MIME.
+         */
+        type: string;
+        /**
+         * Gets and sets the subtype portion of the MIME.
+         */
+        subtype: string;
+        /**
+         * Gets the essence of the MIME.
+         *
+         * Use `mime.type` or `mime.subtype` to alter the MIME.
+         */
+        readonly essence: string;
+        /**
+         * Gets the `MIMEParams` object representing the parameters of the MIME.
+         */
+        readonly params: MIMEParams;
+        /**
+         * Returns the serialized MIME.
+         *
+         * Because of the need for standard compliance, this method
+         * does not allow users to customize the serialization process of the MIME.
+         */
+        toString(): string;
+    }
+    /**
+     * @since v18.13.0
+     */
+    export class MIMEParams {
+        /**
+         * Remove all name-value pairs whose name is `name`.
+         */
+        delete(name: string): void;
+        /**
+         * Returns an iterator over each of the name-value pairs in the parameters.
+         */
+        entries(): IterableIterator<[string, string]>;
+        /**
+         * Returns the value of the first name-value pair whose name is `name`.
+         * If there are no such pairs, `null` is returned.
+         */
+        get(name: string): string | null;
+        /**
+         * Returns `true` if there is at least one name-value pair whose name is `name`.
+         */
+        has(name: string): boolean;
+        /**
+         * Returns an iterator over the names of each name-value pair.
+         */
+        keys(): IterableIterator<string>;
+        /**
+         * Sets the value in the `MIMEParams` object associated with `name` to `value`.
+         * If there are any pre-existing name-value pairs whose names are `name`,
+         * set the first such pair's value to `value`.
+         */
+        set(name: string, value: string): void;
+        /**
+         * Returns an iterator over the values of each name-value pair.
+         */
+        values(): IterableIterator<string>;
+        /**
+         * Returns an iterator over each of the name-value pairs in the parameters.
+         */
+        [Symbol.iterator]: typeof MIMEParams.prototype.entries;
+    }
 }
 declare module 'util/types' {
     export * from 'util/types';
@@ -1647,12 +1821,40 @@ declare module 'util/types' {
      */
     function isModuleNamespaceObject(value: unknown): boolean;
     /**
-     * Returns `true` if the value is an instance of a built-in `Error` type.
+     * Returns `true` if the value was returned by the constructor of a [built-in `Error` type](https://tc39.es/ecma262/#sec-error-objects).
+     *
+     * ```js
+     * console.log(util.types.isNativeError(new Error()));  // true
+     * console.log(util.types.isNativeError(new TypeError()));  // true
+     * console.log(util.types.isNativeError(new RangeError()));  // true
+     * ```
+     *
+     * Subclasses of the native error types are also native errors:
+     *
+     * ```js
+     * class MyError extends Error {}
+     * console.log(util.types.isNativeError(new MyError()));  // true
+     * ```
+     *
+     * A value being `instanceof` a native error class is not equivalent to `isNativeError()`returning `true` for that value. `isNativeError()` returns `true` for errors
+     * which come from a different [realm](https://tc39.es/ecma262/#realm) while `instanceof Error` returns `false`for these errors:
+     *
+     * ```js
+     * const vm = require('node:vm');
+     * const context = vm.createContext({});
+     * const myError = vm.runInContext('new Error()', context);
+     * console.log(util.types.isNativeError(myError)); // true
+     * console.log(myError instanceof Error); // false
+     * ```
+     *
+     * Conversely, `isNativeError()` returns `false` for all objects which were not
+     * returned by the constructor of a native error. That includes values
+     * which are `instanceof` native errors:
      *
      * ```js
-     * util.types.isNativeError(new Error());  // Returns true
-     * util.types.isNativeError(new TypeError());  // Returns true
-     * util.types.isNativeError(new RangeError());  // Returns true
+     * const myError = { __proto__: Error.prototype };
+     * console.log(util.types.isNativeError(myError)); // false
+     * console.log(myError instanceof Error); // true
      * ```
      * @since v10.0.0
      */