@idlebox/stripe-node-types 24.0.14-patch.0 → 24.0.15

package/http2.d.ts

@@ -1,3 +1,18 @@
+// biome-ignore-all lint: generated file
+// biome-ignore-all assist: generated file
+/* eslint-disable */
+// @ts-ignore
+
+/******************************************************************************
+ *  GENERATED FILE, DO NOT MODIFY
+ *  这是生成的文件，千万不要修改
+ * 
+ * @build-script/codegen - The Simple Code Generater
+ * https://github.com/GongT/baobao
+ * 
+ ******************************************************************************/
+
+
 /**
  * The `node:http2` module provides an implementation of the [HTTP/2](https://tools.ietf.org/html/rfc7540) protocol.
  * It can be accessed using:
@@ -6,11 +21,12 @@
  * import http2 from 'node:http2';
  * ```
  * @since v8.4.0
- * @see [source](https://github.com/nodejs/node/blob/v24.x/lib/http2.js)
+ * @see [source](https://github.com/nodejs/node/blob/v25.x/lib/http2.js)
  */
 
 declare module "node:http2" {
-    import EventEmitter = require('node:events');
+    import { NonSharedBuffer } from 'node:buffer';
+    import { InternalEventEmitter } from 'node:events';
     import * as fs from '_not-use-node-type_fs';
     import * as net from 'node:net';
     import * as stream from 'node:stream';
@@ -22,50 +38,56 @@ declare module "node:http2" {
         OutgoingHttpHeaders,
         ServerResponse,
     } from 'node:http';
-    export { OutgoingHttpHeaders } from "node:http";
-    export interface IncomingHttpStatusHeader {
+    interface IncomingHttpStatusHeader {
         ":status"?: number | undefined;
     }
-    export interface IncomingHttpHeaders extends Http1IncomingHttpHeaders {
+    interface IncomingHttpHeaders extends Http1IncomingHttpHeaders {
         ":path"?: string | undefined;
         ":method"?: string | undefined;
         ":authority"?: string | undefined;
         ":scheme"?: string | undefined;
     }
     // Http2Stream
-    export interface StreamPriorityOptions {
-        exclusive?: boolean | undefined;
-        parent?: number | undefined;
-        weight?: number | undefined;
-        silent?: boolean | undefined;
-    }
-    export interface StreamState {
+    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 {
+    interface ServerStreamResponseOptions {
         endStream?: boolean | undefined;
         waitForTrailers?: boolean | undefined;
     }
-    export interface StatOptions {
+    interface StatOptions {
         offset: number;
         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;
+    interface ServerStreamFileResponseOptions {
+        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;
+    interface ServerStreamFileResponseOptionsWithError extends ServerStreamFileResponseOptions {
+        onError?: ((err: NodeJS.ErrnoException) => void) | undefined;
     }
-    export interface Http2Stream extends stream.Duplex {
+    interface Http2StreamEventMap extends stream.DuplexEventMap {
+        "aborted": [];
+        "data": [chunk: string | NonSharedBuffer];
+        "frameError": [type: number, code: number, id: number];
+        "ready": [];
+        "streamClosed": [code: number];
+        "timeout": [];
+        "trailers": [trailers: IncomingHttpHeaders, flags: number];
+        "wantTrailers": [];
+    }
+    interface Http2Stream extends stream.Duplex {
         /**
          * Set to `true` if the `Http2Stream` instance was aborted abnormally. When set,
          * the `'aborted'` event will have been emitted.
@@ -152,10 +174,9 @@ declare module "node: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
          * import http2 from 'node:http2';
@@ -194,160 +215,122 @@ declare module "node:http2" {
          * @since v10.0.0
          */
         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: "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: "pipe", listener: (src: stream.Readable) => void): this;
-        addListener(event: "unpipe", listener: (src: stream.Readable) => void): this;
-        addListener(event: "streamClosed", listener: (code: number) => void): this;
-        addListener(event: "timeout", listener: () => void): this;
-        addListener(event: "trailers", listener: (trailers: IncomingHttpHeaders, flags: number) => void): this;
-        addListener(event: "wantTrailers", listener: () => void): this;
-        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: "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: "pipe", src: stream.Readable): boolean;
-        emit(event: "unpipe", src: stream.Readable): boolean;
-        emit(event: "streamClosed", code: number): boolean;
-        emit(event: "timeout"): boolean;
-        emit(event: "trailers", trailers: IncomingHttpHeaders, flags: number): boolean;
-        emit(event: "wantTrailers"): boolean;
-        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: "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: "pipe", listener: (src: stream.Readable) => void): this;
-        on(event: "unpipe", listener: (src: stream.Readable) => void): this;
-        on(event: "streamClosed", listener: (code: number) => void): this;
-        on(event: "timeout", listener: () => void): this;
-        on(event: "trailers", listener: (trailers: IncomingHttpHeaders, flags: number) => void): this;
-        on(event: "wantTrailers", listener: () => void): this;
-        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: "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: "pipe", listener: (src: stream.Readable) => void): this;
-        once(event: "unpipe", listener: (src: stream.Readable) => void): this;
-        once(event: "streamClosed", listener: (code: number) => void): this;
-        once(event: "timeout", listener: () => void): this;
-        once(event: "trailers", listener: (trailers: IncomingHttpHeaders, flags: number) => void): this;
-        once(event: "wantTrailers", listener: () => void): this;
-        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: "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: "pipe", listener: (src: stream.Readable) => void): this;
-        prependListener(event: "unpipe", listener: (src: stream.Readable) => void): this;
-        prependListener(event: "streamClosed", listener: (code: number) => void): this;
-        prependListener(event: "timeout", listener: () => void): this;
-        prependListener(event: "trailers", listener: (trailers: IncomingHttpHeaders, flags: number) => void): this;
-        prependListener(event: "wantTrailers", listener: () => void): this;
-        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: "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: "pipe", listener: (src: stream.Readable) => void): this;
-        prependOnceListener(event: "unpipe", listener: (src: stream.Readable) => void): this;
-        prependOnceListener(event: "streamClosed", listener: (code: number) => void): this;
-        prependOnceListener(event: "timeout", listener: () => void): this;
-        prependOnceListener(event: "trailers", listener: (trailers: IncomingHttpHeaders, flags: number) => void): this;
-        prependOnceListener(event: "wantTrailers", listener: () => void): this;
-        prependOnceListener(event: string | symbol, listener: (...args: any[]) => void): this;
+        // #region InternalEventEmitter
+        addListener<E extends keyof Http2StreamEventMap>(
+            eventName: E,
+            listener: (...args: Http2StreamEventMap[E]) => void,
+        ): this;
+        addListener(eventName: string | symbol, listener: (...args: any[]) => void): this;
+        emit<E extends keyof Http2StreamEventMap>(eventName: E, ...args: Http2StreamEventMap[E]): boolean;
+        emit(eventName: string | symbol, ...args: any[]): boolean;
+        listenerCount<E extends keyof Http2StreamEventMap>(
+            eventName: E,
+            listener?: (...args: Http2StreamEventMap[E]) => void,
+        ): number;
+        listenerCount(eventName: string | symbol, listener?: (...args: any[]) => void): number;
+        listeners<E extends keyof Http2StreamEventMap>(eventName: E): ((...args: Http2StreamEventMap[E]) => void)[];
+        listeners(eventName: string | symbol): ((...args: any[]) => void)[];
+        off<E extends keyof Http2StreamEventMap>(
+            eventName: E,
+            listener: (...args: Http2StreamEventMap[E]) => void,
+        ): this;
+        off(eventName: string | symbol, listener: (...args: any[]) => void): this;
+        on<E extends keyof Http2StreamEventMap>(
+            eventName: E,
+            listener: (...args: Http2StreamEventMap[E]) => void,
+        ): this;
+        on(eventName: string | symbol, listener: (...args: any[]) => void): this;
+        once<E extends keyof Http2StreamEventMap>(
+            eventName: E,
+            listener: (...args: Http2StreamEventMap[E]) => void,
+        ): this;
+        once(eventName: string | symbol, listener: (...args: any[]) => void): this;
+        prependListener<E extends keyof Http2StreamEventMap>(
+            eventName: E,
+            listener: (...args: Http2StreamEventMap[E]) => void,
+        ): this;
+        prependListener(eventName: string | symbol, listener: (...args: any[]) => void): this;
+        prependOnceListener<E extends keyof Http2StreamEventMap>(
+            eventName: E,
+            listener: (...args: Http2StreamEventMap[E]) => void,
+        ): this;
+        prependOnceListener(eventName: string | symbol, listener: (...args: any[]) => void): this;
+        rawListeners<E extends keyof Http2StreamEventMap>(eventName: E): ((...args: Http2StreamEventMap[E]) => void)[];
+        rawListeners(eventName: string | symbol): ((...args: any[]) => void)[];
+        // eslint-disable-next-line @definitelytyped/no-unnecessary-generics
+        removeAllListeners<E extends keyof Http2StreamEventMap>(eventName?: E): this;
+        removeAllListeners(eventName?: string | symbol): this;
+        removeListener<E extends keyof Http2StreamEventMap>(
+            eventName: E,
+            listener: (...args: Http2StreamEventMap[E]) => void,
+        ): this;
+        removeListener(eventName: string | symbol, listener: (...args: any[]) => void): this;
+        // #endregion
     }
-    export interface ClientHttp2Stream extends Http2Stream {
-        addListener(event: "continue", listener: () => {}): this;
-        addListener(
-            event: "headers",
-            listener: (headers: IncomingHttpHeaders & IncomingHttpStatusHeader, flags: number) => void,
-        ): this;
-        addListener(event: "push", listener: (headers: IncomingHttpHeaders, flags: number) => void): this;
-        addListener(
-            event: "response",
-            listener: (headers: IncomingHttpHeaders & IncomingHttpStatusHeader, flags: number) => 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: "push", headers: IncomingHttpHeaders, flags: number): boolean;
-        emit(event: "response", headers: IncomingHttpHeaders & IncomingHttpStatusHeader, flags: number): boolean;
-        emit(event: string | symbol, ...args: any[]): boolean;
-        on(event: "continue", listener: () => {}): this;
-        on(
-            event: "headers",
-            listener: (headers: IncomingHttpHeaders & IncomingHttpStatusHeader, flags: number) => void,
-        ): this;
-        on(event: "push", listener: (headers: IncomingHttpHeaders, flags: number) => void): this;
-        on(
-            event: "response",
-            listener: (headers: IncomingHttpHeaders & IncomingHttpStatusHeader, flags: number) => 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,
-        ): this;
-        once(event: "push", listener: (headers: IncomingHttpHeaders, flags: number) => void): this;
-        once(
-            event: "response",
-            listener: (headers: IncomingHttpHeaders & IncomingHttpStatusHeader, flags: number) => 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,
-        ): this;
-        prependListener(event: "push", listener: (headers: IncomingHttpHeaders, flags: number) => void): this;
-        prependListener(
-            event: "response",
-            listener: (headers: IncomingHttpHeaders & IncomingHttpStatusHeader, flags: number) => 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,
-        ): this;
-        prependOnceListener(event: "push", listener: (headers: IncomingHttpHeaders, flags: number) => void): this;
-        prependOnceListener(
-            event: "response",
-            listener: (headers: IncomingHttpHeaders & IncomingHttpStatusHeader, flags: number) => void,
-        ): this;
-        prependOnceListener(event: string | symbol, listener: (...args: any[]) => void): this;
+    interface ClientHttp2StreamEventMap extends Http2StreamEventMap {
+        "continue": [];
+        "headers": [headers: IncomingHttpHeaders & IncomingHttpStatusHeader, flags: number, rawHeaders: string[]];
+        "push": [headers: IncomingHttpHeaders, flags: number];
+        "response": [headers: IncomingHttpHeaders & IncomingHttpStatusHeader, flags: number, rawHeaders: string[]];
+    }
+    interface ClientHttp2Stream extends Http2Stream {
+        // #region InternalEventEmitter
+        addListener<E extends keyof ClientHttp2StreamEventMap>(
+            eventName: E,
+            listener: (...args: ClientHttp2StreamEventMap[E]) => void,
+        ): this;
+        addListener(eventName: string | symbol, listener: (...args: any[]) => void): this;
+        emit<E extends keyof ClientHttp2StreamEventMap>(eventName: E, ...args: ClientHttp2StreamEventMap[E]): boolean;
+        emit(eventName: string | symbol, ...args: any[]): boolean;
+        listenerCount<E extends keyof ClientHttp2StreamEventMap>(
+            eventName: E,
+            listener?: (...args: ClientHttp2StreamEventMap[E]) => void,
+        ): number;
+        listenerCount(eventName: string | symbol, listener?: (...args: any[]) => void): number;
+        listeners<E extends keyof ClientHttp2StreamEventMap>(
+            eventName: E,
+        ): ((...args: ClientHttp2StreamEventMap[E]) => void)[];
+        listeners(eventName: string | symbol): ((...args: any[]) => void)[];
+        off<E extends keyof ClientHttp2StreamEventMap>(
+            eventName: E,
+            listener: (...args: ClientHttp2StreamEventMap[E]) => void,
+        ): this;
+        off(eventName: string | symbol, listener: (...args: any[]) => void): this;
+        on<E extends keyof ClientHttp2StreamEventMap>(
+            eventName: E,
+            listener: (...args: ClientHttp2StreamEventMap[E]) => void,
+        ): this;
+        on(eventName: string | symbol, listener: (...args: any[]) => void): this;
+        once<E extends keyof ClientHttp2StreamEventMap>(
+            eventName: E,
+            listener: (...args: ClientHttp2StreamEventMap[E]) => void,
+        ): this;
+        once(eventName: string | symbol, listener: (...args: any[]) => void): this;
+        prependListener<E extends keyof ClientHttp2StreamEventMap>(
+            eventName: E,
+            listener: (...args: ClientHttp2StreamEventMap[E]) => void,
+        ): this;
+        prependListener(eventName: string | symbol, listener: (...args: any[]) => void): this;
+        prependOnceListener<E extends keyof ClientHttp2StreamEventMap>(
+            eventName: E,
+            listener: (...args: ClientHttp2StreamEventMap[E]) => void,
+        ): this;
+        prependOnceListener(eventName: string | symbol, listener: (...args: any[]) => void): this;
+        rawListeners<E extends keyof ClientHttp2StreamEventMap>(
+            eventName: E,
+        ): ((...args: ClientHttp2StreamEventMap[E]) => void)[];
+        rawListeners(eventName: string | symbol): ((...args: any[]) => void)[];
+        // eslint-disable-next-line @definitelytyped/no-unnecessary-generics
+        removeAllListeners<E extends keyof ClientHttp2StreamEventMap>(eventName?: E): this;
+        removeAllListeners(eventName?: string | symbol): this;
+        removeListener<E extends keyof ClientHttp2StreamEventMap>(
+            eventName: E,
+            listener: (...args: ClientHttp2StreamEventMap[E]) => void,
+        ): this;
+        removeListener(eventName: string | symbol, listener: (...args: any[]) => void): this;
+        // #endregion
     }
-    export interface ServerHttp2Stream extends Http2Stream {
+    interface ServerHttp2Stream extends Http2Stream {
         /**
          * True if headers were sent, false otherwise (read-only).
          * @since v8.4.0
@@ -396,7 +379,7 @@ declare module "node:http2" {
         ): void;
         pushStream(
             headers: OutgoingHttpHeaders,
-            options?: StreamPriorityOptions,
+            options?: Pick<ClientSessionRequestOptions, "exclusive" | "parent">,
             callback?: (err: Error | null, pushStream: ServerHttp2Stream, headers: OutgoingHttpHeaders) => void,
         ): void;
         /**
@@ -429,7 +412,7 @@ declare module "node: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
@@ -617,7 +600,7 @@ declare module "node:http2" {
         ): void;
     }
     // Http2Session
-    export interface Settings {
+    interface Settings {
         headerTableSize?: number | undefined;
         enablePush?: boolean | undefined;
         initialWindowSize?: number | undefined;
@@ -626,15 +609,14 @@ declare module "node:http2" {
         maxHeaderListSize?: number | undefined;
         enableConnectProtocol?: boolean | undefined;
     }
-    export interface ClientSessionRequestOptions {
+    interface ClientSessionRequestOptions {
         endStream?: boolean | undefined;
         exclusive?: boolean | undefined;
         parent?: number | undefined;
-        weight?: number | undefined;
         waitForTrailers?: boolean | undefined;
         signal?: AbortSignal | undefined;
     }
-    export interface SessionState {
+    interface SessionState {
         effectiveLocalWindowSize?: number | undefined;
         effectiveRecvDataLength?: number | undefined;
         nextStreamID?: number | undefined;
@@ -645,7 +627,24 @@ declare module "node:http2" {
         deflateDynamicTableSize?: number | undefined;
         inflateDynamicTableSize?: number | undefined;
     }
-    export interface Http2Session extends EventEmitter {
+    interface Http2SessionEventMap {
+        "close": [];
+        "connect": [session: Http2Session, socket: net.Socket | tls.TLSSocket];
+        "error": [err: Error];
+        "frameError": [type: number, code: number, id: number];
+        "goaway": [errorCode: number, lastStreamID: number, opaqueData?: NonSharedBuffer];
+        "localSettings": [settings: Settings];
+        "ping": [payload: Buffer];
+        "remoteSettings": [settings: Settings];
+        "stream": [
+            stream: Http2Stream,
+            headers: IncomingHttpHeaders & IncomingHttpStatusHeader,
+            flags: number,
+            rawHeaders: string[],
+        ];
+        "timeout": [];
+    }
+    interface Http2Session extends InternalEventEmitter<Http2SessionEventMap> {
         /**
          * 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
@@ -790,10 +789,10 @@ declare module "node: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`.
@@ -847,80 +846,19 @@ declare module "node:http2" {
          * @since v9.4.0
          */
         unref(): void;
-        addListener(event: "close", listener: () => void): this;
-        addListener(event: "error", listener: (err: Error) => void): this;
-        addListener(
-            event: "frameError",
-            listener: (frameType: number, errorCode: number, streamID: number) => void,
-        ): this;
-        addListener(
-            event: "goaway",
-            listener: (errorCode: number, lastStreamID: number, opaqueData?: Buffer) => void,
-        ): this;
-        addListener(event: "localSettings", listener: (settings: Settings) => void): this;
-        addListener(event: "ping", listener: () => void): this;
-        addListener(event: "remoteSettings", listener: (settings: Settings) => void): this;
-        addListener(event: "timeout", listener: () => void): this;
-        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: "localSettings", settings: Settings): boolean;
-        emit(event: "ping"): boolean;
-        emit(event: "remoteSettings", settings: Settings): boolean;
-        emit(event: "timeout"): boolean;
-        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: "localSettings", listener: (settings: Settings) => void): this;
-        on(event: "ping", listener: () => void): this;
-        on(event: "remoteSettings", listener: (settings: Settings) => void): this;
-        on(event: "timeout", listener: () => void): this;
-        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: "localSettings", listener: (settings: Settings) => void): this;
-        once(event: "ping", listener: () => void): this;
-        once(event: "remoteSettings", listener: (settings: Settings) => void): this;
-        once(event: "timeout", listener: () => void): this;
-        once(event: string | symbol, listener: (...args: any[]) => void): this;
-        prependListener(event: "close", listener: () => void): this;
-        prependListener(event: "error", listener: (err: Error) => void): this;
-        prependListener(
-            event: "frameError",
-            listener: (frameType: number, errorCode: number, streamID: number) => void,
-        ): this;
-        prependListener(
-            event: "goaway",
-            listener: (errorCode: number, lastStreamID: number, opaqueData?: Buffer) => void,
-        ): this;
-        prependListener(event: "localSettings", listener: (settings: Settings) => void): this;
-        prependListener(event: "ping", listener: () => void): this;
-        prependListener(event: "remoteSettings", listener: (settings: Settings) => void): this;
-        prependListener(event: "timeout", listener: () => void): this;
-        prependListener(event: string | symbol, listener: (...args: any[]) => void): this;
-        prependOnceListener(event: "close", listener: () => void): this;
-        prependOnceListener(event: "error", listener: (err: Error) => void): this;
-        prependOnceListener(
-            event: "frameError",
-            listener: (frameType: number, errorCode: number, streamID: number) => void,
-        ): this;
-        prependOnceListener(
-            event: "goaway",
-            listener: (errorCode: number, lastStreamID: number, opaqueData?: Buffer) => void,
-        ): this;
-        prependOnceListener(event: "localSettings", listener: (settings: Settings) => void): this;
-        prependOnceListener(event: "ping", listener: () => void): this;
-        prependOnceListener(event: "remoteSettings", listener: (settings: Settings) => void): this;
-        prependOnceListener(event: "timeout", listener: () => void): this;
-        prependOnceListener(event: string | symbol, listener: (...args: any[]) => void): this;
     }
-    export interface ClientHttp2Session extends Http2Session {
+    interface ClientHttp2SessionEventMap extends Http2SessionEventMap {
+        "altsvc": [alt: string, origin: string, streamId: number];
+        "connect": [session: ClientHttp2Session, socket: net.Socket | tls.TLSSocket];
+        "origin": [origins: string[]];
+        "stream": [
+            stream: ClientHttp2Stream,
+            headers: IncomingHttpHeaders & IncomingHttpStatusHeader,
+            flags: number,
+            rawHeaders: string[],
+        ];
+    }
+    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
          * HTTP/2 request to the connected server.
@@ -970,93 +908,78 @@ declare module "node:http2" {
             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(
-            event: "connect",
-            listener: (session: ClientHttp2Session, socket: net.Socket | tls.TLSSocket) => void,
-        ): this;
-        addListener(
-            event: "stream",
-            listener: (
-                stream: ClientHttp2Stream,
-                headers: IncomingHttpHeaders & IncomingHttpStatusHeader,
-                flags: number,
-            ) => void,
-        ): this;
-        addListener(event: string | symbol, listener: (...args: any[]) => void): this;
-        emit(event: "altsvc", alt: string, origin: string, stream: number): boolean;
-        emit(event: "origin", origins: readonly string[]): boolean;
-        emit(event: "connect", session: ClientHttp2Session, socket: net.Socket | tls.TLSSocket): boolean;
-        emit(
-            event: "stream",
-            stream: ClientHttp2Stream,
-            headers: IncomingHttpHeaders & IncomingHttpStatusHeader,
-            flags: number,
-        ): boolean;
-        emit(event: string | symbol, ...args: any[]): boolean;
-        on(event: "altsvc", listener: (alt: string, origin: string, stream: number) => void): this;
-        on(event: "origin", listener: (origins: string[]) => void): this;
-        on(event: "connect", listener: (session: ClientHttp2Session, socket: net.Socket | tls.TLSSocket) => void): this;
-        on(
-            event: "stream",
-            listener: (
-                stream: ClientHttp2Stream,
-                headers: IncomingHttpHeaders & IncomingHttpStatusHeader,
-                flags: number,
-            ) => void,
-        ): this;
-        on(event: string | symbol, listener: (...args: any[]) => void): this;
-        once(event: "altsvc", listener: (alt: string, origin: string, stream: number) => void): this;
-        once(event: "origin", listener: (origins: string[]) => void): this;
-        once(
-            event: "connect",
-            listener: (session: ClientHttp2Session, socket: net.Socket | tls.TLSSocket) => void,
-        ): this;
-        once(
-            event: "stream",
-            listener: (
-                stream: ClientHttp2Stream,
-                headers: IncomingHttpHeaders & IncomingHttpStatusHeader,
-                flags: number,
-            ) => void,
-        ): this;
-        once(event: string | symbol, listener: (...args: any[]) => void): this;
-        prependListener(event: "altsvc", listener: (alt: string, origin: string, stream: number) => void): this;
-        prependListener(event: "origin", listener: (origins: string[]) => void): this;
-        prependListener(
-            event: "connect",
-            listener: (session: ClientHttp2Session, socket: net.Socket | tls.TLSSocket) => void,
-        ): this;
-        prependListener(
-            event: "stream",
-            listener: (
-                stream: ClientHttp2Stream,
-                headers: IncomingHttpHeaders & IncomingHttpStatusHeader,
-                flags: number,
-            ) => void,
-        ): this;
-        prependListener(event: string | symbol, listener: (...args: any[]) => void): this;
-        prependOnceListener(event: "altsvc", listener: (alt: string, origin: string, stream: number) => void): this;
-        prependOnceListener(event: "origin", listener: (origins: string[]) => void): this;
-        prependOnceListener(
-            event: "connect",
-            listener: (session: ClientHttp2Session, socket: net.Socket | tls.TLSSocket) => void,
-        ): this;
-        prependOnceListener(
-            event: "stream",
-            listener: (
-                stream: ClientHttp2Stream,
-                headers: IncomingHttpHeaders & IncomingHttpStatusHeader,
-                flags: number,
-            ) => void,
-        ): this;
-        prependOnceListener(event: string | symbol, listener: (...args: any[]) => void): this;
+        // #region InternalEventEmitter
+        addListener<E extends keyof ClientHttp2StreamEventMap>(
+            eventName: E,
+            listener: (...args: ClientHttp2StreamEventMap[E]) => void,
+        ): this;
+        addListener(eventName: string | symbol, listener: (...args: any[]) => void): this;
+        emit<E extends keyof ClientHttp2StreamEventMap>(eventName: E, ...args: ClientHttp2StreamEventMap[E]): boolean;
+        emit(eventName: string | symbol, ...args: any[]): boolean;
+        listenerCount<E extends keyof ClientHttp2StreamEventMap>(
+            eventName: E,
+            listener?: (...args: ClientHttp2StreamEventMap[E]) => void,
+        ): number;
+        listenerCount(eventName: string | symbol, listener?: (...args: any[]) => void): number;
+        listeners<E extends keyof ClientHttp2StreamEventMap>(
+            eventName: E,
+        ): ((...args: ClientHttp2StreamEventMap[E]) => void)[];
+        listeners(eventName: string | symbol): ((...args: any[]) => void)[];
+        off<E extends keyof ClientHttp2StreamEventMap>(
+            eventName: E,
+            listener: (...args: ClientHttp2StreamEventMap[E]) => void,
+        ): this;
+        off(eventName: string | symbol, listener: (...args: any[]) => void): this;
+        on<E extends keyof ClientHttp2StreamEventMap>(
+            eventName: E,
+            listener: (...args: ClientHttp2StreamEventMap[E]) => void,
+        ): this;
+        on(eventName: string | symbol, listener: (...args: any[]) => void): this;
+        once<E extends keyof ClientHttp2StreamEventMap>(
+            eventName: E,
+            listener: (...args: ClientHttp2StreamEventMap[E]) => void,
+        ): this;
+        once(eventName: string | symbol, listener: (...args: any[]) => void): this;
+        prependListener<E extends keyof ClientHttp2StreamEventMap>(
+            eventName: E,
+            listener: (...args: ClientHttp2StreamEventMap[E]) => void,
+        ): this;
+        prependListener(eventName: string | symbol, listener: (...args: any[]) => void): this;
+        prependOnceListener<E extends keyof ClientHttp2StreamEventMap>(
+            eventName: E,
+            listener: (...args: ClientHttp2StreamEventMap[E]) => void,
+        ): this;
+        prependOnceListener(eventName: string | symbol, listener: (...args: any[]) => void): this;
+        rawListeners<E extends keyof ClientHttp2StreamEventMap>(
+            eventName: E,
+        ): ((...args: ClientHttp2StreamEventMap[E]) => void)[];
+        rawListeners(eventName: string | symbol): ((...args: any[]) => void)[];
+        // eslint-disable-next-line @definitelytyped/no-unnecessary-generics
+        removeAllListeners<E extends keyof ClientHttp2StreamEventMap>(eventName?: E): this;
+        removeAllListeners(eventName?: string | symbol): this;
+        removeListener<E extends keyof ClientHttp2StreamEventMap>(
+            eventName: E,
+            listener: (...args: ClientHttp2StreamEventMap[E]) => void,
+        ): this;
+        removeListener(eventName: string | symbol, listener: (...args: any[]) => void): this;
+        // #endregion
     }
-    export interface AlternativeServiceOptions {
+    interface AlternativeServiceOptions {
         origin: number | string | url.URL;
     }
-    export interface ServerHttp2Session<
+    interface ServerHttp2SessionEventMap<
+        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 Http2SessionEventMap {
+        "connect": [
+            session: ServerHttp2Session<Http1Request, Http1Response, Http2Request, Http2Response>,
+            socket: net.Socket | tls.TLSSocket,
+        ];
+        "stream": [stream: ServerHttp2Stream, headers: IncomingHttpHeaders, flags: number, rawHeaders: string[]];
+    }
+    interface ServerHttp2Session<
         Http1Request extends typeof IncomingMessage = typeof IncomingMessage,
         Http1Response extends typeof ServerResponse<InstanceType<Http1Request>> = typeof ServerResponse,
         Http2Request extends typeof Http2ServerRequest = typeof Http2ServerRequest,
@@ -1157,76 +1080,87 @@ declare module "node:http2" {
                 }
             >
         ): void;
-        addListener(
-            event: "connect",
+        // #region InternalEventEmitter
+        addListener<E extends keyof ServerHttp2SessionEventMap>(
+            eventName: E,
             listener: (
-                session: ServerHttp2Session<Http1Request, Http1Response, Http2Request, Http2Response>,
-                socket: net.Socket | tls.TLSSocket,
+                ...args: ServerHttp2SessionEventMap<Http1Request, Http1Response, Http2Request, Http2Response>[E]
             ) => void,
         ): this;
-        addListener(
-            event: "stream",
-            listener: (stream: ServerHttp2Stream, headers: IncomingHttpHeaders, flags: number) => void,
-        ): this;
-        addListener(event: string | symbol, listener: (...args: any[]) => void): this;
-        emit(
-            event: "connect",
-            session: ServerHttp2Session<Http1Request, Http1Response, Http2Request, Http2Response>,
-            socket: net.Socket | tls.TLSSocket,
+        addListener(eventName: string | symbol, listener: (...args: any[]) => void): this;
+        emit<E extends keyof ServerHttp2SessionEventMap>(
+            eventName: E,
+            ...args: ServerHttp2SessionEventMap<Http1Request, Http1Response, Http2Request, Http2Response>[E]
         ): boolean;
-        emit(event: "stream", stream: ServerHttp2Stream, headers: IncomingHttpHeaders, flags: number): boolean;
-        emit(event: string | symbol, ...args: any[]): boolean;
-        on(
-            event: "connect",
+        emit(eventName: string | symbol, ...args: any[]): boolean;
+        listenerCount<E extends keyof ServerHttp2SessionEventMap>(
+            eventName: E,
+            listener?: (
+                ...args: ServerHttp2SessionEventMap<Http1Request, Http1Response, Http2Request, Http2Response>[E]
+            ) => void,
+        ): number;
+        listenerCount(eventName: string | symbol, listener?: (...args: any[]) => void): number;
+        listeners<E extends keyof ServerHttp2SessionEventMap>(
+            eventName: E,
+        ): ((
+            ...args: ServerHttp2SessionEventMap<Http1Request, Http1Response, Http2Request, Http2Response>[E]
+        ) => void)[];
+        listeners(eventName: string | symbol): ((...args: any[]) => void)[];
+        off<E extends keyof ServerHttp2SessionEventMap>(
+            eventName: E,
             listener: (
-                session: ServerHttp2Session<Http1Request, Http1Response, Http2Request, Http2Response>,
-                socket: net.Socket | tls.TLSSocket,
+                ...args: ServerHttp2SessionEventMap<Http1Request, Http1Response, Http2Request, Http2Response>[E]
             ) => void,
         ): this;
-        on(
-            event: "stream",
-            listener: (stream: ServerHttp2Stream, headers: IncomingHttpHeaders, flags: number) => void,
-        ): this;
-        on(event: string | symbol, listener: (...args: any[]) => void): this;
-        once(
-            event: "connect",
+        off(eventName: string | symbol, listener: (...args: any[]) => void): this;
+        on<E extends keyof ServerHttp2SessionEventMap>(
+            eventName: E,
             listener: (
-                session: ServerHttp2Session<Http1Request, Http1Response, Http2Request, Http2Response>,
-                socket: net.Socket | tls.TLSSocket,
+                ...args: ServerHttp2SessionEventMap<Http1Request, Http1Response, Http2Request, Http2Response>[E]
             ) => void,
         ): this;
-        once(
-            event: "stream",
-            listener: (stream: ServerHttp2Stream, headers: IncomingHttpHeaders, flags: number) => void,
-        ): this;
-        once(event: string | symbol, listener: (...args: any[]) => void): this;
-        prependListener(
-            event: "connect",
+        on(eventName: string | symbol, listener: (...args: any[]) => void): this;
+        once<E extends keyof ServerHttp2SessionEventMap>(
+            eventName: E,
             listener: (
-                session: ServerHttp2Session<Http1Request, Http1Response, Http2Request, Http2Response>,
-                socket: net.Socket | tls.TLSSocket,
+                ...args: ServerHttp2SessionEventMap<Http1Request, Http1Response, Http2Request, Http2Response>[E]
             ) => void,
         ): this;
-        prependListener(
-            event: "stream",
-            listener: (stream: ServerHttp2Stream, headers: IncomingHttpHeaders, flags: number) => void,
+        once(eventName: string | symbol, listener: (...args: any[]) => void): this;
+        prependListener<E extends keyof ServerHttp2SessionEventMap>(
+            eventName: E,
+            listener: (
+                ...args: ServerHttp2SessionEventMap<Http1Request, Http1Response, Http2Request, Http2Response>[E]
+            ) => void,
         ): this;
-        prependListener(event: string | symbol, listener: (...args: any[]) => void): this;
-        prependOnceListener(
-            event: "connect",
+        prependListener(eventName: string | symbol, listener: (...args: any[]) => void): this;
+        prependOnceListener<E extends keyof ServerHttp2SessionEventMap>(
+            eventName: E,
             listener: (
-                session: ServerHttp2Session<Http1Request, Http1Response, Http2Request, Http2Response>,
-                socket: net.Socket | tls.TLSSocket,
+                ...args: ServerHttp2SessionEventMap<Http1Request, Http1Response, Http2Request, Http2Response>[E]
             ) => void,
         ): this;
-        prependOnceListener(
-            event: "stream",
-            listener: (stream: ServerHttp2Stream, headers: IncomingHttpHeaders, flags: number) => void,
+        prependOnceListener(eventName: string | symbol, listener: (...args: any[]) => void): this;
+        rawListeners<E extends keyof ServerHttp2SessionEventMap>(
+            eventName: E,
+        ): ((
+            ...args: ServerHttp2SessionEventMap<Http1Request, Http1Response, Http2Request, Http2Response>[E]
+        ) => void)[];
+        rawListeners(eventName: string | symbol): ((...args: any[]) => void)[];
+        // eslint-disable-next-line @definitelytyped/no-unnecessary-generics
+        removeAllListeners<E extends keyof ServerHttp2SessionEventMap>(eventName?: E): this;
+        removeAllListeners(eventName?: string | symbol): this;
+        removeListener<E extends keyof ServerHttp2SessionEventMap>(
+            eventName: E,
+            listener: (
+                ...args: ServerHttp2SessionEventMap<Http1Request, Http1Response, Http2Request, Http2Response>[E]
+            ) => void,
         ): this;
-        prependOnceListener(event: string | symbol, listener: (...args: any[]) => void): this;
+        removeListener(eventName: string | symbol, listener: (...args: any[]) => void): this;
+        // #endregion
     }
     // Http2Server
-    export interface SessionOptions {
+    interface SessionOptions {
         /**
          * Sets the maximum dynamic table size for deflating header fields.
          * @default 4Kib
@@ -1295,8 +1229,16 @@ declare module "node:http2" {
          * @default 100000
          */
         unknownProtocolTimeout?: number | undefined;
+        /**
+         * 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 {
+    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,
@@ -1318,7 +1260,7 @@ declare module "node:http2" {
          */
         protocol?: "http:" | "https:" | undefined;
     }
-    export interface ServerSessionOptions<
+    interface ServerSessionOptions<
         Http1Request extends typeof IncomingMessage = typeof IncomingMessage,
         Http1Response extends typeof ServerResponse<InstanceType<Http1Request>> = typeof ServerResponse,
         Http2Request extends typeof Http2ServerRequest = typeof Http2ServerRequest,
@@ -1331,20 +1273,20 @@ declare module "node:http2" {
         Http2ServerRequest?: Http2Request | undefined;
         Http2ServerResponse?: Http2Response | undefined;
     }
-    export interface SecureClientSessionOptions extends ClientSessionOptions, tls.ConnectionOptions {}
-    export interface SecureServerSessionOptions<
+    interface SecureClientSessionOptions extends ClientSessionOptions, tls.ConnectionOptions {}
+    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<
+    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<
+    interface SecureServerOptions<
         Http1Request extends typeof IncomingMessage = typeof IncomingMessage,
         Http1Response extends typeof ServerResponse<InstanceType<Http1Request>> = typeof ServerResponse,
         Http2Request extends typeof Http2ServerRequest = typeof Http2ServerRequest,
@@ -1353,7 +1295,7 @@ declare module "node:http2" {
         allowHTTP1?: boolean | undefined;
         origins?: string[] | undefined;
     }
-    interface HTTP2ServerCommon {
+    interface Http2ServerCommon {
         setTimeout(msec?: number, callback?: () => void): this;
         /**
          * Throws ERR_HTTP2_INVALID_SETTING_VALUE for invalid settings values.
@@ -1361,243 +1303,194 @@ declare module "node:http2" {
          */
         updateSettings(settings: Settings): void;
     }
-    export interface Http2Server<
+    interface Http2ServerEventMap<
         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: InstanceType<Http2Request>, response: InstanceType<Http2Response>) => void,
-        ): this;
-        addListener(
-            event: "request",
-            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): this;
-        addListener(
-            event: "stream",
-            listener: (stream: ServerHttp2Stream, headers: IncomingHttpHeaders, flags: number) => void,
+    > extends net.ServerEventMap, Pick<Http2SessionEventMap, "stream" | "timeout"> {
+        "checkContinue": [request: InstanceType<Http2Request>, response: InstanceType<Http2Response>];
+        "request": [request: InstanceType<Http2Request>, response: InstanceType<Http2Response>];
+        "session": [session: ServerHttp2Session<Http1Request, Http1Response, Http2Request, Http2Response>];
+        "sessionError": [err: Error];
+    }
+    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 {
+        // #region InternalEventEmitter
+        addListener<E extends keyof Http2ServerEventMap>(
+            eventName: E,
+            listener: (
+                ...args: Http2ServerEventMap<Http1Request, Http1Response, Http2Request, Http2Response>[E]
+            ) => void,
         ): this;
-        addListener(event: "timeout", listener: () => void): this;
-        addListener(event: string | symbol, listener: (...args: any[]) => void): this;
-        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>,
+        addListener(eventName: string | symbol, listener: (...args: any[]) => void): this;
+        emit<E extends keyof Http2ServerEventMap>(
+            eventName: E,
+            ...args: Http2ServerEventMap<Http1Request, Http1Response, Http2Request, Http2Response>[E]
         ): boolean;
-        emit(event: "sessionError", err: Error): boolean;
-        emit(event: "stream", stream: ServerHttp2Stream, headers: IncomingHttpHeaders, flags: number): boolean;
-        emit(event: "timeout"): boolean;
-        emit(event: string | symbol, ...args: any[]): boolean;
-        on(
-            event: "checkContinue",
-            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) => void): this;
-        on(
-            event: "stream",
-            listener: (stream: ServerHttp2Stream, headers: IncomingHttpHeaders, flags: number) => void,
-        ): this;
-        on(event: "timeout", listener: () => void): this;
-        on(event: string | symbol, listener: (...args: any[]) => void): this;
-        once(
-            event: "checkContinue",
-            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) => void): this;
-        once(
-            event: "stream",
-            listener: (stream: ServerHttp2Stream, headers: IncomingHttpHeaders, flags: number) => void,
-        ): this;
-        once(event: "timeout", listener: () => void): this;
-        once(event: string | symbol, listener: (...args: any[]) => void): this;
-        prependListener(
-            event: "checkContinue",
-            listener: (request: InstanceType<Http2Request>, response: InstanceType<Http2Response>) => void,
-        ): this;
-        prependListener(
-            event: "request",
-            listener: (request: InstanceType<Http2Request>, response: InstanceType<Http2Response>) => void,
-        ): this;
-        prependListener(
-            event: "session",
-            listener: (session: ServerHttp2Session<Http1Request, Http1Response, Http2Request, Http2Response>) => void,
+        emit(eventName: string | symbol, ...args: any[]): boolean;
+        listenerCount<E extends keyof Http2ServerEventMap>(
+            eventName: E,
+            listener?: (
+                ...args: Http2ServerEventMap<Http1Request, Http1Response, Http2Request, Http2Response>[E]
+            ) => void,
+        ): number;
+        listenerCount(eventName: string | symbol, listener?: (...args: any[]) => void): number;
+        listeners<E extends keyof Http2ServerEventMap>(
+            eventName: E,
+        ): ((...args: Http2ServerEventMap<Http1Request, Http1Response, Http2Request, Http2Response>[E]) => void)[];
+        listeners(eventName: string | symbol): ((...args: any[]) => void)[];
+        off<E extends keyof Http2ServerEventMap>(
+            eventName: E,
+            listener: (
+                ...args: Http2ServerEventMap<Http1Request, Http1Response, Http2Request, Http2Response>[E]
+            ) => void,
         ): this;
-        prependListener(event: "sessionError", listener: (err: Error) => void): this;
-        prependListener(
-            event: "stream",
-            listener: (stream: ServerHttp2Stream, headers: IncomingHttpHeaders, flags: number) => void,
+        off(eventName: string | symbol, listener: (...args: any[]) => void): this;
+        on<E extends keyof Http2ServerEventMap>(
+            eventName: E,
+            listener: (
+                ...args: Http2ServerEventMap<Http1Request, Http1Response, Http2Request, Http2Response>[E]
+            ) => void,
         ): this;
-        prependListener(event: "timeout", listener: () => void): this;
-        prependListener(event: string | symbol, listener: (...args: any[]) => void): this;
-        prependOnceListener(
-            event: "checkContinue",
-            listener: (request: InstanceType<Http2Request>, response: InstanceType<Http2Response>) => void,
+        on(eventName: string | symbol, listener: (...args: any[]) => void): this;
+        once<E extends keyof Http2ServerEventMap>(
+            eventName: E,
+            listener: (
+                ...args: Http2ServerEventMap<Http1Request, Http1Response, Http2Request, Http2Response>[E]
+            ) => void,
         ): this;
-        prependOnceListener(
-            event: "request",
-            listener: (request: InstanceType<Http2Request>, response: InstanceType<Http2Response>) => void,
+        once(eventName: string | symbol, listener: (...args: any[]) => void): this;
+        prependListener<E extends keyof Http2ServerEventMap>(
+            eventName: E,
+            listener: (
+                ...args: Http2ServerEventMap<Http1Request, Http1Response, Http2Request, Http2Response>[E]
+            ) => void,
         ): this;
-        prependOnceListener(
-            event: "session",
-            listener: (session: ServerHttp2Session<Http1Request, Http1Response, Http2Request, Http2Response>) => void,
+        prependListener(eventName: string | symbol, listener: (...args: any[]) => void): this;
+        prependOnceListener<E extends keyof Http2ServerEventMap>(
+            eventName: E,
+            listener: (
+                ...args: Http2ServerEventMap<Http1Request, Http1Response, Http2Request, Http2Response>[E]
+            ) => void,
         ): this;
-        prependOnceListener(event: "sessionError", listener: (err: Error) => void): this;
-        prependOnceListener(
-            event: "stream",
-            listener: (stream: ServerHttp2Stream, headers: IncomingHttpHeaders, flags: number) => void,
+        prependOnceListener(eventName: string | symbol, listener: (...args: any[]) => void): this;
+        rawListeners<E extends keyof Http2ServerEventMap>(
+            eventName: E,
+        ): ((...args: Http2ServerEventMap<Http1Request, Http1Response, Http2Request, Http2Response>[E]) => void)[];
+        rawListeners(eventName: string | symbol): ((...args: any[]) => void)[];
+        // eslint-disable-next-line @definitelytyped/no-unnecessary-generics
+        removeAllListeners<E extends keyof Http2ServerEventMap>(eventName?: E): this;
+        removeAllListeners(eventName?: string | symbol): this;
+        removeListener<E extends keyof Http2ServerEventMap>(
+            eventName: E,
+            listener: (
+                ...args: Http2ServerEventMap<Http1Request, Http1Response, Http2Request, Http2Response>[E]
+            ) => void,
         ): this;
-        prependOnceListener(event: "timeout", listener: () => void): this;
-        prependOnceListener(event: string | symbol, listener: (...args: any[]) => void): this;
+        removeListener(eventName: string | symbol, listener: (...args: any[]) => void): this;
+        // #endregion
     }
-    export interface Http2SecureServer<
+    interface Http2SecureServerEventMap<
         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: InstanceType<Http2Request>, response: InstanceType<Http2Response>) => void,
-        ): this;
-        addListener(
-            event: "request",
-            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): this;
-        addListener(
-            event: "stream",
-            listener: (stream: ServerHttp2Stream, headers: IncomingHttpHeaders, flags: number) => void,
+    > extends tls.ServerEventMap, Http2ServerEventMap<Http1Request, Http1Response, Http2Request, Http2Response> {
+        "unknownProtocol": [socket: tls.TLSSocket];
+    }
+    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 {
+        // #region InternalEventEmitter
+        addListener<E extends keyof Http2SecureServerEventMap>(
+            eventName: E,
+            listener: (
+                ...args: Http2SecureServerEventMap<Http1Request, Http1Response, Http2Request, Http2Response>[E]
+            ) => void,
         ): this;
-        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: 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>,
+        addListener(eventName: string | symbol, listener: (...args: any[]) => void): this;
+        emit<E extends keyof Http2SecureServerEventMap>(
+            eventName: E,
+            ...args: Http2SecureServerEventMap<Http1Request, Http1Response, Http2Request, Http2Response>[E]
         ): boolean;
-        emit(event: "sessionError", err: Error): 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: 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) => void): this;
-        on(
-            event: "stream",
-            listener: (stream: ServerHttp2Stream, headers: IncomingHttpHeaders, flags: number) => void,
-        ): this;
-        on(event: "timeout", listener: () => void): this;
-        on(event: "unknownProtocol", listener: (socket: tls.TLSSocket) => void): this;
-        on(event: string | symbol, listener: (...args: any[]) => void): this;
-        once(
-            event: "checkContinue",
-            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) => void): this;
-        once(
-            event: "stream",
-            listener: (stream: ServerHttp2Stream, headers: IncomingHttpHeaders, flags: number) => void,
-        ): this;
-        once(event: "timeout", listener: () => void): this;
-        once(event: "unknownProtocol", listener: (socket: tls.TLSSocket) => void): this;
-        once(event: string | symbol, listener: (...args: any[]) => void): this;
-        prependListener(
-            event: "checkContinue",
-            listener: (request: InstanceType<Http2Request>, response: InstanceType<Http2Response>) => void,
-        ): this;
-        prependListener(
-            event: "request",
-            listener: (request: InstanceType<Http2Request>, response: InstanceType<Http2Response>) => void,
-        ): this;
-        prependListener(
-            event: "session",
-            listener: (session: ServerHttp2Session<Http1Request, Http1Response, Http2Request, Http2Response>) => void,
+        emit(eventName: string | symbol, ...args: any[]): boolean;
+        listenerCount<E extends keyof Http2SecureServerEventMap>(
+            eventName: E,
+            listener?: (
+                ...args: Http2SecureServerEventMap<Http1Request, Http1Response, Http2Request, Http2Response>[E]
+            ) => void,
+        ): number;
+        listenerCount(eventName: string | symbol, listener?: (...args: any[]) => void): number;
+        listeners<E extends keyof Http2SecureServerEventMap>(
+            eventName: E,
+        ): ((
+            ...args: Http2SecureServerEventMap<Http1Request, Http1Response, Http2Request, Http2Response>[E]
+        ) => void)[];
+        listeners(eventName: string | symbol): ((...args: any[]) => void)[];
+        off<E extends keyof Http2SecureServerEventMap>(
+            eventName: E,
+            listener: (
+                ...args: Http2SecureServerEventMap<Http1Request, Http1Response, Http2Request, Http2Response>[E]
+            ) => void,
         ): this;
-        prependListener(event: "sessionError", listener: (err: Error) => void): this;
-        prependListener(
-            event: "stream",
-            listener: (stream: ServerHttp2Stream, headers: IncomingHttpHeaders, flags: number) => void,
+        off(eventName: string | symbol, listener: (...args: any[]) => void): this;
+        on<E extends keyof Http2SecureServerEventMap>(
+            eventName: E,
+            listener: (
+                ...args: Http2SecureServerEventMap<Http1Request, Http1Response, Http2Request, Http2Response>[E]
+            ) => void,
         ): this;
-        prependListener(event: "timeout", listener: () => void): this;
-        prependListener(event: "unknownProtocol", listener: (socket: tls.TLSSocket) => void): this;
-        prependListener(event: string | symbol, listener: (...args: any[]) => void): this;
-        prependOnceListener(
-            event: "checkContinue",
-            listener: (request: InstanceType<Http2Request>, response: InstanceType<Http2Response>) => void,
+        on(eventName: string | symbol, listener: (...args: any[]) => void): this;
+        once<E extends keyof Http2SecureServerEventMap>(
+            eventName: E,
+            listener: (
+                ...args: Http2SecureServerEventMap<Http1Request, Http1Response, Http2Request, Http2Response>[E]
+            ) => void,
         ): this;
-        prependOnceListener(
-            event: "request",
-            listener: (request: InstanceType<Http2Request>, response: InstanceType<Http2Response>) => void,
+        once(eventName: string | symbol, listener: (...args: any[]) => void): this;
+        prependListener<E extends keyof Http2SecureServerEventMap>(
+            eventName: E,
+            listener: (
+                ...args: Http2SecureServerEventMap<Http1Request, Http1Response, Http2Request, Http2Response>[E]
+            ) => void,
         ): this;
-        prependOnceListener(
-            event: "session",
-            listener: (session: ServerHttp2Session<Http1Request, Http1Response, Http2Request, Http2Response>) => void,
+        prependListener(eventName: string | symbol, listener: (...args: any[]) => void): this;
+        prependOnceListener<E extends keyof Http2SecureServerEventMap>(
+            eventName: E,
+            listener: (
+                ...args: Http2SecureServerEventMap<Http1Request, Http1Response, Http2Request, Http2Response>[E]
+            ) => void,
         ): this;
-        prependOnceListener(event: "sessionError", listener: (err: Error) => void): this;
-        prependOnceListener(
-            event: "stream",
-            listener: (stream: ServerHttp2Stream, headers: IncomingHttpHeaders, flags: number) => void,
+        prependOnceListener(eventName: string | symbol, listener: (...args: any[]) => void): this;
+        rawListeners<E extends keyof Http2SecureServerEventMap>(
+            eventName: E,
+        ): ((
+            ...args: Http2SecureServerEventMap<Http1Request, Http1Response, Http2Request, Http2Response>[E]
+        ) => void)[];
+        rawListeners(eventName: string | symbol): ((...args: any[]) => void)[];
+        // eslint-disable-next-line @definitelytyped/no-unnecessary-generics
+        removeAllListeners<E extends keyof Http2SecureServerEventMap>(eventName?: E): this;
+        removeAllListeners(eventName?: string | symbol): this;
+        removeListener<E extends keyof Http2SecureServerEventMap>(
+            eventName: E,
+            listener: (
+                ...args: Http2SecureServerEventMap<Http1Request, Http1Response, Http2Request, Http2Response>[E]
+            ) => void,
         ): this;
-        prependOnceListener(event: "timeout", listener: () => void): this;
-        prependOnceListener(event: "unknownProtocol", listener: (socket: tls.TLSSocket) => void): this;
-        prependOnceListener(event: string | symbol, listener: (...args: any[]) => void): this;
+        removeListener(eventName: string | symbol, listener: (...args: any[]) => void): this;
+        // #endregion
+    }
+    interface Http2ServerRequestEventMap extends stream.ReadableEventMap {
+        "aborted": [hadError: boolean, code: number];
+        "data": [chunk: string | NonSharedBuffer];
     }
     /**
      * A `Http2ServerRequest` object is created by {@link Server} or {@link SecureServer} and passed as the first argument to the `'request'` event. It may be used to access a request status,
@@ -1605,7 +1498,7 @@ declare module "node:http2" {
      * data.
      * @since v8.4.0
      */
-    export class Http2ServerRequest extends stream.Readable {
+    class Http2ServerRequest extends stream.Readable {
         constructor(
             stream: ServerHttp2Stream,
             headers: IncomingHttpHeaders,
@@ -1797,55 +1690,68 @@ declare module "node:http2" {
          */
         setTimeout(msecs: number, callback?: () => void): void;
         read(size?: number): Buffer | 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: "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: "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: "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: "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: "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: "end", listener: () => void): this;
-        prependOnceListener(event: "readable", listener: () => void): this;
-        prependOnceListener(event: "error", listener: (err: Error) => void): this;
-        prependOnceListener(event: string | symbol, listener: (...args: any[]) => void): this;
+        // #region InternalEventEmitter
+        addListener<E extends keyof Http2ServerRequestEventMap>(
+            eventName: E,
+            listener: (...args: Http2ServerRequestEventMap[E]) => void,
+        ): this;
+        addListener(eventName: string | symbol, listener: (...args: any[]) => void): this;
+        emit<E extends keyof Http2ServerRequestEventMap>(eventName: E, ...args: Http2ServerRequestEventMap[E]): boolean;
+        emit(eventName: string | symbol, ...args: any[]): boolean;
+        listenerCount<E extends keyof Http2ServerRequestEventMap>(
+            eventName: E,
+            listener?: (...args: Http2ServerRequestEventMap[E]) => void,
+        ): number;
+        listenerCount(eventName: string | symbol, listener?: (...args: any[]) => void): number;
+        listeners<E extends keyof Http2ServerRequestEventMap>(
+            eventName: E,
+        ): ((...args: Http2ServerRequestEventMap[E]) => void)[];
+        listeners(eventName: string | symbol): ((...args: any[]) => void)[];
+        off<E extends keyof Http2ServerRequestEventMap>(
+            eventName: E,
+            listener: (...args: Http2ServerRequestEventMap[E]) => void,
+        ): this;
+        off(eventName: string | symbol, listener: (...args: any[]) => void): this;
+        on<E extends keyof Http2ServerRequestEventMap>(
+            eventName: E,
+            listener: (...args: Http2ServerRequestEventMap[E]) => void,
+        ): this;
+        on(eventName: string | symbol, listener: (...args: any[]) => void): this;
+        once<E extends keyof Http2ServerRequestEventMap>(
+            eventName: E,
+            listener: (...args: Http2ServerRequestEventMap[E]) => void,
+        ): this;
+        once(eventName: string | symbol, listener: (...args: any[]) => void): this;
+        prependListener<E extends keyof Http2ServerRequestEventMap>(
+            eventName: E,
+            listener: (...args: Http2ServerRequestEventMap[E]) => void,
+        ): this;
+        prependListener(eventName: string | symbol, listener: (...args: any[]) => void): this;
+        prependOnceListener<E extends keyof Http2ServerRequestEventMap>(
+            eventName: E,
+            listener: (...args: Http2ServerRequestEventMap[E]) => void,
+        ): this;
+        prependOnceListener(eventName: string | symbol, listener: (...args: any[]) => void): this;
+        rawListeners<E extends keyof Http2ServerRequestEventMap>(
+            eventName: E,
+        ): ((...args: Http2ServerRequestEventMap[E]) => void)[];
+        rawListeners(eventName: string | symbol): ((...args: any[]) => void)[];
+        // eslint-disable-next-line @definitelytyped/no-unnecessary-generics
+        removeAllListeners<E extends keyof Http2ServerRequestEventMap>(eventName?: E): this;
+        removeAllListeners(eventName?: string | symbol): this;
+        removeListener<E extends keyof Http2ServerRequestEventMap>(
+            eventName: E,
+            listener: (...args: Http2ServerRequestEventMap[E]) => void,
+        ): this;
+        removeListener(eventName: string | symbol, listener: (...args: any[]) => void): this;
+        // #endregion
     }
     /**
      * This object is created internally by an HTTP server, not by the user. It is
      * passed as the second parameter to the `'request'` event.
      * @since v8.4.0
      */
-    export class Http2ServerResponse<Request extends Http2ServerRequest = Http2ServerRequest> extends stream.Writable {
+    class Http2ServerResponse<Request extends Http2ServerRequest = Http2ServerRequest> extends stream.Writable {
         constructor(stream: ServerHttp2Stream);
         /**
          * See `response.socket`.
@@ -1861,7 +1767,7 @@ declare module "node:http2" {
          * 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.
+         * [TypeError](https://nodejs.org/docs/latest-v25.x/api/errors.html#class-typeerror) being thrown.
          *
          * ```js
          * // Returns headers including "set-cookie: a" and "set-cookie: b"
@@ -2193,8 +2099,8 @@ declare module "node: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
@@ -2209,50 +2115,8 @@ declare module "node:http2" {
             headers: OutgoingHttpHeaders,
             callback: (err: Error | null, res: Http2ServerResponse) => void,
         ): void;
-        addListener(event: "close", listener: () => void): this;
-        addListener(event: "drain", listener: () => void): this;
-        addListener(event: "error", listener: (error: Error) => void): this;
-        addListener(event: "finish", listener: () => void): this;
-        addListener(event: "pipe", listener: (src: stream.Readable) => void): this;
-        addListener(event: "unpipe", listener: (src: stream.Readable) => void): this;
-        addListener(event: string | symbol, listener: (...args: any[]) => void): this;
-        emit(event: "close"): boolean;
-        emit(event: "drain"): boolean;
-        emit(event: "error", error: Error): boolean;
-        emit(event: "finish"): boolean;
-        emit(event: "pipe", src: stream.Readable): boolean;
-        emit(event: "unpipe", src: stream.Readable): boolean;
-        emit(event: string | symbol, ...args: any[]): boolean;
-        on(event: "close", listener: () => void): this;
-        on(event: "drain", listener: () => void): this;
-        on(event: "error", listener: (error: Error) => void): this;
-        on(event: "finish", listener: () => void): this;
-        on(event: "pipe", listener: (src: stream.Readable) => void): this;
-        on(event: "unpipe", listener: (src: stream.Readable) => void): this;
-        on(event: string | symbol, listener: (...args: any[]) => void): this;
-        once(event: "close", listener: () => void): this;
-        once(event: "drain", listener: () => void): this;
-        once(event: "error", listener: (error: Error) => void): this;
-        once(event: "finish", listener: () => void): this;
-        once(event: "pipe", listener: (src: stream.Readable) => void): this;
-        once(event: "unpipe", listener: (src: stream.Readable) => void): this;
-        once(event: string | symbol, listener: (...args: any[]) => void): this;
-        prependListener(event: "close", listener: () => void): this;
-        prependListener(event: "drain", listener: () => void): this;
-        prependListener(event: "error", listener: (error: Error) => void): this;
-        prependListener(event: "finish", listener: () => void): this;
-        prependListener(event: "pipe", listener: (src: stream.Readable) => void): this;
-        prependListener(event: "unpipe", listener: (src: stream.Readable) => void): this;
-        prependListener(event: string | symbol, listener: (...args: any[]) => void): this;
-        prependOnceListener(event: "close", listener: () => void): this;
-        prependOnceListener(event: "drain", listener: () => void): this;
-        prependOnceListener(event: "error", listener: (error: Error) => void): this;
-        prependOnceListener(event: "finish", listener: () => void): this;
-        prependOnceListener(event: "pipe", listener: (src: stream.Readable) => void): this;
-        prependOnceListener(event: "unpipe", listener: (src: stream.Readable) => void): this;
-        prependOnceListener(event: string | symbol, listener: (...args: any[]) => void): this;
     }
-    export namespace constants {
+    namespace constants {
         const NGHTTP2_SESSION_SERVER: number;
         const NGHTTP2_SESSION_CLIENT: number;
         const NGHTTP2_STREAM_STATE_IDLE: number;
@@ -2472,13 +2336,13 @@ declare module "node:http2" {
      * This symbol can be set as a property on the HTTP/2 headers object with
      * an array value in order to provide a list of headers considered sensitive.
      */
-    export const sensitiveHeaders: symbol;
+    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
      * so instances returned may be safely modified for use.
      * @since v8.4.0
      */
-    export function getDefaultSettings(): Settings;
+    function getDefaultSettings(): Settings;
     /**
      * Returns a `Buffer` instance containing serialized representation of the given
      * HTTP/2 settings as specified in the [HTTP/2](https://tools.ietf.org/html/rfc7540) specification. This is intended
@@ -2494,14 +2358,14 @@ declare module "node:http2" {
      * ```
      * @since v8.4.0
      */
-    export function getPackedSettings(settings: Settings): Buffer;
+    function getPackedSettings(settings: Settings): NonSharedBuffer;
     /**
      * Returns a `HTTP/2 Settings Object` containing the deserialized settings from
      * the given `Buffer` as generated by `http2.getPackedSettings()`.
      * @since v8.4.0
      * @param buf The packed settings.
      */
-    export function getUnpackedSettings(buf: Uint8Array): Settings;
+    function getUnpackedSettings(buf: Uint8Array): Settings;
     /**
      * Returns a `net.Server` instance that creates and manages `Http2Session` instances.
      *
@@ -2531,10 +2395,10 @@ declare module "node:http2" {
      * @since v8.4.0
      * @param onRequestHandler See `Compatibility API`
      */
-    export function createServer(
+    function createServer(
         onRequestHandler?: (request: Http2ServerRequest, response: Http2ServerResponse) => void,
     ): Http2Server;
-    export function createServer<
+    function createServer<
         Http1Request extends typeof IncomingMessage = typeof IncomingMessage,
         Http1Response extends typeof ServerResponse<InstanceType<Http1Request>> = typeof ServerResponse,
         Http2Request extends typeof Http2ServerRequest = typeof Http2ServerRequest,
@@ -2571,10 +2435,10 @@ declare module "node:http2" {
      * @since v8.4.0
      * @param onRequestHandler See `Compatibility API`
      */
-    export function createSecureServer(
+    function createSecureServer(
         onRequestHandler?: (request: Http2ServerRequest, response: Http2ServerResponse) => void,
     ): Http2SecureServer;
-    export function createSecureServer<
+    function createSecureServer<
         Http1Request extends typeof IncomingMessage = typeof IncomingMessage,
         Http1Response extends typeof ServerResponse<InstanceType<Http1Request>> = typeof ServerResponse,
         Http2Request extends typeof Http2ServerRequest = typeof Http2ServerRequest,
@@ -2599,11 +2463,11 @@ declare module "node:http2" {
      * is used). Userinfo (user ID and password), path, querystring, and fragment details in the URL will be ignored.
      * @param listener Will be registered as a one-time listener of the {@link 'connect'} event.
      */
-    export function connect(
+    function connect(
         authority: string | url.URL,
         listener: (session: ClientHttp2Session, socket: net.Socket | tls.TLSSocket) => void,
     ): ClientHttp2Session;
-    export function connect(
+    function connect(
         authority: string | url.URL,
         options?: ClientSessionOptions | SecureClientSessionOptions,
         listener?: (session: ClientHttp2Session, socket: net.Socket | tls.TLSSocket) => void,
@@ -2614,7 +2478,7 @@ declare module "node:http2" {
      * @param options Any `{@link createServer}` options can be provided.
      * @since v20.12.0
      */
-    export function performServerHandshake<
+    function performServerHandshake<
         Http1Request extends typeof IncomingMessage = typeof IncomingMessage,
         Http1Response extends typeof ServerResponse<InstanceType<Http1Request>> = typeof ServerResponse,
         Http2Request extends typeof Http2ServerRequest = typeof Http2ServerRequest,
@@ -2624,3 +2488,6 @@ declare module "node:http2" {
         options?: ServerOptions<Http1Request, Http1Response, Http2Request, Http2Response>,
     ): ServerHttp2Session<Http1Request, Http1Response, Http2Request, Http2Response>;
 }
+declare module "node:http2" {
+    export { OutgoingHttpHeaders } from "node:http";
+}