cloudstructs 0.12.10 → 0.12.11

package/node_modules/@types/responselike/node_modules/@types/node/crypto.d.ts

@@ -1,21 +1,3 @@
-/**
- * The `node:crypto` module provides cryptographic functionality that includes a
- * set of wrappers for OpenSSL's hash, HMAC, cipher, decipher, sign, and verify
- * functions.
- *
- * ```js
- * const { createHmac } = await import('node:crypto');
- *
- * const secret = 'abcdefg';
- * const hash = createHmac('sha256', secret)
- *                .update('I love cupcakes')
- *                .digest('hex');
- * console.log(hash);
- * // Prints:
- * //   c0fa1bc00531bd78ef38c628449c5102aeabd49b5dc3a2a516ea6ea959d6658e
- * ```
- * @see [source](https://github.com/nodejs/node/blob/v25.x/lib/crypto.js)
- */
 declare module "node:crypto" {
     import { NonSharedBuffer } from "node:buffer";
     import * as stream from "node:stream";

package/node_modules/@types/responselike/node_modules/@types/node/dgram.d.ts

@@ -1,30 +1,3 @@
-/**
- * The `node:dgram` module provides an implementation of UDP datagram sockets.
- *
- * ```js
- * import dgram from 'node:dgram';
- *
- * const server = dgram.createSocket('udp4');
- *
- * server.on('error', (err) => {
- *   console.error(`server error:\n${err.stack}`);
- *   server.close();
- * });
- *
- * server.on('message', (msg, rinfo) => {
- *   console.log(`server got: ${msg} from ${rinfo.address}:${rinfo.port}`);
- * });
- *
- * server.on('listening', () => {
- *   const address = server.address();
- *   console.log(`server listening ${address.address}:${address.port}`);
- * });
- *
- * server.bind(41234);
- * // Prints: server listening 0.0.0.0:41234
- * ```
- * @see [source](https://github.com/nodejs/node/blob/v25.x/lib/dgram.js)
- */
 declare module "node:dgram" {
     import { NonSharedBuffer } from "node:buffer";
     import * as dns from "node:dns";

package/node_modules/@types/responselike/node_modules/@types/node/diagnostics_channel.d.ts

@@ -1,27 +1,3 @@
-/**
- * The `node:diagnostics_channel` module provides an API to create named channels
- * to report arbitrary message data for diagnostics purposes.
- *
- * It can be accessed using:
- *
- * ```js
- * import diagnostics_channel from 'node:diagnostics_channel';
- * ```
- *
- * It is intended that a module writer wanting to report diagnostics messages
- * will create one or many top-level channels to report messages through.
- * Channels may also be acquired at runtime but it is not encouraged
- * due to the additional overhead of doing so. Channels may be exported for
- * convenience, but as long as the name is known it can be acquired anywhere.
- *
- * If you intend for your module to produce diagnostics data for others to
- * consume it is recommended that you include documentation of what named
- * channels are used along with the shape of the message data. Channel names
- * should generally include the module name to avoid collisions with data from
- * other modules.
- * @since v15.1.0, v14.17.0
- * @see [source](https://github.com/nodejs/node/blob/v25.x/lib/diagnostics_channel.js)
- */
 declare module "node:diagnostics_channel" {
     import { AsyncLocalStorage } from "node:async_hooks";
     /**

package/node_modules/@types/responselike/node_modules/@types/node/dns/promises.d.ts

@@ -1,9 +1,3 @@
-/**
- * The `dns.promises` API provides an alternative set of asynchronous DNS methods
- * that return `Promise` objects rather than using callbacks. The API is accessible
- * via `import { promises as dnsPromises } from 'node:dns'` or `import dnsPromises from 'node:dns/promises'`.
- * @since v10.6.0
- */
 declare module "node:dns/promises" {
     import {
         AnyRecord,

package/node_modules/@types/responselike/node_modules/@types/node/dns.d.ts

@@ -1,49 +1,3 @@
-/**
- * The `node:dns` module enables name resolution. For example, use it to look up IP
- * addresses of host names.
- *
- * Although named for the [Domain Name System (DNS)](https://en.wikipedia.org/wiki/Domain_Name_System), it does not always use the
- * DNS protocol for lookups. {@link lookup} uses the operating system
- * facilities to perform name resolution. It may not need to perform any network
- * communication. To perform name resolution the way other applications on the same
- * system do, use {@link lookup}.
- *
- * ```js
- * import dns from 'node:dns';
- *
- * dns.lookup('example.org', (err, address, family) => {
- *   console.log('address: %j family: IPv%s', address, family);
- * });
- * // address: "93.184.216.34" family: IPv4
- * ```
- *
- * All other functions in the `node:dns` module connect to an actual DNS server to
- * perform name resolution. They will always use the network to perform DNS
- * queries. These functions do not use the same set of configuration files used by {@link lookup} (e.g. `/etc/hosts`). Use these functions to always perform
- * DNS queries, bypassing other name-resolution facilities.
- *
- * ```js
- * import dns from 'node:dns';
- *
- * dns.resolve4('archive.org', (err, addresses) => {
- *   if (err) throw err;
- *
- *   console.log(`addresses: ${JSON.stringify(addresses)}`);
- *
- *   addresses.forEach((a) => {
- *     dns.reverse(a, (err, hostnames) => {
- *       if (err) {
- *         throw err;
- *       }
- *       console.log(`reverse for ${a}: ${JSON.stringify(hostnames)}`);
- *     });
- *   });
- * });
- * ```
- *
- * See the [Implementation considerations section](https://nodejs.org/docs/latest-v25.x/api/dns.html#implementation-considerations) for more information.
- * @see [source](https://github.com/nodejs/node/blob/v25.x/lib/dns.js)
- */
 declare module "node:dns" {
     // Supported getaddrinfo flags.
     /**

package/node_modules/@types/responselike/node_modules/@types/node/domain.d.ts

@@ -1,19 +1,3 @@
-/**
- * **This module is pending deprecation.** Once a replacement API has been
- * finalized, this module will be fully deprecated. Most developers should
- * **not** have cause to use this module. Users who absolutely must have
- * the functionality that domains provide may rely on it for the time being
- * but should expect to have to migrate to a different solution
- * in the future.
- *
- * Domains provide a way to handle multiple different IO operations as a
- * single group. If any of the event emitters or callbacks registered to a
- * domain emit an `'error'` event, or throw an error, then the domain object
- * 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/v25.x/lib/domain.js)
- */
 declare module "node:domain" {
     import { EventEmitter } from "node:events";
     /**

package/node_modules/@types/responselike/node_modules/@types/node/events.d.ts

@@ -1,39 +1,3 @@
-/**
- * Much of the Node.js core API is built around an idiomatic asynchronous
- * event-driven architecture in which certain kinds of objects (called "emitters")
- * emit named events that cause `Function` objects ("listeners") to be called.
- *
- * For instance: a `net.Server` object emits an event each time a peer
- * connects to it; a `fs.ReadStream` emits an event when the file is opened;
- * a `stream` emits an event whenever data is available to be read.
- *
- * All objects that emit events are instances of the `EventEmitter` class. These
- * objects expose an `eventEmitter.on()` function that allows one or more
- * functions to be attached to named events emitted by the object. Typically,
- * event names are camel-cased strings but any valid JavaScript property key
- * can be used.
- *
- * When the `EventEmitter` object emits an event, all of the functions attached
- * to that specific event are called _synchronously_. Any values returned by the
- * called listeners are _ignored_ and discarded.
- *
- * The following example shows a simple `EventEmitter` instance with a single
- * listener. The `eventEmitter.on()` method is used to register listeners, while
- * the `eventEmitter.emit()` method is used to trigger the event.
- *
- * ```js
- * import { EventEmitter } from 'node:events';
- *
- * class MyEmitter extends EventEmitter {}
- *
- * const myEmitter = new MyEmitter();
- * myEmitter.on('event', () => {
- *   console.log('an event occurred!');
- * });
- * myEmitter.emit('event');
- * ```
- * @see [source](https://github.com/nodejs/node/blob/v25.x/lib/events.js)
- */
 declare module "node:events" {
     import { AsyncResource, AsyncResourceOptions } from "node:async_hooks";
     // #region Event map helpers

package/node_modules/@types/responselike/node_modules/@types/node/fs/promises.d.ts

@@ -1,13 +1,3 @@
-/**
- * The `fs/promises` API provides asynchronous file system methods that return
- * promises.
- *
- * The promise APIs use the underlying Node.js threadpool to perform file
- * system operations off the event loop thread. These operations are not
- * synchronized or threadsafe. Care must be taken when performing multiple
- * concurrent modifications on the same file or data corruption may occur.
- * @since v10.0.0
- */
 declare module "node:fs/promises" {
     import { NonSharedBuffer } from "node:buffer";
     import { Abortable } from "node:events";

package/node_modules/@types/responselike/node_modules/@types/node/fs.d.ts

@@ -1,23 +1,3 @@
-/**
- * The `node:fs` module enables interacting with the file system in a
- * way modeled on standard POSIX functions.
- *
- * To use the promise-based APIs:
- *
- * ```js
- * import * as fs from 'node:fs/promises';
- * ```
- *
- * To use the callback and sync APIs:
- *
- * ```js
- * import * as fs from 'node:fs';
- * ```
- *
- * 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/v25.x/lib/fs.js)
- */
 declare module "node:fs" {
     import { NonSharedBuffer } from "node:buffer";
     import { Abortable, EventEmitter, InternalEventEmitter } from "node:events";

package/node_modules/@types/responselike/node_modules/@types/node/http.d.ts

@@ -1,44 +1,3 @@
-/**
- * To use the HTTP server and client one must import the `node:http` module.
- *
- * The HTTP interfaces in Node.js are designed to support many features
- * of the protocol which have been traditionally difficult to use.
- * In particular, large, possibly chunk-encoded, messages. The interface is
- * careful to never buffer entire requests or responses, so the
- * user is able to stream data.
- *
- * HTTP message headers are represented by an object like this:
- *
- * ```json
- * { "content-length": "123",
- *   "content-type": "text/plain",
- *   "connection": "keep-alive",
- *   "host": "example.com",
- *   "accept": "*" }
- * ```
- *
- * Keys are lowercased. Values are not modified.
- *
- * In order to support the full spectrum of possible HTTP applications, the Node.js
- * HTTP API is very low-level. It deals with stream handling and message
- * parsing only. It parses a message into headers and body but it does not
- * parse the actual headers or the body.
- *
- * See `message.headers` for details on how duplicate headers are handled.
- *
- * The raw headers as they were received are retained in the `rawHeaders` property, which is an array of `[key, value, key2, value2, ...]`. For
- * example, the previous message header object might have a `rawHeaders` list like the following:
- *
- * ```js
- * [ 'ConTent-Length', '123456',
- *   'content-LENGTH', '123',
- *   'content-type', 'text/plain',
- *   'CONNECTION', 'keep-alive',
- *   'Host', 'example.com',
- *   'accepT', '*' ]
- * ```
- * @see [source](https://github.com/nodejs/node/blob/v25.x/lib/http.js)
- */
 declare module "node:http" {
     import { NonSharedBuffer } from "node:buffer";
     import { LookupOptions } from "node:dns";

package/node_modules/@types/responselike/node_modules/@types/node/http2.d.ts

@@ -1,13 +1,3 @@
-/**
- * The `node:http2` module provides an implementation of the [HTTP/2](https://tools.ietf.org/html/rfc7540) protocol.
- * It can be accessed using:
- *
- * ```js
- * import http2 from 'node:http2';
- * ```
- * @since v8.4.0
- * @see [source](https://github.com/nodejs/node/blob/v25.x/lib/http2.js)
- */
 declare module "node:http2" {
     import { NonSharedBuffer } from "node:buffer";
     import { InternalEventEmitter } from "node:events";

package/node_modules/@types/responselike/node_modules/@types/node/https.d.ts

@@ -1,8 +1,3 @@
-/**
- * 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/v25.x/lib/https.js)
- */
 declare module "node:https" {
     import * as http from "node:http";
     import { Duplex } from "node:stream";

package/node_modules/@types/responselike/node_modules/@types/node/inspector/promises.d.ts

@@ -1,9 +1,3 @@
-/**
- * The `node:inspector/promises` module provides an API for interacting with the V8
- * inspector.
- * @see [source](https://github.com/nodejs/node/blob/v25.x/lib/inspector/promises.js)
- * @since v19.0.0
- */
 declare module "node:inspector/promises" {
     import { EventEmitter } from "node:events";
     export { close, console, NetworkResources, open, url, waitForDebugger } from "node:inspector";

package/node_modules/@types/responselike/node_modules/@types/node/inspector.d.ts

@@ -1,8 +1,3 @@
-/**
- * The `node:inspector` module provides an API for interacting with the V8
- * inspector.
- * @see [source](https://github.com/nodejs/node/blob/v25.x/lib/inspector.js)
- */
 declare module "node:inspector" {
     import { EventEmitter } from "node:events";
     /**

package/node_modules/@types/responselike/node_modules/@types/node/module.d.ts

@@ -1,6 +1,3 @@
-/**
- * @since v0.3.7
- */
 declare module "node:module" {
     import { URL } from "node:url";
     class Module {

package/node_modules/@types/responselike/node_modules/@types/node/net.d.ts

@@ -1,17 +1,3 @@
-/**
- * > Stability: 2 - Stable
- *
- * The `node:net` module provides an asynchronous network API for creating stream-based
- * TCP or `IPC` servers ({@link createServer}) and clients
- * ({@link createConnection}).
- *
- * It can be accessed using:
- *
- * ```js
- * import net from 'node:net';
- * ```
- * @see [source](https://github.com/nodejs/node/blob/v25.x/lib/net.js)
- */
 declare module "node:net" {
     import { NonSharedBuffer } from "node:buffer";
     import * as dns from "node:dns";
@@ -38,6 +24,7 @@ declare module "node:net" {
         keepAlive?: boolean | undefined;
         keepAliveInitialDelay?: number | undefined;
         blockList?: BlockList | undefined;
+        typeOfService?: number | undefined;
     }
     interface OnReadOpts {
         buffer: Uint8Array | (() => Uint8Array);
@@ -116,9 +103,14 @@ declare module "node:net" {
          * See `Writable` stream `write()` method for more
          * information.
          * @since v0.1.90
-         * @param [encoding='utf8'] Only used when data is `string`.
          */
         write(buffer: Uint8Array | string, cb?: (err?: Error | null) => void): boolean;
+        /**
+         * Sends data on the socket, with an explicit encoding for string data.
+         * @see {@link Socket.write} for full details.
+         * @since v0.1.90
+         * @param [encoding='utf8'] Only used when data is `string`.
+         */
         write(str: Uint8Array | string, encoding?: BufferEncoding, cb?: (err?: Error | null) => void): boolean;
         /**
          * Initiate a connection on a given socket.
@@ -226,6 +218,37 @@ declare module "node:net" {
          * @return The socket itself.
          */
         setKeepAlive(enable?: boolean, initialDelay?: number): this;
+        /**
+         * Returns the current Type of Service (TOS) field for IPv4 packets or Traffic
+         * Class for IPv6 packets for this socket.
+         *
+         * `setTypeOfService()` may be called before the socket is connected; the value
+         * will be cached and applied when the socket establishes a connection.
+         * `getTypeOfService()` will return the currently set value even before connection.
+         *
+         * On some platforms (e.g., Linux), certain TOS/ECN bits may be masked or ignored,
+         * and behavior can differ between IPv4 and IPv6 or dual-stack sockets. Callers
+         * should verify platform-specific semantics.
+         * @since v25.6.0
+         * @returns The current TOS value.
+         */
+        getTypeOfService(): number;
+        /**
+         * Sets the Type of Service (TOS) field for IPv4 packets or Traffic Class for IPv6
+         * Packets sent from this socket. This can be used to prioritize network traffic.
+         *
+         * `setTypeOfService()` may be called before the socket is connected; the value
+         * will be cached and applied when the socket establishes a connection.
+         * `getTypeOfService()` will return the currently set value even before connection.
+         *
+         * On some platforms (e.g., Linux), certain TOS/ECN bits may be masked or ignored,
+         * and behavior can differ between IPv4 and IPv6 or dual-stack sockets. Callers
+         * should verify platform-specific semantics.
+         * @since v25.6.0
+         * @param tos The TOS value to set (0-255).
+         * @returns The socket itself.
+         */
+        setTypeOfService(tos: number): this;
         /**
          * Returns the bound `address`, the address `family` name and `port` of the
          * socket as reported by the operating system:`{ port: 12346, family: 'IPv4', address: '127.0.0.1' }`
@@ -358,12 +381,26 @@ declare module "node:net" {
          *
          * See `writable.end()` for further details.
          * @since v0.1.90
-         * @param [encoding='utf8'] Only used when data is `string`.
          * @param callback Optional callback for when the socket is finished.
          * @return The socket itself.
          */
         end(callback?: () => void): this;
+        /**
+         * Half-closes the socket, with one final chunk of data.
+         * @see {@link Socket.end} for full details.
+         * @since v0.1.90
+         * @param callback Optional callback for when the socket is finished.
+         * @return The socket itself.
+         */
         end(buffer: Uint8Array | string, callback?: () => void): this;
+        /**
+         * Half-closes the socket, with one final chunk of data.
+         * @see {@link Socket.end} for full details.
+         * @since v0.1.90
+         * @param [encoding='utf8'] Only used when data is `string`.
+         * @param callback Optional callback for when the socket is finished.
+         * @return The socket itself.
+         */
         end(str: Uint8Array | string, encoding?: BufferEncoding, callback?: () => void): this;
         // #region InternalEventEmitter
         addListener<E extends keyof SocketEventMap>(eventName: E, listener: (...args: SocketEventMap[E]) => void): this;

package/node_modules/@types/responselike/node_modules/@types/node/os.d.ts

@@ -1,12 +1,3 @@
-/**
- * The `node:os` module provides operating system-related utility methods and
- * properties. It can be accessed using:
- *
- * ```js
- * import os from 'node:os';
- * ```
- * @see [source](https://github.com/nodejs/node/blob/v25.x/lib/os.js)
- */
 declare module "node:os" {
     import { NonSharedBuffer } from "buffer";
     interface CpuInfo {

package/node_modules/@types/responselike/node_modules/@types/node/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@types/node",
-    "version": "25.5.0",
+    "version": "25.6.0",
     "description": "TypeScript definitions for node",
     "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/node",
     "license": "MIT",
@@ -147,9 +147,9 @@
     },
     "scripts": {},
     "dependencies": {
-        "undici-types": "~7.18.0"
+        "undici-types": "~7.19.0"
     },
     "peerDependencies": {},
-    "typesPublisherContentHash": "4b6968335abe1dc64bd6086fd546d6e9c50f986c37d49de8073f4ed1c900057c",
-    "typeScriptVersion": "5.2"
+    "typesPublisherContentHash": "753bd9272f1c86686cc2d1bb435a7f033157f700201f64f0319742347e1ca060",
+    "typeScriptVersion": "5.3"
 }

package/node_modules/@types/responselike/node_modules/@types/node/path.d.ts

@@ -1,12 +1,3 @@
-/**
- * The `node:path` module provides utilities for working with file and directory
- * paths. It can be accessed using:
- *
- * ```js
- * import path from 'node:path';
- * ```
- * @see [source](https://github.com/nodejs/node/blob/v25.x/lib/path.js)
- */
 declare module "node:path" {
     namespace path {
         /**

package/node_modules/@types/responselike/node_modules/@types/node/perf_hooks.d.ts

@@ -1,34 +1,3 @@
-/**
- * This module provides an implementation of a subset of the W3C [Web Performance APIs](https://w3c.github.io/perf-timing-primer/) as well as additional APIs for
- * Node.js-specific performance measurements.
- *
- * Node.js supports the following [Web Performance APIs](https://w3c.github.io/perf-timing-primer/):
- *
- * * [High Resolution Time](https://www.w3.org/TR/hr-time-2)
- * * [Performance Timeline](https://w3c.github.io/performance-timeline/)
- * * [User Timing](https://www.w3.org/TR/user-timing/)
- * * [Resource Timing](https://www.w3.org/TR/resource-timing-2/)
- *
- * ```js
- * import { PerformanceObserver, performance } from 'node:perf_hooks';
- *
- * const obs = new PerformanceObserver((items) => {
- *   console.log(items.getEntries()[0].duration);
- *   performance.clearMarks();
- * });
- * obs.observe({ type: 'measure' });
- * performance.measure('Start to Now');
- *
- * performance.mark('A');
- * doSomeLongRunningProcess(() => {
- *   performance.measure('A to Now', 'A');
- *
- *   performance.mark('B');
- *   performance.measure('A to B', 'A', 'B');
- * });
- * ```
- * @see [source](https://github.com/nodejs/node/blob/v25.x/lib/perf_hooks.js)
- */
 declare module "node:perf_hooks" {
     import { InternalEventTargetEventProperties } from "node:events";
     // #region web types

package/node_modules/@types/responselike/node_modules/@types/node/punycode.d.ts

@@ -1,31 +1,3 @@
-/**
- * **The version of the punycode module bundled in Node.js is being deprecated. **In a future major version of Node.js this module will be removed. Users
- * currently depending on the `punycode` module should switch to using the
- * userland-provided [Punycode.js](https://github.com/bestiejs/punycode.js) module instead. For punycode-based URL
- * encoding, see `url.domainToASCII` or, more generally, the `WHATWG URL API`.
- *
- * The `punycode` module is a bundled version of the [Punycode.js](https://github.com/bestiejs/punycode.js) module. It
- * can be accessed using:
- *
- * ```js
- * import punycode from 'node:punycode';
- * ```
- *
- * [Punycode](https://tools.ietf.org/html/rfc3492) is a character encoding scheme defined by RFC 3492 that is
- * primarily intended for use in Internationalized Domain Names. Because host
- * names in URLs are limited to ASCII characters only, Domain Names that contain
- * non-ASCII characters must be converted into ASCII using the Punycode scheme.
- * For instance, the Japanese character that translates into the English word, `'example'` is `'例'`. The Internationalized Domain Name, `'例.com'` (equivalent
- * to `'example.com'`) is represented by Punycode as the ASCII string `'xn--fsq.com'`.
- *
- * The `punycode` module provides a simple implementation of the Punycode standard.
- *
- * The `punycode` module is a third-party dependency used by Node.js and
- * 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
- * @see [source](https://github.com/nodejs/node/blob/v25.x/lib/punycode.js)
- */
 declare module "node:punycode" {
     /**
      * The `punycode.decode()` method converts a [Punycode](https://tools.ietf.org/html/rfc3492) string of ASCII-only

package/node_modules/@types/responselike/node_modules/@types/node/querystring.d.ts

@@ -1,16 +1,3 @@
-/**
- * The `node:querystring` module provides utilities for parsing and formatting URL
- * query strings. It can be accessed using:
- *
- * ```js
- * import querystring from 'node:querystring';
- * ```
- *
- * `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/v25.x/lib/querystring.js)
- */
 declare module "node:querystring" {
     interface StringifyOptions {
         /**

package/node_modules/@types/responselike/node_modules/@types/node/quic.d.ts

@@ -1,16 +1,3 @@
-/**
- * The 'node:quic' module provides an implementation of the QUIC protocol.
- * To access it, start Node.js with the `--experimental-quic` option and:
- *
- * ```js
- * import quic from 'node:quic';
- * ```
- *
- * The module is only available under the `node:` scheme.
- * @since v23.8.0
- * @experimental
- * @see [source](https://github.com/nodejs/node/blob/v25.x/lib/quic.js)
- */
 declare module "node:quic" {
     import { KeyObject, webcrypto } from "node:crypto";
     import { SocketAddress } from "node:net";

package/node_modules/@types/responselike/node_modules/@types/node/readline/promises.d.ts

@@ -1,6 +1,3 @@
-/**
- * @since v17.0.0
- */
 declare module "node:readline/promises" {
     import { Abortable } from "node:events";
     import {

package/node_modules/@types/responselike/node_modules/@types/node/readline.d.ts

@@ -1,38 +1,3 @@
-/**
- * The `node:readline` module provides an interface for reading data from a [Readable](https://nodejs.org/docs/latest-v25.x/api/stream.html#readable-streams) stream
- * (such as [`process.stdin`](https://nodejs.org/docs/latest-v25.x/api/process.html#processstdin)) one line at a time.
- *
- * To use the promise-based APIs:
- *
- * ```js
- * import * as readline from 'node:readline/promises';
- * ```
- *
- * To use the callback and sync APIs:
- *
- * ```js
- * import * as readline from 'node:readline';
- * ```
- *
- * The following simple example illustrates the basic use of the `node:readline` module.
- *
- * ```js
- * import * as readline from 'node:readline/promises';
- * import { stdin as input, stdout as output } from 'node:process';
- *
- * const rl = readline.createInterface({ input, output });
- *
- * const answer = await rl.question('What do you think of Node.js? ');
- *
- * console.log(`Thank you for your valuable feedback: ${answer}`);
- *
- * rl.close();
- * ```
- *
- * Once this code is invoked, the Node.js application will not terminate until the `readline.Interface` is closed because the interface waits for data to be
- * received on the `input` stream.
- * @see [source](https://github.com/nodejs/node/blob/v25.x/lib/readline.js)
- */
 declare module "node:readline" {
     import { Abortable, EventEmitter, InternalEventEmitter } from "node:events";
     interface Key {