cloudstructs 0.12.9 → 0.12.11

package/node_modules/@types/cacheable-request/node_modules/@types/node/sqlite.d.ts

@@ -1,47 +1,3 @@
-/**
- * The `node:sqlite` module facilitates working with SQLite databases.
- * To access it:
- *
- * ```js
- * import sqlite from 'node:sqlite';
- * ```
- *
- * This module is only available under the `node:` scheme. The following will not
- * work:
- *
- * ```js
- * import sqlite from 'sqlite';
- * ```
- *
- * The following example shows the basic usage of the `node:sqlite` module to open
- * an in-memory database, write data to the database, and then read the data back.
- *
- * ```js
- * import { DatabaseSync } from 'node:sqlite';
- * const database = new DatabaseSync(':memory:');
- *
- * // Execute SQL statements from strings.
- * database.exec(`
- *   CREATE TABLE data(
- *     key INTEGER PRIMARY KEY,
- *     value TEXT
- *   ) STRICT
- * `);
- * // Create a prepared statement to insert data into the database.
- * const insert = database.prepare('INSERT INTO data (key, value) VALUES (?, ?)');
- * // Execute the prepared statement with bound values.
- * insert.run(1, 'hello');
- * insert.run(2, 'world');
- * // Create a prepared statement to read data from the database.
- * const query = database.prepare('SELECT * FROM data ORDER BY key');
- * // Execute the prepared statement and log the result set.
- * console.log(query.all());
- * // Prints: [ { key: 1, value: 'hello' }, { key: 2, value: 'world' } ]
- * ```
- * @since v22.5.0
- * @experimental
- * @see [source](https://github.com/nodejs/node/blob/v25.x/lib/sqlite.js)
- */
 declare module "node:sqlite" {
     import { PathLike } from "node:fs";
     type SQLInputValue = null | number | bigint | string | NodeJS.ArrayBufferView;
@@ -128,7 +84,7 @@ declare module "node:sqlite" {
          * language features that allow ordinary SQL to deliberately corrupt the database file are disabled.
          * The defensive flag can also be set using `enableDefensive()`.
          * @since v25.1.0
-         * @default false
+         * @default true
          */
         defensive?: boolean | undefined;
     }
@@ -233,6 +189,28 @@ declare module "node:sqlite" {
          */
         inverse?: ((accumulator: T, ...args: SQLOutputValue[]) => T) | undefined;
     }
+    interface PrepareOptions {
+        /**
+         * If `true`, integer fields are read as `BigInt`s.
+         * @since v25.5.0
+         */
+        readBigInts?: boolean | undefined;
+        /**
+         * If `true`, results are returned as arrays.
+         * @since v25.5.0
+         */
+        returnArrays?: boolean | undefined;
+        /**
+         * If `true`, allows binding named parameters without the prefix character.
+         * @since v25.5.0
+         */
+        allowBareNamedParameters?: boolean | undefined;
+        /**
+         * If `true`, unknown named parameters are ignored.
+         * @since v25.5.0
+         */
+        allowUnknownNamedParameters?: boolean | undefined;
+    }
     /**
      * This class represents a single [connection](https://www.sqlite.org/c3ref/sqlite3.html) to a SQLite database. All APIs
      * exposed by this class execute synchronously.
@@ -425,19 +403,73 @@ declare module "node:sqlite" {
          * around [`sqlite3_prepare_v2()`](https://www.sqlite.org/c3ref/prepare.html).
          * @since v22.5.0
          * @param sql A SQL string to compile to a prepared statement.
+         * @param options Optional configuration for the prepared statement.
          * @return The prepared statement.
          */
-        prepare(sql: string): StatementSync;
+        prepare(sql: string, options?: PrepareOptions): StatementSync;
         /**
-         * Creates a new `SQLTagStore`, which is an LRU (Least Recently Used) cache for
-         * storing prepared statements. This allows for the efficient reuse of prepared
-         * statements by tagging them with a unique identifier.
+         * Creates a new {@link SQLTagStore}, which is a Least Recently Used (LRU) cache
+         * for storing prepared statements. This allows for the efficient reuse of
+         * prepared statements by tagging them with a unique identifier.
          *
          * When a tagged SQL literal is executed, the `SQLTagStore` checks if a prepared
-         * statement for that specific SQL string already exists in the cache. If it does,
-         * the cached statement is used. If not, a new prepared statement is created,
-         * executed, and then stored in the cache for future use. This mechanism helps to
-         * avoid the overhead of repeatedly parsing and preparing the same SQL statements.
+         * statement for the corresponding SQL query string already exists in the cache.
+         * If it does, the cached statement is used. If not, a new prepared statement is
+         * created, executed, and then stored in the cache for future use. This mechanism
+         * helps to avoid the overhead of repeatedly parsing and preparing the same SQL
+         * statements.
+         *
+         * Tagged statements bind the placeholder values from the template literal as
+         * parameters to the underlying prepared statement. For example:
+         *
+         * ```js
+         * sqlTagStore.get`SELECT ${value}`;
+         * ```
+         *
+         * is equivalent to:
+         *
+         * ```js
+         * db.prepare('SELECT ?').get(value);
+         * ```
+         *
+         * However, in the first example, the tag store will cache the underlying prepared
+         * statement for future use.
+         *
+         * > **Note:** The `${value}` syntax in tagged statements _binds_ a parameter to
+         * > the prepared statement. This differs from its behavior in _untagged_ template
+         * > literals, where it performs string interpolation.
+         * >
+         * > ```js
+         * > // This a safe example of binding a parameter to a tagged statement.
+         * > sqlTagStore.run`INSERT INTO t1 (id) VALUES (${id})`;
+         * >
+         * > // This is an *unsafe* example of an untagged template string.
+         * > // `id` is interpolated into the query text as a string.
+         * > // This can lead to SQL injection and data corruption.
+         * > db.run(`INSERT INTO t1 (id) VALUES (${id})`);
+         * > ```
+         *
+         * The tag store will match a statement from the cache if the query strings
+         * (including the positions of any bound placeholders) are identical.
+         *
+         * ```js
+         * // The following statements will match in the cache:
+         * sqlTagStore.get`SELECT * FROM t1 WHERE id = ${id} AND active = 1`;
+         * sqlTagStore.get`SELECT * FROM t1 WHERE id = ${12345} AND active = 1`;
+         *
+         * // The following statements will not match, as the query strings
+         * // and bound placeholders differ:
+         * sqlTagStore.get`SELECT * FROM t1 WHERE id = ${id} AND active = 1`;
+         * sqlTagStore.get`SELECT * FROM t1 WHERE id = 12345 AND active = 1`;
+         *
+         * // The following statements will not match, as matches are case-sensitive:
+         * sqlTagStore.get`SELECT * FROM t1 WHERE id = ${id} AND active = 1`;
+         * sqlTagStore.get`select * from t1 where id = ${id} and active = 1`;
+         * ```
+         *
+         * The only way of binding parameters in tagged statements is with the `${value}`
+         * syntax. Do not add parameter binding placeholders (`?` etc.) to the SQL query
+         * string itself.
          *
          * ```js
          * import { DatabaseSync } from 'node:sqlite';
@@ -453,8 +485,8 @@ declare module "node:sqlite" {
          * sql.run`INSERT INTO users VALUES (2, 'Bob')`;
          *
          * // Using the 'get' method to retrieve a single row.
-         * const id = 1;
-         * const user = sql.get`SELECT * FROM users WHERE id = ${id}`;
+         * const name = 'Alice';
+         * const user = sql.get`SELECT * FROM users WHERE name = ${name}`;
          * console.log(user); // { id: 1, name: 'Alice' }
          *
          * // Using the 'all' method to retrieve all rows.
@@ -543,26 +575,39 @@ declare module "node:sqlite" {
          * [`sqlite3session_delete()`](https://www.sqlite.org/session/sqlite3session_delete.html).
          */
         close(): void;
+        /**
+         * Closes the session. If the session is already closed, does nothing.
+         * @since v24.9.0
+         */
+        [Symbol.dispose](): void;
     }
     /**
      * This class represents a single LRU (Least Recently Used) cache for storing
      * prepared statements.
      *
-     * Instances of this class are created via the database.createSQLTagStore() method,
-     * not by using a constructor. The store caches prepared statements based on the
-     * provided SQL query string. When the same query is seen again, the store
+     * Instances of this class are created via the `database.createTagStore()`
+     * method, not by using a constructor. The store caches prepared statements based
+     * on the provided SQL query string. When the same query is seen again, the store
      * retrieves the cached statement and safely applies the new values through
      * parameter binding, thereby preventing attacks like SQL injection.
      *
      * The cache has a maxSize that defaults to 1000 statements, but a custom size can
-     * be provided (e.g., database.createSQLTagStore(100)). All APIs exposed by this
+     * be provided (e.g., `database.createTagStore(100)`). All APIs exposed by this
      * class execute synchronously.
      * @since v24.9.0
      */
     interface SQLTagStore {
         /**
-         * Executes the given SQL query and returns all resulting rows as an array of objects.
+         * Executes the given SQL query and returns all resulting rows as an array of
+         * objects.
+         *
+         * This function is intended to be used as a template literal tag, not to be
+         * called directly.
          * @since v24.9.0
+         * @param stringElements Template literal elements containing the SQL
+         * query.
+         * @param boundParameters Parameter values to be bound to placeholders in the template string.
+         * @returns An array of objects representing the rows returned by the query.
          */
         all(
             stringElements: TemplateStringsArray,
@@ -570,7 +615,15 @@ declare module "node:sqlite" {
         ): Record<string, SQLOutputValue>[];
         /**
          * Executes the given SQL query and returns the first resulting row as an object.
+         *
+         * This function is intended to be used as a template literal tag, not to be
+         * called directly.
          * @since v24.9.0
+         * @param stringElements Template literal elements containing the SQL
+         * query.
+         * @param boundParameters Parameter values to be bound to placeholders in the template string.
+         * @returns An object representing the first row returned by
+         * the query, or `undefined` if no rows are returned.
          */
         get(
             stringElements: TemplateStringsArray,
@@ -578,7 +631,14 @@ declare module "node:sqlite" {
         ): Record<string, SQLOutputValue> | undefined;
         /**
          * Executes the given SQL query and returns an iterator over the resulting rows.
+         *
+         * This function is intended to be used as a template literal tag, not to be
+         * called directly.
          * @since v24.9.0
+         * @param stringElements Template literal elements containing the SQL
+         * query.
+         * @param boundParameters Parameter values to be bound to placeholders in the template string.
+         * @returns An iterator that yields objects representing the rows returned by the query.
          */
         iterate(
             stringElements: TemplateStringsArray,
@@ -586,15 +646,21 @@ declare module "node:sqlite" {
         ): NodeJS.Iterator<Record<string, SQLOutputValue>>;
         /**
          * Executes the given SQL query, which is expected to not return any rows (e.g., INSERT, UPDATE, DELETE).
+         *
+         * This function is intended to be used as a template literal tag, not to be
+         * called directly.
          * @since v24.9.0
+         * @param stringElements Template literal elements containing the SQL
+         * query.
+         * @param boundParameters Parameter values to be bound to placeholders in the template string.
+         * @returns An object containing information about the execution, including `changes` and `lastInsertRowid`.
          */
         run(stringElements: TemplateStringsArray, ...boundParameters: SQLInputValue[]): StatementResultingChanges;
         /**
          * A read-only property that returns the number of prepared statements currently in the cache.
          * @since v24.9.0
-         * @returns The maximum number of prepared statements the cache can hold.
          */
-        size(): number;
+        readonly size: number;
         /**
          * A read-only property that returns the maximum number of prepared statements the cache can hold.
          * @since v24.9.0

package/node_modules/@types/cacheable-request/node_modules/@types/node/stream/consumers.d.ts

@@ -1,33 +1,109 @@
-/**
- * The utility consumer functions provide common options for consuming
- * streams.
- * @since v16.7.0
- */
 declare module "node:stream/consumers" {
     import { Blob, NonSharedBuffer } from "node:buffer";
     import { ReadableStream } from "node:stream/web";
     /**
+     * ```js
+     * import { arrayBuffer } from 'node:stream/consumers';
+     * import { Readable } from 'node:stream';
+     * import { TextEncoder } from 'node:util';
+     *
+     * const encoder = new TextEncoder();
+     * const dataArray = encoder.encode('hello world from consumers!');
+     *
+     * const readable = Readable.from(dataArray);
+     * const data = await arrayBuffer(readable);
+     * console.log(`from readable: ${data.byteLength}`);
+     * // Prints: from readable: 76
+     * ```
      * @since v16.7.0
      * @returns Fulfills with an `ArrayBuffer` containing the full contents of the stream.
      */
     function arrayBuffer(stream: ReadableStream | NodeJS.ReadableStream | AsyncIterable<any>): Promise<ArrayBuffer>;
     /**
+     * ```js
+     * import { blob } from 'node:stream/consumers';
+     *
+     * const dataBlob = new Blob(['hello world from consumers!']);
+     *
+     * const readable = dataBlob.stream();
+     * const data = await blob(readable);
+     * console.log(`from readable: ${data.size}`);
+     * // Prints: from readable: 27
+     * ```
      * @since v16.7.0
      * @returns Fulfills with a `Blob` containing the full contents of the stream.
      */
     function blob(stream: ReadableStream | NodeJS.ReadableStream | AsyncIterable<any>): Promise<Blob>;
     /**
+     * ```js
+     * import { buffer } from 'node:stream/consumers';
+     * import { Readable } from 'node:stream';
+     * import { Buffer } from 'node:buffer';
+     *
+     * const dataBuffer = Buffer.from('hello world from consumers!');
+     *
+     * const readable = Readable.from(dataBuffer);
+     * const data = await buffer(readable);
+     * console.log(`from readable: ${data.length}`);
+     * // Prints: from readable: 27
+     * ```
      * @since v16.7.0
      * @returns Fulfills with a `Buffer` containing the full contents of the stream.
      */
     function buffer(stream: ReadableStream | NodeJS.ReadableStream | AsyncIterable<any>): Promise<NonSharedBuffer>;
     /**
+     * ```js
+     * import { bytes } from 'node:stream/consumers';
+     * import { Readable } from 'node:stream';
+     * import { Buffer } from 'node:buffer';
+     *
+     * const dataBuffer = Buffer.from('hello world from consumers!');
+     *
+     * const readable = Readable.from(dataBuffer);
+     * const data = await bytes(readable);
+     * console.log(`from readable: ${data.length}`);
+     * // Prints: from readable: 27
+     * ```
+     * @since v25.6.0
+     * @returns Fulfills with a `Uint8Array` containing the full contents of the stream.
+     */
+    function bytes(
+        stream: ReadableStream | NodeJS.ReadableStream | AsyncIterable<any>,
+    ): Promise<NodeJS.NonSharedUint8Array>;
+    /**
+     * ```js
+     * import { json } from 'node:stream/consumers';
+     * import { Readable } from 'node:stream';
+     *
+     * const items = Array.from(
+     *   {
+     *     length: 100,
+     *   },
+     *   () => ({
+     *     message: 'hello world from consumers!',
+     *   }),
+     * );
+     *
+     * const readable = Readable.from(JSON.stringify(items));
+     * const data = await json(readable);
+     * console.log(`from readable: ${data.length}`);
+     * // Prints: from readable: 100
+     * ```
      * @since v16.7.0
      * @returns Fulfills with the contents of the stream parsed as a
      * UTF-8 encoded string that is then passed through `JSON.parse()`.
      */
     function json(stream: ReadableStream | NodeJS.ReadableStream | AsyncIterable<any>): Promise<unknown>;
     /**
+     * ```js
+     * import { text } from 'node:stream/consumers';
+     * import { Readable } from 'node:stream';
+     *
+     * const readable = Readable.from('Hello world from consumers!');
+     * const data = await text(readable);
+     * console.log(`from readable: ${data.length}`);
+     * // Prints: from readable: 27
+     * ```
      * @since v16.7.0
      * @returns Fulfills with the contents of the stream parsed as a UTF-8 encoded string.
      */

package/node_modules/@types/cacheable-request/node_modules/@types/node/stream/web.d.ts

@@ -206,7 +206,7 @@ declare module "node:stream/web" {
     interface ReadableStreamDefaultController<R = any> {
         readonly desiredSize: number | null;
         close(): void;
-        enqueue(chunk?: R): void;
+        enqueue(chunk: R): void;
         error(e?: any): void;
     }
     var ReadableStreamDefaultController: {
@@ -251,7 +251,7 @@ declare module "node:stream/web" {
     };
     interface TransformStreamDefaultController<O = any> {
         readonly desiredSize: number | null;
-        enqueue(chunk?: O): void;
+        enqueue(chunk: O): void;
         error(reason?: any): void;
         terminate(): void;
     }
@@ -284,7 +284,7 @@ declare module "node:stream/web" {
         abort(reason?: any): Promise<void>;
         close(): Promise<void>;
         releaseLock(): void;
-        write(chunk?: W): Promise<void>;
+        write(chunk: W): Promise<void>;
     }
     var WritableStreamDefaultWriter: {
         prototype: WritableStreamDefaultWriter;

package/node_modules/@types/cacheable-request/node_modules/@types/node/stream.d.ts

@@ -1,22 +1,3 @@
-/**
- * A stream is an abstract interface for working with streaming data in Node.js.
- * The `node:stream` module provides an API for implementing the stream interface.
- *
- * There are many stream objects provided by Node.js. For instance, a [request to an HTTP server](https://nodejs.org/docs/latest-v25.x/api/http.html#class-httpincomingmessage)
- * and [`process.stdout`](https://nodejs.org/docs/latest-v25.x/api/process.html#processstdout) are both stream instances.
- *
- * Streams can be readable, writable, or both. All streams are instances of [`EventEmitter`](https://nodejs.org/docs/latest-v25.x/api/events.html#class-eventemitter).
- *
- * To access the `node:stream` module:
- *
- * ```js
- * import stream from 'node:stream';
- * ```
- *
- * The `node:stream` module is useful for creating new types of stream instances.
- * It is usually not necessary to use the `node:stream` module to consume streams.
- * @see [source](https://github.com/nodejs/node/blob/v25.x/lib/stream.js)
- */
 declare module "node:stream" {
     import { Blob } from "node:buffer";
     import { Abortable, EventEmitter } from "node:events";
@@ -81,6 +62,7 @@ declare module "node:stream" {
         interface ArrayOptions extends ReadableOperatorOptions {}
         interface ReadableToWebOptions {
             strategy?: web.QueuingStrategy | undefined;
+            type?: web.ReadableStreamType | undefined;
         }
         interface ReadableEventMap {
             "close": [];
@@ -485,13 +467,18 @@ declare module "node:stream" {
              *   }
              * }
              *
-             * const wordsStream = Readable.from(['this is', 'compose as operator']).compose(splitToWords);
+             * const wordsStream = Readable.from(['text passed through', 'composed stream']).compose(splitToWords);
              * const words = await wordsStream.toArray();
              *
-             * console.log(words); // prints ['this', 'is', 'compose', 'as', 'operator']
+             * console.log(words); // prints ['text', 'passed', 'through', 'composed', 'stream']
              * ```
              *
-             * See [`stream.compose`](https://nodejs.org/docs/latest-v25.x/api/stream.html#streamcomposestreams) for more information.
+             * `readable.compose(s)` is equivalent to `stream.compose(readable, s)`.
+             *
+             * This method also allows for an `AbortSignal` to be provided, which will destroy
+             * the composed stream when aborted.
+             *
+             * See [`stream.compose(...streams)`](https://nodejs.org/docs/latest-v25.x/api/stream.html#streamcomposestreams) for more information.
              * @since v19.1.0, v18.13.0
              * @returns a stream composed with the stream `stream`.
              */
@@ -893,11 +880,20 @@ declare module "node:stream" {
              * @since v0.9.4
              * @param chunk Optional data to write. For streams not operating in object mode, `chunk` must be a {string}, {Buffer},
              * {TypedArray} or {DataView}. For object mode streams, `chunk` may be any JavaScript value other than `null`.
-             * @param [encoding='utf8'] The encoding, if `chunk` is a string.
              * @param callback Callback for when this chunk of data is flushed.
              * @return `false` if the stream wishes for the calling code to wait for the `'drain'` event to be emitted before continuing to write additional data; otherwise `true`.
              */
             write(chunk: any, callback?: (error: Error | null | undefined) => void): boolean;
+            /**
+             * Writes data to the stream, with an explicit encoding for string data.
+             * @see {@link Writable.write} for full details.
+             * @since v0.9.4
+             * @param chunk Optional data to write. For streams not operating in object mode, `chunk` must be a {string}, {Buffer},
+             * {TypedArray} or {DataView}. For object mode streams, `chunk` may be any JavaScript value other than `null`.
+             * @param encoding The encoding, if `chunk` is a string.
+             * @param callback Callback for when this chunk of data is flushed.
+             * @return `false` if the stream wishes for the calling code to wait for the `'drain'` event to be emitted before continuing to write additional data; otherwise `true`.
+             */
             write(chunk: any, encoding: BufferEncoding, callback?: (error: Error | null | undefined) => void): boolean;
             /**
              * The `writable.setDefaultEncoding()` method sets the default `encoding` for a `Writable` stream.
@@ -922,13 +918,27 @@ declare module "node:stream" {
              * // Writing more now is not allowed!
              * ```
              * @since v0.9.4
+             * @param cb Callback for when the stream is finished.
+             */
+            end(cb?: () => void): this;
+            /**
+             * Signals that no more data will be written, with one final chunk of data.
+             * @see {@link Writable.end} for full details.
+             * @since v0.9.4
              * @param chunk Optional data to write. For streams not operating in object mode, `chunk` must be a {string}, {Buffer},
              * {TypedArray} or {DataView}. For object mode streams, `chunk` may be any JavaScript value other than `null`.
-             * @param encoding The encoding if `chunk` is a string
-             * @param callback Callback for when the stream is finished.
+             * @param cb Callback for when the stream is finished.
              */
-            end(cb?: () => void): this;
             end(chunk: any, cb?: () => void): this;
+            /**
+             * Signals that no more data will be written, with one final chunk of data.
+             * @see {@link Writable.end} for full details.
+             * @since v0.9.4
+             * @param chunk Optional data to write. For streams not operating in object mode, `chunk` must be a {string}, {Buffer},
+             * {TypedArray} or {DataView}. For object mode streams, `chunk` may be any JavaScript value other than `null`.
+             * @param encoding The encoding if `chunk` is a string
+             * @param cb Callback for when the stream is finished.
+             */
             end(chunk: any, encoding: BufferEncoding, cb?: () => void): this;
             /**
              * The `writable.cork()` method forces all written data to be buffered in memory.
@@ -1056,6 +1066,9 @@ declare module "node:stream" {
             writableHighWaterMark?: number | undefined;
             writableCorked?: number | undefined;
         }
+        interface DuplexToWebOptions {
+            type?: web.ReadableStreamType | undefined;
+        }
         interface DuplexEventMap extends ReadableEventMap, WritableEventMap {}
         /**
          * Duplex streams are streams that implement both the `Readable` and `Writable` interfaces.
@@ -1109,7 +1122,7 @@ declare module "node:stream" {
              * A utility method for creating a web `ReadableStream` and `WritableStream` from a `Duplex`.
              * @since v17.0.0
              */
-            static toWeb(streamDuplex: NodeJS.ReadWriteStream): web.ReadableWritablePair;
+            static toWeb(streamDuplex: NodeJS.ReadWriteStream, options?: DuplexToWebOptions): web.ReadableWritablePair;
             /**
              * A utility method for creating a `Duplex` from a web `ReadableStream` and `WritableStream`.
              * @since v17.0.0
@@ -1653,7 +1666,8 @@ declare module "node:stream" {
          * console.log(res); // prints 'HELLOWORLD'
          * ```
          *
-         * See [`readable.compose(stream)`](https://nodejs.org/docs/latest-v25.x/api/stream.html#readablecomposestream-options) for `stream.compose` as operator.
+         * For convenience, the `readable.compose(stream)` method is available on
+         * `Readable` and `Duplex` streams as a wrapper for this function.
          * @since v16.9.0
          * @experimental
          */

package/node_modules/@types/cacheable-request/node_modules/@types/node/string_decoder.d.ts

@@ -1,43 +1,3 @@
-/**
- * The `node:string_decoder` module provides an API for decoding `Buffer` objects
- * into strings in a manner that preserves encoded multi-byte UTF-8 and UTF-16
- * characters. It can be accessed using:
- *
- * ```js
- * import { StringDecoder } from 'node:string_decoder';
- * ```
- *
- * The following example shows the basic use of the `StringDecoder` class.
- *
- * ```js
- * import { StringDecoder } from 'node:string_decoder';
- * const decoder = new StringDecoder('utf8');
- *
- * const cent = Buffer.from([0xC2, 0xA2]);
- * console.log(decoder.write(cent)); // Prints: ¢
- *
- * const euro = Buffer.from([0xE2, 0x82, 0xAC]);
- * console.log(decoder.write(euro)); // Prints: €
- * ```
- *
- * When a `Buffer` instance is written to the `StringDecoder` instance, an
- * internal buffer is used to ensure that the decoded string does not contain
- * any incomplete multibyte characters. These are held in the buffer until the
- * next call to `stringDecoder.write()` or until `stringDecoder.end()` is called.
- *
- * In the following example, the three UTF-8 encoded bytes of the European Euro
- * symbol (`€`) are written over three separate operations:
- *
- * ```js
- * import { StringDecoder } from 'node:string_decoder';
- * const decoder = new StringDecoder('utf8');
- *
- * decoder.write(Buffer.from([0xE2]));
- * decoder.write(Buffer.from([0x82]));
- * console.log(decoder.end(Buffer.from([0xAC]))); // Prints: €
- * ```
- * @see [source](https://github.com/nodejs/node/blob/v25.x/lib/string_decoder.js)
- */
 declare module "node:string_decoder" {
     class StringDecoder {
         constructor(encoding?: BufferEncoding);

package/node_modules/@types/cacheable-request/node_modules/@types/node/test/reporters.d.ts

@@ -1,41 +1,3 @@
-/**
- * The `node:test` module supports passing `--test-reporter`
- * flags for the test runner to use a specific reporter.
- *
- * The following built-reporters are supported:
- *
- * * `spec`
- *   The `spec` reporter outputs the test results in a human-readable format. This
- *   is the default reporter.
- *
- * * `tap`
- *   The `tap` reporter outputs the test results in the [TAP](https://testanything.org/) format.
- *
- * * `dot`
- *   The `dot` reporter outputs the test results in a compact format,
- *   where each passing test is represented by a `.`,
- *   and each failing test is represented by a `X`.
- *
- * * `junit`
- *   The junit reporter outputs test results in a jUnit XML format
- *
- * * `lcov`
- *   The `lcov` reporter outputs test coverage when used with the
- *   `--experimental-test-coverage` flag.
- *
- * The exact output of these reporters is subject to change between versions of
- * Node.js, and should not be relied on programmatically. If programmatic access
- * to the test runner's output is required, use the events emitted by the
- * `TestsStream`.
- *
- * The reporters are available via the `node:test/reporters` module:
- *
- * ```js
- * import { tap, spec, dot, junit, lcov } from 'node:test/reporters';
- * ```
- * @since v19.9.0, v18.17.0
- * @see [source](https://github.com/nodejs/node/blob/v25.x/lib/test/reporters.js)
- */
 declare module "node:test/reporters" {
     import { Transform, TransformOptions } from "node:stream";
     import { EventData } from "node:test";