@types/node 17.0.45 → 18.0.2

node v17.0/events.d.ts → node/events.d.ts

@@ -32,7 +32,7 @@
  * });
  * myEmitter.emit('event');
  * ```
- * @see [source](https://github.com/nodejs/node/blob/v17.0.0/lib/events.js)
+ * @see [source](https://github.com/nodejs/node/blob/v18.0.0/lib/events.js)
  */
 declare module 'events' {
     interface EventEmitterOptions {
@@ -50,7 +50,7 @@ declare module 'events' {
             listener: (...args: any[]) => void,
             opts?: {
                 once: boolean;
-            },
+            }
         ): any;
     }
     interface StaticEventEmitterOptions {
@@ -154,11 +154,7 @@ declare module 'events' {
          * ```
          * @since v11.13.0, v10.16.0
          */
-        static once(
-            emitter: NodeEventTarget,
-            eventName: string | symbol,
-            options?: StaticEventEmitterOptions,
-        ): Promise<any[]>;
+        static once(emitter: NodeEventTarget, eventName: string | symbol, options?: StaticEventEmitterOptions): Promise<any[]>;
         static once(emitter: DOMEventTarget, eventName: string, options?: StaticEventEmitterOptions): Promise<any[]>;
         /**
          * ```js
@@ -218,11 +214,7 @@ declare module 'events' {
          * @param eventName The name of the event being listened for
          * @return that iterates `eventName` events emitted by the `emitter`
          */
-        static on(
-            emitter: NodeJS.EventEmitter,
-            eventName: string,
-            options?: StaticEventEmitterOptions,
-        ): AsyncIterableIterator<any>;
+        static on(emitter: NodeJS.EventEmitter, eventName: string, options?: StaticEventEmitterOptions): AsyncIterableIterator<any>;
         /**
          * A class method that returns the number of listeners for the given `eventName`registered on the given `emitter`.
          *
@@ -269,23 +261,21 @@ declare module 'events' {
          */
         static getEventListeners(emitter: DOMEventTarget | NodeJS.EventEmitter, name: string | symbol): Function[];
         /**
-         * By default `EventEmitter`s will print a warning if more than `10` listeners are
-         * added for a particular event. This is a useful default that helps finding
-         * memory leaks. The `EventEmitter.setMaxListeners()` method allows the default limit to be
-         * modified (if eventTargets is empty) or modify the limit specified in every `EventTarget` | `EventEmitter` passed as arguments.
-         * The value can be set to`Infinity` (or `0`) to indicate an unlimited number of listeners.
-         *
          * ```js
-         * EventEmitter.setMaxListeners(20);
-         * // Equivalent to
-         * EventEmitter.defaultMaxListeners = 20;
-         *
-         * const eventTarget = new EventTarget();
-         * // Only way to increase limit for `EventTarget` instances
-         * // as these doesn't expose its own `setMaxListeners` method
-         * EventEmitter.setMaxListeners(20, eventTarget);
+         * const {
+         *   setMaxListeners,
+         *   EventEmitter
+         * } = require('events');
+         *
+         * const target = new EventTarget();
+         * const emitter = new EventEmitter();
+         *
+         * setMaxListeners(5, target, emitter);
          * ```
-         * @since v15.3.0, v14.17.0
+         * @since v15.4.0
+         * @param n A non-negative number. The maximum number of listeners per `EventTarget` event.
+         * @param eventsTargets Zero or more {EventTarget} or {EventEmitter} instances. If none are specified, `n` is set as the default max for all newly created {EventTarget} and {EventEmitter}
+         * objects.
          */
         static setMaxListeners(n?: number, ...eventTargets: Array<DOMEventTarget | NodeJS.EventEmitter>): void;
         /**

node v17.0/fs/promises.d.ts → node/fs/promises.d.ts

@@ -11,6 +11,7 @@
 declare module 'fs/promises' {
     import { Abortable } from 'node:events';
     import { Stream } from 'node:stream';
+    import { ReadableStream } from 'node:stream/web';
     import {
         Stats,
         BigIntStats,
@@ -163,9 +164,9 @@ declare module 'fs/promises' {
         /**
          * `options` may also include a `start` option to allow writing data at some
          * position past the beginning of the file, allowed values are in the
-         * \[0, [`Number.MAX_SAFE_INTEGER`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/MAX_SAFE_INTEGER)\] range. Modifying a file rather than replacing
-         * it may require the `flags` `open` option to be set to `r+` rather than the
-         * default `r`. The `encoding` can be any one of those accepted by `Buffer`.
+         * \[0, [`Number.MAX_SAFE_INTEGER`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/MAX_SAFE_INTEGER)\] range. Modifying a file rather than
+         * replacing it may require the `flags` `open` option to be set to `r+` rather than
+         * the default `r`. The `encoding` can be any one of those accepted by `Buffer`.
          *
          * If `autoClose` is set to true (default behavior) on `'error'` or `'finish'`the file descriptor will be closed automatically. If `autoClose` is false,
          * then the file descriptor won't be closed, even if there's an error.
@@ -209,6 +210,29 @@ declare module 'fs/promises' {
          */
         read<T extends NodeJS.ArrayBufferView>(buffer: T, offset?: number | null, length?: number | null, position?: number | null): Promise<FileReadResult<T>>;
         read<T extends NodeJS.ArrayBufferView = Buffer>(options?: FileReadOptions<T>): Promise<FileReadResult<T>>;
+        /**
+         * Returns a `ReadableStream` that may be used to read the files data.
+         *
+         * An error will be thrown if this method is called more than once or is called after the `FileHandle` is closed
+         * or closing.
+         *
+         * ```js
+         * import { open } from 'node:fs/promises';
+         *
+         * const file = await open('./some/file/to/read');
+         *
+         * for await (const chunk of file.readableWebStream())
+         *   console.log(chunk);
+         *
+         * await file.close();
+         * ```
+         *
+         * While the `ReadableStream` will read the file to completion, it will not close the `FileHandle` automatically. User code must still call the `fileHandle.close()` method.
+         *
+         * @since v17.0.0
+         * @experimental
+         */
+        readableWebStream(): ReadableStream;
         /**
          * Asynchronously reads the entire contents of a file.
          *
@@ -309,9 +333,8 @@ declare module 'fs/promises' {
         /**
          * Asynchronously writes data to a file, replacing the file if it already exists.`data` can be a string, a buffer, an
          * [AsyncIterable](https://tc39.github.io/ecma262/#sec-asynciterable-interface) or
-         * [Iterable](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Iteration_protocols#The_iterable_protocol) object, or an
-         * object with an own `toString` function
-         * property. The promise is resolved with no arguments upon success.
+         * [Iterable](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Iteration_protocols#The_iterable_protocol) object.
+         * The promise is resolved with no arguments upon success.
          *
          * If `options` is a string, then it specifies the `encoding`.
          *
@@ -329,20 +352,18 @@ declare module 'fs/promises' {
         /**
          * Write `buffer` to the file.
          *
-         * If `buffer` is a plain object, it must have an own (not inherited) `toString`function property.
-         *
          * The promise is resolved with an object containing two properties:
          *
          * It is unsafe to use `filehandle.write()` multiple times on the same file
          * without waiting for the promise to be resolved (or rejected). For this
-         * scenario, use `fs.createWriteStream()`.
+         * scenario, use `filehandle.createWriteStream()`.
          *
          * On Linux, positional writes do not work when the file is opened in append mode.
          * The kernel ignores the position argument and always appends the data to
          * the end of the file.
          * @since v10.0.0
          * @param [offset=0] The start position from within `buffer` where the data to write begins.
-         * @param [length=buffer.byteLength] The number of bytes from `buffer` to write.
+         * @param [length=buffer.byteLength - offset] The number of bytes from `buffer` to write.
          * @param position The offset from the beginning of the file where the data from `buffer` should be written. If `position` is not a `number`, the data will be written at the current position.
          * See the POSIX pwrite(2) documentation for more detail.
          */
@@ -408,9 +429,9 @@ declare module 'fs/promises' {
     /**
      * Tests a user's permissions for the file or directory specified by `path`.
      * The `mode` argument is an optional integer that specifies the accessibility
-     * checks to be performed. Check `File access constants` for possible values
-     * of `mode`. It is possible to create a mask consisting of the bitwise OR of
-     * two or more values (e.g. `fs.constants.W_OK | fs.constants.R_OK`).
+     * checks to be performed. `mode` should be either the value `fs.constants.F_OK`or a mask consisting of the bitwise OR of any of `fs.constants.R_OK`,`fs.constants.W_OK`, and `fs.constants.X_OK`
+     * (e.g.`fs.constants.W_OK | fs.constants.R_OK`). Check `File access constants` for
+     * possible values of `mode`.
      *
      * If the accessibility check is successful, the promise is resolved with no
      * value. If any of the accessibility checks fail, the promise is rejected
@@ -487,7 +508,7 @@ declare module 'fs/promises' {
      * @param [mode=0o666] Sets the file mode (permission and sticky bits) if the file is created.
      * @return Fulfills with a {FileHandle} object.
      */
-    function open(path: PathLike, flags: string | number, mode?: Mode): Promise<FileHandle>;
+    function open(path: PathLike, flags?: string | number, mode?: Mode): Promise<FileHandle>;
     /**
      * Renames `oldPath` to `newPath`.
      * @since v10.0.0
@@ -830,7 +851,9 @@ declare module 'fs/promises' {
      */
     function mkdtemp(prefix: string, options?: ObjectEncodingOptions | BufferEncoding | null): Promise<string | Buffer>;
     /**
-     * Asynchronously writes data to a file, replacing the file if it already exists.`data` can be a string, a `Buffer`, or, an object with an own (not inherited)`toString` function property.
+     * Asynchronously writes data to a file, replacing the file if it already exists.`data` can be a string, a buffer, an
+     * [AsyncIterable](https://tc39.github.io/ecma262/#sec-asynciterable-interface) or
+     * [Iterable](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Iteration_protocols#The_iterable_protocol) object.
      *
      * The `encoding` option is ignored if `data` is a buffer.
      *
@@ -845,7 +868,7 @@ declare module 'fs/promises' {
      *
      * Similarly to `fsPromises.readFile` \- `fsPromises.writeFile` is a convenience
      * method that performs multiple `write` calls internally to write the buffer
-     * passed to it. For performance sensitive code consider using `fs.createWriteStream()`.
+     * passed to it. For performance sensitive code consider using `fs.createWriteStream()` or `filehandle.createWriteStream()`.
      *
      * It is possible to use an `AbortSignal` to cancel an `fsPromises.writeFile()`.
      * Cancelation is "best effort", and some amount of data is likely still
@@ -1084,7 +1107,7 @@ declare module 'fs/promises' {
      * @param dest destination path to copy to.
      * @return Fulfills with `undefined` upon success.
      */
-    function cp(source: string, destination: string, opts?: CopyOptions): Promise<void>;
+    function cp(source: string | URL, destination: string | URL, opts?: CopyOptions): Promise<void>;
 }
 declare module 'node:fs/promises' {
     export * from 'fs/promises';

node v17.0/fs.d.ts → node/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/v17.0.0/lib/fs.js)
+ * @see [source](https://github.com/nodejs/node/blob/v18.0.0/lib/fs.js)
  */
 declare module 'fs' {
     import * as stream from 'node:stream';
@@ -1123,15 +1123,15 @@ declare module 'fs' {
      * ```js
      * import { symlink } from 'fs';
      *
-     * symlink('./mew', './example/mewtwo', callback);
+     * symlink('./mew', './mewtwo', callback);
      * ```
      *
-     * The above example creates a symbolic link `mewtwo` in the `example` which points
-     * to `mew` in the same directory:
+     * The above example creates a symbolic link `mewtwo` which points to `mew` in the
+     * same directory:
      *
      * ```bash
-     * $ tree example/
-     * example/
+     * $ tree .
+     * .
      * ├── mew
      * └── mewtwo -> ./mew
      * ```
@@ -1998,12 +1998,19 @@ declare module 'fs' {
      * @param [flags='r'] See `support of file system `flags``.
      * @param [mode=0o666]
      */
-    export function open(path: PathLike, flags: OpenMode, mode: Mode | undefined | null, callback: (err: NodeJS.ErrnoException | null, fd: number) => void): void;
+    export function open(path: PathLike, flags: OpenMode | undefined, mode: Mode | undefined | null, callback: (err: NodeJS.ErrnoException | null, fd: number) => void): void;
+    /**
+     * Asynchronous open(2) - open and possibly create a file. If the file is created, its mode will be `0o666`.
+     * @param path A path to a file. If a URL is provided, it must use the `file:` protocol.
+     * @param [flags='r'] See `support of file system `flags``.
+     */
+    export function open(path: PathLike, flags: OpenMode | undefined, callback: (err: NodeJS.ErrnoException | null, fd: number) => void): void;
     /**
      * Asynchronous open(2) - open and possibly create a file. If the file is created, its mode will be `0o666`.
      * @param path A path to a file. If a URL is provided, it must use the `file:` protocol.
      */
-    export function open(path: PathLike, flags: OpenMode, callback: (err: NodeJS.ErrnoException | null, fd: number) => void): void;
+    export function open(path: PathLike, callback: (err: NodeJS.ErrnoException | null, fd: number) => void): void;
+
     export namespace open {
         /**
          * Asynchronous open(2) - open and possibly create a file.
@@ -2092,8 +2099,7 @@ declare module 'fs' {
      */
     export function fsyncSync(fd: number): void;
     /**
-     * Write `buffer` to the file specified by `fd`. If `buffer` is a normal object, it
-     * must have an own `toString` function property.
+     * Write `buffer` to the file specified by `fd`.
      *
      * `offset` determines the part of the buffer to be written, and `length` is
      * an integer specifying the number of bytes to write.
@@ -2216,8 +2222,6 @@ declare module 'fs' {
         }>;
     }
     /**
-     * If `buffer` is a plain object, it must have an own (not inherited) `toString`function property.
-     *
      * For detailed information, see the documentation of the asynchronous version of
      * this API: {@link write}.
      * @since v0.1.21
@@ -2289,10 +2293,7 @@ declare module 'fs' {
         options: ReadAsyncOptions<TBuffer>,
         callback: (err: NodeJS.ErrnoException | null, bytesRead: number, buffer: TBuffer) => void
     ): void;
-    export function read(
-        fd: number,
-        callback: (err: NodeJS.ErrnoException | null, bytesRead: number, buffer: NodeJS.ArrayBufferView) => void
-    ): void;
+    export function read(fd: number, callback: (err: NodeJS.ErrnoException | null, bytesRead: number, buffer: NodeJS.ArrayBufferView) => void): void;
     export namespace read {
         /**
          * @param fd A file descriptor.
@@ -2318,9 +2319,7 @@ declare module 'fs' {
             bytesRead: number;
             buffer: TBuffer;
         }>;
-        function __promisify__(
-            fd: number
-        ): Promise<{
+        function __promisify__(fd: number): Promise<{
             bytesRead: number;
             buffer: NodeJS.ArrayBufferView;
         }>;
@@ -2588,8 +2587,6 @@ declare module 'fs' {
      *
      * The `mode` option only affects the newly created file. See {@link open} for more details.
      *
-     * If `data` is a plain object, it must have an own (not inherited) `toString`function property.
-     *
      * ```js
      * import { writeFile } from 'fs';
      * import { Buffer } from 'buffer';
@@ -2666,8 +2663,6 @@ declare module 'fs' {
     /**
      * Returns `undefined`.
      *
-     * If `data` is a plain object, it must have an own (not inherited) `toString`function property.
-     *
      * The `mode` option only affects the newly created file. See {@link open} for more details.
      *
      * For detailed information, see the documentation of the asynchronous version of
@@ -3265,9 +3260,9 @@ declare module 'fs' {
     /**
      * Tests a user's permissions for the file or directory specified by `path`.
      * The `mode` argument is an optional integer that specifies the accessibility
-     * checks to be performed. Check `File access constants` for possible values
-     * of `mode`. It is possible to create a mask consisting of the bitwise OR of
-     * two or more values (e.g. `fs.constants.W_OK | fs.constants.R_OK`).
+     * checks to be performed. `mode` should be either the value `fs.constants.F_OK`or a mask consisting of the bitwise OR of any of `fs.constants.R_OK`,`fs.constants.W_OK`, and `fs.constants.X_OK`
+     * (e.g.`fs.constants.W_OK | fs.constants.R_OK`). Check `File access constants` for
+     * possible values of `mode`.
      *
      * The final argument, `callback`, is a callback function that is invoked with
      * a possible error argument. If any of the accessibility checks fail, the error
@@ -3293,14 +3288,9 @@ declare module 'fs' {
      *   console.log(`${file} ${err ? 'is not writable' : 'is writable'}`);
      * });
      *
-     * // Check if the file exists in the current directory, and if it is writable.
-     * access(file, constants.F_OK | constants.W_OK, (err) => {
-     *   if (err) {
-     *     console.error(
-     *       `${file} ${err.code === 'ENOENT' ? 'does not exist' : 'is read-only'}`);
-     *   } else {
-     *     console.log(`${file} exists, and it is writable`);
-     *   }
+     * // Check if the file is readable and writable.
+     * access(file, constants.R_OK | constants.W_OK, (err) => {
+     *   console.log(`${file} ${err ? 'is not' : 'is'} readable and writable`);
      * });
      * ```
      *
@@ -3444,10 +3434,9 @@ declare module 'fs' {
     /**
      * Synchronously tests a user's permissions for the file or directory specified
      * by `path`. The `mode` argument is an optional integer that specifies the
-     * accessibility checks to be performed. Check `File access constants` for
-     * possible values of `mode`. It is possible to create a mask consisting of
-     * the bitwise OR of two or more values
-     * (e.g. `fs.constants.W_OK | fs.constants.R_OK`).
+     * accessibility checks to be performed. `mode` should be either the value`fs.constants.F_OK` or a mask consisting of the bitwise OR of any of`fs.constants.R_OK`, `fs.constants.W_OK`, and
+     * `fs.constants.X_OK` (e.g.`fs.constants.W_OK | fs.constants.R_OK`). Check `File access constants` for
+     * possible values of `mode`.
      *
      * If any of the accessibility checks fail, an `Error` will be thrown. Otherwise,
      * the method will return `undefined`.
@@ -3550,9 +3539,9 @@ declare module 'fs' {
     /**
      * `options` may also include a `start` option to allow writing data at some
      * position past the beginning of the file, allowed values are in the
-     * \[0, [`Number.MAX_SAFE_INTEGER`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/MAX_SAFE_INTEGER)\] range. Modifying a file rather than replacing
-     * it may require the `flags` option to be set to `r+` rather than the default `w`.
-     * The `encoding` can be any one of those accepted by `Buffer`.
+     * \[0, [`Number.MAX_SAFE_INTEGER`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/MAX_SAFE_INTEGER)\] range. Modifying a file rather than
+     * replacing it may require the `flags` option to be set to `r+` rather than the
+     * default `w`. The `encoding` can be any one of those accepted by `Buffer`.
      *
      * If `autoClose` is set to true (default behavior) on `'error'` or `'finish'`the file descriptor will be closed automatically. If `autoClose` is false,
      * then the file descriptor won't be closed, even if there's an error.
@@ -3849,8 +3838,8 @@ declare module 'fs' {
      * @param src source path to copy.
      * @param dest destination path to copy to.
      */
-    export function cp(source: string, destination: string, callback: (err: NodeJS.ErrnoException | null) => void): void;
-    export function cp(source: string, destination: string, opts: CopyOptions, callback: (err: NodeJS.ErrnoException | null) => void): void;
+    export function cp(source: string | URL, destination: string | URL, callback: (err: NodeJS.ErrnoException | null) => void): void;
+    export function cp(source: string | URL, destination: string | URL, opts: CopyOptions, callback: (err: NodeJS.ErrnoException | null) => void): void;
     /**
      * Synchronously copies the entire directory structure from `src` to `dest`,
      * including subdirectories and files.
@@ -3862,7 +3851,7 @@ declare module 'fs' {
      * @param src source path to copy.
      * @param dest destination path to copy to.
      */
-    export function cpSync(source: string, destination: string, opts?: CopyOptions): void;
+    export function cpSync(source: string | URL, destination: string | URL, opts?: CopyOptions): void;
 }
 declare module 'node:fs' {
     export * from 'fs';

node v17.0/http.d.ts → node/http.d.ts

@@ -13,7 +13,7 @@
  * { 'content-length': '123',
  *   'content-type': 'text/plain',
  *   'connection': 'keep-alive',
- *   'host': 'mysite.com',
+ *   'host': 'example.com',
  *   'accept': '*' }
  * ```
  *
@@ -34,10 +34,10 @@
  *   'content-LENGTH', '123',
  *   'content-type', 'text/plain',
  *   'CONNECTION', 'keep-alive',
- *   'Host', 'mysite.com',
+ *   'Host', 'example.com',
  *   'accepT', '*' ]
  * ```
- * @see [source](https://github.com/nodejs/node/blob/v17.0.0/lib/http.js)
+ * @see [source](https://github.com/nodejs/node/blob/v18.0.0/lib/http.js)
  */
 declare module 'http' {
     import * as stream from 'node:stream';
@@ -211,14 +211,12 @@ declare module 'http' {
          * Limit the amount of time the parser will wait to receive the complete HTTP
          * headers.
          *
-         * In case of inactivity, the rules defined in `server.timeout` apply. However,
-         * that inactivity based timeout would still allow the connection to be kept open
-         * if the headers are being sent very slowly (by default, up to a byte per 2
-         * minutes). In order to prevent this, whenever header data arrives an additional
-         * check is made that more than `server.headersTimeout` milliseconds has not
-         * passed since the connection was established. If the check fails, a `'timeout'`event is emitted on the server object, and (by default) the socket is destroyed.
-         * See `server.timeout` for more information on how timeout behavior can be
-         * customized.
+         * If the timeout expires, the server responds with status 408 without
+         * forwarding the request to the request listener and then closes the connection.
+         *
+         * It must be set to a non-zero value (e.g. 120 seconds) to protect against
+         * potential Denial-of-Service attacks in case the server is deployed without a
+         * reverse proxy in front.
          * @since v11.3.0, v10.14.0
          */
         headersTimeout: number;
@@ -251,6 +249,16 @@ declare module 'http' {
          * @since v14.11.0
          */
         requestTimeout: number;
+        /**
+         * Closes all connections connected to this server.
+         * @since v18.2.0
+         */
+        closeAllConnections(): void;
+        /**
+         * Closes all connections connected to this server which are not sending a request or waiting for a response.
+         * @since v18.2.0
+         */
+        closeIdleConnections(): void;
         addListener(event: string, listener: (...args: any[]) => void): this;
         addListener(event: 'close', listener: () => void): this;
         addListener(event: 'connection', listener: (socket: Socket) => void): this;
@@ -392,13 +400,13 @@ declare module 'http' {
          * const headers = outgoingMessage.getHeaders();
          * // headers === { foo: 'bar', 'set-cookie': ['foo=bar', 'bar=baz'] }
          * ```
-         * @since v8.0.0
+         * @since v7.7.0
          */
         getHeaders(): OutgoingHttpHeaders;
         /**
          * Returns an array of names of headers of the outgoing outgoingMessage. All
          * names are lowercase.
-         * @since v8.0.0
+         * @since v7.7.0
          */
         getHeaderNames(): string[];
         /**
@@ -408,7 +416,7 @@ declare module 'http' {
          * ```js
          * const hasContentType = outgoingMessage.hasHeader('content-type');
          * ```
-         * @since v8.0.0
+         * @since v7.7.0
          */
         hasHeader(name: string): boolean;
         /**
@@ -418,6 +426,7 @@ declare module 'http' {
          * outgoingMessage.removeHeader('Content-Encoding');
          * ```
          * @since v0.4.0
+         * @param name Header name
          */
         removeHeader(name: string): void;
         /**
@@ -608,7 +617,7 @@ declare module 'http' {
          * The `request.aborted` property will be `true` if the request has
          * been aborted.
          * @since v0.11.14
-         * @deprecated Since v17.0.0 - Check `destroyed` instead.
+         * @deprecated Since v17.0.0,v16.12.0 - Check `destroyed` instead.
          */
         aborted: boolean;
         /**
@@ -622,13 +631,58 @@ declare module 'http' {
          */
         protocol: string;
         /**
-         * Whether the request is send through a reused socket.
+         * When sending request through a keep-alive enabled agent, the underlying socket
+         * might be reused. But if server closes connection at unfortunate time, client
+         * may run into a 'ECONNRESET' error.
+         *
+         * ```js
+         * const http = require('http');
+         *
+         * // Server has a 5 seconds keep-alive timeout by default
+         * http
+         *   .createServer((req, res) => {
+         *     res.write('hello\n');
+         *     res.end();
+         *   })
+         *   .listen(3000);
+         *
+         * setInterval(() => {
+         *   // Adapting a keep-alive agent
+         *   http.get('http://localhost:3000', { agent }, (res) => {
+         *     res.on('data', (data) => {
+         *       // Do nothing
+         *     });
+         *   });
+         * }, 5000); // Sending request on 5s interval so it's easy to hit idle timeout
+         * ```
+         *
+         * By marking a request whether it reused socket or not, we can do
+         * automatic error retry base on it.
+         *
+         * ```js
+         * const http = require('http');
+         * const agent = new http.Agent({ keepAlive: true });
+         *
+         * function retriableRequest() {
+         *   const req = http
+         *     .get('http://localhost:3000', { agent }, (res) => {
+         *       // ...
+         *     })
+         *     .on('error', (err) => {
+         *       // Check if retry is needed
+         *       if (req.reusedSocket && err.code === 'ECONNRESET') {
+         *         retriableRequest();
+         *       }
+         *     });
+         * }
+         *
+         * retriableRequest();
+         * ```
          * @since v13.0.0, v12.16.0
          */
         reusedSocket: boolean;
         /**
          * Limits maximum response headers count. If set to 0, no limit will be applied.
-         * @default 2000
          */
         maxHeadersCount: number;
         constructor(url: string | URL | ClientRequestArgs, cb?: (res: IncomingMessage) => void);
@@ -788,7 +842,7 @@ declare module 'http' {
          * The `message.aborted` property will be `true` if the request has
          * been aborted.
          * @since v10.1.0
-         * @deprecated Since v17.0.0 - Check `message.destroyed` from [stream.Readable](https://nodejs.org/dist/latest-v17.x/docs/api/stream.html#class-streamreadable).
+         * @deprecated Since v17.0.0,v16.12.0 - Check `message.destroyed` from <a href="stream.html#class-streamreadable" class="type">stream.Readable</a>.
          */
         aborted: boolean;
         /**
@@ -840,7 +894,7 @@ declare module 'http' {
          *
          * This property is guaranteed to be an instance of the `net.Socket` class,
          * a subclass of `stream.Duplex`, unless the user specified a socket
-         * type other than `net.Socket`.
+         * type other than `net.Socket` or internally nulled.
          * @since v0.3.0
          */
         socket: Socket;
@@ -855,7 +909,7 @@ declare module 'http' {
          * // { 'user-agent': 'curl/7.22.0',
          * //   host: '127.0.0.1:8000',
          * //   accept: '*' }
-         * console.log(request.headers);
+         * console.log(request.getHeaders());
          * ```
          *
          * Duplicates in raw headers are handled in the following ways, depending on the
@@ -931,14 +985,14 @@ declare module 'http' {
          * To parse the URL into its parts:
          *
          * ```js
-         * new URL(request.url, `http://${request.headers.host}`);
+         * new URL(request.url, `http://${request.getHeaders().host}`);
          * ```
          *
-         * When `request.url` is `'/status?name=ryan'` and`request.headers.host` is `'localhost:3000'`:
+         * When `request.url` is `'/status?name=ryan'` and`request.getHeaders().host` is `'localhost:3000'`:
          *
          * ```console
          * $ node
-         * > new URL(request.url, `http://${request.headers.host}`)
+         * > new URL(request.url, `http://${request.getHeaders().host}`)
          * URL {
          *   href: 'http://localhost:3000/status?name=ryan',
          *   origin: 'http://localhost:3000',
@@ -1137,6 +1191,8 @@ declare module 'http' {
     // create interface RequestOptions would make the naming more clear to developers
     interface RequestOptions extends ClientRequestArgs {}
     /**
+     * `options` in `socket.connect()` are also supported.
+     *
      * Node.js maintains several connections per server to make HTTP requests.
      * This function allows one to transparently issue requests.
      *

node v17.0/http2.d.ts → node/http2.d.ts

@@ -6,7 +6,7 @@
  * const http2 = require('http2');
  * ```
  * @since v8.4.0
- * @see [source](https://github.com/nodejs/node/blob/v17.0.0/lib/http2.js)
+ * @see [source](https://github.com/nodejs/node/blob/v18.0.0/lib/http2.js)
  */
 declare module 'http2' {
     import EventEmitter = require('node:events');
@@ -83,7 +83,7 @@ declare module 'http2' {
          */
         readonly destroyed: boolean;
         /**
-         * Set the `true` if the `END_STREAM` flag was set in the request or response
+         * Set to `true` if the `END_STREAM` flag was set in the request or response
          * HEADERS frame received, indicating that no additional data should be received
          * and the readable side of the `Http2Stream` will be closed.
          * @since v10.11.0
@@ -846,6 +846,11 @@ declare module 'http2' {
          * For HTTP/2 Client `Http2Session` instances only, the `http2session.request()`creates and returns an `Http2Stream` instance that can be used to send an
          * HTTP/2 request to the connected server.
          *
+         * When a `ClientHttp2Session` is first created, the socket may not yet be
+         * connected. if `clienthttp2session.request()` is called during this time, the
+         * actual request will be deferred until the socket is ready to go.
+         * If the `session` is closed before the actual request be executed, an`ERR_HTTP2_GOAWAY_SESSION` is thrown.
+         *
          * This method is only available if `http2session.type` is equal to`http2.constants.NGHTTP2_SESSION_CLIENT`.
          *
          * ```js