@types/node 16.18.110 → 16.18.111

node v16.18/string_decoder.d.ts

@@ -4,13 +4,13 @@
  * characters. It can be accessed using:
  *
  * ```js
- * const { StringDecoder } = require('node:string_decoder');
+ * import { StringDecoder } from 'node:string_decoder';
  * ```
  *
  * The following example shows the basic use of the `StringDecoder` class.
  *
  * ```js
- * const { StringDecoder } = require('node:string_decoder');
+ * import { StringDecoder } from 'node:string_decoder';
  * const decoder = new StringDecoder('utf8');
  *
  * const cent = Buffer.from([0xC2, 0xA2]);
@@ -29,7 +29,7 @@
  * symbol (`€`) are written over three separate operations:
  *
  * ```js
- * const { StringDecoder } = require('node:string_decoder');
+ * import { StringDecoder } from 'node:string_decoder';
  * const decoder = new StringDecoder('utf8');
  *
  * decoder.write(Buffer.from([0xE2]));

node v16.18/timers/promises.d.ts

@@ -1,6 +1,6 @@
 /**
  * The `timers/promises` API provides an alternative set of timer functions
- * that return `Promise` objects. The API is accessible via`require('timers/promises')`.
+ * that return `Promise` objects. The API is accessible via `import timersPromises from 'node:timers/promises'`.
  *
  * ```js
  * import {

node v16.18/timers.d.ts

@@ -1,7 +1,7 @@
 /**
  * The `timer` module exposes a global API for scheduling functions to
  * be called at some future period of time. Because the timer functions are
- * globals, there is no need to call `require('timers')` to use the API.
+ * globals, there is no need to import `node:timers` to use the API.
  *
  * The timer functions within Node.js implement a similar API as the timers API
  * provided by Web Browsers but use a different internal implementation that is

node v16.18/tls.d.ts

@@ -4,7 +4,7 @@
  * The module can be accessed using:
  *
  * ```js
- * const tls = require('tls');
+ * import tls from 'node:tls';
  * ```
  * @see [source](https://github.com/nodejs/node/blob/v16.9.0/lib/tls.js)
  */
@@ -905,8 +905,8 @@ declare module "tls" {
      * The following illustrates a simple echo server:
      *
      * ```js
-     * const tls = require('tls');
-     * const fs = require('fs');
+     * import tls from 'node:tls';
+     * import fs from 'node:fs';
      *
      * const options = {
      *   key: fs.readFileSync('server-key.pem'),
@@ -951,8 +951,8 @@ declare module "tls" {
      *
      * ```js
      * // Assumes an echo server that is listening on port 8000.
-     * const tls = require('tls');
-     * const fs = require('fs');
+     * import tls from 'node:tls';
+     * import fs from 'node:fs';
      *
      * const options = {
      *   // Necessary only if the server requires client certificate authentication.

node v16.18/trace_events.d.ts

@@ -46,7 +46,7 @@
  * Alternatively, trace events may be enabled using the `trace_events` module:
  *
  * ```js
- * const trace_events = require('trace_events');
+ * import trace_events from 'node:trace_events';
  * const tracing = trace_events.createTracing({ categories: ['node.perf'] });
  * tracing.enable();  // Enable trace event capture for the 'node.perf' category
  *
@@ -122,7 +122,7 @@ declare module "trace_events" {
      * Creates and returns a `Tracing` object for the given set of `categories`.
      *
      * ```js
-     * const trace_events = require('trace_events');
+     * import trace_events from 'node:trace_events';
      * const categories = ['node.perf', 'node.async_hooks'];
      * const tracing = trace_events.createTracing({ categories });
      * tracing.enable();
@@ -142,7 +142,7 @@ declare module "trace_events" {
      * Given the file `test.js` below, the command`node --trace-event-categories node.perf test.js` will print`'node.async_hooks,node.perf'` to the console.
      *
      * ```js
-     * const trace_events = require('trace_events');
+     * import trace_events from 'node:trace_events';
      * const t1 = trace_events.createTracing({ categories: ['node.async_hooks'] });
      * const t2 = trace_events.createTracing({ categories: ['node.perf'] });
      * const t3 = trace_events.createTracing({ categories: ['v8'] });

node v16.18/tty.d.ts

@@ -4,7 +4,7 @@
  * However, it can be accessed using:
  *
  * ```js
- * const tty = require('tty');
+ * import tty from 'node:tty';
  * ```
  *
  * When Node.js detects that it is being run with a text terminal ("TTY")

node v16.18/url.d.ts

@@ -107,7 +107,7 @@ declare module "url" {
      * The `url.format()` method returns a formatted URL string derived from `urlObject`.
      *
      * ```js
-     * const url = require('node:url');
+     * import url from 'node:url';
      * url.format({
      *   protocol: 'https',
      *   hostname: 'example.com',
@@ -172,7 +172,7 @@ declare module "url" {
      * manner similar to that of a Web browser resolving an anchor tag HREF.
      *
      * ```js
-     * const url = require('node:url');
+     * import url from 'node:url';
      * url.resolve('/one/two/three', 'four');         // '/one/two/four'
      * url.resolve('http://example.com/', '/one');    // 'http://example.com/one'
      * url.resolve('http://example.com/one', '/two'); // 'http://example.com/two'
@@ -354,10 +354,10 @@ declare module "url" {
          * Creates a `'blob:nodedata:...'` URL string that represents the given `Blob` object and can be used to retrieve the `Blob` later.
          *
          * ```js
-         * const {
+         * import {
          *   Blob,
          *   resolveObjectURL,
-         * } = require('node:buffer');
+         * } from 'node:buffer';
          *
          * const blob = new Blob(['hello']);
          * const id = URL.createObjectURL(blob);
@@ -861,7 +861,7 @@ declare module "url" {
             URLSearchParams: typeof _URLSearchParams;
         }
         /**
-         * `URL` class is a global reference for `require('url').URL`
+         * `URL` class is a global reference for `import { URL } from 'node:url'`
          * https://nodejs.org/api/url.html#the-whatwg-url-api
          * @since v10.0.0
          */
@@ -870,7 +870,7 @@ declare module "url" {
             typeof globalThis extends { onmessage: any; URL: infer URL } ? URL
                 : typeof _URL;
         /**
-         * `URLSearchParams` class is a global reference for `require('url').URLSearchParams`.
+         * `URLSearchParams` class is a global reference for `import { URLSearchParams } from 'node:url'`.
          * https://nodejs.org/api/url.html#class-urlsearchparams
          * @since v10.0.0
          */

node v16.18/util.d.ts

@@ -4,7 +4,7 @@
  * it:
  *
  * ```js
- * const util = require('util');
+ * import util from 'node:util';
  * ```
  * @see [source](https://github.com/nodejs/node/blob/v16.9.0/lib/util.js)
  */
@@ -158,7 +158,7 @@ declare module "util" {
      * timestamp.
      *
      * ```js
-     * const util = require('util');
+     * import util from 'node:util';
      *
      * util.log('Timestamped message.');
      * ```
@@ -199,7 +199,7 @@ declare module "util" {
      * Circular references point to their anchor by using a reference index:
      *
      * ```js
-     * const { inspect } = require('util');
+     * import { inspect } from 'node:util';
      *
      * const obj = {};
      * obj.a = [obj];
@@ -217,7 +217,7 @@ declare module "util" {
      * The following example inspects all properties of the `util` object:
      *
      * ```js
-     * const util = require('util');
+     * import util from 'node:util';
      *
      * console.log(util.inspect(util, { showHidden: true, depth: null }));
      * ```
@@ -225,7 +225,7 @@ declare module "util" {
      * The following example highlights the effect of the `compact` option:
      *
      * ```js
-     * const util = require('util');
+     * import util from 'node:util';
      *
      * const o = {
      *   a: [1, 2, [[
@@ -282,7 +282,7 @@ declare module "util" {
      * with no remaining strong references may be garbage collected at any time.
      *
      * ```js
-     * const { inspect } = require('util');
+     * import { inspect } from 'node:util';
      *
      * const obj = { a: 1 };
      * const obj2 = { b: 2 };
@@ -296,8 +296,8 @@ declare module "util" {
      * impact the result of `util.inspect()`.
      *
      * ```js
-     * const { inspect } = require('util');
-     * const assert = require('assert');
+     * import { inspect } from 'node:util';
+     * import assert from 'node:assert';
      *
      * const o1 = {
      *   b: [2, 3, 1],
@@ -350,7 +350,7 @@ declare module "util" {
      * Returns `true` if the given `object` is an `Array`. Otherwise, returns `false`.
      *
      * ```js
-     * const util = require('util');
+     * import util from 'node:util';
      *
      * util.isArray([]);
      * // Returns: true
@@ -367,7 +367,7 @@ declare module "util" {
      * Returns `true` if the given `object` is a `RegExp`. Otherwise, returns `false`.
      *
      * ```js
-     * const util = require('util');
+     * import util from 'node:util';
      *
      * util.isRegExp(/some regexp/);
      * // Returns: true
@@ -384,7 +384,7 @@ declare module "util" {
      * Returns `true` if the given `object` is a `Date`. Otherwise, returns `false`.
      *
      * ```js
-     * const util = require('util');
+     * import util from 'node:util';
      *
      * util.isDate(new Date());
      * // Returns: true
@@ -401,7 +401,7 @@ declare module "util" {
      * Returns `true` if the given `object` is an `Error`. Otherwise, returns`false`.
      *
      * ```js
-     * const util = require('util');
+     * import util from 'node:util';
      *
      * util.isError(new Error());
      * // Returns: true
@@ -415,7 +415,7 @@ declare module "util" {
      * possible to obtain an incorrect result when the `object` argument manipulates`@@toStringTag`.
      *
      * ```js
-     * const util = require('util');
+     * import util from 'node:util';
      * const obj = { name: 'Error', message: 'an error occurred' };
      *
      * util.isError(obj);
@@ -440,8 +440,8 @@ declare module "util" {
      * through the `constructor.super_` property.
      *
      * ```js
-     * const util = require('util');
-     * const EventEmitter = require('events');
+     * import util from 'node:util';
+     * import EventEmitter from 'node:events';
      *
      * function MyStream() {
      *   EventEmitter.call(this);
@@ -467,7 +467,7 @@ declare module "util" {
      * ES6 example using `class` and `extends`:
      *
      * ```js
-     * const EventEmitter = require('events');
+     * import EventEmitter from 'node:events';
      *
      * class MyStream extends EventEmitter {
      *   write(data) {
@@ -496,7 +496,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');
+     * import util from 'node:util';
      * const debuglog = util.debuglog('foo');
      *
      * debuglog('hello from foo [%d]', 123);
@@ -515,7 +515,7 @@ declare module "util" {
      * The `section` supports wildcard also:
      *
      * ```js
-     * const util = require('util');
+     * import util from 'node:util';
      * const debuglog = util.debuglog('foo-bar');
      *
      * debuglog('hi there, it\'s foo-bar [%d]', 2333);
@@ -535,7 +535,7 @@ declare module "util" {
      * unnecessary wrapping.
      *
      * ```js
-     * const util = require('util');
+     * import util from 'node:util';
      * let debuglog = util.debuglog('internals', (debug) => {
      *   // Replace with a logging function that optimizes out
      *   // testing if the section is enabled
@@ -553,7 +553,7 @@ declare module "util" {
      * Returns `true` if the given `object` is a `Boolean`. Otherwise, returns `false`.
      *
      * ```js
-     * const util = require('util');
+     * import util from 'node:util';
      *
      * util.isBoolean(1);
      * // Returns: false
@@ -570,7 +570,7 @@ declare module "util" {
      * Returns `true` if the given `object` is a `Buffer`. Otherwise, returns `false`.
      *
      * ```js
-     * const util = require('util');
+     * import util from 'node:util';
      *
      * util.isBuffer({ length: 0 });
      * // Returns: false
@@ -587,7 +587,7 @@ declare module "util" {
      * Returns `true` if the given `object` is a `Function`. Otherwise, returns`false`.
      *
      * ```js
-     * const util = require('util');
+     * import util from 'node:util';
      *
      * function Foo() {}
      * const Bar = () => {};
@@ -607,7 +607,7 @@ declare module "util" {
      * Returns `true` if the given `object` is strictly `null`. Otherwise, returns`false`.
      *
      * ```js
-     * const util = require('util');
+     * import util from 'node:util';
      *
      * util.isNull(0);
      * // Returns: false
@@ -625,7 +625,7 @@ declare module "util" {
      * returns `false`.
      *
      * ```js
-     * const util = require('util');
+     * import util from 'node:util';
      *
      * util.isNullOrUndefined(0);
      * // Returns: false
@@ -642,7 +642,7 @@ declare module "util" {
      * Returns `true` if the given `object` is a `Number`. Otherwise, returns `false`.
      *
      * ```js
-     * const util = require('util');
+     * import util from 'node:util';
      *
      * util.isNumber(false);
      * // Returns: false
@@ -662,7 +662,7 @@ declare module "util" {
      * Otherwise, returns `false`.
      *
      * ```js
-     * const util = require('util');
+     * import util from 'node:util';
      *
      * util.isObject(5);
      * // Returns: false
@@ -681,7 +681,7 @@ declare module "util" {
      * Returns `true` if the given `object` is a primitive type. Otherwise, returns`false`.
      *
      * ```js
-     * const util = require('util');
+     * import util from 'node:util';
      *
      * util.isPrimitive(5);
      * // Returns: true
@@ -710,7 +710,7 @@ declare module "util" {
      * Returns `true` if the given `object` is a `string`. Otherwise, returns `false`.
      *
      * ```js
-     * const util = require('util');
+     * import util from 'node:util';
      *
      * util.isString('');
      * // Returns: true
@@ -729,7 +729,7 @@ declare module "util" {
      * Returns `true` if the given `object` is a `Symbol`. Otherwise, returns `false`.
      *
      * ```js
-     * const util = require('util');
+     * import util from 'node:util';
      *
      * util.isSymbol(5);
      * // Returns: false
@@ -746,7 +746,7 @@ declare module "util" {
      * Returns `true` if the given `object` is `undefined`. Otherwise, returns `false`.
      *
      * ```js
-     * const util = require('util');
+     * import util from 'node:util';
      *
      * const foo = undefined;
      * util.isUndefined(5);
@@ -765,7 +765,7 @@ declare module "util" {
      * such a way that it is marked as deprecated.
      *
      * ```js
-     * const util = require('util');
+     * import util from 'node:util';
      *
      * exports.obsoleteFunction = util.deprecate(() => {
      *   // Do something here.
@@ -781,7 +781,7 @@ declare module "util" {
      * the warning will be emitted only once for that `code`.
      *
      * ```js
-     * const util = require('util');
+     * import util from 'node:util';
      *
      * const fn1 = util.deprecate(someFunction, someMessage, 'DEP0001');
      * const fn2 = util.deprecate(someOtherFunction, someOtherMessage, 'DEP0001');
@@ -835,7 +835,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');
+     * import util from 'node:util';
      *
      * async function fn() {
      *   return 'hello world';
@@ -961,8 +961,8 @@ declare module "util" {
      * that returns promises.
      *
      * ```js
-     * const util = require('util');
-     * const fs = require('fs');
+     * import util from 'node:util';
+     * import fs from 'node:fs';
      *
      * const stat = util.promisify(fs.stat);
      * stat('.').then((stats) => {
@@ -975,8 +975,8 @@ declare module "util" {
      * Or, equivalently using `async function`s:
      *
      * ```js
-     * const util = require('util');
-     * const fs = require('fs');
+     * import util from 'node:util';
+     * import fs from 'node:fs';
      *
      * const stat = util.promisify(fs.stat);
      *
@@ -997,7 +997,7 @@ declare module "util" {
      * work as expected unless handled specially:
      *
      * ```js
-     * const util = require('util');
+     * import util from 'node:util';
      *
      * class Foo {
      *   constructor() {
@@ -1166,7 +1166,7 @@ declare module "util" {
     import { TextDecoder as _TextDecoder, TextEncoder as _TextEncoder } from "util";
     global {
         /**
-         * `TextDecoder` class is a global reference for `require('util').TextDecoder`
+         * `TextDecoder` class is a global reference for `import { TextDecoder } from 'node:util'`
          * https://nodejs.org/api/globals.html#textdecoder
          * @since v11.0.0
          */
@@ -1177,7 +1177,7 @@ declare module "util" {
             : typeof _TextDecoder;
 
         /**
-         * `TextEncoder` class is a global reference for `require('util').TextEncoder`
+         * `TextEncoder` class is a global reference for `import { TextEncoder } from 'node:util'`
          * https://nodejs.org/api/globals.html#textencoder
          * @since v11.0.0
          */

node v16.18/v8.d.ts

@@ -2,7 +2,7 @@
  * The `node:v8` module exposes APIs that are specific to the version of [V8](https://developers.google.com/v8/) built into the Node.js binary. It can be accessed using:
  *
  * ```js
- * const v8 = require('node:v8');
+ * import v8 from 'node:v8';
  * ```
  * @see [source](https://github.com/nodejs/node/blob/v16.20.2/lib/v8.js)
  */
@@ -164,7 +164,7 @@ declare module "v8" {
      *
      * ```js
      * // Print GC events to stdout for one minute.
-     * const v8 = require('node:v8');
+     * import v8 from 'node:v8';
      * v8.setFlagsFromString('--trace_gc');
      * setTimeout(() => { v8.setFlagsFromString('--notrace_gc'); }, 60e3);
      * ```
@@ -187,7 +187,7 @@ declare module "v8" {
      *
      * ```js
      * // Print heap snapshot to the console
-     * const v8 = require('node:v8');
+     * import v8 from 'node:v8';
      * const stream = v8.getHeapSnapshot();
      * stream.pipe(process.stdout);
      * ```
@@ -212,12 +212,12 @@ declare module "v8" {
      * for a duration depending on the heap size.
      *
      * ```js
-     * const { writeHeapSnapshot } = require('node:v8');
-     * const {
+     * import { writeHeapSnapshot } from 'node:v8';
+     * import {
      *   Worker,
      *   isMainThread,
      *   parentPort,
-     * } = require('node:worker_threads');
+     * } from 'node:worker_threads';
      *
      * if (isMainThread) {
      *   const worker = new Worker(__filename);
@@ -554,12 +554,12 @@ declare module "v8" {
      * ```js
      * 'use strict';
      *
-     * const fs = require('node:fs');
-     * const zlib = require('node:zlib');
-     * const path = require('node:path');
-     * const assert = require('node:assert');
+     * import fs from 'node:fs';
+     * import zlib from 'node:zlib';
+     * import path from 'node:path';
+     * import assert from 'node:assert';
      *
-     * const v8 = require('node:v8');
+     * import v8 from 'node:v8';
      *
      * class BookShelf {
      *   storage = new Map();

node v16.18/vm.d.ts

@@ -15,7 +15,7 @@
  * code are reflected in the context object.
  *
  * ```js
- * const vm = require('vm');
+ * import vm from 'node:vm';
  *
  * const x = 1;
  *
@@ -166,7 +166,7 @@ declare module "vm" {
          * The globals are contained in the `context` object.
          *
          * ```js
-         * const vm = require('vm');
+         * import vm from 'node:vm';
          *
          * const context = {
          *   animal: 'cat',
@@ -202,7 +202,7 @@ declare module "vm" {
          * contained within each individual `context`.
          *
          * ```js
-         * const vm = require('vm');
+         * import vm from 'node:vm';
          *
          * const script = new vm.Script('globalVar = "set"');
          *
@@ -227,7 +227,7 @@ declare module "vm" {
          * executes that code multiple times:
          *
          * ```js
-         * const vm = require('vm');
+         * import vm from 'node:vm';
          *
          * global.globalVar = 0;
          *
@@ -280,7 +280,7 @@ declare module "vm" {
      * will remain unchanged.
      *
      * ```js
-     * const vm = require('vm');
+     * import vm from 'node:vm';
      *
      * global.globalVar = 3;
      *
@@ -327,7 +327,7 @@ declare module "vm" {
      * The following example compiles and executes different scripts using a single `contextified` object:
      *
      * ```js
-     * const vm = require('vm');
+     * import vm from 'node:vm';
      *
      * const contextObject = { globalVar: 1 };
      * vm.createContext(contextObject);
@@ -356,7 +356,7 @@ declare module "vm" {
      * variable and sets a new one. These globals are contained in the `contextObject`.
      *
      * ```js
-     * const vm = require('vm');
+     * import vm from 'node:vm';
      *
      * const contextObject = {
      *   animal: 'cat',
@@ -384,7 +384,7 @@ declare module "vm" {
      * the JavaScript [`eval()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/eval) function to run the same code:
      *
      * ```js
-     * const vm = require('vm');
+     * import vm from 'node:vm';
      * let localVar = 'initial value';
      *
      * const vmResult = vm.runInThisContext('localVar = "vm";');
@@ -411,12 +411,11 @@ declare module "vm" {
      *
      * ```js
      * 'use strict';
-     * const vm = require('vm');
+     * import vm from 'node:vm';
      *
      * const code = `
      * ((require) => {
-     *   const http = require('http');
-     *
+     *   const http = require('node:http');
      *   http.createServer((request, response) => {
      *     response.writeHead(200, { 'Content-Type': 'text/plain' });
      *     response.end('Hello World\\n');
@@ -458,7 +457,7 @@ declare module "vm" {
      * the memory occupied by each heap space in the current V8 instance.
      *
      * ```js
-     * const vm = require('vm');
+     * import vm from 'node:vm';
      * // Measure the memory used by the main context.
      * vm.measureMemory({ mode: 'summary' })
      *   // This is the same as vm.measureMemory()