cloudstructs 0.6.32 → 0.6.34

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

@@ -1,5 +1,5 @@
 /**
- * To use the HTTP server and client one must `require('http')`.
+ * To use the HTTP server and client one must `require('node:http')`.
  *
  * The HTTP interfaces in Node.js are designed to support many features
  * of the protocol which have been traditionally difficult to use.
@@ -37,13 +37,14 @@
  *   'Host', 'example.com',
  *   'accepT', '*' ]
  * ```
- * @see [source](https://github.com/nodejs/node/blob/v18.0.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;
@@ -184,6 +185,13 @@ declare module 'http' {
          * @default 30000
          */
         connectionsCheckingInterval?: number | undefined;
+        /**
+         * Optionally overrides all `socket`s' `readableHighWaterMark` and `writableHighWaterMark`.
+         * This affects `highWaterMark` property of both `IncomingMessage` and `ServerResponse`.
+         * Default: @see stream.getDefaultHighWaterMark().
+         * @since v20.1.0
+         */
+        highWaterMark?: number | undefined;
         /**
          * Use an insecure HTTP parser that accepts invalid HTTP headers when `true`.
          * Using the insecure parser should be avoided.
@@ -329,7 +337,8 @@ declare module 'http' {
          */
         closeAllConnections(): void;
         /**
-         * Closes all connections connected to this server which are not sending a request or waiting for a response.
+         * Closes all connections connected to this server which are not sending a request
+         * or waiting for a response.
          * @since v18.2.0
          */
         closeIdleConnections(): void;
@@ -341,15 +350,10 @@ declare module 'http' {
         addListener(event: 'checkContinue', listener: RequestListener<Request, Response>): this;
         addListener(event: 'checkExpectation', listener: RequestListener<Request, Response>): this;
         addListener(event: 'clientError', listener: (err: Error, socket: stream.Duplex) => void): this;
-        addListener(
-            event: 'connect',
-            listener: (req: InstanceType<Request>, socket: stream.Duplex, head: Buffer) => void,
-        ): this;
+        addListener(event: 'connect', listener: (req: InstanceType<Request>, socket: stream.Duplex, head: Buffer) => void): this;
+        addListener(event: 'dropRequest', listener: (req: InstanceType<Request>, socket: stream.Duplex) => void): this;
         addListener(event: 'request', listener: RequestListener<Request, Response>): this;
-        addListener(
-            event: 'upgrade',
-            listener: (req: InstanceType<Request>, socket: stream.Duplex, head: Buffer) => void,
-        ): this;
+        addListener(event: 'upgrade', listener: (req: InstanceType<Request>, socket: stream.Duplex, head: Buffer) => void): this;
         emit(event: string, ...args: any[]): boolean;
         emit(event: 'close'): boolean;
         emit(event: 'connection', socket: Socket): boolean;
@@ -367,6 +371,7 @@ declare module 'http' {
         ): boolean;
         emit(event: 'clientError', err: Error, socket: stream.Duplex): boolean;
         emit(event: 'connect', req: InstanceType<Request>, socket: stream.Duplex, head: Buffer): boolean;
+        emit(event: 'dropRequest', req: InstanceType<Request>, socket: stream.Duplex): boolean;
         emit(
             event: 'request',
             req: InstanceType<Request>,
@@ -382,6 +387,7 @@ declare module 'http' {
         on(event: 'checkExpectation', listener: RequestListener<Request, Response>): this;
         on(event: 'clientError', listener: (err: Error, socket: stream.Duplex) => void): this;
         on(event: 'connect', listener: (req: InstanceType<Request>, socket: stream.Duplex, head: Buffer) => void): this;
+        on(event: 'dropRequest', listener: (req: InstanceType<Request>, socket: stream.Duplex) => void): this;
         on(event: 'request', listener: RequestListener<Request, Response>): this;
         on(event: 'upgrade', listener: (req: InstanceType<Request>, socket: stream.Duplex, head: Buffer) => void): this;
         once(event: string, listener: (...args: any[]) => void): this;
@@ -392,15 +398,10 @@ declare module 'http' {
         once(event: 'checkContinue', listener: RequestListener<Request, Response>): this;
         once(event: 'checkExpectation', listener: RequestListener<Request, Response>): this;
         once(event: 'clientError', listener: (err: Error, socket: stream.Duplex) => void): this;
-        once(
-            event: 'connect',
-            listener: (req: InstanceType<Request>, socket: stream.Duplex, head: Buffer) => void,
-        ): this;
+        once(event: 'connect', listener: (req: InstanceType<Request>, socket: stream.Duplex, head: Buffer) => void): this;
+        once(event: 'dropRequest', listener: (req: InstanceType<Request>, socket: stream.Duplex) => void): this;
         once(event: 'request', listener: RequestListener<Request, Response>): this;
-        once(
-            event: 'upgrade',
-            listener: (req: InstanceType<Request>, socket: stream.Duplex, head: Buffer) => void,
-        ): this;
+        once(event: 'upgrade', listener: (req: InstanceType<Request>, socket: stream.Duplex, head: Buffer) => void): this;
         prependListener(event: string, listener: (...args: any[]) => void): this;
         prependListener(event: 'close', listener: () => void): this;
         prependListener(event: 'connection', listener: (socket: Socket) => void): this;
@@ -409,15 +410,10 @@ declare module 'http' {
         prependListener(event: 'checkContinue', listener: RequestListener<Request, Response>): this;
         prependListener(event: 'checkExpectation', listener: RequestListener<Request, Response>): this;
         prependListener(event: 'clientError', listener: (err: Error, socket: stream.Duplex) => void): this;
-        prependListener(
-            event: 'connect',
-            listener: (req: InstanceType<Request>, socket: stream.Duplex, head: Buffer) => void,
-        ): this;
+        prependListener(event: 'connect', listener: (req: InstanceType<Request>, socket: stream.Duplex, head: Buffer) => void): this;
+        prependListener(event: 'dropRequest', listener: (req: InstanceType<Request>, socket: stream.Duplex) => void): this;
         prependListener(event: 'request', listener: RequestListener<Request, Response>): this;
-        prependListener(
-            event: 'upgrade',
-            listener: (req: InstanceType<Request>, socket: stream.Duplex, head: Buffer) => void,
-        ): this;
+        prependListener(event: 'upgrade', listener: (req: InstanceType<Request>, socket: stream.Duplex, head: Buffer) => void): this;
         prependOnceListener(event: string, listener: (...args: any[]) => void): this;
         prependOnceListener(event: 'close', listener: () => void): this;
         prependOnceListener(event: 'connection', listener: (socket: Socket) => void): this;
@@ -426,19 +422,14 @@ declare module 'http' {
         prependOnceListener(event: 'checkContinue', listener: RequestListener<Request, Response>): this;
         prependOnceListener(event: 'checkExpectation', listener: RequestListener<Request, Response>): this;
         prependOnceListener(event: 'clientError', listener: (err: Error, socket: stream.Duplex) => void): this;
-        prependOnceListener(
-            event: 'connect',
-            listener: (req: InstanceType<Request>, socket: stream.Duplex, head: Buffer) => void,
-        ): this;
+        prependOnceListener(event: 'connect', listener: (req: InstanceType<Request>, socket: stream.Duplex, head: Buffer) => void): this;
+        prependOnceListener(event: 'dropRequest', listener: (req: InstanceType<Request>, socket: stream.Duplex) => void): this;
         prependOnceListener(event: 'request', listener: RequestListener<Request, Response>): this;
-        prependOnceListener(
-            event: 'upgrade',
-            listener: (req: InstanceType<Request>, socket: stream.Duplex, head: Buffer) => void,
-        ): this;
+        prependOnceListener(event: 'upgrade', listener: (req: InstanceType<Request>, socket: stream.Duplex, head: Buffer) => void): this;
     }
     /**
-     * This class serves as the parent class of {@link ClientRequest} and {@link ServerResponse}. It is an abstract of outgoing message from
-     * the perspective of the participants of HTTP transaction.
+     * This class serves as the parent class of {@link ClientRequest} and {@link ServerResponse}. It is an abstract outgoing message from
+     * the perspective of the participants of an HTTP transaction.
      * @since v0.1.17
      */
     class OutgoingMessage<Request extends IncomingMessage = IncomingMessage> extends stream.Writable {
@@ -457,7 +448,7 @@ declare module 'http' {
          */
         readonly headersSent: boolean;
         /**
-         * Aliases of `outgoingMessage.socket`
+         * Alias of `outgoingMessage.socket`.
          * @since v0.3.0
          * @deprecated Since v15.12.0,v14.17.1 - Use `socket` instead.
          */
@@ -478,15 +469,33 @@ declare module 'http' {
          */
         setTimeout(msecs: number, callback?: () => void): this;
         /**
-         * Sets a single header value for the header object.
+         * Sets a single header value. If the header already exists in the to-be-sent
+         * headers, its value will be replaced. Use an array of strings to send multiple
+         * headers with the same name.
          * @since v0.4.0
          * @param name Header name
          * @param value Header value
          */
         setHeader(name: string, value: number | string | ReadonlyArray<string>): this;
         /**
-         * Gets the value of HTTP header with the given name. If such a name doesn't
-         * exist in message, it will be `undefined`.
+         * Append a single header value for the header object.
+         *
+         * If the value is an array, this is equivalent of calling this method multiple
+         * times.
+         *
+         * If there were no previous value for the header, this is equivalent of calling `outgoingMessage.setHeader(name, value)`.
+         *
+         * Depending of the value of `options.uniqueHeaders` when the client request or the
+         * server were created, this will end up in the header being sent multiple times or
+         * a single time with values joined using `; `.
+         * @since v18.3.0, v16.17.0
+         * @param name Header name
+         * @param value Header value
+         */
+        appendHeader(name: string, value: string | ReadonlyArray<string>): this;
+        /**
+         * Gets the value of the HTTP header with the given name. If that header is not
+         * set, the returned value will be `undefined`.
          * @since v0.4.0
          * @param name Name of header
          */
@@ -499,8 +508,8 @@ declare module 'http' {
          * values. All header names are lowercase.
          *
          * The object returned by the `outgoingMessage.getHeaders()` method does
-         * not prototypically inherit from the JavaScript Object. This means that
-         * typical Object methods such as `obj.toString()`, `obj.hasOwnProperty()`,
+         * not prototypically inherit from the JavaScript `Object`. This means that
+         * typical `Object` methods such as `obj.toString()`, `obj.hasOwnProperty()`,
          * and others are not defined and will not work.
          *
          * ```js
@@ -514,8 +523,8 @@ declare module 'http' {
          */
         getHeaders(): OutgoingHttpHeaders;
         /**
-         * Returns an array of names of headers of the outgoing outgoingMessage. All
-         * names are lowercase.
+         * Returns an array containing the unique names of the current outgoing headers.
+         * All names are lowercase.
          * @since v7.7.0
          */
         getHeaderNames(): string[];
@@ -542,11 +551,11 @@ declare module 'http' {
         /**
          * Adds HTTP trailers (headers but at the end of the message) to the message.
          *
-         * Trailers are **only** be emitted if the message is chunked encoded. If not,
-         * the trailer will be silently discarded.
+         * Trailers will **only** be emitted if the message is chunked encoded. If not,
+         * the trailers will be silently discarded.
          *
          * HTTP requires the `Trailer` header to be sent to emit trailers,
-         * with a list of header fields in its value, e.g.
+         * with a list of header field names in its value, e.g.
          *
          * ```js
          * message.writeHead(200, { 'Content-Type': 'text/plain',
@@ -562,7 +571,7 @@ declare module 'http' {
          */
         addTrailers(headers: OutgoingHttpHeaders | ReadonlyArray<[string, string]>): void;
         /**
-         * Compulsorily flushes the message headers
+         * Flushes the message headers.
          *
          * For efficiency reason, Node.js normally buffers the message headers
          * until `outgoingMessage.end()` is called or the first chunk of message data
@@ -570,7 +579,7 @@ declare module 'http' {
          * packet.
          *
          * It is usually desired (it saves a TCP round-trip), but not when the first
-         * data is not sent until possibly much later. `outgoingMessage.flushHeaders()`bypasses the optimization and kickstarts the request.
+         * data is not sent until possibly much later. `outgoingMessage.flushHeaders()`bypasses the optimization and kickstarts the message.
          * @since v1.6.0
          */
         flushHeaders(): void;
@@ -610,6 +619,13 @@ declare module 'http' {
          * @since v0.11.8
          */
         statusMessage: string;
+        /**
+         * If set to `true`, Node.js will check whether the `Content-Length`header value and the size of the body, in bytes, are equal.
+         * Mismatching the `Content-Length` header value will result
+         * in an `Error` being thrown, identified by `code:``'ERR_HTTP_CONTENT_LENGTH_MISMATCH'`.
+         * @since v18.10.0, v16.18.0
+         */
+        strictContentLength: boolean;
         constructor(req: Request);
         assignSocket(socket: Socket): void;
         detachSocket(socket: Socket): void;
@@ -626,7 +642,7 @@ declare module 'http' {
          * early hints message. The optional `callback` argument will be called when
          * the response message has been written.
          *
-         * Example:
+         * **Example**
          *
          * ```js
          * const earlyHintsLink = '</styles.css>; rel=preload; as=style';
@@ -640,15 +656,14 @@ declare module 'http' {
          * ];
          * response.writeEarlyHints({
          *   'link': earlyHintsLinks,
-         *   'x-trace-id': 'id for diagnostics'
+         *   'x-trace-id': 'id for diagnostics',
          * });
          *
          * const earlyHintsCallback = () => console.log('early hints message sent');
          * response.writeEarlyHints({
-         *   'link': earlyHintsLinks
+         *   'link': earlyHintsLinks,
          * }, earlyHintsCallback);
          * ```
-         *
          * @since v18.11.0
          * @param hints An object containing the values of headers
          * @param callback Will be called when the response message has been written
@@ -672,7 +687,7 @@ declare module 'http' {
          * response
          *   .writeHead(200, {
          *     'Content-Length': Buffer.byteLength(body),
-         *     'Content-Type': 'text/plain'
+         *     'Content-Type': 'text/plain',
          *   })
          *   .end(body);
          * ```
@@ -703,12 +718,12 @@ declare module 'http' {
          * });
          * ```
          *
-         * `Content-Length` is given in bytes, not characters. Use `Buffer.byteLength()` to determine the length of the body in bytes. Node.js
-         * does not check whether `Content-Length` and the length of the body which has
+         * `Content-Length` is read in bytes, not characters. Use `Buffer.byteLength()` to determine the length of the body in bytes. Node.js
+         * will check whether `Content-Length` and the length of the body which has
          * been transmitted are equal or not.
          *
          * Attempting to set a header field name or value that contains invalid characters
-         * will result in a `TypeError` being thrown.
+         * will result in a \[`Error`\]\[\] being thrown.
          * @since v0.1.30
          */
         writeHead(
@@ -718,7 +733,7 @@ declare module 'http' {
         ): this;
         writeHead(statusCode: number, headers?: OutgoingHttpHeaders | OutgoingHttpHeader[]): this;
         /**
-         * Sends an HTTP/1.1 102 Processing message to the client, indicating that
+         * Sends a HTTP/1.1 102 Processing message to the client, indicating that
          * the request body should be sent.
          * @since v10.0.0
          */
@@ -757,8 +772,11 @@ declare module 'http' {
      *
      * For backward compatibility, `res` will only emit `'error'` if there is an`'error'` listener registered.
      *
-     * Node.js does not check whether Content-Length and the length of the
-     * body which has been transmitted are equal or not.
+     * Set `Content-Length` header to limit the response body size.
+     * If `response.strictContentLength` is set to `true`, mismatching the`Content-Length` header value will result in an `Error` being thrown,
+     * identified by `code:``'ERR_HTTP_CONTENT_LENGTH_MISMATCH'`.
+     *
+     * `Content-Length` value should be in bytes, not characters. Use `Buffer.byteLength()` to determine the length of the body in bytes.
      * @since v0.1.17
      */
     class ClientRequest extends OutgoingMessage {
@@ -785,7 +803,7 @@ declare module 'http' {
          * may run into a 'ECONNRESET' error.
          *
          * ```js
-         * const http = require('http');
+         * const http = require('node:http');
          *
          * // Server has a 5 seconds keep-alive timeout by default
          * http
@@ -809,7 +827,7 @@ declare module 'http' {
          * automatic error retry base on it.
          *
          * ```js
-         * const http = require('http');
+         * const http = require('node:http');
          * const agent = new http.Agent({ keepAlive: true });
          *
          * function retriableRequest() {
@@ -888,19 +906,13 @@ declare module 'http' {
          * @deprecated
          */
         addListener(event: 'abort', listener: () => void): this;
-        addListener(
-            event: 'connect',
-            listener: (response: IncomingMessage, socket: Socket, head: Buffer) => void,
-        ): this;
+        addListener(event: 'connect', listener: (response: IncomingMessage, socket: Socket, head: Buffer) => void): this;
         addListener(event: 'continue', listener: () => void): this;
         addListener(event: 'information', listener: (info: InformationEvent) => void): this;
         addListener(event: 'response', listener: (response: IncomingMessage) => void): this;
         addListener(event: 'socket', listener: (socket: Socket) => void): this;
         addListener(event: 'timeout', listener: () => void): this;
-        addListener(
-            event: 'upgrade',
-            listener: (response: IncomingMessage, socket: Socket, head: Buffer) => void,
-        ): this;
+        addListener(event: 'upgrade', listener: (response: IncomingMessage, socket: Socket, head: Buffer) => void): this;
         addListener(event: 'close', listener: () => void): this;
         addListener(event: 'drain', listener: () => void): this;
         addListener(event: 'error', listener: (err: Error) => void): this;
@@ -948,19 +960,13 @@ declare module 'http' {
          * @deprecated
          */
         prependListener(event: 'abort', listener: () => void): this;
-        prependListener(
-            event: 'connect',
-            listener: (response: IncomingMessage, socket: Socket, head: Buffer) => void,
-        ): this;
+        prependListener(event: 'connect', listener: (response: IncomingMessage, socket: Socket, head: Buffer) => void): this;
         prependListener(event: 'continue', listener: () => void): this;
         prependListener(event: 'information', listener: (info: InformationEvent) => void): this;
         prependListener(event: 'response', listener: (response: IncomingMessage) => void): this;
         prependListener(event: 'socket', listener: (socket: Socket) => void): this;
         prependListener(event: 'timeout', listener: () => void): this;
-        prependListener(
-            event: 'upgrade',
-            listener: (response: IncomingMessage, socket: Socket, head: Buffer) => void,
-        ): this;
+        prependListener(event: 'upgrade', listener: (response: IncomingMessage, socket: Socket, head: Buffer) => void): this;
         prependListener(event: 'close', listener: () => void): this;
         prependListener(event: 'drain', listener: () => void): this;
         prependListener(event: 'error', listener: (err: Error) => void): this;
@@ -972,19 +978,13 @@ declare module 'http' {
          * @deprecated
          */
         prependOnceListener(event: 'abort', listener: () => void): this;
-        prependOnceListener(
-            event: 'connect',
-            listener: (response: IncomingMessage, socket: Socket, head: Buffer) => void,
-        ): this;
+        prependOnceListener(event: 'connect', listener: (response: IncomingMessage, socket: Socket, head: Buffer) => void): this;
         prependOnceListener(event: 'continue', listener: () => void): this;
         prependOnceListener(event: 'information', listener: (info: InformationEvent) => void): this;
         prependOnceListener(event: 'response', listener: (response: IncomingMessage) => void): this;
         prependOnceListener(event: 'socket', listener: (socket: Socket) => void): this;
         prependOnceListener(event: 'timeout', listener: () => void): this;
-        prependOnceListener(
-            event: 'upgrade',
-            listener: (response: IncomingMessage, socket: Socket, head: Buffer) => void,
-        ): this;
+        prependOnceListener(event: 'upgrade', listener: (response: IncomingMessage, socket: Socket, head: Buffer) => void): this;
         prependOnceListener(event: 'close', listener: () => void): this;
         prependOnceListener(event: 'drain', listener: () => void): this;
         prependOnceListener(event: 'error', listener: (err: Error) => void): this;
@@ -996,7 +996,7 @@ declare module 'http' {
     /**
      * An `IncomingMessage` object is created by {@link Server} or {@link ClientRequest} and passed as the first argument to the `'request'` and `'response'` event respectively. It may be used to
      * access response
-     * status, headers and data.
+     * status, headers, and data.
      *
      * Different from its `socket` value which is a subclass of `stream.Duplex`, the`IncomingMessage` itself extends `stream.Readable` and is created separately to
      * parse and emit the incoming HTTP headers and payload, as the underlying socket
@@ -1034,7 +1034,7 @@ declare module 'http' {
          * const req = http.request({
          *   host: '127.0.0.1',
          *   port: 8080,
-         *   method: 'POST'
+         *   method: 'POST',
          * }, (res) => {
          *   res.resume();
          *   res.on('end', () => {
@@ -1076,7 +1076,7 @@ declare module 'http' {
          * // { 'user-agent': 'curl/7.22.0',
          * //   host: '127.0.0.1:8000',
          * //   accept: '*' }
-         * console.log(request.getHeaders());
+         * console.log(request.headers);
          * ```
          *
          * Duplicates in raw headers are handled in the following ways, depending on the
@@ -1084,12 +1084,30 @@ declare module 'http' {
          *
          * * Duplicates of `age`, `authorization`, `content-length`, `content-type`,`etag`, `expires`, `from`, `host`, `if-modified-since`, `if-unmodified-since`,`last-modified`, `location`,
          * `max-forwards`, `proxy-authorization`, `referer`,`retry-after`, `server`, or `user-agent` are discarded.
+         * To allow duplicate values of the headers listed above to be joined,
+         * use the option `joinDuplicateHeaders` in {@link request} and {@link createServer}. See RFC 9110 Section 5.3 for more
+         * information.
          * * `set-cookie` is always an array. Duplicates are added to the array.
-         * * For duplicate `cookie` headers, the values are joined together with '; '.
-         * * For all other headers, the values are joined together with ', '.
+         * * For duplicate `cookie` headers, the values are joined together with `; `.
+         * * For all other headers, the values are joined together with `, `.
          * @since v0.1.5
          */
         headers: IncomingHttpHeaders;
+        /**
+         * Similar to `message.headers`, but there is no join logic and the values are
+         * always arrays of strings, even for headers received just once.
+         *
+         * ```js
+         * // Prints something like:
+         * //
+         * // { 'user-agent': ['curl/7.22.0'],
+         * //   host: ['127.0.0.1:8000'],
+         * //   accept: ['*'] }
+         * console.log(request.headersDistinct);
+         * ```
+         * @since v18.3.0, v16.17.0
+         */
+        headersDistinct: NodeJS.Dict<string[]>;
         /**
          * The raw request/response headers list exactly as they were received.
          *
@@ -1120,6 +1138,13 @@ declare module 'http' {
          * @since v0.3.0
          */
         trailers: NodeJS.Dict<string>;
+        /**
+         * Similar to `message.trailers`, but there is no join logic and the values are
+         * always arrays of strings, even for headers received just once.
+         * Only populated at the `'end'` event.
+         * @since v18.3.0, v16.17.0
+         */
+        trailersDistinct: NodeJS.Dict<string[]>;
         /**
          * The raw request/response trailer keys and values exactly as they were
          * received. Only populated at the `'end'` event.
@@ -1152,14 +1177,14 @@ declare module 'http' {
          * To parse the URL into its parts:
          *
          * ```js
-         * new URL(request.url, `http://${request.getHeaders().host}`);
+         * new URL(request.url, `http://${request.headers.host}`);
          * ```
          *
-         * When `request.url` is `'/status?name=ryan'` and`request.getHeaders().host` is `'localhost:3000'`:
+         * When `request.url` is `'/status?name=ryan'` and `request.headers.host` is`'localhost:3000'`:
          *
          * ```console
          * $ node
-         * > new URL(request.url, `http://${request.getHeaders().host}`)
+         * > new URL(request.url, `http://${request.headers.host}`)
          * URL {
          *   href: 'http://localhost:3000/status?name=ryan',
          *   origin: 'http://localhost:3000',
@@ -1279,16 +1304,16 @@ declare module 'http' {
      *   hostname: 'localhost',
      *   port: 80,
      *   path: '/',
-     *   agent: false  // Create a new agent just for this one request
+     *   agent: false,  // Create a new agent just for this one request
      * }, (res) => {
      *   // Do stuff with response
      * });
      * ```
      * @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
@@ -1384,10 +1409,10 @@ declare module 'http' {
      * upload a file with a POST request, then write to the `ClientRequest` object.
      *
      * ```js
-     * const http = require('http');
+     * const http = require('node:http');
      *
      * const postData = JSON.stringify({
-     *   'msg': 'Hello World!'
+     *   'msg': 'Hello World!',
      * });
      *
      * const options = {
@@ -1397,8 +1422,8 @@ declare module 'http' {
      *   method: 'POST',
      *   headers: {
      *     'Content-Type': 'application/json',
-     *     'Content-Length': Buffer.byteLength(postData)
-     *   }
+     *     'Content-Length': Buffer.byteLength(postData),
+     *   },
      * };
      *
      * const req = http.request(options, (res) => {
@@ -1485,7 +1510,7 @@ declare module 'http' {
      *    * `'data'` any number of times, on the `res` object
      * * (connection closed here)
      * * `'aborted'` on the `res` object
-     * * `'error'` on the `res` object with an error with message`'Error: aborted'` and code `'ECONNRESET'`.
+     * * `'error'` on the `res` object with an error with message`'Error: aborted'` and code `'ECONNRESET'`
      * * `'close'`
      * * `'close'` on the `res` object
      *
@@ -1493,7 +1518,7 @@ declare module 'http' {
      * events will be emitted in the following order:
      *
      * * (`req.destroy()` called here)
-     * * `'error'` with an error with message `'Error: socket hang up'` and code`'ECONNRESET'`
+     * * `'error'` with an error with message `'Error: socket hang up'` and code`'ECONNRESET'`, or the error with which `req.destroy()` was called
      * * `'close'`
      *
      * If `req.destroy()` is called before the connection succeeds, the following
@@ -1501,7 +1526,7 @@ declare module 'http' {
      *
      * * `'socket'`
      * * (`req.destroy()` called here)
-     * * `'error'` with an error with message `'Error: socket hang up'` and code`'ECONNRESET'`
+     * * `'error'` with an error with message `'Error: socket hang up'` and code`'ECONNRESET'`, or the error with which `req.destroy()` was called
      * * `'close'`
      *
      * If `req.destroy()` is called after the response is received, the following
@@ -1512,7 +1537,7 @@ declare module 'http' {
      *    * `'data'` any number of times, on the `res` object
      * * (`req.destroy()` called here)
      * * `'aborted'` on the `res` object
-     * * `'error'` on the `res` object with an error with message`'Error: aborted'` and code `'ECONNRESET'`.
+     * * `'error'` on the `res` object with an error with message `'Error: aborted'`and code `'ECONNRESET'`, or the error with which `req.destroy()` was called
      * * `'close'`
      * * `'close'` on the `res` object
      *
@@ -1548,16 +1573,13 @@ declare module 'http' {
      * Setting the `timeout` option or using the `setTimeout()` function will
      * not abort the request or do anything besides add a `'timeout'` event.
      *
-     * Passing an `AbortSignal` and then calling `abort` on the corresponding`AbortController` will behave the same way as calling `.destroy()` on the
-     * request itself.
+     * Passing an `AbortSignal` and then calling `abort()` on the corresponding`AbortController` will behave the same way as calling `.destroy()` on the
+     * request. Specifically, the `'error'` event will be emitted with an error with
+     * the message `'AbortError: The operation was aborted'`, the code `'ABORT_ERR'`and the `cause`, if one was provided.
      * @since v0.3.6
      */
     function request(options: RequestOptions | string | URL, callback?: (res: IncomingMessage) => void): ClientRequest;
-    function request(
-        url: string | URL,
-        options: RequestOptions,
-        callback?: (res: IncomingMessage) => void,
-    ): ClientRequest;
+    function request(url: string | URL, options: RequestOptions, callback?: (res: IncomingMessage) => void): ClientRequest;
     /**
      * Since most requests are GET requests without bodies, Node.js provides this
      * convenience method. The only difference between this method and {@link request} is that it sets the method to GET and calls `req.end()`automatically. The callback must take care to consume the
@@ -1609,7 +1631,7 @@ declare module 'http' {
      * const server = http.createServer((req, res) => {
      *   res.writeHead(200, { 'Content-Type': 'application/json' });
      *   res.end(JSON.stringify({
-     *     data: 'Hello World!'
+     *     data: 'Hello World!',
      *   }));
      * });
      *
@@ -1620,32 +1642,76 @@ declare module 'http' {
      */
     function get(options: RequestOptions | string | URL, callback?: (res: IncomingMessage) => void): ClientRequest;
     function get(url: string | URL, options: RequestOptions, callback?: (res: IncomingMessage) => void): ClientRequest;
-
     /**
-     * Performs the low-level validations on the provided name that are done when `res.setHeader(name, value)` is called.
-     * Passing illegal value as name will result in a TypeError being thrown, identified by `code: 'ERR_INVALID_HTTP_TOKEN'`.
-     * @param name Header name
+     * Performs the low-level validations on the provided `name` that are done when`res.setHeader(name, value)` is called.
+     *
+     * Passing illegal value as `name` will result in a `TypeError` being thrown,
+     * identified by `code: 'ERR_INVALID_HTTP_TOKEN'`.
+     *
+     * It is not necessary to use this method before passing headers to an HTTP request
+     * or response. The HTTP module will automatically validate such headers.
+     * Examples:
+     *
+     * Example:
+     *
+     * ```js
+     * const { validateHeaderName } = require('node:http');
+     *
+     * try {
+     *   validateHeaderName('');
+     * } catch (err) {
+     *   console.error(err instanceof TypeError); // --> true
+     *   console.error(err.code); // --> 'ERR_INVALID_HTTP_TOKEN'
+     *   console.error(err.message); // --> 'Header name must be a valid HTTP token [""]'
+     * }
+     * ```
      * @since v14.3.0
+     * @param [label='Header name'] Label for error message.
      */
     function validateHeaderName(name: string): void;
     /**
-     * Performs the low-level validations on the provided value that are done when `res.setHeader(name, value)` is called.
-     * Passing illegal value as value will result in a TypeError being thrown.
-     * - Undefined value error is identified by `code: 'ERR_HTTP_INVALID_HEADER_VALUE'`.
-     * - Invalid value character error is identified by `code: 'ERR_INVALID_CHAR'`.
+     * Performs the low-level validations on the provided `value` that are done when`res.setHeader(name, value)` is called.
+     *
+     * Passing illegal value as `value` will result in a `TypeError` being thrown.
+     *
+     * * Undefined value error is identified by `code: 'ERR_HTTP_INVALID_HEADER_VALUE'`.
+     * * Invalid value character error is identified by `code: 'ERR_INVALID_CHAR'`.
+     *
+     * It is not necessary to use this method before passing headers to an HTTP request
+     * or response. The HTTP module will automatically validate such headers.
+     *
+     * Examples:
+     *
+     * ```js
+     * const { validateHeaderValue } = require('node:http');
+     *
+     * try {
+     *   validateHeaderValue('x-my-header', undefined);
+     * } catch (err) {
+     *   console.error(err instanceof TypeError); // --> true
+     *   console.error(err.code === 'ERR_HTTP_INVALID_HEADER_VALUE'); // --> true
+     *   console.error(err.message); // --> 'Invalid value "undefined" for header "x-my-header"'
+     * }
+     *
+     * try {
+     *   validateHeaderValue('x-my-header', 'oʊmɪɡə');
+     * } catch (err) {
+     *   console.error(err instanceof TypeError); // --> true
+     *   console.error(err.code === 'ERR_INVALID_CHAR'); // --> true
+     *   console.error(err.message); // --> 'Invalid character in header content ["x-my-header"]'
+     * }
+     * ```
+     * @since v14.3.0
      * @param name Header name
      * @param value Header value
-     * @since v14.3.0
      */
     function validateHeaderValue(name: string, value: string): void;
-
     /**
-     * Set the maximum number of idle HTTP parsers. Default: 1000.
-     * @param count
+     * Set the maximum number of idle HTTP parsers.
      * @since v18.8.0, v16.18.0
+     * @param [max=1000]
      */
-    function setMaxIdleHTTPParsers(count: number): void;
-
+    function setMaxIdleHTTPParsers(max: number): void;
     let globalAgent: Agent;
     /**
      * Read-only property specifying the maximum allowed size of HTTP headers in bytes.