@rio-cloud/cdk-v2-constructs 8.2.0-alpha.0 → 8.2.1-alpha.0

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

@@ -3,12 +3,13 @@
  * It can be accessed using:
  *
  * ```js
- * const http2 = require('node:http2');
+ * import http2 from 'node:http2';
  * ```
  * @since v8.4.0
- * @see [source](https://github.com/nodejs/node/blob/v20.2.0/lib/http2.js)
+ * @see [source](https://github.com/nodejs/node/blob/v24.x/lib/http2.js)
  */
 declare module "http2" {
+    import { NonSharedBuffer } from "node:buffer";
     import EventEmitter = require("node:events");
     import * as fs from "node:fs";
     import * as net from "node:net";
@@ -30,20 +31,17 @@ declare module "http2" {
         ":method"?: string | undefined;
         ":authority"?: string | undefined;
         ":scheme"?: string | undefined;
+        ":protocol"?: string | undefined;
     }
     // Http2Stream
-    export interface StreamPriorityOptions {
-        exclusive?: boolean | undefined;
-        parent?: number | undefined;
-        weight?: number | undefined;
-        silent?: boolean | undefined;
-    }
     export interface StreamState {
         localWindowSize?: number | undefined;
         state?: number | undefined;
         localClose?: number | undefined;
         remoteClose?: number | undefined;
+        /** @deprecated */
         sumDependencyWeight?: number | undefined;
+        /** @deprecated */
         weight?: number | undefined;
     }
     export interface ServerStreamResponseOptions {
@@ -55,14 +53,15 @@ declare module "http2" {
         length: number;
     }
     export interface ServerStreamFileResponseOptions {
-        // eslint-disable-next-line @typescript-eslint/no-invalid-void-type
-        statCheck?(stats: fs.Stats, headers: OutgoingHttpHeaders, statOptions: StatOptions): void | boolean;
+        statCheck?:
+            | ((stats: fs.Stats, headers: OutgoingHttpHeaders, statOptions: StatOptions) => void)
+            | undefined;
         waitForTrailers?: boolean | undefined;
         offset?: number | undefined;
         length?: number | undefined;
     }
     export interface ServerStreamFileResponseOptionsWithError extends ServerStreamFileResponseOptions {
-        onError?(err: NodeJS.ErrnoException): void;
+        onError?: ((err: NodeJS.ErrnoException) => void) | undefined;
     }
     export interface Http2Stream extends stream.Duplex {
         /**
@@ -96,7 +95,7 @@ declare module "http2" {
          */
         readonly endAfterHeaders: boolean;
         /**
-         * The numeric stream identifier of this `Http2Stream` instance. Set to `undefined`if the stream identifier has not yet been assigned.
+         * The numeric stream identifier of this `Http2Stream` instance. Set to `undefined` if the stream identifier has not yet been assigned.
          * @since v8.4.0
          */
         readonly id?: number | undefined;
@@ -109,7 +108,7 @@ declare module "http2" {
         /**
          * Set to the `RST_STREAM` `error code` reported when the `Http2Stream` is
          * destroyed after either receiving an `RST_STREAM` frame from the connected peer,
-         * calling `http2stream.close()`, or `http2stream.destroy()`. Will be`undefined` if the `Http2Stream` has not been closed.
+         * calling `http2stream.close()`, or `http2stream.destroy()`. Will be `undefined` if the `Http2Stream` has not been closed.
          * @since v8.4.0
          */
         readonly rstCode: number;
@@ -136,7 +135,7 @@ declare module "http2" {
          */
         readonly session: Http2Session | undefined;
         /**
-         * Provides miscellaneous information about the current state of the`Http2Stream`.
+         * Provides miscellaneous information about the current state of the `Http2Stream`.
          *
          * A current state of this `Http2Stream`.
          * @since v8.4.0
@@ -151,13 +150,12 @@ declare module "http2" {
          */
         close(code?: number, callback?: () => void): void;
         /**
-         * Updates the priority for this `Http2Stream` instance.
-         * @since v8.4.0
+         * @deprecated Priority signaling is no longer supported in Node.js.
          */
-        priority(options: StreamPriorityOptions): void;
+        priority(options: unknown): void;
         /**
          * ```js
-         * const http2 = require('node:http2');
+         * import http2 from 'node:http2';
          * const client = http2.connect('http://example.org:8000');
          * const { NGHTTP2_CANCEL } = http2.constants;
          * const req = client.request({ ':path': '/' });
@@ -177,7 +175,7 @@ declare module "http2" {
          * trailers can be sent.
          *
          * ```js
-         * const http2 = require('node:http2');
+         * import http2 from 'node:http2';
          * const server = http2.createServer();
          * server.on('stream', (stream) => {
          *   stream.respond(undefined, { waitForTrailers: true });
@@ -195,12 +193,15 @@ declare module "http2" {
         sendTrailers(headers: OutgoingHttpHeaders): void;
         addListener(event: "aborted", listener: () => void): this;
         addListener(event: "close", listener: () => void): this;
-        addListener(event: "data", listener: (chunk: Buffer | string) => void): this;
+        addListener(event: "data", listener: (chunk: NonSharedBuffer | string) => void): this;
         addListener(event: "drain", listener: () => void): this;
         addListener(event: "end", listener: () => void): this;
         addListener(event: "error", listener: (err: Error) => void): this;
         addListener(event: "finish", listener: () => void): this;
-        addListener(event: "frameError", listener: (frameType: number, errorCode: number) => void): this;
+        addListener(
+            event: "frameError",
+            listener: (frameType: number, errorCode: number, id: number) => void,
+        ): this;
         addListener(event: "pipe", listener: (src: stream.Readable) => void): this;
         addListener(event: "unpipe", listener: (src: stream.Readable) => void): this;
         addListener(event: "streamClosed", listener: (code: number) => void): this;
@@ -210,12 +211,12 @@ declare module "http2" {
         addListener(event: string | symbol, listener: (...args: any[]) => void): this;
         emit(event: "aborted"): boolean;
         emit(event: "close"): boolean;
-        emit(event: "data", chunk: Buffer | string): boolean;
+        emit(event: "data", chunk: NonSharedBuffer | string): boolean;
         emit(event: "drain"): boolean;
         emit(event: "end"): boolean;
         emit(event: "error", err: Error): boolean;
         emit(event: "finish"): boolean;
-        emit(event: "frameError", frameType: number, errorCode: number): boolean;
+        emit(event: "frameError", frameType: number, errorCode: number, id: number): boolean;
         emit(event: "pipe", src: stream.Readable): boolean;
         emit(event: "unpipe", src: stream.Readable): boolean;
         emit(event: "streamClosed", code: number): boolean;
@@ -225,12 +226,12 @@ declare module "http2" {
         emit(event: string | symbol, ...args: any[]): boolean;
         on(event: "aborted", listener: () => void): this;
         on(event: "close", listener: () => void): this;
-        on(event: "data", listener: (chunk: Buffer | string) => void): this;
+        on(event: "data", listener: (chunk: NonSharedBuffer | string) => void): this;
         on(event: "drain", listener: () => void): this;
         on(event: "end", listener: () => void): this;
         on(event: "error", listener: (err: Error) => void): this;
         on(event: "finish", listener: () => void): this;
-        on(event: "frameError", listener: (frameType: number, errorCode: number) => void): this;
+        on(event: "frameError", listener: (frameType: number, errorCode: number, id: number) => void): this;
         on(event: "pipe", listener: (src: stream.Readable) => void): this;
         on(event: "unpipe", listener: (src: stream.Readable) => void): this;
         on(event: "streamClosed", listener: (code: number) => void): this;
@@ -240,12 +241,12 @@ declare module "http2" {
         on(event: string | symbol, listener: (...args: any[]) => void): this;
         once(event: "aborted", listener: () => void): this;
         once(event: "close", listener: () => void): this;
-        once(event: "data", listener: (chunk: Buffer | string) => void): this;
+        once(event: "data", listener: (chunk: NonSharedBuffer | string) => void): this;
         once(event: "drain", listener: () => void): this;
         once(event: "end", listener: () => void): this;
         once(event: "error", listener: (err: Error) => void): this;
         once(event: "finish", listener: () => void): this;
-        once(event: "frameError", listener: (frameType: number, errorCode: number) => void): this;
+        once(event: "frameError", listener: (frameType: number, errorCode: number, id: number) => void): this;
         once(event: "pipe", listener: (src: stream.Readable) => void): this;
         once(event: "unpipe", listener: (src: stream.Readable) => void): this;
         once(event: "streamClosed", listener: (code: number) => void): this;
@@ -255,12 +256,15 @@ declare module "http2" {
         once(event: string | symbol, listener: (...args: any[]) => void): this;
         prependListener(event: "aborted", listener: () => void): this;
         prependListener(event: "close", listener: () => void): this;
-        prependListener(event: "data", listener: (chunk: Buffer | string) => void): this;
+        prependListener(event: "data", listener: (chunk: NonSharedBuffer | string) => void): this;
         prependListener(event: "drain", listener: () => void): this;
         prependListener(event: "end", listener: () => void): this;
         prependListener(event: "error", listener: (err: Error) => void): this;
         prependListener(event: "finish", listener: () => void): this;
-        prependListener(event: "frameError", listener: (frameType: number, errorCode: number) => void): this;
+        prependListener(
+            event: "frameError",
+            listener: (frameType: number, errorCode: number, id: number) => void,
+        ): this;
         prependListener(event: "pipe", listener: (src: stream.Readable) => void): this;
         prependListener(event: "unpipe", listener: (src: stream.Readable) => void): this;
         prependListener(event: "streamClosed", listener: (code: number) => void): this;
@@ -270,12 +274,15 @@ declare module "http2" {
         prependListener(event: string | symbol, listener: (...args: any[]) => void): this;
         prependOnceListener(event: "aborted", listener: () => void): this;
         prependOnceListener(event: "close", listener: () => void): this;
-        prependOnceListener(event: "data", listener: (chunk: Buffer | string) => void): this;
+        prependOnceListener(event: "data", listener: (chunk: NonSharedBuffer | string) => void): this;
         prependOnceListener(event: "drain", listener: () => void): this;
         prependOnceListener(event: "end", listener: () => void): this;
         prependOnceListener(event: "error", listener: (err: Error) => void): this;
         prependOnceListener(event: "finish", listener: () => void): this;
-        prependOnceListener(event: "frameError", listener: (frameType: number, errorCode: number) => void): this;
+        prependOnceListener(
+            event: "frameError",
+            listener: (frameType: number, errorCode: number, id: number) => void,
+        ): this;
         prependOnceListener(event: "pipe", listener: (src: stream.Readable) => void): this;
         prependOnceListener(event: "unpipe", listener: (src: stream.Readable) => void): this;
         prependOnceListener(event: "streamClosed", listener: (code: number) => void): this;
@@ -288,61 +295,111 @@ declare module "http2" {
         addListener(event: "continue", listener: () => {}): this;
         addListener(
             event: "headers",
-            listener: (headers: IncomingHttpHeaders & IncomingHttpStatusHeader, flags: number) => void,
+            listener: (
+                headers: IncomingHttpHeaders & IncomingHttpStatusHeader,
+                flags: number,
+                rawHeaders: string[],
+            ) => void,
         ): this;
         addListener(event: "push", listener: (headers: IncomingHttpHeaders, flags: number) => void): this;
         addListener(
             event: "response",
-            listener: (headers: IncomingHttpHeaders & IncomingHttpStatusHeader, flags: number) => void,
+            listener: (
+                headers: IncomingHttpHeaders & IncomingHttpStatusHeader,
+                flags: number,
+                rawHeaders: string[],
+            ) => void,
         ): this;
         addListener(event: string | symbol, listener: (...args: any[]) => void): this;
         emit(event: "continue"): boolean;
-        emit(event: "headers", headers: IncomingHttpHeaders & IncomingHttpStatusHeader, flags: number): boolean;
+        emit(
+            event: "headers",
+            headers: IncomingHttpHeaders & IncomingHttpStatusHeader,
+            flags: number,
+            rawHeaders: string[],
+        ): boolean;
         emit(event: "push", headers: IncomingHttpHeaders, flags: number): boolean;
-        emit(event: "response", headers: IncomingHttpHeaders & IncomingHttpStatusHeader, flags: number): boolean;
+        emit(
+            event: "response",
+            headers: IncomingHttpHeaders & IncomingHttpStatusHeader,
+            flags: number,
+            rawHeaders: string[],
+        ): boolean;
         emit(event: string | symbol, ...args: any[]): boolean;
         on(event: "continue", listener: () => {}): this;
         on(
             event: "headers",
-            listener: (headers: IncomingHttpHeaders & IncomingHttpStatusHeader, flags: number) => void,
+            listener: (
+                headers: IncomingHttpHeaders & IncomingHttpStatusHeader,
+                flags: number,
+                rawHeaders: string[],
+            ) => void,
         ): this;
         on(event: "push", listener: (headers: IncomingHttpHeaders, flags: number) => void): this;
         on(
             event: "response",
-            listener: (headers: IncomingHttpHeaders & IncomingHttpStatusHeader, flags: number) => void,
+            listener: (
+                headers: IncomingHttpHeaders & IncomingHttpStatusHeader,
+                flags: number,
+                rawHeaders: string[],
+            ) => void,
         ): this;
         on(event: string | symbol, listener: (...args: any[]) => void): this;
         once(event: "continue", listener: () => {}): this;
         once(
             event: "headers",
-            listener: (headers: IncomingHttpHeaders & IncomingHttpStatusHeader, flags: number) => void,
+            listener: (
+                headers: IncomingHttpHeaders & IncomingHttpStatusHeader,
+                flags: number,
+                rawHeaders: string[],
+            ) => void,
         ): this;
         once(event: "push", listener: (headers: IncomingHttpHeaders, flags: number) => void): this;
         once(
             event: "response",
-            listener: (headers: IncomingHttpHeaders & IncomingHttpStatusHeader, flags: number) => void,
+            listener: (
+                headers: IncomingHttpHeaders & IncomingHttpStatusHeader,
+                flags: number,
+                rawHeaders: string[],
+            ) => void,
         ): this;
         once(event: string | symbol, listener: (...args: any[]) => void): this;
         prependListener(event: "continue", listener: () => {}): this;
         prependListener(
             event: "headers",
-            listener: (headers: IncomingHttpHeaders & IncomingHttpStatusHeader, flags: number) => void,
+            listener: (
+                headers: IncomingHttpHeaders & IncomingHttpStatusHeader,
+                flags: number,
+                rawHeaders: string[],
+            ) => void,
         ): this;
         prependListener(event: "push", listener: (headers: IncomingHttpHeaders, flags: number) => void): this;
         prependListener(
             event: "response",
-            listener: (headers: IncomingHttpHeaders & IncomingHttpStatusHeader, flags: number) => void,
+            listener: (
+                headers: IncomingHttpHeaders & IncomingHttpStatusHeader,
+                flags: number,
+                rawHeaders: string[],
+            ) => void,
         ): this;
         prependListener(event: string | symbol, listener: (...args: any[]) => void): this;
         prependOnceListener(event: "continue", listener: () => {}): this;
         prependOnceListener(
             event: "headers",
-            listener: (headers: IncomingHttpHeaders & IncomingHttpStatusHeader, flags: number) => void,
+            listener: (
+                headers: IncomingHttpHeaders & IncomingHttpStatusHeader,
+                flags: number,
+                rawHeaders: string[],
+            ) => void,
         ): this;
         prependOnceListener(event: "push", listener: (headers: IncomingHttpHeaders, flags: number) => void): this;
         prependOnceListener(
             event: "response",
-            listener: (headers: IncomingHttpHeaders & IncomingHttpStatusHeader, flags: number) => void,
+            listener: (
+                headers: IncomingHttpHeaders & IncomingHttpStatusHeader,
+                flags: number,
+                rawHeaders: string[],
+            ) => void,
         ): this;
         prependOnceListener(event: string | symbol, listener: (...args: any[]) => void): this;
     }
@@ -355,7 +412,7 @@ declare module "http2" {
         /**
          * Read-only property mapped to the `SETTINGS_ENABLE_PUSH` flag of the remote
          * client's most recent `SETTINGS` frame. Will be `true` if the remote peer
-         * accepts push streams, `false` otherwise. Settings are the same for every`Http2Stream` in the same `Http2Session`.
+         * accepts push streams, `false` otherwise. Settings are the same for every `Http2Stream` in the same `Http2Session`.
          * @since v8.4.0
          */
         readonly pushAllowed: boolean;
@@ -365,10 +422,10 @@ declare module "http2" {
          */
         additionalHeaders(headers: OutgoingHttpHeaders): void;
         /**
-         * Initiates a push stream. The callback is invoked with the new `Http2Stream`instance created for the push stream passed as the second argument, or an`Error` passed as the first argument.
+         * Initiates a push stream. The callback is invoked with the new `Http2Stream` instance created for the push stream passed as the second argument, or an `Error` passed as the first argument.
          *
          * ```js
-         * const http2 = require('node:http2');
+         * import http2 from 'node:http2';
          * const server = http2.createServer();
          * server.on('stream', (stream) => {
          *   stream.respond({ ':status': 200 });
@@ -382,7 +439,7 @@ declare module "http2" {
          * ```
          *
          * Setting the weight of a push stream is not allowed in the `HEADERS` frame. Pass
-         * a `weight` value to `http2stream.priority` with the `silent` option set to`true` to enable server-side bandwidth balancing between concurrent streams.
+         * a `weight` value to `http2stream.priority` with the `silent` option set to `true` to enable server-side bandwidth balancing between concurrent streams.
          *
          * Calling `http2stream.pushStream()` from within a pushed stream is not permitted
          * and will throw an error.
@@ -395,12 +452,12 @@ declare module "http2" {
         ): void;
         pushStream(
             headers: OutgoingHttpHeaders,
-            options?: StreamPriorityOptions,
+            options?: Pick<ClientSessionRequestOptions, "exclusive" | "parent">,
             callback?: (err: Error | null, pushStream: ServerHttp2Stream, headers: OutgoingHttpHeaders) => void,
         ): void;
         /**
          * ```js
-         * const http2 = require('node:http2');
+         * import http2 from 'node:http2';
          * const server = http2.createServer();
          * server.on('stream', (stream) => {
          *   stream.respond({ ':status': 200 });
@@ -408,15 +465,15 @@ declare module "http2" {
          * });
          * ```
          *
-         * Initiates a response. When the `options.waitForTrailers` option is set, the`'wantTrailers'` event will be emitted immediately after queuing the last chunk
-         * of payload data to be sent. The `http2stream.sendTrailers()` method can then be
-         * used to sent trailing header fields to the peer.
+         * Initiates a response. When the `options.waitForTrailers` option is set, the `'wantTrailers'` event
+         * will be emitted immediately after queuing the last chunk of payload data to be sent.
+         * The `http2stream.sendTrailers()` method can then be used to send trailing header fields to the peer.
          *
          * When `options.waitForTrailers` is set, the `Http2Stream` will not automatically
-         * close when the final `DATA` frame is transmitted. User code must call either`http2stream.sendTrailers()` or `http2stream.close()` to close the`Http2Stream`.
+         * close when the final `DATA` frame is transmitted. User code must call either `http2stream.sendTrailers()` or `http2stream.close()` to close the `Http2Stream`.
          *
          * ```js
-         * const http2 = require('node:http2');
+         * import http2 from 'node:http2';
          * const server = http2.createServer();
          * server.on('stream', (stream) => {
          *   stream.respond({ ':status': 200 }, { waitForTrailers: true });
@@ -428,7 +485,7 @@ declare module "http2" {
          * ```
          * @since v8.4.0
          */
-        respond(headers?: OutgoingHttpHeaders, options?: ServerStreamResponseOptions): void;
+        respond(headers?: OutgoingHttpHeaders | readonly string[], options?: ServerStreamResponseOptions): void;
         /**
          * Initiates a response whose data is read from the given file descriptor. No
          * validation is performed on the given file descriptor. If an error occurs while
@@ -439,8 +496,8 @@ declare module "http2" {
          * automatically.
          *
          * ```js
-         * const http2 = require('node:http2');
-         * const fs = require('node:fs');
+         * import http2 from 'node:http2';
+         * import fs from 'node:fs';
          *
          * const server = http2.createServer();
          * server.on('stream', (stream) => {
@@ -459,8 +516,8 @@ declare module "http2" {
          *
          * The optional `options.statCheck` function may be specified to give user code
          * an opportunity to set additional content headers based on the `fs.Stat` details
-         * of the given fd. If the `statCheck` function is provided, the`http2stream.respondWithFD()` method will perform an `fs.fstat()` call to
-         * collect details on the provided file descriptor.
+         * of the given fd. If the `statCheck` function is provided, the `http2stream.respondWithFD()` method will
+         * perform an `fs.fstat()` call to collect details on the provided file descriptor.
          *
          * The `offset` and `length` options may be used to limit the response to a
          * specific range subset. This can be used, for instance, to support HTTP Range
@@ -478,11 +535,12 @@ declare module "http2" {
          * header fields to the peer.
          *
          * When `options.waitForTrailers` is set, the `Http2Stream` will not automatically
-         * close when the final `DATA` frame is transmitted. User code _must_ call either`http2stream.sendTrailers()` or `http2stream.close()` to close the`Http2Stream`.
+         * close when the final `DATA` frame is transmitted. User code _must_ call either `http2stream.sendTrailers()`
+         * or `http2stream.close()` to close the `Http2Stream`.
          *
          * ```js
-         * const http2 = require('node:http2');
-         * const fs = require('node:fs');
+         * import http2 from 'node:http2';
+         * import fs from 'node:fs';
          *
          * const server = http2.createServer();
          * server.on('stream', (stream) => {
@@ -521,14 +579,14 @@ declare module "http2" {
          * an opportunity to set additional content headers based on the `fs.Stat` details
          * of the given file:
          *
-         * If an error occurs while attempting to read the file data, the `Http2Stream`will be closed using an `RST_STREAM` frame using the standard `INTERNAL_ERROR`code. If the `onError` callback is
-         * defined, then it will be called. Otherwise
-         * the stream will be destroyed.
+         * If an error occurs while attempting to read the file data, the `Http2Stream` will be closed using an
+         * `RST_STREAM` frame using the standard `INTERNAL_ERROR` code.
+         * If the `onError` callback is defined, then it will be called. Otherwise, the stream will be destroyed.
          *
          * Example using a file path:
          *
          * ```js
-         * const http2 = require('node:http2');
+         * import http2 from 'node:http2';
          * const server = http2.createServer();
          * server.on('stream', (stream) => {
          *   function statCheck(stat, headers) {
@@ -559,10 +617,10 @@ declare module "http2" {
          *
          * The `options.statCheck` function may also be used to cancel the send operation
          * by returning `false`. For instance, a conditional request may check the stat
-         * results to determine if the file has been modified to return an appropriate`304` response:
+         * results to determine if the file has been modified to return an appropriate `304` response:
          *
          * ```js
-         * const http2 = require('node:http2');
+         * import http2 from 'node:http2';
          * const server = http2.createServer();
          * server.on('stream', (stream) => {
          *   function statCheck(stat, headers) {
@@ -595,7 +653,7 @@ declare module "http2" {
          * close when the final `DATA` frame is transmitted. User code must call either`http2stream.sendTrailers()` or `http2stream.close()` to close the`Http2Stream`.
          *
          * ```js
-         * const http2 = require('node:http2');
+         * import http2 from 'node:http2';
          * const server = http2.createServer();
          * server.on('stream', (stream) => {
          *   stream.respondWithFile('/some/file',
@@ -623,12 +681,12 @@ declare module "http2" {
         maxConcurrentStreams?: number | undefined;
         maxHeaderListSize?: number | undefined;
         enableConnectProtocol?: boolean | undefined;
+        customSettings?: { [key: number]: number };
     }
     export interface ClientSessionRequestOptions {
         endStream?: boolean | undefined;
         exclusive?: boolean | undefined;
         parent?: number | undefined;
-        weight?: number | undefined;
         waitForTrailers?: boolean | undefined;
         signal?: AbortSignal | undefined;
     }
@@ -647,18 +705,18 @@ declare module "http2" {
         /**
          * Value will be `undefined` if the `Http2Session` is not yet connected to a
          * socket, `h2c` if the `Http2Session` is not connected to a `TLSSocket`, or
-         * will return the value of the connected `TLSSocket`'s own `alpnProtocol`property.
+         * will return the value of the connected `TLSSocket`'s own `alpnProtocol` property.
          * @since v9.4.0
          */
         readonly alpnProtocol?: string | undefined;
         /**
-         * Will be `true` if this `Http2Session` instance has been closed, otherwise`false`.
+         * Will be `true` if this `Http2Session` instance has been closed, otherwise `false`.
          * @since v9.4.0
          */
         readonly closed: boolean;
         /**
          * Will be `true` if this `Http2Session` instance is still connecting, will be set
-         * to `false` before emitting `connect` event and/or calling the `http2.connect`callback.
+         * to `false` before emitting `connect` event and/or calling the `http2.connect` callback.
          * @since v10.0.0
          */
         readonly connecting: boolean;
@@ -677,7 +735,8 @@ declare module "http2" {
          */
         readonly encrypted?: boolean | undefined;
         /**
-         * A prototype-less object describing the current local settings of this`Http2Session`. The local settings are local to _this_`Http2Session` instance.
+         * A prototype-less object describing the current local settings of this `Http2Session`.
+         * The local settings are local to _this_`Http2Session` instance.
          * @since v8.4.0
          */
         readonly localSettings: Settings;
@@ -692,12 +751,14 @@ declare module "http2" {
         readonly originSet?: string[] | undefined;
         /**
          * Indicates whether the `Http2Session` is currently waiting for acknowledgment of
-         * a sent `SETTINGS` frame. Will be `true` after calling the`http2session.settings()` method. Will be `false` once all sent `SETTINGS`frames have been acknowledged.
+         * a sent `SETTINGS` frame. Will be `true` after calling the `http2session.settings()` method.
+         * Will be `false` once all sent `SETTINGS` frames have been acknowledged.
          * @since v8.4.0
          */
         readonly pendingSettingsAck: boolean;
         /**
-         * A prototype-less object describing the current remote settings of this`Http2Session`. The remote settings are set by the _connected_ HTTP/2 peer.
+         * A prototype-less object describing the current remote settings of this`Http2Session`.
+         * The remote settings are set by the _connected_ HTTP/2 peer.
          * @since v8.4.0
          */
         readonly remoteSettings: Settings;
@@ -722,7 +783,7 @@ declare module "http2" {
          */
         readonly state: SessionState;
         /**
-         * The `http2session.type` will be equal to`http2.constants.NGHTTP2_SESSION_SERVER` if this `Http2Session` instance is a
+         * The `http2session.type` will be equal to `http2.constants.NGHTTP2_SESSION_SERVER` if this `Http2Session` instance is a
          * server, and `http2.constants.NGHTTP2_SESSION_CLIENT` if the instance is a
          * client.
          * @since v8.4.0
@@ -739,11 +800,11 @@ declare module "http2" {
          */
         close(callback?: () => void): void;
         /**
-         * Immediately terminates the `Http2Session` and the associated `net.Socket` or`tls.TLSSocket`.
+         * Immediately terminates the `Http2Session` and the associated `net.Socket` or `tls.TLSSocket`.
          *
-         * Once destroyed, the `Http2Session` will emit the `'close'` event. If `error`is not undefined, an `'error'` event will be emitted immediately before the`'close'` event.
+         * Once destroyed, the `Http2Session` will emit the `'close'` event. If `error` is not undefined, an `'error'` event will be emitted immediately before the `'close'` event.
          *
-         * If there are any remaining open `Http2Streams` associated with the`Http2Session`, those will also be destroyed.
+         * If there are any remaining open `Http2Streams` associated with the `Http2Session`, those will also be destroyed.
          * @since v8.4.0
          * @param error An `Error` object if the `Http2Session` is being destroyed due to an error.
          * @param code The HTTP/2 error code to send in the final `GOAWAY` frame. If unspecified, and `error` is not undefined, the default is `INTERNAL_ERROR`, otherwise defaults to `NO_ERROR`.
@@ -759,17 +820,17 @@ declare module "http2" {
         goaway(code?: number, lastStreamID?: number, opaqueData?: NodeJS.ArrayBufferView): void;
         /**
          * Sends a `PING` frame to the connected HTTP/2 peer. A `callback` function must
-         * be provided. The method will return `true` if the `PING` was sent, `false`otherwise.
+         * be provided. The method will return `true` if the `PING` was sent, `false` otherwise.
          *
-         * The maximum number of outstanding (unacknowledged) pings is determined by the`maxOutstandingPings` configuration option. The default maximum is 10.
+         * The maximum number of outstanding (unacknowledged) pings is determined by the `maxOutstandingPings` configuration option. The default maximum is 10.
          *
-         * If provided, the `payload` must be a `Buffer`, `TypedArray`, or `DataView`containing 8 bytes of data that will be transmitted with the `PING` and
+         * If provided, the `payload` must be a `Buffer`, `TypedArray`, or `DataView` containing 8 bytes of data that will be transmitted with the `PING` and
          * returned with the ping acknowledgment.
          *
          * The callback will be invoked with three arguments: an error argument that will
          * be `null` if the `PING` was successfully acknowledged, a `duration` argument
          * that reports the number of milliseconds elapsed since the ping was sent and the
-         * acknowledgment was received, and a `Buffer` containing the 8-byte `PING`payload.
+         * acknowledgment was received, and a `Buffer` containing the 8-byte `PING` payload.
          *
          * ```js
          * session.ping(Buffer.from('abcdefgh'), (err, duration, payload) => {
@@ -785,13 +846,13 @@ declare module "http2" {
          * @since v8.9.3
          * @param payload Optional ping payload.
          */
-        ping(callback: (err: Error | null, duration: number, payload: Buffer) => void): boolean;
+        ping(callback: (err: Error | null, duration: number, payload: NonSharedBuffer) => void): boolean;
         ping(
             payload: NodeJS.ArrayBufferView,
-            callback: (err: Error | null, duration: number, payload: Buffer) => void,
+            callback: (err: Error | null, duration: number, payload: NonSharedBuffer) => void,
         ): boolean;
         /**
-         * Calls `ref()` on this `Http2Session`instance's underlying `net.Socket`.
+         * Calls `ref()` on this `Http2Session` instance's underlying `net.Socket`.
          * @since v9.4.0
          */
         ref(): void;
@@ -801,7 +862,7 @@ declare module "http2" {
          * the delta.
          *
          * ```js
-         * const http2 = require('node:http2');
+         * import http2 from 'node:http2';
          *
          * const server = http2.createServer();
          * const expectedWindowSize = 2 ** 20;
@@ -822,9 +883,9 @@ declare module "http2" {
          */
         setTimeout(msecs: number, callback?: () => void): void;
         /**
-         * Updates the current local settings for this `Http2Session` and sends a new`SETTINGS` frame to the connected HTTP/2 peer.
+         * Updates the current local settings for this `Http2Session` and sends a new `SETTINGS` frame to the connected HTTP/2 peer.
          *
-         * Once called, the `http2session.pendingSettingsAck` property will be `true`while the session is waiting for the remote peer to acknowledge the new
+         * Once called, the `http2session.pendingSettingsAck` property will be `true` while the session is waiting for the remote peer to acknowledge the new
          * settings.
          *
          * The new settings will not become effective until the `SETTINGS` acknowledgment
@@ -846,11 +907,11 @@ declare module "http2" {
         addListener(event: "error", listener: (err: Error) => void): this;
         addListener(
             event: "frameError",
-            listener: (frameType: number, errorCode: number, streamID: number) => void,
+            listener: (frameType: number, errorCode: number, id: number) => void,
         ): this;
         addListener(
             event: "goaway",
-            listener: (errorCode: number, lastStreamID: number, opaqueData?: Buffer) => void,
+            listener: (errorCode: number, lastStreamID: number, opaqueData?: NonSharedBuffer) => void,
         ): this;
         addListener(event: "localSettings", listener: (settings: Settings) => void): this;
         addListener(event: "ping", listener: () => void): this;
@@ -859,8 +920,8 @@ declare module "http2" {
         addListener(event: string | symbol, listener: (...args: any[]) => void): this;
         emit(event: "close"): boolean;
         emit(event: "error", err: Error): boolean;
-        emit(event: "frameError", frameType: number, errorCode: number, streamID: number): boolean;
-        emit(event: "goaway", errorCode: number, lastStreamID: number, opaqueData?: Buffer): boolean;
+        emit(event: "frameError", frameType: number, errorCode: number, id: number): boolean;
+        emit(event: "goaway", errorCode: number, lastStreamID: number, opaqueData?: NonSharedBuffer): boolean;
         emit(event: "localSettings", settings: Settings): boolean;
         emit(event: "ping"): boolean;
         emit(event: "remoteSettings", settings: Settings): boolean;
@@ -868,8 +929,11 @@ declare module "http2" {
         emit(event: string | symbol, ...args: any[]): boolean;
         on(event: "close", listener: () => void): this;
         on(event: "error", listener: (err: Error) => void): this;
-        on(event: "frameError", listener: (frameType: number, errorCode: number, streamID: number) => void): this;
-        on(event: "goaway", listener: (errorCode: number, lastStreamID: number, opaqueData?: Buffer) => void): this;
+        on(event: "frameError", listener: (frameType: number, errorCode: number, id: number) => void): this;
+        on(
+            event: "goaway",
+            listener: (errorCode: number, lastStreamID: number, opaqueData?: NonSharedBuffer) => void,
+        ): this;
         on(event: "localSettings", listener: (settings: Settings) => void): this;
         on(event: "ping", listener: () => void): this;
         on(event: "remoteSettings", listener: (settings: Settings) => void): this;
@@ -877,8 +941,11 @@ declare module "http2" {
         on(event: string | symbol, listener: (...args: any[]) => void): this;
         once(event: "close", listener: () => void): this;
         once(event: "error", listener: (err: Error) => void): this;
-        once(event: "frameError", listener: (frameType: number, errorCode: number, streamID: number) => void): this;
-        once(event: "goaway", listener: (errorCode: number, lastStreamID: number, opaqueData?: Buffer) => void): this;
+        once(event: "frameError", listener: (frameType: number, errorCode: number, id: number) => void): this;
+        once(
+            event: "goaway",
+            listener: (errorCode: number, lastStreamID: number, opaqueData?: NonSharedBuffer) => void,
+        ): this;
         once(event: "localSettings", listener: (settings: Settings) => void): this;
         once(event: "ping", listener: () => void): this;
         once(event: "remoteSettings", listener: (settings: Settings) => void): this;
@@ -888,11 +955,11 @@ declare module "http2" {
         prependListener(event: "error", listener: (err: Error) => void): this;
         prependListener(
             event: "frameError",
-            listener: (frameType: number, errorCode: number, streamID: number) => void,
+            listener: (frameType: number, errorCode: number, id: number) => void,
         ): this;
         prependListener(
             event: "goaway",
-            listener: (errorCode: number, lastStreamID: number, opaqueData?: Buffer) => void,
+            listener: (errorCode: number, lastStreamID: number, opaqueData?: NonSharedBuffer) => void,
         ): this;
         prependListener(event: "localSettings", listener: (settings: Settings) => void): this;
         prependListener(event: "ping", listener: () => void): this;
@@ -903,11 +970,11 @@ declare module "http2" {
         prependOnceListener(event: "error", listener: (err: Error) => void): this;
         prependOnceListener(
             event: "frameError",
-            listener: (frameType: number, errorCode: number, streamID: number) => void,
+            listener: (frameType: number, errorCode: number, id: number) => void,
         ): this;
         prependOnceListener(
             event: "goaway",
-            listener: (errorCode: number, lastStreamID: number, opaqueData?: Buffer) => void,
+            listener: (errorCode: number, lastStreamID: number, opaqueData?: NonSharedBuffer) => void,
         ): this;
         prependOnceListener(event: "localSettings", listener: (settings: Settings) => void): this;
         prependOnceListener(event: "ping", listener: () => void): this;
@@ -917,18 +984,18 @@ declare module "http2" {
     }
     export interface ClientHttp2Session extends Http2Session {
         /**
-         * For HTTP/2 Client `Http2Session` instances only, the `http2session.request()`creates and returns an `Http2Stream` instance that can be used to send an
+         * 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.
+         * 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`.
+         * This method is only available if `http2session.type` is equal to `http2.constants.NGHTTP2_SESSION_CLIENT`.
          *
          * ```js
-         * const http2 = require('node:http2');
+         * import http2 from 'node:http2';
          * const clientSession = http2.connect('https://localhost:1234');
          * const {
          *   HTTP2_HEADER_PATH,
@@ -961,7 +1028,10 @@ declare module "http2" {
          * * `:path` \= `/`
          * @since v8.4.0
          */
-        request(headers?: OutgoingHttpHeaders, options?: ClientSessionRequestOptions): ClientHttp2Stream;
+        request(
+            headers?: OutgoingHttpHeaders | readonly string[],
+            options?: ClientSessionRequestOptions,
+        ): ClientHttp2Stream;
         addListener(event: "altsvc", listener: (alt: string, origin: string, stream: number) => void): this;
         addListener(event: "origin", listener: (origins: string[]) => void): this;
         addListener(
@@ -974,6 +1044,7 @@ declare module "http2" {
                 stream: ClientHttp2Stream,
                 headers: IncomingHttpHeaders & IncomingHttpStatusHeader,
                 flags: number,
+                rawHeaders: string[],
             ) => void,
         ): this;
         addListener(event: string | symbol, listener: (...args: any[]) => void): this;
@@ -985,6 +1056,7 @@ declare module "http2" {
             stream: ClientHttp2Stream,
             headers: IncomingHttpHeaders & IncomingHttpStatusHeader,
             flags: number,
+            rawHeaders: string[],
         ): boolean;
         emit(event: string | symbol, ...args: any[]): boolean;
         on(event: "altsvc", listener: (alt: string, origin: string, stream: number) => void): this;
@@ -996,6 +1068,7 @@ declare module "http2" {
                 stream: ClientHttp2Stream,
                 headers: IncomingHttpHeaders & IncomingHttpStatusHeader,
                 flags: number,
+                rawHeaders: string[],
             ) => void,
         ): this;
         on(event: string | symbol, listener: (...args: any[]) => void): this;
@@ -1011,6 +1084,7 @@ declare module "http2" {
                 stream: ClientHttp2Stream,
                 headers: IncomingHttpHeaders & IncomingHttpStatusHeader,
                 flags: number,
+                rawHeaders: string[],
             ) => void,
         ): this;
         once(event: string | symbol, listener: (...args: any[]) => void): this;
@@ -1026,6 +1100,7 @@ declare module "http2" {
                 stream: ClientHttp2Stream,
                 headers: IncomingHttpHeaders & IncomingHttpStatusHeader,
                 flags: number,
+                rawHeaders: string[],
             ) => void,
         ): this;
         prependListener(event: string | symbol, listener: (...args: any[]) => void): this;
@@ -1041,6 +1116,7 @@ declare module "http2" {
                 stream: ClientHttp2Stream,
                 headers: IncomingHttpHeaders & IncomingHttpStatusHeader,
                 flags: number,
+                rawHeaders: string[],
             ) => void,
         ): this;
         prependOnceListener(event: string | symbol, listener: (...args: any[]) => void): this;
@@ -1048,13 +1124,20 @@ declare module "http2" {
     export interface AlternativeServiceOptions {
         origin: number | string | url.URL;
     }
-    export interface ServerHttp2Session extends Http2Session {
-        readonly server: Http2Server | Http2SecureServer;
+    export interface ServerHttp2Session<
+        Http1Request extends typeof IncomingMessage = typeof IncomingMessage,
+        Http1Response extends typeof ServerResponse<InstanceType<Http1Request>> = typeof ServerResponse,
+        Http2Request extends typeof Http2ServerRequest = typeof Http2ServerRequest,
+        Http2Response extends typeof Http2ServerResponse<InstanceType<Http2Request>> = typeof Http2ServerResponse,
+    > extends Http2Session {
+        readonly server:
+            | Http2Server<Http1Request, Http1Response, Http2Request, Http2Response>
+            | Http2SecureServer<Http1Request, Http1Response, Http2Request, Http2Response>;
         /**
          * Submits an `ALTSVC` frame (as defined by [RFC 7838](https://tools.ietf.org/html/rfc7838)) to the connected client.
          *
          * ```js
-         * const http2 = require('node:http2');
+         * import http2 from 'node:http2';
          *
          * const server = http2.createServer();
          * server.on('session', (session) => {
@@ -1095,7 +1178,7 @@ declare module "http2" {
          * authoritative responses.
          *
          * ```js
-         * const http2 = require('node:http2');
+         * import http2 from 'node:http2';
          * const options = getSecureOptionsSomehow();
          * const server = http2.createSecureServer(options);
          * server.on('stream', (stream) => {
@@ -1108,7 +1191,7 @@ declare module "http2" {
          * ```
          *
          * When a string is passed as an `origin`, it will be parsed as a URL and the
-         * origin will be derived. For instance, the origin for the HTTP URL`'https://example.org/foo/bar'` is the ASCII string`'https://example.org'`. An error will be thrown if either the given
+         * origin will be derived. For instance, the origin for the HTTP URL `'https://example.org/foo/bar'` is the ASCII string` 'https://example.org'`. An error will be thrown if either the given
          * string
          * cannot be parsed as a URL or if a valid origin cannot be derived.
          *
@@ -1121,7 +1204,7 @@ declare module "http2" {
          * server using the `http2.createSecureServer()` method:
          *
          * ```js
-         * const http2 = require('node:http2');
+         * import http2 from 'node:http2';
          * const options = getSecureOptionsSomehow();
          * options.origins = ['https://example.com', 'https://example.org'];
          * const server = http2.createSecureServer(options);
@@ -1144,60 +1227,166 @@ declare module "http2" {
         ): void;
         addListener(
             event: "connect",
-            listener: (session: ServerHttp2Session, socket: net.Socket | tls.TLSSocket) => void,
+            listener: (
+                session: ServerHttp2Session<Http1Request, Http1Response, Http2Request, Http2Response>,
+                socket: net.Socket | tls.TLSSocket,
+            ) => void,
         ): this;
         addListener(
             event: "stream",
-            listener: (stream: ServerHttp2Stream, headers: IncomingHttpHeaders, flags: number) => void,
+            listener: (
+                stream: ServerHttp2Stream,
+                headers: IncomingHttpHeaders,
+                flags: number,
+                rawHeaders: string[],
+            ) => void,
         ): this;
         addListener(event: string | symbol, listener: (...args: any[]) => void): this;
-        emit(event: "connect", session: ServerHttp2Session, socket: net.Socket | tls.TLSSocket): boolean;
-        emit(event: "stream", stream: ServerHttp2Stream, headers: IncomingHttpHeaders, flags: number): boolean;
+        emit(
+            event: "connect",
+            session: ServerHttp2Session<Http1Request, Http1Response, Http2Request, Http2Response>,
+            socket: net.Socket | tls.TLSSocket,
+        ): boolean;
+        emit(
+            event: "stream",
+            stream: ServerHttp2Stream,
+            headers: IncomingHttpHeaders,
+            flags: number,
+            rawHeaders: string[],
+        ): boolean;
         emit(event: string | symbol, ...args: any[]): boolean;
-        on(event: "connect", listener: (session: ServerHttp2Session, socket: net.Socket | tls.TLSSocket) => void): this;
+        on(
+            event: "connect",
+            listener: (
+                session: ServerHttp2Session<Http1Request, Http1Response, Http2Request, Http2Response>,
+                socket: net.Socket | tls.TLSSocket,
+            ) => void,
+        ): this;
         on(
             event: "stream",
-            listener: (stream: ServerHttp2Stream, headers: IncomingHttpHeaders, flags: number) => void,
+            listener: (
+                stream: ServerHttp2Stream,
+                headers: IncomingHttpHeaders,
+                flags: number,
+                rawHeaders: string[],
+            ) => void,
         ): this;
         on(event: string | symbol, listener: (...args: any[]) => void): this;
         once(
             event: "connect",
-            listener: (session: ServerHttp2Session, socket: net.Socket | tls.TLSSocket) => void,
+            listener: (
+                session: ServerHttp2Session<Http1Request, Http1Response, Http2Request, Http2Response>,
+                socket: net.Socket | tls.TLSSocket,
+            ) => void,
         ): this;
         once(
             event: "stream",
-            listener: (stream: ServerHttp2Stream, headers: IncomingHttpHeaders, flags: number) => void,
+            listener: (
+                stream: ServerHttp2Stream,
+                headers: IncomingHttpHeaders,
+                flags: number,
+                rawHeaders: string[],
+            ) => void,
         ): this;
         once(event: string | symbol, listener: (...args: any[]) => void): this;
         prependListener(
             event: "connect",
-            listener: (session: ServerHttp2Session, socket: net.Socket | tls.TLSSocket) => void,
+            listener: (
+                session: ServerHttp2Session<Http1Request, Http1Response, Http2Request, Http2Response>,
+                socket: net.Socket | tls.TLSSocket,
+            ) => void,
         ): this;
         prependListener(
             event: "stream",
-            listener: (stream: ServerHttp2Stream, headers: IncomingHttpHeaders, flags: number) => void,
+            listener: (
+                stream: ServerHttp2Stream,
+                headers: IncomingHttpHeaders,
+                flags: number,
+                rawHeaders: string[],
+            ) => void,
         ): this;
         prependListener(event: string | symbol, listener: (...args: any[]) => void): this;
         prependOnceListener(
             event: "connect",
-            listener: (session: ServerHttp2Session, socket: net.Socket | tls.TLSSocket) => void,
+            listener: (
+                session: ServerHttp2Session<Http1Request, Http1Response, Http2Request, Http2Response>,
+                socket: net.Socket | tls.TLSSocket,
+            ) => void,
         ): this;
         prependOnceListener(
             event: "stream",
-            listener: (stream: ServerHttp2Stream, headers: IncomingHttpHeaders, flags: number) => void,
+            listener: (
+                stream: ServerHttp2Stream,
+                headers: IncomingHttpHeaders,
+                flags: number,
+                rawHeaders: string[],
+            ) => void,
         ): this;
         prependOnceListener(event: string | symbol, listener: (...args: any[]) => void): this;
     }
     // Http2Server
     export interface SessionOptions {
+        /**
+         * Sets the maximum dynamic table size for deflating header fields.
+         * @default 4Kib
+         */
         maxDeflateDynamicTableSize?: number | undefined;
+        /**
+         * Sets the maximum number of settings entries per `SETTINGS` frame.
+         * The minimum value allowed is `1`.
+         * @default 32
+         */
+        maxSettings?: number | undefined;
+        /**
+         * Sets the maximum memory that the `Http2Session` is permitted to use.
+         * The value is expressed in terms of number of megabytes, e.g. `1` equal 1 megabyte.
+         * The minimum value allowed is `1`.
+         * This is a credit based limit, existing `Http2Stream`s may cause this limit to be exceeded,
+         * but new `Http2Stream` instances will be rejected while this limit is exceeded.
+         * The current number of `Http2Stream` sessions, the current memory use of the header compression tables,
+         * current data queued to be sent, and unacknowledged `PING` and `SETTINGS` frames are all counted towards the current limit.
+         * @default 10
+         */
         maxSessionMemory?: number | undefined;
+        /**
+         * Sets the maximum number of header entries.
+         * This is similar to `server.maxHeadersCount` or `request.maxHeadersCount` in the `node:http` module.
+         * The minimum value is `1`.
+         * @default 128
+         */
         maxHeaderListPairs?: number | undefined;
+        /**
+         * Sets the maximum number of outstanding, unacknowledged pings.
+         * @default 10
+         */
         maxOutstandingPings?: number | undefined;
+        /**
+         * Sets the maximum allowed size for a serialized, compressed block of headers.
+         * Attempts to send headers that exceed this limit will result in
+         * a `'frameError'` event being emitted and the stream being closed and destroyed.
+         */
         maxSendHeaderBlockLength?: number | undefined;
+        /**
+         * Strategy used for determining the amount of padding to use for `HEADERS` and `DATA` frames.
+         * @default http2.constants.PADDING_STRATEGY_NONE
+         */
         paddingStrategy?: number | undefined;
+        /**
+         * Sets the maximum number of concurrent streams for the remote peer as if a `SETTINGS` frame had been received.
+         * Will be overridden if the remote peer sets its own value for `maxConcurrentStreams`.
+         * @default 100
+         */
         peerMaxConcurrentStreams?: number | undefined;
+        /**
+         * The initial settings to send to the remote peer upon connection.
+         */
         settings?: Settings | undefined;
+        /**
+         * The array of integer values determines the settings types,
+         * which are included in the `CustomSettings`-property of the received remoteSettings.
+         * Please see the `CustomSettings`-property of the `Http2Settings` object for more information, on the allowed setting types.
+         */
+        remoteCustomSettings?: number[] | undefined;
         /**
          * Specifies a timeout in milliseconds that
          * a server should wait when an [`'unknownProtocol'`][] is emitted. If the
@@ -1205,23 +1394,71 @@ declare module "http2" {
          * @default 100000
          */
         unknownProtocolTimeout?: number | undefined;
-        selectPadding?(frameLen: number, maxFrameLen: number): number;
+        /**
+         * If `true`, it turns on strict leading
+         * and trailing whitespace validation for HTTP/2 header field names and values
+         * as per [RFC-9113](https://www.rfc-editor.org/rfc/rfc9113.html#section-8.2.1).
+         * @since v24.2.0
+         * @default true
+         */
+        strictFieldWhitespaceValidation?: boolean | undefined;
     }
     export interface ClientSessionOptions extends SessionOptions {
+        /**
+         * Sets the maximum number of reserved push streams the client will accept at any given time.
+         * Once the current number of currently reserved push streams exceeds reaches this limit,
+         * new push streams sent by the server will be automatically rejected.
+         * The minimum allowed value is 0. The maximum allowed value is 2<sup>32</sup>-1.
+         * A negative value sets this option to the maximum allowed value.
+         * @default 200
+         */
         maxReservedRemoteStreams?: number | undefined;
+        /**
+         * An optional callback that receives the `URL` instance passed to `connect` and the `options` object,
+         * and returns any `Duplex` stream that is to be used as the connection for this session.
+         */
         createConnection?: ((authority: url.URL, option: SessionOptions) => stream.Duplex) | undefined;
+        /**
+         * The protocol to connect with, if not set in the `authority`.
+         * Value may be either `'http:'` or `'https:'`.
+         * @default 'https:'
+         */
         protocol?: "http:" | "https:" | undefined;
     }
-    export interface ServerSessionOptions extends SessionOptions {
-        Http1IncomingMessage?: typeof IncomingMessage | undefined;
-        Http1ServerResponse?: typeof ServerResponse | undefined;
-        Http2ServerRequest?: typeof Http2ServerRequest | undefined;
-        Http2ServerResponse?: typeof Http2ServerResponse | undefined;
+    export interface ServerSessionOptions<
+        Http1Request extends typeof IncomingMessage = typeof IncomingMessage,
+        Http1Response extends typeof ServerResponse<InstanceType<Http1Request>> = typeof ServerResponse,
+        Http2Request extends typeof Http2ServerRequest = typeof Http2ServerRequest,
+        Http2Response extends typeof Http2ServerResponse<InstanceType<Http2Request>> = typeof Http2ServerResponse,
+    > extends SessionOptions {
+        maxSessionRejectedStreams?: number | undefined;
+        maxSessionInvalidFrames?: number | undefined;
+        streamResetBurst?: number | undefined;
+        streamResetRate?: number | undefined;
+        Http1IncomingMessage?: Http1Request | undefined;
+        Http1ServerResponse?: Http1Response | undefined;
+        Http2ServerRequest?: Http2Request | undefined;
+        Http2ServerResponse?: Http2Response | undefined;
     }
     export interface SecureClientSessionOptions extends ClientSessionOptions, tls.ConnectionOptions {}
-    export interface SecureServerSessionOptions extends ServerSessionOptions, tls.TlsOptions {}
-    export interface ServerOptions extends ServerSessionOptions {}
-    export interface SecureServerOptions extends SecureServerSessionOptions {
+    export interface SecureServerSessionOptions<
+        Http1Request extends typeof IncomingMessage = typeof IncomingMessage,
+        Http1Response extends typeof ServerResponse<InstanceType<Http1Request>> = typeof ServerResponse,
+        Http2Request extends typeof Http2ServerRequest = typeof Http2ServerRequest,
+        Http2Response extends typeof Http2ServerResponse<InstanceType<Http2Request>> = typeof Http2ServerResponse,
+    > extends ServerSessionOptions<Http1Request, Http1Response, Http2Request, Http2Response>, tls.TlsOptions {}
+    export interface ServerOptions<
+        Http1Request extends typeof IncomingMessage = typeof IncomingMessage,
+        Http1Response extends typeof ServerResponse<InstanceType<Http1Request>> = typeof ServerResponse,
+        Http2Request extends typeof Http2ServerRequest = typeof Http2ServerRequest,
+        Http2Response extends typeof Http2ServerResponse<InstanceType<Http2Request>> = typeof Http2ServerResponse,
+    > extends ServerSessionOptions<Http1Request, Http1Response, Http2Request, Http2Response> {}
+    export interface SecureServerOptions<
+        Http1Request extends typeof IncomingMessage = typeof IncomingMessage,
+        Http1Response extends typeof ServerResponse<InstanceType<Http1Request>> = typeof ServerResponse,
+        Http2Request extends typeof Http2ServerRequest = typeof Http2ServerRequest,
+        Http2Response extends typeof Http2ServerResponse<InstanceType<Http2Request>> = typeof Http2ServerResponse,
+    > extends SecureServerSessionOptions<Http1Request, Http1Response, Http2Request, Http2Response> {
         allowHTTP1?: boolean | undefined;
         origins?: string[] | undefined;
     }
@@ -1233,100 +1470,210 @@ declare module "http2" {
          */
         updateSettings(settings: Settings): void;
     }
-    export interface Http2Server extends net.Server, HTTP2ServerCommon {
+    export interface Http2Server<
+        Http1Request extends typeof IncomingMessage = typeof IncomingMessage,
+        Http1Response extends typeof ServerResponse<InstanceType<Http1Request>> = typeof ServerResponse,
+        Http2Request extends typeof Http2ServerRequest = typeof Http2ServerRequest,
+        Http2Response extends typeof Http2ServerResponse<InstanceType<Http2Request>> = typeof Http2ServerResponse,
+    > extends net.Server, HTTP2ServerCommon {
         addListener(
             event: "checkContinue",
-            listener: (request: Http2ServerRequest, response: Http2ServerResponse) => void,
+            listener: (request: InstanceType<Http2Request>, response: InstanceType<Http2Response>) => void,
         ): this;
         addListener(
             event: "request",
-            listener: (request: Http2ServerRequest, response: Http2ServerResponse) => void,
+            listener: (request: InstanceType<Http2Request>, response: InstanceType<Http2Response>) => void,
+        ): this;
+        addListener(
+            event: "session",
+            listener: (session: ServerHttp2Session<Http1Request, Http1Response, Http2Request, Http2Response>) => void,
+        ): this;
+        addListener(
+            event: "sessionError",
+            listener: (
+                err: Error,
+                session: ServerHttp2Session<Http1Request, Http1Response, Http2Request, Http2Response>,
+            ) => void,
         ): this;
-        addListener(event: "session", listener: (session: ServerHttp2Session) => void): this;
-        addListener(event: "sessionError", listener: (err: Error) => void): this;
         addListener(
             event: "stream",
-            listener: (stream: ServerHttp2Stream, headers: IncomingHttpHeaders, flags: number) => void,
+            listener: (
+                stream: ServerHttp2Stream,
+                headers: IncomingHttpHeaders,
+                flags: number,
+                rawHeaders: string[],
+            ) => void,
         ): this;
         addListener(event: "timeout", listener: () => void): this;
         addListener(event: string | symbol, listener: (...args: any[]) => void): this;
-        emit(event: "checkContinue", request: Http2ServerRequest, response: Http2ServerResponse): boolean;
-        emit(event: "request", request: Http2ServerRequest, response: Http2ServerResponse): boolean;
-        emit(event: "session", session: ServerHttp2Session): boolean;
-        emit(event: "sessionError", err: Error): boolean;
-        emit(event: "stream", stream: ServerHttp2Stream, headers: IncomingHttpHeaders, flags: number): boolean;
+        emit(
+            event: "checkContinue",
+            request: InstanceType<Http2Request>,
+            response: InstanceType<Http2Response>,
+        ): boolean;
+        emit(event: "request", request: InstanceType<Http2Request>, response: InstanceType<Http2Response>): boolean;
+        emit(
+            event: "session",
+            session: ServerHttp2Session<Http1Request, Http1Response, Http2Request, Http2Response>,
+        ): boolean;
+        emit(
+            event: "sessionError",
+            err: Error,
+            session: ServerHttp2Session<Http1Request, Http1Response, Http2Request, Http2Response>,
+        ): boolean;
+        emit(
+            event: "stream",
+            stream: ServerHttp2Stream,
+            headers: IncomingHttpHeaders,
+            flags: number,
+            rawHeaders: string[],
+        ): boolean;
         emit(event: "timeout"): boolean;
         emit(event: string | symbol, ...args: any[]): boolean;
         on(
             event: "checkContinue",
-            listener: (request: Http2ServerRequest, response: Http2ServerResponse) => void,
+            listener: (request: InstanceType<Http2Request>, response: InstanceType<Http2Response>) => void,
+        ): this;
+        on(
+            event: "request",
+            listener: (request: InstanceType<Http2Request>, response: InstanceType<Http2Response>) => void,
+        ): this;
+        on(
+            event: "session",
+            listener: (session: ServerHttp2Session<Http1Request, Http1Response, Http2Request, Http2Response>) => void,
+        ): this;
+        on(
+            event: "sessionError",
+            listener: (
+                err: Error,
+                session: ServerHttp2Session<Http1Request, Http1Response, Http2Request, Http2Response>,
+            ) => void,
         ): this;
-        on(event: "request", listener: (request: Http2ServerRequest, response: Http2ServerResponse) => void): this;
-        on(event: "session", listener: (session: ServerHttp2Session) => void): this;
-        on(event: "sessionError", listener: (err: Error) => void): this;
         on(
             event: "stream",
-            listener: (stream: ServerHttp2Stream, headers: IncomingHttpHeaders, flags: number) => void,
+            listener: (
+                stream: ServerHttp2Stream,
+                headers: IncomingHttpHeaders,
+                flags: number,
+                rawHeaders: string[],
+            ) => void,
         ): this;
         on(event: "timeout", listener: () => void): this;
         on(event: string | symbol, listener: (...args: any[]) => void): this;
         once(
             event: "checkContinue",
-            listener: (request: Http2ServerRequest, response: Http2ServerResponse) => void,
+            listener: (request: InstanceType<Http2Request>, response: InstanceType<Http2Response>) => void,
+        ): this;
+        once(
+            event: "request",
+            listener: (request: InstanceType<Http2Request>, response: InstanceType<Http2Response>) => void,
+        ): this;
+        once(
+            event: "session",
+            listener: (session: ServerHttp2Session<Http1Request, Http1Response, Http2Request, Http2Response>) => void,
+        ): this;
+        once(
+            event: "sessionError",
+            listener: (
+                err: Error,
+                session: ServerHttp2Session<Http1Request, Http1Response, Http2Request, Http2Response>,
+            ) => void,
         ): this;
-        once(event: "request", listener: (request: Http2ServerRequest, response: Http2ServerResponse) => void): this;
-        once(event: "session", listener: (session: ServerHttp2Session) => void): this;
-        once(event: "sessionError", listener: (err: Error) => void): this;
         once(
             event: "stream",
-            listener: (stream: ServerHttp2Stream, headers: IncomingHttpHeaders, flags: number) => void,
+            listener: (
+                stream: ServerHttp2Stream,
+                headers: IncomingHttpHeaders,
+                flags: number,
+                rawHeaders: string[],
+            ) => void,
         ): this;
         once(event: "timeout", listener: () => void): this;
         once(event: string | symbol, listener: (...args: any[]) => void): this;
         prependListener(
             event: "checkContinue",
-            listener: (request: Http2ServerRequest, response: Http2ServerResponse) => void,
+            listener: (request: InstanceType<Http2Request>, response: InstanceType<Http2Response>) => void,
         ): this;
         prependListener(
             event: "request",
-            listener: (request: Http2ServerRequest, response: Http2ServerResponse) => void,
+            listener: (request: InstanceType<Http2Request>, response: InstanceType<Http2Response>) => void,
+        ): this;
+        prependListener(
+            event: "session",
+            listener: (session: ServerHttp2Session<Http1Request, Http1Response, Http2Request, Http2Response>) => void,
+        ): this;
+        prependListener(
+            event: "sessionError",
+            listener: (
+                err: Error,
+                session: ServerHttp2Session<Http1Request, Http1Response, Http2Request, Http2Response>,
+            ) => void,
         ): this;
-        prependListener(event: "session", listener: (session: ServerHttp2Session) => void): this;
-        prependListener(event: "sessionError", listener: (err: Error) => void): this;
         prependListener(
             event: "stream",
-            listener: (stream: ServerHttp2Stream, headers: IncomingHttpHeaders, flags: number) => void,
+            listener: (
+                stream: ServerHttp2Stream,
+                headers: IncomingHttpHeaders,
+                flags: number,
+                rawHeaders: string[],
+            ) => void,
         ): this;
         prependListener(event: "timeout", listener: () => void): this;
         prependListener(event: string | symbol, listener: (...args: any[]) => void): this;
         prependOnceListener(
             event: "checkContinue",
-            listener: (request: Http2ServerRequest, response: Http2ServerResponse) => void,
+            listener: (request: InstanceType<Http2Request>, response: InstanceType<Http2Response>) => void,
         ): this;
         prependOnceListener(
             event: "request",
-            listener: (request: Http2ServerRequest, response: Http2ServerResponse) => void,
+            listener: (request: InstanceType<Http2Request>, response: InstanceType<Http2Response>) => void,
+        ): this;
+        prependOnceListener(
+            event: "session",
+            listener: (session: ServerHttp2Session<Http1Request, Http1Response, Http2Request, Http2Response>) => void,
+        ): this;
+        prependOnceListener(
+            event: "sessionError",
+            listener: (
+                err: Error,
+                session: ServerHttp2Session<Http1Request, Http1Response, Http2Request, Http2Response>,
+            ) => void,
         ): this;
-        prependOnceListener(event: "session", listener: (session: ServerHttp2Session) => void): this;
-        prependOnceListener(event: "sessionError", listener: (err: Error) => void): this;
         prependOnceListener(
             event: "stream",
-            listener: (stream: ServerHttp2Stream, headers: IncomingHttpHeaders, flags: number) => void,
+            listener: (
+                stream: ServerHttp2Stream,
+                headers: IncomingHttpHeaders,
+                flags: number,
+                rawHeaders: string[],
+            ) => void,
         ): this;
         prependOnceListener(event: "timeout", listener: () => void): this;
         prependOnceListener(event: string | symbol, listener: (...args: any[]) => void): this;
     }
-    export interface Http2SecureServer extends tls.Server, HTTP2ServerCommon {
+    export interface Http2SecureServer<
+        Http1Request extends typeof IncomingMessage = typeof IncomingMessage,
+        Http1Response extends typeof ServerResponse<InstanceType<Http1Request>> = typeof ServerResponse,
+        Http2Request extends typeof Http2ServerRequest = typeof Http2ServerRequest,
+        Http2Response extends typeof Http2ServerResponse<InstanceType<Http2Request>> = typeof Http2ServerResponse,
+    > extends tls.Server, HTTP2ServerCommon {
         addListener(
             event: "checkContinue",
-            listener: (request: Http2ServerRequest, response: Http2ServerResponse) => void,
+            listener: (request: InstanceType<Http2Request>, response: InstanceType<Http2Response>) => void,
         ): this;
         addListener(
             event: "request",
-            listener: (request: Http2ServerRequest, response: Http2ServerResponse) => void,
+            listener: (request: InstanceType<Http2Request>, response: InstanceType<Http2Response>) => void,
+        ): this;
+        addListener(
+            event: "session",
+            listener: (session: ServerHttp2Session<Http1Request, Http1Response, Http2Request, Http2Response>) => void,
+        ): this;
+        addListener(
+            event: "sessionError",
+            listener: (err: Error) => void,
+            session: ServerHttp2Session<Http1Request, Http1Response, Http2Request, Http2Response>,
         ): this;
-        addListener(event: "session", listener: (session: ServerHttp2Session) => void): this;
-        addListener(event: "sessionError", listener: (err: Error) => void): this;
         addListener(
             event: "stream",
             listener: (stream: ServerHttp2Stream, headers: IncomingHttpHeaders, flags: number) => void,
@@ -1334,21 +1681,44 @@ declare module "http2" {
         addListener(event: "timeout", listener: () => void): this;
         addListener(event: "unknownProtocol", listener: (socket: tls.TLSSocket) => void): this;
         addListener(event: string | symbol, listener: (...args: any[]) => void): this;
-        emit(event: "checkContinue", request: Http2ServerRequest, response: Http2ServerResponse): boolean;
-        emit(event: "request", request: Http2ServerRequest, response: Http2ServerResponse): boolean;
-        emit(event: "session", session: ServerHttp2Session): boolean;
-        emit(event: "sessionError", err: Error): boolean;
+        emit(
+            event: "checkContinue",
+            request: InstanceType<Http2Request>,
+            response: InstanceType<Http2Response>,
+        ): boolean;
+        emit(event: "request", request: InstanceType<Http2Request>, response: InstanceType<Http2Response>): boolean;
+        emit(
+            event: "session",
+            session: ServerHttp2Session<Http1Request, Http1Response, Http2Request, Http2Response>,
+        ): boolean;
+        emit(
+            event: "sessionError",
+            err: Error,
+            session: ServerHttp2Session<Http1Request, Http1Response, Http2Request, Http2Response>,
+        ): boolean;
         emit(event: "stream", stream: ServerHttp2Stream, headers: IncomingHttpHeaders, flags: number): boolean;
         emit(event: "timeout"): boolean;
         emit(event: "unknownProtocol", socket: tls.TLSSocket): boolean;
         emit(event: string | symbol, ...args: any[]): boolean;
         on(
             event: "checkContinue",
-            listener: (request: Http2ServerRequest, response: Http2ServerResponse) => void,
+            listener: (request: InstanceType<Http2Request>, response: InstanceType<Http2Response>) => void,
+        ): this;
+        on(
+            event: "request",
+            listener: (request: InstanceType<Http2Request>, response: InstanceType<Http2Response>) => void,
+        ): this;
+        on(
+            event: "session",
+            listener: (session: ServerHttp2Session<Http1Request, Http1Response, Http2Request, Http2Response>) => void,
+        ): this;
+        on(
+            event: "sessionError",
+            listener: (
+                err: Error,
+                session: ServerHttp2Session<Http1Request, Http1Response, Http2Request, Http2Response>,
+            ) => void,
         ): this;
-        on(event: "request", listener: (request: Http2ServerRequest, response: Http2ServerResponse) => void): this;
-        on(event: "session", listener: (session: ServerHttp2Session) => void): this;
-        on(event: "sessionError", listener: (err: Error) => void): this;
         on(
             event: "stream",
             listener: (stream: ServerHttp2Stream, headers: IncomingHttpHeaders, flags: number) => void,
@@ -1358,11 +1728,23 @@ declare module "http2" {
         on(event: string | symbol, listener: (...args: any[]) => void): this;
         once(
             event: "checkContinue",
-            listener: (request: Http2ServerRequest, response: Http2ServerResponse) => void,
+            listener: (request: InstanceType<Http2Request>, response: InstanceType<Http2Response>) => void,
+        ): this;
+        once(
+            event: "request",
+            listener: (request: InstanceType<Http2Request>, response: InstanceType<Http2Response>) => void,
+        ): this;
+        once(
+            event: "session",
+            listener: (session: ServerHttp2Session<Http1Request, Http1Response, Http2Request, Http2Response>) => void,
+        ): this;
+        once(
+            event: "sessionError",
+            listener: (
+                err: Error,
+                session: ServerHttp2Session<Http1Request, Http1Response, Http2Request, Http2Response>,
+            ) => void,
         ): this;
-        once(event: "request", listener: (request: Http2ServerRequest, response: Http2ServerResponse) => void): this;
-        once(event: "session", listener: (session: ServerHttp2Session) => void): this;
-        once(event: "sessionError", listener: (err: Error) => void): this;
         once(
             event: "stream",
             listener: (stream: ServerHttp2Stream, headers: IncomingHttpHeaders, flags: number) => void,
@@ -1372,14 +1754,23 @@ declare module "http2" {
         once(event: string | symbol, listener: (...args: any[]) => void): this;
         prependListener(
             event: "checkContinue",
-            listener: (request: Http2ServerRequest, response: Http2ServerResponse) => void,
+            listener: (request: InstanceType<Http2Request>, response: InstanceType<Http2Response>) => void,
         ): this;
         prependListener(
             event: "request",
-            listener: (request: Http2ServerRequest, response: Http2ServerResponse) => void,
+            listener: (request: InstanceType<Http2Request>, response: InstanceType<Http2Response>) => void,
+        ): this;
+        prependListener(
+            event: "session",
+            listener: (session: ServerHttp2Session<Http1Request, Http1Response, Http2Request, Http2Response>) => void,
+        ): this;
+        prependListener(
+            event: "sessionError",
+            listener: (
+                err: Error,
+                session: ServerHttp2Session<Http1Request, Http1Response, Http2Request, Http2Response>,
+            ) => void,
         ): this;
-        prependListener(event: "session", listener: (session: ServerHttp2Session) => void): this;
-        prependListener(event: "sessionError", listener: (err: Error) => void): this;
         prependListener(
             event: "stream",
             listener: (stream: ServerHttp2Stream, headers: IncomingHttpHeaders, flags: number) => void,
@@ -1389,14 +1780,23 @@ declare module "http2" {
         prependListener(event: string | symbol, listener: (...args: any[]) => void): this;
         prependOnceListener(
             event: "checkContinue",
-            listener: (request: Http2ServerRequest, response: Http2ServerResponse) => void,
+            listener: (request: InstanceType<Http2Request>, response: InstanceType<Http2Response>) => void,
         ): this;
         prependOnceListener(
             event: "request",
-            listener: (request: Http2ServerRequest, response: Http2ServerResponse) => void,
+            listener: (request: InstanceType<Http2Request>, response: InstanceType<Http2Response>) => void,
+        ): this;
+        prependOnceListener(
+            event: "session",
+            listener: (session: ServerHttp2Session<Http1Request, Http1Response, Http2Request, Http2Response>) => void,
+        ): this;
+        prependOnceListener(
+            event: "sessionError",
+            listener: (
+                err: Error,
+                session: ServerHttp2Session<Http1Request, Http1Response, Http2Request, Http2Response>,
+            ) => void,
         ): this;
-        prependOnceListener(event: "session", listener: (session: ServerHttp2Session) => void): this;
-        prependOnceListener(event: "sessionError", listener: (err: Error) => void): this;
         prependOnceListener(
             event: "stream",
             listener: (stream: ServerHttp2Stream, headers: IncomingHttpHeaders, flags: number) => void,
@@ -1426,7 +1826,7 @@ declare module "http2" {
         readonly aborted: boolean;
         /**
          * The request authority pseudo header field. Because HTTP/2 allows requests
-         * to set either `:authority` or `host`, this value is derived from`req.headers[':authority']` if present. Otherwise, it is derived from`req.headers['host']`.
+         * to set either `:authority` or `host`, this value is derived from `req.headers[':authority']` if present. Otherwise, it is derived from `req.headers['host']`.
          * @since v8.4.0
          */
         readonly authority: string;
@@ -1473,9 +1873,9 @@ declare module "http2" {
         readonly headers: IncomingHttpHeaders;
         /**
          * In case of server request, the HTTP version sent by the client. In the case of
-         * client response, the HTTP version of the connected-to server. Returns`'2.0'`.
+         * client response, the HTTP version of the connected-to server. Returns `'2.0'`.
          *
-         * Also `message.httpVersionMajor` is the first integer and`message.httpVersionMinor` is the second.
+         * Also `message.httpVersionMajor` is the first integer and `message.httpVersionMinor` is the second.
          * @since v8.4.0
          */
         readonly httpVersion: string;
@@ -1530,11 +1930,11 @@ declare module "http2" {
          * `destroyed`, `readable`, and `writable` properties will be retrieved from and
          * set on `request.stream`.
          *
-         * `destroy`, `emit`, `end`, `on` and `once` methods will be called on`request.stream`.
+         * `destroy`, `emit`, `end`, `on` and `once` methods will be called on `request.stream`.
          *
          * `setTimeout` method will be called on `request.stream.session`.
          *
-         * `pause`, `read`, `resume`, and `write` will throw an error with code`ERR_HTTP2_NO_SOCKET_MANIPULATION`. See `Http2Session and Sockets` for
+         * `pause`, `read`, `resume`, and `write` will throw an error with code `ERR_HTTP2_NO_SOCKET_MANIPULATION`. See `Http2Session and Sockets` for
          * more information.
          *
          * All other interactions will be routed directly to the socket. With TLS support,
@@ -1597,50 +1997,50 @@ declare module "http2" {
          * the response object.
          *
          * If no `'timeout'` listener is added to the request, the response, or
-         * the server, then `Http2Stream` s are destroyed when they time out. If a
+         * the server, then `Http2Stream`s are destroyed when they time out. If a
          * handler is assigned to the request, the response, or the server's `'timeout'`events, timed out sockets must be handled explicitly.
          * @since v8.4.0
          */
         setTimeout(msecs: number, callback?: () => void): void;
-        read(size?: number): Buffer | string | null;
+        read(size?: number): NonSharedBuffer | string | null;
         addListener(event: "aborted", listener: (hadError: boolean, code: number) => void): this;
         addListener(event: "close", listener: () => void): this;
-        addListener(event: "data", listener: (chunk: Buffer | string) => void): this;
+        addListener(event: "data", listener: (chunk: NonSharedBuffer | string) => void): this;
         addListener(event: "end", listener: () => void): this;
         addListener(event: "readable", listener: () => void): this;
         addListener(event: "error", listener: (err: Error) => void): this;
         addListener(event: string | symbol, listener: (...args: any[]) => void): this;
         emit(event: "aborted", hadError: boolean, code: number): boolean;
         emit(event: "close"): boolean;
-        emit(event: "data", chunk: Buffer | string): boolean;
+        emit(event: "data", chunk: NonSharedBuffer | string): boolean;
         emit(event: "end"): boolean;
         emit(event: "readable"): boolean;
         emit(event: "error", err: Error): boolean;
         emit(event: string | symbol, ...args: any[]): boolean;
         on(event: "aborted", listener: (hadError: boolean, code: number) => void): this;
         on(event: "close", listener: () => void): this;
-        on(event: "data", listener: (chunk: Buffer | string) => void): this;
+        on(event: "data", listener: (chunk: NonSharedBuffer | string) => void): this;
         on(event: "end", listener: () => void): this;
         on(event: "readable", listener: () => void): this;
         on(event: "error", listener: (err: Error) => void): this;
         on(event: string | symbol, listener: (...args: any[]) => void): this;
         once(event: "aborted", listener: (hadError: boolean, code: number) => void): this;
         once(event: "close", listener: () => void): this;
-        once(event: "data", listener: (chunk: Buffer | string) => void): this;
+        once(event: "data", listener: (chunk: NonSharedBuffer | string) => void): this;
         once(event: "end", listener: () => void): this;
         once(event: "readable", listener: () => void): this;
         once(event: "error", listener: (err: Error) => void): this;
         once(event: string | symbol, listener: (...args: any[]) => void): this;
         prependListener(event: "aborted", listener: (hadError: boolean, code: number) => void): this;
         prependListener(event: "close", listener: () => void): this;
-        prependListener(event: "data", listener: (chunk: Buffer | string) => void): this;
+        prependListener(event: "data", listener: (chunk: NonSharedBuffer | string) => void): this;
         prependListener(event: "end", listener: () => void): this;
         prependListener(event: "readable", listener: () => void): this;
         prependListener(event: "error", listener: (err: Error) => void): this;
         prependListener(event: string | symbol, listener: (...args: any[]) => void): this;
         prependOnceListener(event: "aborted", listener: (hadError: boolean, code: number) => void): this;
         prependOnceListener(event: "close", listener: () => void): this;
-        prependOnceListener(event: "data", listener: (chunk: Buffer | string) => void): this;
+        prependOnceListener(event: "data", listener: (chunk: NonSharedBuffer | string) => void): this;
         prependOnceListener(event: "end", listener: () => void): this;
         prependOnceListener(event: "readable", listener: () => void): this;
         prependOnceListener(event: "error", listener: (err: Error) => void): this;
@@ -1651,7 +2051,7 @@ declare module "http2" {
      * passed as the second parameter to the `'request'` event.
      * @since v8.4.0
      */
-    export class Http2ServerResponse extends stream.Writable {
+    export class Http2ServerResponse<Request extends Http2ServerRequest = Http2ServerRequest> extends stream.Writable {
         constructor(stream: ServerHttp2Stream);
         /**
          * See `response.socket`.
@@ -1659,6 +2059,28 @@ declare module "http2" {
          * @deprecated Since v13.0.0 - Use `socket`.
          */
         readonly connection: net.Socket | tls.TLSSocket;
+        /**
+         * Append a single header value to the header object.
+         *
+         * If the value is an array, this is equivalent to calling this method multiple times.
+         *
+         * If there were no previous values for the header, this is equivalent to calling {@link setHeader}.
+         *
+         * Attempting to set a header field name or value that contains invalid characters will result in a
+         * [TypeError](https://nodejs.org/docs/latest-v24.x/api/errors.html#class-typeerror) being thrown.
+         *
+         * ```js
+         * // Returns headers including "set-cookie: a" and "set-cookie: b"
+         * const server = http2.createServer((req, res) => {
+         *   res.setHeader('set-cookie', 'a');
+         *   res.appendHeader('set-cookie', 'b');
+         *   res.writeHead(200);
+         *   res.end('ok');
+         * });
+         * ```
+         * @since v20.12.0
+         */
+        appendHeader(name: string, value: string | string[]): void;
         /**
          * Boolean value that indicates whether the response has completed. Starts
          * as `false`. After `response.end()` executes, the value will be `true`.
@@ -1675,7 +2097,7 @@ declare module "http2" {
          * A reference to the original HTTP2 `request` object.
          * @since v15.7.0
          */
-        readonly req: Http2ServerRequest;
+        readonly req: Request;
         /**
          * Returns a `Proxy` object that acts as a `net.Socket` (or `tls.TLSSocket`) but
          * applies getters, setters, and methods based on HTTP/2 logic.
@@ -1683,17 +2105,17 @@ declare module "http2" {
          * `destroyed`, `readable`, and `writable` properties will be retrieved from and
          * set on `response.stream`.
          *
-         * `destroy`, `emit`, `end`, `on` and `once` methods will be called on`response.stream`.
+         * `destroy`, `emit`, `end`, `on` and `once` methods will be called on `response.stream`.
          *
          * `setTimeout` method will be called on `response.stream.session`.
          *
-         * `pause`, `read`, `resume`, and `write` will throw an error with code`ERR_HTTP2_NO_SOCKET_MANIPULATION`. See `Http2Session and Sockets` for
+         * `pause`, `read`, `resume`, and `write` will throw an error with code `ERR_HTTP2_NO_SOCKET_MANIPULATION`. See `Http2Session and Sockets` for
          * more information.
          *
          * All other interactions will be routed directly to the socket.
          *
          * ```js
-         * const http2 = require('node:http2');
+         * import http2 from 'node:http2';
          * const server = http2.createServer((req, res) => {
          *   const ip = req.socket.remoteAddress;
          *   const port = req.socket.remotePort;
@@ -1791,7 +2213,7 @@ declare module "http2" {
          * header names and the values are the respective header values. All header names
          * are lowercase.
          *
-         * The object returned by the `response.getHeaders()` method _does not_prototypically inherit from the JavaScript `Object`. This means that typical`Object` methods such as `obj.toString()`,
+         * The object returned by the `response.getHeaders()` method _does 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_.
          *
@@ -1865,7 +2287,7 @@ declare module "http2" {
          *
          * If no `'timeout'` listener is added to the request, the response, or
          * the server, then `Http2Stream` s are destroyed when they time out. If a
-         * handler is assigned to the request, the response, or the server's `'timeout'`events, timed out sockets must be handled explicitly.
+         * handler is assigned to the request, the response, or the server's `'timeout'` events, timed out sockets must be handled explicitly.
          * @since v8.4.0
          */
         setTimeout(msecs: number, callback?: () => void): void;
@@ -1901,7 +2323,7 @@ declare module "http2" {
         write(chunk: string | Uint8Array, encoding: BufferEncoding, callback?: (err: Error) => void): boolean;
         /**
          * Sends a status `100 Continue` to the client, indicating that the request body
-         * should be sent. See the `'checkContinue'` event on `Http2Server` and`Http2SecureServer`.
+         * should be sent. See the `'checkContinue'` event on `Http2Server` and `Http2SecureServer`.
          * @since v8.4.0
          */
         writeContinue(): void;
@@ -1952,7 +2374,7 @@ declare module "http2" {
          * `Content-Length` is given in bytes not characters. The`Buffer.byteLength()` API may be used to determine the number of bytes in a
          * given encoding. On outbound messages, Node.js does not check if Content-Length
          * and the length of the body being transmitted are equal or not. However, when
-         * receiving messages, Node.js will automatically reject messages when the`Content-Length` does not match the actual payload size.
+         * receiving messages, Node.js will automatically reject messages when the `Content-Length` does not match the actual payload size.
          *
          * This method may be called at most one time on a message before `response.end()` is called.
          *
@@ -1977,8 +2399,8 @@ declare module "http2" {
          * will result in a `TypeError` being thrown.
          * @since v8.4.0
          */
-        writeHead(statusCode: number, headers?: OutgoingHttpHeaders): this;
-        writeHead(statusCode: number, statusMessage: string, headers?: OutgoingHttpHeaders): this;
+        writeHead(statusCode: number, headers?: OutgoingHttpHeaders | readonly string[]): this;
+        writeHead(statusCode: number, statusMessage: string, headers?: OutgoingHttpHeaders | readonly string[]): this;
         /**
          * Call `http2stream.pushStream()` with the given headers, and wrap the
          * given `Http2Stream` on a newly created `Http2ServerResponse` as the callback
@@ -2094,7 +2516,13 @@ declare module "http2" {
         const HTTP2_HEADER_ACCEPT_LANGUAGE: string;
         const HTTP2_HEADER_ACCEPT_RANGES: string;
         const HTTP2_HEADER_ACCEPT: string;
+        const HTTP2_HEADER_ACCESS_CONTROL_ALLOW_CREDENTIALS: string;
+        const HTTP2_HEADER_ACCESS_CONTROL_ALLOW_HEADERS: string;
+        const HTTP2_HEADER_ACCESS_CONTROL_ALLOW_METHODS: string;
         const HTTP2_HEADER_ACCESS_CONTROL_ALLOW_ORIGIN: string;
+        const HTTP2_HEADER_ACCESS_CONTROL_EXPOSE_HEADERS: string;
+        const HTTP2_HEADER_ACCESS_CONTROL_REQUEST_HEADERS: string;
+        const HTTP2_HEADER_ACCESS_CONTROL_REQUEST_METHOD: string;
         const HTTP2_HEADER_AGE: string;
         const HTTP2_HEADER_ALLOW: string;
         const HTTP2_HEADER_AUTHORIZATION: string;
@@ -2252,7 +2680,7 @@ declare module "http2" {
      */
     export const sensitiveHeaders: symbol;
     /**
-     * Returns an object containing the default settings for an `Http2Session`instance. This method returns a new object instance every time it is called
+     * Returns an object containing the default settings for an `Http2Session` instance. This method returns a new object instance every time it is called
      * so instances returned may be safely modified for use.
      * @since v8.4.0
      */
@@ -2263,7 +2691,7 @@ declare module "http2" {
      * for use with the `HTTP2-Settings` header field.
      *
      * ```js
-     * const http2 = require('node:http2');
+     * import http2 from 'node:http2';
      *
      * const packed = http2.getPackedSettings({ enablePush: false });
      *
@@ -2272,7 +2700,7 @@ declare module "http2" {
      * ```
      * @since v8.4.0
      */
-    export function getPackedSettings(settings: Settings): Buffer;
+    export function getPackedSettings(settings: Settings): NonSharedBuffer;
     /**
      * Returns a `HTTP/2 Settings Object` containing the deserialized settings from
      * the given `Buffer` as generated by `http2.getPackedSettings()`.
@@ -2281,14 +2709,14 @@ declare module "http2" {
      */
     export function getUnpackedSettings(buf: Uint8Array): Settings;
     /**
-     * Returns a `net.Server` instance that creates and manages `Http2Session`instances.
+     * Returns a `net.Server` instance that creates and manages `Http2Session` instances.
      *
      * Since there are no browsers known that support [unencrypted HTTP/2](https://http2.github.io/faq/#does-http2-require-encryption), the use of {@link createSecureServer} is necessary when
      * communicating
      * with browser clients.
      *
      * ```js
-     * const http2 = require('node:http2');
+     * import http2 from 'node:http2';
      *
      * // Create an unencrypted HTTP/2 server.
      * // Since there are no browsers known that support
@@ -2312,16 +2740,21 @@ declare module "http2" {
     export function createServer(
         onRequestHandler?: (request: Http2ServerRequest, response: Http2ServerResponse) => void,
     ): Http2Server;
-    export function createServer(
-        options: ServerOptions,
-        onRequestHandler?: (request: Http2ServerRequest, response: Http2ServerResponse) => void,
-    ): Http2Server;
+    export function createServer<
+        Http1Request extends typeof IncomingMessage = typeof IncomingMessage,
+        Http1Response extends typeof ServerResponse<InstanceType<Http1Request>> = typeof ServerResponse,
+        Http2Request extends typeof Http2ServerRequest = typeof Http2ServerRequest,
+        Http2Response extends typeof Http2ServerResponse<InstanceType<Http2Request>> = typeof Http2ServerResponse,
+    >(
+        options: ServerOptions<Http1Request, Http1Response, Http2Request, Http2Response>,
+        onRequestHandler?: (request: InstanceType<Http2Request>, response: InstanceType<Http2Response>) => void,
+    ): Http2Server<Http1Request, Http1Response, Http2Request, Http2Response>;
     /**
-     * Returns a `tls.Server` instance that creates and manages `Http2Session`instances.
+     * Returns a `tls.Server` instance that creates and manages `Http2Session` instances.
      *
      * ```js
-     * const http2 = require('node:http2');
-     * const fs = require('node:fs');
+     * import http2 from 'node:http2';
+     * import fs from 'node:fs';
      *
      * const options = {
      *   key: fs.readFileSync('server-key.pem'),
@@ -2347,15 +2780,20 @@ declare module "http2" {
     export function createSecureServer(
         onRequestHandler?: (request: Http2ServerRequest, response: Http2ServerResponse) => void,
     ): Http2SecureServer;
-    export function createSecureServer(
-        options: SecureServerOptions,
-        onRequestHandler?: (request: Http2ServerRequest, response: Http2ServerResponse) => void,
-    ): Http2SecureServer;
+    export function createSecureServer<
+        Http1Request extends typeof IncomingMessage = typeof IncomingMessage,
+        Http1Response extends typeof ServerResponse<InstanceType<Http1Request>> = typeof ServerResponse,
+        Http2Request extends typeof Http2ServerRequest = typeof Http2ServerRequest,
+        Http2Response extends typeof Http2ServerResponse<InstanceType<Http2Request>> = typeof Http2ServerResponse,
+    >(
+        options: SecureServerOptions<Http1Request, Http1Response, Http2Request, Http2Response>,
+        onRequestHandler?: (request: InstanceType<Http2Request>, response: InstanceType<Http2Response>) => void,
+    ): Http2SecureServer<Http1Request, Http1Response, Http2Request, Http2Response>;
     /**
      * Returns a `ClientHttp2Session` instance.
      *
      * ```js
-     * const http2 = require('node:http2');
+     * import http2 from 'node:http2';
      * const client = http2.connect('https://localhost:1234');
      *
      * // Use the client
@@ -2376,6 +2814,21 @@ declare module "http2" {
         options?: ClientSessionOptions | SecureClientSessionOptions,
         listener?: (session: ClientHttp2Session, socket: net.Socket | tls.TLSSocket) => void,
     ): ClientHttp2Session;
+    /**
+     * Create an HTTP/2 server session from an existing socket.
+     * @param socket A Duplex Stream
+     * @param options Any `{@link createServer}` options can be provided.
+     * @since v20.12.0
+     */
+    export function performServerHandshake<
+        Http1Request extends typeof IncomingMessage = typeof IncomingMessage,
+        Http1Response extends typeof ServerResponse<InstanceType<Http1Request>> = typeof ServerResponse,
+        Http2Request extends typeof Http2ServerRequest = typeof Http2ServerRequest,
+        Http2Response extends typeof Http2ServerResponse<InstanceType<Http2Request>> = typeof Http2ServerResponse,
+    >(
+        socket: stream.Duplex,
+        options?: ServerOptions<Http1Request, Http1Response, Http2Request, Http2Response>,
+    ): ServerHttp2Session<Http1Request, Http1Response, Http2Request, Http2Response>;
 }
 declare module "node:http2" {
     export * from "http2";