cloudstructs 0.6.33 → 0.6.35

package/node_modules/@types/is-stream/node_modules/@types/node/ts4.8/dns.d.ts

@@ -42,7 +42,7 @@
  * ```
  *
  * See the `Implementation considerations section` for more information.
- * @see [source](https://github.com/nodejs/node/blob/v20.1.0/lib/dns.js)
+ * @see [source](https://github.com/nodejs/node/blob/v20.2.0/lib/dns.js)
  */
 declare module 'dns' {
     import * as dnsPromises from 'node:dns/promises';
@@ -633,6 +633,7 @@ declare module 'dns' {
         resolve4: typeof resolve4;
         resolve6: typeof resolve6;
         resolveAny: typeof resolveAny;
+        resolveCaa: typeof resolveCaa;
         resolveCname: typeof resolveCname;
         resolveMx: typeof resolveMx;
         resolveNaptr: typeof resolveNaptr;

package/node_modules/@types/is-stream/node_modules/@types/node/ts4.8/domain.d.ts

@@ -12,7 +12,7 @@
  * will be notified, rather than losing the context of the error in the`process.on('uncaughtException')` handler, or causing the program to
  * exit immediately with an error code.
  * @deprecated Since v1.4.2 - Deprecated
- * @see [source](https://github.com/nodejs/node/blob/v20.1.0/lib/domain.js)
+ * @see [source](https://github.com/nodejs/node/blob/v20.2.0/lib/domain.js)
  */
 declare module 'domain' {
     import EventEmitter = require('node:events');

package/node_modules/@types/is-stream/node_modules/@types/node/ts4.8/events.d.ts

@@ -32,7 +32,7 @@
  * });
  * myEmitter.emit('event');
  * ```
- * @see [source](https://github.com/nodejs/node/blob/v20.1.0/lib/events.js)
+ * @see [source](https://github.com/nodejs/node/blob/v20.2.0/lib/events.js)
  */
 declare module 'events' {
     // NOTE: This class is in the docs but is **not actually exported** by Node.
@@ -310,21 +310,63 @@ declare module 'events' {
          */
         static setMaxListeners(n?: number, ...eventTargets: Array<_DOMEventTarget | NodeJS.EventEmitter>): void;
         /**
-         * This symbol shall be used to install a listener for only monitoring `'error'`
-         * events. Listeners installed using this symbol are called before the regular
-         * `'error'` listeners are called.
+         * This symbol shall be used to install a listener for only monitoring `'error'`events. Listeners installed using this symbol are called before the regular`'error'` listeners are called.
          *
-         * Installing a listener using this symbol does not change the behavior once an
-         * `'error'` event is emitted, therefore the process will still crash if no
+         * Installing a listener using this symbol does not change the behavior once an`'error'` event is emitted. Therefore, the process will still crash if no
          * regular `'error'` listener is installed.
+         * @since v13.6.0, v12.17.0
          */
         static readonly errorMonitor: unique symbol;
+        /**
+         * Value: `Symbol.for('nodejs.rejection')`
+         *
+         * See how to write a custom `rejection handler`.
+         * @since v13.4.0, v12.16.0
+         */
         static readonly captureRejectionSymbol: unique symbol;
         /**
-         * Sets or gets the default captureRejection value for all emitters.
+         * Value: [boolean](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type)
+         *
+         * Change the default `captureRejections` option on all new `EventEmitter` objects.
+         * @since v13.4.0, v12.16.0
          */
-        // TODO: These should be described using static getter/setter pairs:
         static captureRejections: boolean;
+        /**
+         * By default, a maximum of `10` listeners can be registered for any single
+         * event. This limit can be changed for individual `EventEmitter` instances
+         * using the `emitter.setMaxListeners(n)` method. To change the default
+         * for _all_`EventEmitter` instances, the `events.defaultMaxListeners`property can be used. If this value is not a positive number, a `RangeError`is thrown.
+         *
+         * Take caution when setting the `events.defaultMaxListeners` because the
+         * change affects _all_`EventEmitter` instances, including those created before
+         * the change is made. However, calling `emitter.setMaxListeners(n)` still has
+         * precedence over `events.defaultMaxListeners`.
+         *
+         * This is not a hard limit. The `EventEmitter` instance will allow
+         * more listeners to be added but will output a trace warning to stderr indicating
+         * that a "possible EventEmitter memory leak" has been detected. For any single`EventEmitter`, the `emitter.getMaxListeners()` and `emitter.setMaxListeners()`methods can be used to
+         * temporarily avoid this warning:
+         *
+         * ```js
+         * import { EventEmitter } from 'node:events';
+         * const emitter = new EventEmitter();
+         * emitter.setMaxListeners(emitter.getMaxListeners() + 1);
+         * emitter.once('event', () => {
+         *   // do stuff
+         *   emitter.setMaxListeners(Math.max(emitter.getMaxListeners() - 1, 0));
+         * });
+         * ```
+         *
+         * The `--trace-warnings` command-line flag can be used to display the
+         * stack trace for such warnings.
+         *
+         * The emitted warning can be inspected with `process.on('warning')` and will
+         * have the additional `emitter`, `type`, and `count` properties, referring to
+         * the event emitter instance, the event's name and the number of attached
+         * listeners, respectively.
+         * Its `name` property is set to `'MaxListenersExceededWarning'`.
+         * @since v0.11.2
+         */
         static defaultMaxListeners: number;
     }
     import internal = require('node:events');

package/node_modules/@types/is-stream/node_modules/@types/node/ts4.8/fs/promises.d.ts

@@ -43,7 +43,7 @@ declare module 'fs/promises' {
     import { Interface as ReadlineInterface } from 'node:readline';
     interface FileChangeInfo<T extends string | Buffer> {
         eventType: WatchEventType;
-        filename: T;
+        filename: T | null;
     }
     interface FlagAndOpenMode {
         mode?: Mode | undefined;

package/node_modules/@types/is-stream/node_modules/@types/node/ts4.8/fs.d.ts

@@ -16,7 +16,7 @@
  *
  * All file system operations have synchronous, callback, and promise-based
  * forms, and are accessible using both CommonJS syntax and ES6 Modules (ESM).
- * @see [source](https://github.com/nodejs/node/blob/v20.1.0/lib/fs.js)
+ * @see [source](https://github.com/nodejs/node/blob/v20.2.0/lib/fs.js)
  */
 declare module 'fs' {
     import * as stream from 'node:stream';
@@ -149,12 +149,38 @@ declare module 'fs' {
     }
     export interface StatsFs extends StatsFsBase<number> {}
     /**
-     * Provides information about a mounted file system
+     * Provides information about a mounted file system.
      *
-     * Objects returned from {@link statfs} and {@link statfsSync} are of this type.
-     * If `bigint` in the `options` passed to those methods is true, the numeric values
-     * will be `bigint` instead of `number`.
-     * @since  v18.15.0
+     * Objects returned from {@link statfs} and its synchronous counterpart are of
+     * this type. If `bigint` in the `options` passed to those methods is `true`, the
+     * numeric values will be `bigint` instead of `number`.
+     *
+     * ```console
+     * StatFs {
+     *   type: 1397114950,
+     *   bsize: 4096,
+     *   blocks: 121938943,
+     *   bfree: 61058895,
+     *   bavail: 61058895,
+     *   files: 999,
+     *   ffree: 1000000
+     * }
+     * ```
+     *
+     * `bigint` version:
+     *
+     * ```console
+     * StatFs {
+     *   type: 1397114950n,
+     *   bsize: 4096n,
+     *   blocks: 121938943n,
+     *   bfree: 61058895n,
+     *   bavail: 61058895n,
+     *   files: 999n,
+     *   ffree: 1000000n
+     * }
+     * ```
+     * @since v19.6.0, v18.15.0
      */
     export class StatsFs {}
     export interface BigIntStatsFs extends StatsFsBase<bigint> {}
@@ -214,6 +240,11 @@ declare module 'fs' {
          * @since v10.10.0
          */
         name: string;
+        /**
+         * The base path that this `fs.Dirent` object refers to.
+         * @since v20.1.0
+         */
+        path: string;
     }
     /**
      * A class representing a directory stream.
@@ -1215,7 +1246,8 @@ declare module 'fs' {
      * It can be set to `'dir'`, `'file'`, or `'junction'`. If the `type` argument is
      * not a string, Node.js will autodetect `target` type and use `'file'` or `'dir'`.
      * If the `target` does not exist, `'file'` will be used. Windows junction points
-     * require the destination path to be absolute. When using `'junction'`, the`target` argument will automatically be normalized to absolute path.
+     * require the destination path to be absolute. When using `'junction'`, the`target` argument will automatically be normalized to absolute path. Junction
+     * points on NTFS volumes can only point to directories.
      *
      * Relative targets are relative to the link's parent directory.
      *
@@ -3020,7 +3052,7 @@ declare module 'fs' {
                   bigint?: false | undefined;
               })
             | undefined,
-        listener: (curr: Stats, prev: Stats) => void
+        listener: StatsListener
     ): StatWatcher;
     export function watchFile(
         filename: PathLike,
@@ -3029,13 +3061,13 @@ declare module 'fs' {
                   bigint: true;
               })
             | undefined,
-        listener: (curr: BigIntStats, prev: BigIntStats) => void
+        listener: BigIntStatsListener
     ): StatWatcher;
     /**
      * Watch for changes on `filename`. The callback `listener` will be called each time the file is accessed.
      * @param filename A path to a file or directory. If a URL is provided, it must use the `file:` protocol.
      */
-    export function watchFile(filename: PathLike, listener: (curr: Stats, prev: Stats) => void): StatWatcher;
+    export function watchFile(filename: PathLike, listener: StatsListener): StatWatcher;
     /**
      * Stop watching for changes on `filename`. If `listener` is specified, only that
      * particular listener is removed. Otherwise, _all_ listeners are removed,
@@ -3048,14 +3080,17 @@ declare module 'fs' {
      * @since v0.1.31
      * @param listener Optional, a listener previously attached using `fs.watchFile()`
      */
-    export function unwatchFile(filename: PathLike, listener?: (curr: Stats, prev: Stats) => void): void;
+    export function unwatchFile(filename: PathLike, listener?: StatsListener): void;
+    export function unwatchFile(filename: PathLike, listener?: BigIntStatsListener): void;
     export interface WatchOptions extends Abortable {
         encoding?: BufferEncoding | 'buffer' | undefined;
         persistent?: boolean | undefined;
         recursive?: boolean | undefined;
     }
     export type WatchEventType = 'rename' | 'change';
-    export type WatchListener<T> = (event: WatchEventType, filename: T) => void;
+    export type WatchListener<T> = (event: WatchEventType, filename: T | null) => void;
+    export type StatsListener = (curr: Stats, prev: Stats) => void;
+    export type BigIntStatsListener = (curr: BigIntStats, prev: BigIntStats) => void;
     /**
      * Watch for changes on `filename`, where `filename` is either a file or a
      * directory.

package/node_modules/@types/is-stream/node_modules/@types/node/ts4.8/globals.d.ts

@@ -64,6 +64,7 @@ interface AbortSignal extends EventTarget {
     readonly aborted: boolean;
     readonly reason: any;
     onabort: null | ((this: AbortSignal, event: Event) => any);
+    throwIfAborted(): void;
 }
 
 declare var AbortController: typeof globalThis extends {onmessage: any; AbortController: infer T}

package/node_modules/@types/is-stream/node_modules/@types/node/ts4.8/http.d.ts

@@ -37,13 +37,14 @@
  *   'Host', 'example.com',
  *   'accepT', '*' ]
  * ```
- * @see [source](https://github.com/nodejs/node/blob/v20.1.0/lib/http.js)
+ * @see [source](https://github.com/nodejs/node/blob/v20.2.0/lib/http.js)
  */
 declare module 'http' {
     import * as stream from 'node:stream';
     import { URL } from 'node:url';
-    import { TcpSocketConnectOpts, Socket, Server as NetServer, LookupFunction } from 'node:net';
     import { LookupOptions } from 'node:dns';
+    import { EventEmitter } from 'node:events';
+    import { TcpSocketConnectOpts, Socket, Server as NetServer, LookupFunction } from 'node:net';
     // incoming headers will never contain number
     interface IncomingHttpHeaders extends NodeJS.Dict<string | string[]> {
         accept?: string | undefined;
@@ -1310,9 +1311,9 @@ declare module 'http' {
      * ```
      * @since v0.3.4
      */
-    class Agent {
+    class Agent extends EventEmitter {
         /**
-         * By default set to 256\. For agents with `keepAlive` enabled, this
+         * By default set to 256. For agents with `keepAlive` enabled, this
          * sets the maximum number of sockets that will be left open in the free
          * state.
          * @since v0.11.7

package/node_modules/@types/is-stream/node_modules/@types/node/ts4.8/http2.d.ts

@@ -6,7 +6,7 @@
  * const http2 = require('node:http2');
  * ```
  * @since v8.4.0
- * @see [source](https://github.com/nodejs/node/blob/v20.1.0/lib/http2.js)
+ * @see [source](https://github.com/nodejs/node/blob/v20.2.0/lib/http2.js)
  */
 declare module 'http2' {
     import EventEmitter = require('node:events');

package/node_modules/@types/is-stream/node_modules/@types/node/ts4.8/https.d.ts

@@ -1,7 +1,7 @@
 /**
  * HTTPS is the HTTP protocol over TLS/SSL. In Node.js this is implemented as a
  * separate module.
- * @see [source](https://github.com/nodejs/node/blob/v20.1.0/lib/https.js)
+ * @see [source](https://github.com/nodejs/node/blob/v20.2.0/lib/https.js)
  */
 declare module 'https' {
     import { Duplex } from 'node:stream';

package/node_modules/@types/is-stream/node_modules/@types/node/ts4.8/inspector.d.ts

@@ -22,7 +22,7 @@
  * ```js
  * import * as inspector from 'node:inspector';
  * ```
- * @see [source](https://github.com/nodejs/node/blob/v20.1.0/lib/inspector.js)
+ * @see [source](https://github.com/nodejs/node/blob/v20.2.0/lib/inspector.js)
  */
 declare module 'inspector' {
     import EventEmitter = require('node:events');

package/node_modules/@types/is-stream/node_modules/@types/node/ts4.8/net.d.ts

@@ -10,7 +10,7 @@
  * ```js
  * const net = require('node:net');
  * ```
- * @see [source](https://github.com/nodejs/node/blob/v20.1.0/lib/net.js)
+ * @see [source](https://github.com/nodejs/node/blob/v20.2.0/lib/net.js)
  */
 declare module 'net' {
     import * as stream from 'node:stream';

package/node_modules/@types/is-stream/node_modules/@types/node/ts4.8/os.d.ts

@@ -5,7 +5,7 @@
  * ```js
  * const os = require('node:os');
  * ```
- * @see [source](https://github.com/nodejs/node/blob/v20.1.0/lib/os.js)
+ * @see [source](https://github.com/nodejs/node/blob/v20.2.0/lib/os.js)
  */
 declare module 'os' {
     interface CpuInfo {

package/node_modules/@types/is-stream/node_modules/@types/node/ts4.8/path.d.ts

@@ -13,7 +13,7 @@ declare module 'path/win32' {
  * ```js
  * const path = require('node:path');
  * ```
- * @see [source](https://github.com/nodejs/node/blob/v20.1.0/lib/path.js)
+ * @see [source](https://github.com/nodejs/node/blob/v20.2.0/lib/path.js)
  */
 declare module 'path' {
     namespace path {

package/node_modules/@types/is-stream/node_modules/@types/node/ts4.8/perf_hooks.d.ts

@@ -27,7 +27,7 @@
  *   performance.measure('A to B', 'A', 'B');
  * });
  * ```
- * @see [source](https://github.com/nodejs/node/blob/v20.1.0/lib/perf_hooks.js)
+ * @see [source](https://github.com/nodejs/node/blob/v20.2.0/lib/perf_hooks.js)
  */
 declare module 'perf_hooks' {
     import { AsyncResource } from 'node:async_hooks';

package/node_modules/@types/is-stream/node_modules/@types/node/ts4.8/punycode.d.ts

@@ -24,7 +24,7 @@
  * made available to developers as a convenience. Fixes or other modifications to
  * the module must be directed to the [Punycode.js](https://github.com/bestiejs/punycode.js) project.
  * @deprecated Since v7.0.0 - Deprecated
- * @see [source](https://github.com/nodejs/node/blob/v20.1.0/lib/punycode.js)
+ * @see [source](https://github.com/nodejs/node/blob/v20.2.0/lib/punycode.js)
  */
 declare module 'punycode' {
     /**

package/node_modules/@types/is-stream/node_modules/@types/node/ts4.8/querystring.d.ts

@@ -9,7 +9,7 @@
  * `querystring` is more performant than `URLSearchParams` but is not a
  * standardized API. Use `URLSearchParams` when performance is not critical or
  * when compatibility with browser code is desirable.
- * @see [source](https://github.com/nodejs/node/blob/v20.1.0/lib/querystring.js)
+ * @see [source](https://github.com/nodejs/node/blob/v20.2.0/lib/querystring.js)
  */
 declare module 'querystring' {
     interface StringifyOptions {

package/node_modules/@types/is-stream/node_modules/@types/node/ts4.8/readline/promises.d.ts

@@ -1,22 +1,28 @@
 /**
- * The `readline/promise` module provides an API for reading lines of input from a Readable stream one line at a time.
- *
- * @see [source](https://github.com/nodejs/node/blob/v18.0.0/lib/readline/promises.js)
  * @since v17.0.0
+ * @experimental
  */
 declare module 'readline/promises' {
     import { Interface as _Interface, ReadLineOptions, Completer, AsyncCompleter, Direction } from 'node:readline';
     import { Abortable } from 'node:events';
+    /**
+     * Instances of the `readlinePromises.Interface` class are constructed using the`readlinePromises.createInterface()` method. Every instance is associated with a
+     * single `input` `Readable` stream and a single `output` `Writable` stream.
+     * The `output` stream is used to print prompts for user input that arrives on,
+     * and is read from, the `input` stream.
+     * @since v17.0.0
+     */
     class Interface extends _Interface {
         /**
-         * The rl.question() method displays the query by writing it to the output, waits for user input to be provided on input,
-         * then invokes the callback function passing the provided input as the first argument.
+         * The `rl.question()` method displays the `query` by writing it to the `output`,
+         * waits for user input to be provided on `input`, then invokes the `callback`function passing the provided input as the first argument.
          *
-         * When called, rl.question() will resume the input stream if it has been paused.
+         * When called, `rl.question()` will resume the `input` stream if it has been
+         * paused.
          *
-         * If the readlinePromises.Interface was created with output set to null or undefined the query is not written.
+         * If the `Interface` was created with `output` set to `null` or`undefined` the `query` is not written.
          *
-         * If the question is called after rl.close(), it returns a rejected promise.
+         * If the question is called after `rl.close()`, it returns a rejected promise.
          *
          * Example usage:
          *
@@ -25,7 +31,7 @@ declare module 'readline/promises' {
          * console.log(`Oh, so your favorite food is ${answer}`);
          * ```
          *
-         * Using an AbortSignal to cancel a question.
+         * Using an `AbortSignal` to cancel a question.
          *
          * ```js
          * const signal = AbortSignal.timeout(10_000);
@@ -37,13 +43,16 @@ declare module 'readline/promises' {
          * const answer = await rl.question('What is your favorite food? ', { signal });
          * console.log(`Oh, so your favorite food is ${answer}`);
          * ```
-         *
          * @since v17.0.0
-         * @param query A statement or query to write to output, prepended to the prompt.
+         * @param query A statement or query to write to `output`, prepended to the prompt.
+         * @return A promise that is fulfilled with the user's input in response to the `query`.
          */
         question(query: string): Promise<string>;
         question(query: string, options: Abortable): Promise<string>;
     }
+    /**
+     * @since v17.0.0
+     */
     class Readline {
         /**
          * @param stream A TTY stream.
@@ -55,46 +64,66 @@ declare module 'readline/promises' {
             }
         );
         /**
-         * The `rl.clearLine()` method adds to the internal list of pending action an action that clears current line of the associated `stream` in a specified direction identified by `dir`.
-         * Call `rl.commit()` to see the effect of this method, unless `autoCommit: true` was passed to the constructor.
+         * The `rl.clearLine()` method adds to the internal list of pending action an
+         * action that clears current line of the associated `stream` in a specified
+         * direction identified by `dir`.
+         * Call `rl.commit()` to see the effect of this method, unless `autoCommit: true`was passed to the constructor.
+         * @since v17.0.0
+         * @return this
          */
         clearLine(dir: Direction): this;
         /**
-         * The `rl.clearScreenDown()` method adds to the internal list of pending action an action that clears the associated `stream` from the current position of the cursor down.
-         * Call `rl.commit()` to see the effect of this method, unless `autoCommit: true` was passed to the constructor.
+         * The `rl.clearScreenDown()` method adds to the internal list of pending action an
+         * action that clears the associated stream from the current position of the
+         * cursor down.
+         * Call `rl.commit()` to see the effect of this method, unless `autoCommit: true`was passed to the constructor.
+         * @since v17.0.0
+         * @return this
          */
         clearScreenDown(): this;
         /**
-         * The `rl.commit()` method sends all the pending actions to the associated `stream` and clears the internal list of pending actions.
+         * The `rl.commit()` method sends all the pending actions to the associated`stream` and clears the internal list of pending actions.
+         * @since v17.0.0
          */
         commit(): Promise<void>;
         /**
-         * The `rl.cursorTo()` method adds to the internal list of pending action an action that moves cursor to the specified position in the associated `stream`.
-         * Call `rl.commit()` to see the effect of this method, unless `autoCommit: true` was passed to the constructor.
+         * The `rl.cursorTo()` method adds to the internal list of pending action an action
+         * that moves cursor to the specified position in the associated `stream`.
+         * Call `rl.commit()` to see the effect of this method, unless `autoCommit: true`was passed to the constructor.
+         * @since v17.0.0
+         * @return this
          */
         cursorTo(x: number, y?: number): this;
         /**
-         * The `rl.moveCursor()` method adds to the internal list of pending action an action that moves the cursor relative to its current position in the associated `stream`.
-         * Call `rl.commit()` to see the effect of this method, unless autoCommit: true was passed to the constructor.
+         * The `rl.moveCursor()` method adds to the internal list of pending action an
+         * action that moves the cursor _relative_ to its current position in the
+         * associated `stream`.
+         * Call `rl.commit()` to see the effect of this method, unless `autoCommit: true`was passed to the constructor.
+         * @since v17.0.0
+         * @return this
          */
         moveCursor(dx: number, dy: number): this;
         /**
-         * The `rl.rollback()` method clears the internal list of pending actions without sending it to the associated `stream`.
+         * The `rl.rollback` methods clears the internal list of pending actions without
+         * sending it to the associated `stream`.
+         * @since v17.0.0
+         * @return this
          */
         rollback(): this;
     }
     /**
-     * The `readlinePromises.createInterface()` method creates a new `readlinePromises.Interface` instance.
+     * The `readlinePromises.createInterface()` method creates a new `readlinePromises.Interface`instance.
      *
      * ```js
      * const readlinePromises = require('node:readline/promises');
      * const rl = readlinePromises.createInterface({
      *   input: process.stdin,
-     *   output: process.stdout
+     *   output: process.stdout,
      * });
      * ```
      *
-     * Once the `readlinePromises.Interface` instance is created, the most common case is to listen for the `'line'` event:
+     * Once the `readlinePromises.Interface` instance is created, the most common case
+     * is to listen for the `'line'` event:
      *
      * ```js
      * rl.on('line', (line) => {
@@ -102,42 +131,13 @@ declare module 'readline/promises' {
      * });
      * ```
      *
-     * If `terminal` is `true` for this instance then the `output` stream will get the best compatibility if it defines an `output.columns` property,
-     * and emits a `'resize'` event on the `output`, if or when the columns ever change (`process.stdout` does this automatically when it is a TTY).
-     *
-     * ## Use of the `completer` function
-     *
-     * The `completer` function takes the current line entered by the user as an argument, and returns an `Array` with 2 entries:
-     *
-     * - An Array with matching entries for the completion.
-     * - The substring that was used for the matching.
-     *
-     * For instance: `[[substr1, substr2, ...], originalsubstring]`.
-     *
-     * ```js
-     * function completer(line) {
-     *   const completions = '.help .error .exit .quit .q'.split(' ');
-     *   const hits = completions.filter((c) => c.startsWith(line));
-     *   // Show all completions if none found
-     *   return [hits.length ? hits : completions, line];
-     * }
-     * ```
-     *
-     * The `completer` function can also returns a `Promise`, or be asynchronous:
-     *
-     * ```js
-     * async function completer(linePartial) {
-     *   await someAsyncWork();
-     *   return [['123'], linePartial];
-     * }
-     * ```
+     * If `terminal` is `true` for this instance then the `output` stream will get
+     * the best compatibility if it defines an `output.columns` property and emits
+     * a `'resize'` event on the `output` if or when the columns ever change
+     * (`process.stdout` does this automatically when it is a TTY).
+     * @since v17.0.0
      */
-    function createInterface(
-        input: NodeJS.ReadableStream,
-        output?: NodeJS.WritableStream,
-        completer?: Completer | AsyncCompleter,
-        terminal?: boolean,
-    ): Interface;
+    function createInterface(input: NodeJS.ReadableStream, output?: NodeJS.WritableStream, completer?: Completer | AsyncCompleter, terminal?: boolean): Interface;
     function createInterface(options: ReadLineOptions): Interface;
 }
 declare module 'node:readline/promises' {