@code-yeongyu/senpi 2026.6.3 → 2026.6.6-3

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

@@ -1,51 +1,10 @@
-/**
- * To use the HTTP server and client one must import the `node:http` module.
- *
- * The HTTP interfaces in Node.js are designed to support many features
- * of the protocol which have been traditionally difficult to use.
- * In particular, large, possibly chunk-encoded, messages. The interface is
- * careful to never buffer entire requests or responses, so the
- * user is able to stream data.
- *
- * HTTP message headers are represented by an object like this:
- *
- * ```json
- * { "content-length": "123",
- *   "content-type": "text/plain",
- *   "connection": "keep-alive",
- *   "host": "example.com",
- *   "accept": "*" }
- * ```
- *
- * Keys are lowercased. Values are not modified.
- *
- * In order to support the full spectrum of possible HTTP applications, the Node.js
- * HTTP API is very low-level. It deals with stream handling and message
- * parsing only. It parses a message into headers and body but it does not
- * parse the actual headers or the body.
- *
- * See `message.headers` for details on how duplicate headers are handled.
- *
- * The raw headers as they were received are retained in the `rawHeaders` property, which is an array of `[key, value, key2, value2, ...]`. For
- * example, the previous message header object might have a `rawHeaders` list like the following:
- *
- * ```js
- * [ 'ConTent-Length', '123456',
- *   'content-LENGTH', '123',
- *   'content-type', 'text/plain',
- *   'CONNECTION', 'keep-alive',
- *   'Host', 'example.com',
- *   'accepT', '*' ]
- * ```
- * @see [source](https://github.com/nodejs/node/blob/v22.x/lib/http.js)
- */
-declare module "http" {
+declare module "node:http" {
     import { NonSharedBuffer } from "node:buffer";
-    import * as stream from "node:stream";
-    import { URL } from "node:url";
     import { LookupOptions } from "node:dns";
     import { EventEmitter } from "node:events";
-    import { LookupFunction, Server as NetServer, Socket, TcpSocketConnectOpts } from "node:net";
+    import * as net from "node:net";
+    import * as stream from "node:stream";
+    import { URL } from "node:url";
     // incoming headers will never contain number
     interface IncomingHttpHeaders extends NodeJS.Dict<string | string[]> {
         accept?: string | undefined;
@@ -219,7 +178,7 @@ declare module "http" {
         insecureHTTPParser?: boolean | undefined;
         localAddress?: string | undefined;
         localPort?: number | undefined;
-        lookup?: LookupFunction | undefined;
+        lookup?: net.LookupFunction | undefined;
         /**
          * @default 16384
          */
@@ -272,7 +231,7 @@ declare module "http" {
         /**
          * An additional buffer time added to the
          * `server.keepAliveTimeout` to extend the internal socket timeout.
-         * @since 22.19.0
+         * @since 24.6.0
          * @default 1000
          */
         keepAliveTimeoutBuffer?: number | undefined;
@@ -340,24 +299,57 @@ declare module "http" {
          * If the header's value is an array, the items will be joined using `; `.
          */
         uniqueHeaders?: Array<string | string[]> | undefined;
+        /**
+         * A callback which receives an
+         * incoming request and returns a boolean, to control which upgrade attempts
+         * should be accepted. Accepted upgrades will fire an `'upgrade'` event (or
+         * their sockets will be destroyed, if no listener is registered) while
+         * rejected upgrades will fire a `'request'` event like any non-upgrade
+         * request.
+         * @since v24.9.0
+         * @default () => server.listenerCount('upgrade') > 0
+         */
+        shouldUpgradeCallback?: ((request: InstanceType<Request>) => boolean) | undefined;
         /**
          * If set to `true`, an error is thrown when writing to an HTTP response which does not have a body.
          * @default false
          * @since v18.17.0, v20.2.0
          */
         rejectNonStandardBodyWrites?: boolean | undefined;
+        /**
+         * If set to `true`, requests without `Content-Length`
+         * or `Transfer-Encoding` headers (indicating no body) will be initialized with an
+         * already-ended body stream, so they will never emit any stream events
+         * (like `'data'` or `'end'`). You can use `req.readableEnded` to detect this case.
+         * @since v25.1.0
+         * @default false
+         */
+        optimizeEmptyRequests?: boolean | undefined;
     }
     type RequestListener<
         Request extends typeof IncomingMessage = typeof IncomingMessage,
         Response extends typeof ServerResponse<InstanceType<Request>> = typeof ServerResponse,
-    > = (req: InstanceType<Request>, res: InstanceType<Response> & { req: InstanceType<Request> }) => void;
+    > = (request: InstanceType<Request>, response: InstanceType<Response> & { req: InstanceType<Request> }) => void;
+    interface ServerEventMap<
+        Request extends typeof IncomingMessage = typeof IncomingMessage,
+        Response extends typeof ServerResponse<InstanceType<Request>> = typeof ServerResponse,
+    > extends net.ServerEventMap {
+        "checkContinue": Parameters<RequestListener<Request, Response>>;
+        "checkExpectation": Parameters<RequestListener<Request, Response>>;
+        "clientError": [exception: Error, socket: stream.Duplex];
+        "connect": [request: InstanceType<Request>, socket: stream.Duplex, head: NonSharedBuffer];
+        "connection": [socket: net.Socket];
+        "dropRequest": [request: InstanceType<Request>, socket: stream.Duplex];
+        "request": Parameters<RequestListener<Request, Response>>;
+        "upgrade": [req: InstanceType<Request>, socket: stream.Duplex, head: NonSharedBuffer];
+    }
     /**
      * @since v0.1.17
      */
     class Server<
         Request extends typeof IncomingMessage = typeof IncomingMessage,
         Response extends typeof ServerResponse<InstanceType<Request>> = typeof ServerResponse,
-    > extends NetServer {
+    > extends net.Server {
         constructor(requestListener?: RequestListener<Request, Response>);
         constructor(options: ServerOptions<Request, Response>, requestListener?: RequestListener<Request, Response>);
         /**
@@ -374,8 +366,8 @@ declare module "http" {
          * @since v0.9.12
          * @param [msecs=0 (no timeout)]
          */
-        setTimeout(msecs?: number, callback?: (socket: Socket) => void): this;
-        setTimeout(callback: (socket: Socket) => void): this;
+        setTimeout(msecs?: number, callback?: (socket: net.Socket) => void): this;
+        setTimeout(callback: (socket: net.Socket) => void): this;
         /**
          * Limits maximum incoming headers count. If set to 0, no limit will be applied.
          * @since v0.7.0
@@ -447,7 +439,7 @@ declare module "http" {
          * the socket timeout slightly beyond the advertised keep-alive timeout.
          *
          * This option applies only to new incoming connections.
-         * @since v22.19.0
+         * @since v24.6.0
          * @default 1000
          */
         keepAliveTimeoutBuffer: number;
@@ -475,126 +467,64 @@ declare module "http" {
          * @since v18.2.0
          */
         closeIdleConnections(): void;
-        addListener(event: string, listener: (...args: any[]) => void): this;
-        addListener(event: "close", listener: () => void): this;
-        addListener(event: "connection", listener: (socket: Socket) => void): this;
-        addListener(event: "error", listener: (err: Error) => void): this;
-        addListener(event: "listening", listener: () => void): this;
-        addListener(event: "checkContinue", listener: RequestListener<Request, Response>): this;
-        addListener(event: "checkExpectation", listener: RequestListener<Request, Response>): this;
-        addListener(event: "clientError", listener: (err: Error, socket: stream.Duplex) => void): this;
-        addListener(
-            event: "connect",
-            listener: (req: InstanceType<Request>, socket: stream.Duplex, head: NonSharedBuffer) => void,
-        ): this;
-        addListener(event: "dropRequest", listener: (req: InstanceType<Request>, socket: stream.Duplex) => void): this;
-        addListener(event: "request", listener: RequestListener<Request, Response>): this;
-        addListener(
-            event: "upgrade",
-            listener: (req: InstanceType<Request>, socket: stream.Duplex, head: NonSharedBuffer) => void,
-        ): this;
-        emit(event: string, ...args: any[]): boolean;
-        emit(event: "close"): boolean;
-        emit(event: "connection", socket: Socket): boolean;
-        emit(event: "error", err: Error): boolean;
-        emit(event: "listening"): boolean;
-        emit(
-            event: "checkContinue",
-            req: InstanceType<Request>,
-            res: InstanceType<Response> & { req: InstanceType<Request> },
-        ): boolean;
-        emit(
-            event: "checkExpectation",
-            req: InstanceType<Request>,
-            res: InstanceType<Response> & { req: InstanceType<Request> },
-        ): boolean;
-        emit(event: "clientError", err: Error, socket: stream.Duplex): boolean;
-        emit(event: "connect", req: InstanceType<Request>, socket: stream.Duplex, head: NonSharedBuffer): boolean;
-        emit(event: "dropRequest", req: InstanceType<Request>, socket: stream.Duplex): boolean;
-        emit(
-            event: "request",
-            req: InstanceType<Request>,
-            res: InstanceType<Response> & { req: InstanceType<Request> },
-        ): boolean;
-        emit(event: "upgrade", req: InstanceType<Request>, socket: stream.Duplex, head: NonSharedBuffer): boolean;
-        on(event: string, listener: (...args: any[]) => void): this;
-        on(event: "close", listener: () => void): this;
-        on(event: "connection", listener: (socket: Socket) => void): this;
-        on(event: "error", listener: (err: Error) => void): this;
-        on(event: "listening", listener: () => void): this;
-        on(event: "checkContinue", listener: RequestListener<Request, Response>): this;
-        on(event: "checkExpectation", listener: RequestListener<Request, Response>): this;
-        on(event: "clientError", listener: (err: Error, socket: stream.Duplex) => void): this;
-        on(
-            event: "connect",
-            listener: (req: InstanceType<Request>, socket: stream.Duplex, head: NonSharedBuffer) => void,
+        // #region InternalEventEmitter
+        addListener<E extends keyof ServerEventMap>(
+            eventName: E,
+            listener: (...args: ServerEventMap<Request, Response>[E]) => void,
         ): this;
-        on(event: "dropRequest", listener: (req: InstanceType<Request>, socket: stream.Duplex) => void): this;
-        on(event: "request", listener: RequestListener<Request, Response>): this;
-        on(
-            event: "upgrade",
-            listener: (req: InstanceType<Request>, socket: stream.Duplex, head: NonSharedBuffer) => void,
+        addListener(eventName: string | symbol, listener: (...args: any[]) => void): this;
+        emit<E extends keyof ServerEventMap>(eventName: E, ...args: ServerEventMap<Request, Response>[E]): boolean;
+        emit(eventName: string | symbol, ...args: any[]): boolean;
+        listenerCount<E extends keyof ServerEventMap>(
+            eventName: E,
+            listener?: (...args: ServerEventMap<Request, Response>[E]) => void,
+        ): number;
+        listenerCount(eventName: string | symbol, listener?: (...args: any[]) => void): number;
+        listeners<E extends keyof ServerEventMap>(
+            eventName: E,
+        ): ((...args: ServerEventMap<Request, Response>[E]) => void)[];
+        listeners(eventName: string | symbol): ((...args: any[]) => void)[];
+        off<E extends keyof ServerEventMap>(
+            eventName: E,
+            listener: (...args: ServerEventMap<Request, Response>[E]) => void,
         ): this;
-        once(event: string, listener: (...args: any[]) => void): this;
-        once(event: "close", listener: () => void): this;
-        once(event: "connection", listener: (socket: Socket) => void): this;
-        once(event: "error", listener: (err: Error) => void): this;
-        once(event: "listening", listener: () => void): this;
-        once(event: "checkContinue", listener: RequestListener<Request, Response>): this;
-        once(event: "checkExpectation", listener: RequestListener<Request, Response>): this;
-        once(event: "clientError", listener: (err: Error, socket: stream.Duplex) => void): this;
-        once(
-            event: "connect",
-            listener: (req: InstanceType<Request>, socket: stream.Duplex, head: NonSharedBuffer) => void,
+        off(eventName: string | symbol, listener: (...args: any[]) => void): this;
+        on<E extends keyof ServerEventMap>(
+            eventName: E,
+            listener: (...args: ServerEventMap<Request, Response>[E]) => void,
         ): this;
-        once(event: "dropRequest", listener: (req: InstanceType<Request>, socket: stream.Duplex) => void): this;
-        once(event: "request", listener: RequestListener<Request, Response>): this;
-        once(
-            event: "upgrade",
-            listener: (req: InstanceType<Request>, socket: stream.Duplex, head: NonSharedBuffer) => void,
+        on(eventName: string | symbol, listener: (...args: any[]) => void): this;
+        once<E extends keyof ServerEventMap>(
+            eventName: E,
+            listener: (...args: ServerEventMap<Request, Response>[E]) => void,
         ): this;
-        prependListener(event: string, listener: (...args: any[]) => void): this;
-        prependListener(event: "close", listener: () => void): this;
-        prependListener(event: "connection", listener: (socket: Socket) => void): this;
-        prependListener(event: "error", listener: (err: Error) => void): this;
-        prependListener(event: "listening", listener: () => void): this;
-        prependListener(event: "checkContinue", listener: RequestListener<Request, Response>): this;
-        prependListener(event: "checkExpectation", listener: RequestListener<Request, Response>): this;
-        prependListener(event: "clientError", listener: (err: Error, socket: stream.Duplex) => void): this;
-        prependListener(
-            event: "connect",
-            listener: (req: InstanceType<Request>, socket: stream.Duplex, head: NonSharedBuffer) => void,
+        once(eventName: string | symbol, listener: (...args: any[]) => void): this;
+        prependListener<E extends keyof ServerEventMap>(
+            eventName: E,
+            listener: (...args: ServerEventMap<Request, Response>[E]) => void,
         ): this;
-        prependListener(
-            event: "dropRequest",
-            listener: (req: InstanceType<Request>, socket: stream.Duplex) => void,
+        prependListener(eventName: string | symbol, listener: (...args: any[]) => void): this;
+        prependOnceListener<E extends keyof ServerEventMap>(
+            eventName: E,
+            listener: (...args: ServerEventMap<Request, Response>[E]) => void,
         ): this;
-        prependListener(event: "request", listener: RequestListener<Request, Response>): this;
-        prependListener(
-            event: "upgrade",
-            listener: (req: InstanceType<Request>, socket: stream.Duplex, head: NonSharedBuffer) => void,
-        ): this;
-        prependOnceListener(event: string, listener: (...args: any[]) => void): this;
-        prependOnceListener(event: "close", listener: () => void): this;
-        prependOnceListener(event: "connection", listener: (socket: Socket) => void): this;
-        prependOnceListener(event: "error", listener: (err: Error) => void): this;
-        prependOnceListener(event: "listening", listener: () => void): this;
-        prependOnceListener(event: "checkContinue", listener: RequestListener<Request, Response>): this;
-        prependOnceListener(event: "checkExpectation", listener: RequestListener<Request, Response>): this;
-        prependOnceListener(event: "clientError", listener: (err: Error, socket: stream.Duplex) => void): this;
-        prependOnceListener(
-            event: "connect",
-            listener: (req: InstanceType<Request>, socket: stream.Duplex, head: NonSharedBuffer) => void,
-        ): this;
-        prependOnceListener(
-            event: "dropRequest",
-            listener: (req: InstanceType<Request>, socket: stream.Duplex) => void,
-        ): this;
-        prependOnceListener(event: "request", listener: RequestListener<Request, Response>): this;
-        prependOnceListener(
-            event: "upgrade",
-            listener: (req: InstanceType<Request>, socket: stream.Duplex, head: NonSharedBuffer) => void,
+        prependOnceListener(eventName: string | symbol, listener: (...args: any[]) => void): this;
+        rawListeners<E extends keyof ServerEventMap>(
+            eventName: E,
+        ): ((...args: ServerEventMap<Request, Response>[E]) => void)[];
+        rawListeners(eventName: string | symbol): ((...args: any[]) => void)[];
+        // eslint-disable-next-line @definitelytyped/no-unnecessary-generics
+        removeAllListeners<E extends keyof ServerEventMap>(eventName?: E): this;
+        removeAllListeners(eventName?: string | symbol): this;
+        removeListener<E extends keyof ServerEventMap>(
+            eventName: E,
+            listener: (...args: ServerEventMap<Request, Response>[E]) => void,
         ): this;
+        removeListener(eventName: string | symbol, listener: (...args: any[]) => void): this;
+        // #endregion
+    }
+    interface OutgoingMessageEventMap extends stream.WritableEventMap {
+        "prefinish": [];
     }
     /**
      * This class serves as the parent class of {@link ClientRequest} and {@link ServerResponse}. It is an abstract outgoing message from
@@ -602,6 +532,7 @@ declare module "http" {
      * @since v0.1.17
      */
     class OutgoingMessage<Request extends IncomingMessage = IncomingMessage> extends stream.Writable {
+        constructor();
         readonly req: Request;
         chunkedEncoding: boolean;
         shouldKeepAlive: boolean;
@@ -621,7 +552,7 @@ declare module "http" {
          * @since v0.3.0
          * @deprecated Since v15.12.0,v14.17.1 - Use `socket` instead.
          */
-        readonly connection: Socket | null;
+        readonly connection: net.Socket | null;
         /**
          * Reference to the underlying socket. Usually, users will not want to access
          * this property.
@@ -629,8 +560,7 @@ declare module "http" {
          * After calling `outgoingMessage.end()`, this property will be nulled.
          * @since v0.3.0
          */
-        readonly socket: Socket | null;
-        constructor();
+        readonly socket: net.Socket | null;
         /**
          * Once a socket is associated with the message and is connected, `socket.setTimeout()` will be called with `msecs` as the first parameter.
          * @since v0.9.12
@@ -788,6 +718,61 @@ declare module "http" {
          * @since v1.6.0
          */
         flushHeaders(): void;
+        // #region InternalEventEmitter
+        addListener<E extends keyof OutgoingMessageEventMap>(
+            eventName: E,
+            listener: (...args: OutgoingMessageEventMap[E]) => void,
+        ): this;
+        addListener(eventName: string | symbol, listener: (...args: any[]) => void): this;
+        emit<E extends keyof OutgoingMessageEventMap>(eventName: E, ...args: OutgoingMessageEventMap[E]): boolean;
+        emit(eventName: string | symbol, ...args: any[]): boolean;
+        listenerCount<E extends keyof OutgoingMessageEventMap>(
+            eventName: E,
+            listener?: (...args: OutgoingMessageEventMap[E]) => void,
+        ): number;
+        listenerCount(eventName: string | symbol, listener?: (...args: any[]) => void): number;
+        listeners<E extends keyof OutgoingMessageEventMap>(
+            eventName: E,
+        ): ((...args: OutgoingMessageEventMap[E]) => void)[];
+        listeners(eventName: string | symbol): ((...args: any[]) => void)[];
+        off<E extends keyof OutgoingMessageEventMap>(
+            eventName: E,
+            listener: (...args: OutgoingMessageEventMap[E]) => void,
+        ): this;
+        off(eventName: string | symbol, listener: (...args: any[]) => void): this;
+        on<E extends keyof OutgoingMessageEventMap>(
+            eventName: E,
+            listener: (...args: OutgoingMessageEventMap[E]) => void,
+        ): this;
+        on(eventName: string | symbol, listener: (...args: any[]) => void): this;
+        once<E extends keyof OutgoingMessageEventMap>(
+            eventName: E,
+            listener: (...args: OutgoingMessageEventMap[E]) => void,
+        ): this;
+        once(eventName: string | symbol, listener: (...args: any[]) => void): this;
+        prependListener<E extends keyof OutgoingMessageEventMap>(
+            eventName: E,
+            listener: (...args: OutgoingMessageEventMap[E]) => void,
+        ): this;
+        prependListener(eventName: string | symbol, listener: (...args: any[]) => void): this;
+        prependOnceListener<E extends keyof OutgoingMessageEventMap>(
+            eventName: E,
+            listener: (...args: OutgoingMessageEventMap[E]) => void,
+        ): this;
+        prependOnceListener(eventName: string | symbol, listener: (...args: any[]) => void): this;
+        rawListeners<E extends keyof OutgoingMessageEventMap>(
+            eventName: E,
+        ): ((...args: OutgoingMessageEventMap[E]) => void)[];
+        rawListeners(eventName: string | symbol): ((...args: any[]) => void)[];
+        // eslint-disable-next-line @definitelytyped/no-unnecessary-generics
+        removeAllListeners<E extends keyof OutgoingMessageEventMap>(eventName?: E): this;
+        removeAllListeners(eventName?: string | symbol): this;
+        removeListener<E extends keyof OutgoingMessageEventMap>(
+            eventName: E,
+            listener: (...args: OutgoingMessageEventMap[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
@@ -832,8 +817,8 @@ declare module "http" {
          */
         strictContentLength: boolean;
         constructor(req: Request);
-        assignSocket(socket: Socket): void;
-        detachSocket(socket: Socket): void;
+        assignSocket(socket: net.Socket): void;
+        detachSocket(socket: net.Socket): void;
         /**
          * Sends an HTTP/1.1 100 Continue message to the client, indicating that
          * the request body should be sent. See the `'checkContinue'` event on `Server`.
@@ -945,14 +930,25 @@ declare module "http" {
         writeProcessing(callback?: () => void): void;
     }
     interface InformationEvent {
-        statusCode: number;
-        statusMessage: string;
         httpVersion: string;
         httpVersionMajor: number;
         httpVersionMinor: number;
+        statusCode: number;
+        statusMessage: string;
         headers: IncomingHttpHeaders;
         rawHeaders: string[];
     }
+    interface ClientRequestEventMap extends stream.WritableEventMap {
+        /** @deprecated Listen for the `'close'` event instead. */
+        "abort": [];
+        "connect": [response: IncomingMessage, socket: net.Socket, head: NonSharedBuffer];
+        "continue": [];
+        "information": [info: InformationEvent];
+        "response": [response: IncomingMessage];
+        "socket": [socket: net.Socket];
+        "timeout": [];
+        "upgrade": [response: IncomingMessage, socket: net.Socket, head: NonSharedBuffer];
+    }
     /**
      * This object is created internally and returned from {@link request}. It
      * represents an _in-progress_ request whose header has already been queued. The
@@ -1009,6 +1005,7 @@ declare module "http" {
          *
          * ```js
          * import http from 'node:http';
+         * const agent = new http.Agent({ keepAlive: true });
          *
          * // Server has a 5 seconds keep-alive timeout by default
          * http
@@ -1075,7 +1072,7 @@ declare module "http" {
          * @deprecated Since v14.1.0,v13.14.0 - Use `destroy` instead.
          */
         abort(): void;
-        onSocket(socket: Socket): void;
+        onSocket(socket: net.Socket): void;
         /**
          * Once a socket is assigned to this request and is connected `socket.setTimeout()` will be called.
          * @since v0.5.9
@@ -1107,126 +1104,63 @@ declare module "http" {
          * @since v15.13.0, v14.17.0
          */
         getRawHeaderNames(): string[];
-        /**
-         * @deprecated
-         */
-        addListener(event: "abort", listener: () => void): this;
-        addListener(
-            event: "connect",
-            listener: (response: IncomingMessage, socket: Socket, head: NonSharedBuffer) => void,
-        ): this;
-        addListener(event: "continue", listener: () => void): this;
-        addListener(event: "information", listener: (info: InformationEvent) => void): this;
-        addListener(event: "response", listener: (response: IncomingMessage) => void): this;
-        addListener(event: "socket", listener: (socket: Socket) => void): this;
-        addListener(event: "timeout", listener: () => void): this;
-        addListener(
-            event: "upgrade",
-            listener: (response: IncomingMessage, socket: Socket, head: NonSharedBuffer) => void,
-        ): this;
-        addListener(event: "close", listener: () => void): this;
-        addListener(event: "drain", listener: () => void): this;
-        addListener(event: "error", listener: (err: 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;
-        /**
-         * @deprecated
-         */
-        on(event: "abort", listener: () => void): this;
-        on(
-            event: "connect",
-            listener: (response: IncomingMessage, socket: Socket, head: NonSharedBuffer) => void,
+        // #region InternalEventEmitter
+        addListener<E extends keyof ClientRequestEventMap>(
+            eventName: E,
+            listener: (...args: ClientRequestEventMap[E]) => void,
         ): this;
-        on(event: "continue", listener: () => void): this;
-        on(event: "information", listener: (info: InformationEvent) => void): this;
-        on(event: "response", listener: (response: IncomingMessage) => void): this;
-        on(event: "socket", listener: (socket: Socket) => void): this;
-        on(event: "timeout", listener: () => void): this;
-        on(
-            event: "upgrade",
-            listener: (response: IncomingMessage, socket: Socket, head: NonSharedBuffer) => void,
+        addListener(eventName: string | symbol, listener: (...args: any[]) => void): this;
+        emit<E extends keyof ClientRequestEventMap>(eventName: E, ...args: ClientRequestEventMap[E]): boolean;
+        emit(eventName: string | symbol, ...args: any[]): boolean;
+        listenerCount<E extends keyof ClientRequestEventMap>(
+            eventName: E,
+            listener?: (...args: ClientRequestEventMap[E]) => void,
+        ): number;
+        listenerCount(eventName: string | symbol, listener?: (...args: any[]) => void): number;
+        listeners<E extends keyof ClientRequestEventMap>(eventName: E): ((...args: ClientRequestEventMap[E]) => void)[];
+        listeners(eventName: string | symbol): ((...args: any[]) => void)[];
+        off<E extends keyof ClientRequestEventMap>(
+            eventName: E,
+            listener: (...args: ClientRequestEventMap[E]) => void,
         ): this;
-        on(event: "close", listener: () => void): this;
-        on(event: "drain", listener: () => void): this;
-        on(event: "error", listener: (err: 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;
-        /**
-         * @deprecated
-         */
-        once(event: "abort", listener: () => void): this;
-        once(
-            event: "connect",
-            listener: (response: IncomingMessage, socket: Socket, head: NonSharedBuffer) => void,
+        off(eventName: string | symbol, listener: (...args: any[]) => void): this;
+        on<E extends keyof ClientRequestEventMap>(
+            eventName: E,
+            listener: (...args: ClientRequestEventMap[E]) => void,
         ): this;
-        once(event: "continue", listener: () => void): this;
-        once(event: "information", listener: (info: InformationEvent) => void): this;
-        once(event: "response", listener: (response: IncomingMessage) => void): this;
-        once(event: "socket", listener: (socket: Socket) => void): this;
-        once(event: "timeout", listener: () => void): this;
-        once(
-            event: "upgrade",
-            listener: (response: IncomingMessage, socket: Socket, head: NonSharedBuffer) => void,
+        on(eventName: string | symbol, listener: (...args: any[]) => void): this;
+        once<E extends keyof ClientRequestEventMap>(
+            eventName: E,
+            listener: (...args: ClientRequestEventMap[E]) => void,
         ): this;
-        once(event: "close", listener: () => void): this;
-        once(event: "drain", listener: () => void): this;
-        once(event: "error", listener: (err: 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;
-        /**
-         * @deprecated
-         */
-        prependListener(event: "abort", listener: () => void): this;
-        prependListener(
-            event: "connect",
-            listener: (response: IncomingMessage, socket: Socket, head: NonSharedBuffer) => void,
+        once(eventName: string | symbol, listener: (...args: any[]) => void): this;
+        prependListener<E extends keyof ClientRequestEventMap>(
+            eventName: E,
+            listener: (...args: ClientRequestEventMap[E]) => void,
         ): this;
-        prependListener(event: "continue", listener: () => void): this;
-        prependListener(event: "information", listener: (info: InformationEvent) => void): this;
-        prependListener(event: "response", listener: (response: IncomingMessage) => void): this;
-        prependListener(event: "socket", listener: (socket: Socket) => void): this;
-        prependListener(event: "timeout", listener: () => void): this;
-        prependListener(
-            event: "upgrade",
-            listener: (response: IncomingMessage, socket: Socket, head: NonSharedBuffer) => void,
+        prependListener(eventName: string | symbol, listener: (...args: any[]) => void): this;
+        prependOnceListener<E extends keyof ClientRequestEventMap>(
+            eventName: E,
+            listener: (...args: ClientRequestEventMap[E]) => void,
         ): this;
-        prependListener(event: "close", listener: () => void): this;
-        prependListener(event: "drain", listener: () => void): this;
-        prependListener(event: "error", listener: (err: 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;
-        /**
-         * @deprecated
-         */
-        prependOnceListener(event: "abort", listener: () => void): this;
-        prependOnceListener(
-            event: "connect",
-            listener: (response: IncomingMessage, socket: Socket, head: NonSharedBuffer) => void,
+        prependOnceListener(eventName: string | symbol, listener: (...args: any[]) => void): this;
+        rawListeners<E extends keyof ClientRequestEventMap>(
+            eventName: E,
+        ): ((...args: ClientRequestEventMap[E]) => void)[];
+        rawListeners(eventName: string | symbol): ((...args: any[]) => void)[];
+        // eslint-disable-next-line @definitelytyped/no-unnecessary-generics
+        removeAllListeners<E extends keyof ClientRequestEventMap>(eventName?: E): this;
+        removeAllListeners(eventName?: string | symbol): this;
+        removeListener<E extends keyof ClientRequestEventMap>(
+            eventName: E,
+            listener: (...args: ClientRequestEventMap[E]) => void,
         ): this;
-        prependOnceListener(event: "continue", listener: () => void): this;
-        prependOnceListener(event: "information", listener: (info: InformationEvent) => void): this;
-        prependOnceListener(event: "response", listener: (response: IncomingMessage) => void): this;
-        prependOnceListener(event: "socket", listener: (socket: Socket) => void): this;
-        prependOnceListener(event: "timeout", listener: () => void): this;
-        prependOnceListener(
-            event: "upgrade",
-            listener: (response: IncomingMessage, socket: Socket, head: NonSharedBuffer) => void,
-        ): this;
-        prependOnceListener(event: "close", listener: () => void): this;
-        prependOnceListener(event: "drain", listener: () => void): this;
-        prependOnceListener(event: "error", listener: (err: 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;
+        removeListener(eventName: string | symbol, listener: (...args: any[]) => void): this;
+        // #endregion
+    }
+    interface IncomingMessageEventMap extends stream.ReadableEventMap {
+        /** @deprecated Listen for `'close'` event instead. */
+        "aborted": [];
     }
     /**
      * An `IncomingMessage` object is created by {@link Server} or {@link ClientRequest} and passed as the first argument to the `'request'` and `'response'` event respectively. It may be used to
@@ -1239,7 +1173,7 @@ declare module "http" {
      * @since v0.1.17
      */
     class IncomingMessage extends stream.Readable {
-        constructor(socket: Socket);
+        constructor(socket: net.Socket);
         /**
          * The `message.aborted` property will be `true` if the request has
          * been aborted.
@@ -1287,7 +1221,7 @@ declare module "http" {
          * @since v0.1.90
          * @deprecated Since v16.0.0 - Use `socket`.
          */
-        connection: Socket;
+        connection: net.Socket;
         /**
          * The `net.Socket` object associated with the connection.
          *
@@ -1299,7 +1233,7 @@ declare module "http" {
          * type other than `net.Socket` or internally nulled.
          * @since v0.3.0
          */
-        socket: Socket;
+        socket: net.Socket;
         /**
          * The request/response headers object.
          *
@@ -1461,8 +1395,71 @@ declare module "http" {
          * @since v0.3.0
          */
         destroy(error?: Error): this;
+        // #region InternalEventEmitter
+        addListener<E extends keyof IncomingMessageEventMap>(
+            eventName: E,
+            listener: (...args: IncomingMessageEventMap[E]) => void,
+        ): this;
+        addListener(eventName: string | symbol, listener: (...args: any[]) => void): this;
+        emit<E extends keyof IncomingMessageEventMap>(eventName: E, ...args: IncomingMessageEventMap[E]): boolean;
+        emit(eventName: string | symbol, ...args: any[]): boolean;
+        listenerCount<E extends keyof IncomingMessageEventMap>(
+            eventName: E,
+            listener?: (...args: IncomingMessageEventMap[E]) => void,
+        ): number;
+        listenerCount(eventName: string | symbol, listener?: (...args: any[]) => void): number;
+        listeners<E extends keyof IncomingMessageEventMap>(
+            eventName: E,
+        ): ((...args: IncomingMessageEventMap[E]) => void)[];
+        listeners(eventName: string | symbol): ((...args: any[]) => void)[];
+        off<E extends keyof IncomingMessageEventMap>(
+            eventName: E,
+            listener: (...args: IncomingMessageEventMap[E]) => void,
+        ): this;
+        off(eventName: string | symbol, listener: (...args: any[]) => void): this;
+        on<E extends keyof IncomingMessageEventMap>(
+            eventName: E,
+            listener: (...args: IncomingMessageEventMap[E]) => void,
+        ): this;
+        on(eventName: string | symbol, listener: (...args: any[]) => void): this;
+        once<E extends keyof IncomingMessageEventMap>(
+            eventName: E,
+            listener: (...args: IncomingMessageEventMap[E]) => void,
+        ): this;
+        once(eventName: string | symbol, listener: (...args: any[]) => void): this;
+        prependListener<E extends keyof IncomingMessageEventMap>(
+            eventName: E,
+            listener: (...args: IncomingMessageEventMap[E]) => void,
+        ): this;
+        prependListener(eventName: string | symbol, listener: (...args: any[]) => void): this;
+        prependOnceListener<E extends keyof IncomingMessageEventMap>(
+            eventName: E,
+            listener: (...args: IncomingMessageEventMap[E]) => void,
+        ): this;
+        prependOnceListener(eventName: string | symbol, listener: (...args: any[]) => void): this;
+        rawListeners<E extends keyof IncomingMessageEventMap>(
+            eventName: E,
+        ): ((...args: IncomingMessageEventMap[E]) => void)[];
+        rawListeners(eventName: string | symbol): ((...args: any[]) => void)[];
+        // eslint-disable-next-line @definitelytyped/no-unnecessary-generics
+        removeAllListeners<E extends keyof IncomingMessageEventMap>(eventName?: E): this;
+        removeAllListeners(eventName?: string | symbol): this;
+        removeListener<E extends keyof IncomingMessageEventMap>(
+            eventName: E,
+            listener: (...args: IncomingMessageEventMap[E]) => void,
+        ): this;
+        removeListener(eventName: string | symbol, listener: (...args: any[]) => void): this;
+        // #endregion
+    }
+    interface ProxyEnv extends NodeJS.ProcessEnv {
+        HTTP_PROXY?: string | undefined;
+        HTTPS_PROXY?: string | undefined;
+        NO_PROXY?: string | undefined;
+        http_proxy?: string | undefined;
+        https_proxy?: string | undefined;
+        no_proxy?: string | undefined;
     }
-    interface AgentOptions extends NodeJS.PartialOptions<TcpSocketConnectOpts> {
+    interface AgentOptions extends NodeJS.PartialOptions<net.TcpSocketConnectOpts> {
         /**
          * Keep sockets around in a pool to be used by other requests in the future. Default = false
          */
@@ -1472,6 +1469,16 @@ declare module "http" {
          * Only relevant if keepAlive is set to true.
          */
         keepAliveMsecs?: number | undefined;
+        /**
+         * Milliseconds to subtract from
+         * the server-provided `keep-alive: timeout=...` hint when determining socket
+         * expiration time. This buffer helps ensure the agent closes the socket
+         * slightly before the server does, reducing the chance of sending a request
+         * on a socket that’s about to be closed by the server.
+         * @since v24.7.0
+         * @default 1000
+         */
+        agentKeepAliveTimeoutBuffer?: number | undefined;
         /**
          * Maximum number of sockets to allow per host. Default for Node 0.10 is 5, default for Node 0.12 is Infinity
          */
@@ -1493,6 +1500,22 @@ declare module "http" {
          * @default `lifo`
          */
         scheduling?: "fifo" | "lifo" | undefined;
+        /**
+         * Environment variables for proxy configuration. See
+         * [Built-in Proxy Support](https://nodejs.org/docs/latest-v25.x/api/http.html#built-in-proxy-support) for details.
+         * @since v24.5.0
+         */
+        proxyEnv?: ProxyEnv | undefined;
+        /**
+         * Default port to use when the port is not specified in requests.
+         * @since v24.5.0
+         */
+        defaultPort?: number | undefined;
+        /**
+         * The protocol to use for the agent.
+         * @since v24.5.0
+         */
+        protocol?: string | undefined;
     }
     /**
      * An `Agent` is responsible for managing connection persistence
@@ -1548,7 +1571,7 @@ declare module "http" {
      * });
      * ```
      *
-     * `options` in [`socket.connect()`](https://nodejs.org/docs/latest-v22.x/api/net.html#socketconnectoptions-connectlistener) are also supported.
+     * `options` in [`socket.connect()`](https://nodejs.org/docs/latest-v25.x/api/net.html#socketconnectoptions-connectlistener) are also supported.
      *
      * To configure any of them, a custom {@link Agent} instance must be created.
      *
@@ -1588,13 +1611,13 @@ declare module "http" {
          * removed from the array on `'timeout'`.
          * @since v0.11.4
          */
-        readonly freeSockets: NodeJS.ReadOnlyDict<Socket[]>;
+        readonly freeSockets: NodeJS.ReadOnlyDict<net.Socket[]>;
         /**
          * An object which contains arrays of sockets currently in use by the
          * agent. Do not modify.
          * @since v0.3.6
          */
-        readonly sockets: NodeJS.ReadOnlyDict<Socket[]>;
+        readonly sockets: NodeJS.ReadOnlyDict<net.Socket[]>;
         /**
          * An object which contains queues of requests that have not yet been assigned to
          * sockets. Do not modify.
@@ -1616,20 +1639,34 @@ declare module "http" {
         /**
          * Produces a socket/stream to be used for HTTP requests.
          *
-         * By default, this function is the same as `net.createConnection()`. However,
-         * custom agents may override this method in case greater flexibility is desired.
+         * By default, this function behaves identically to `net.createConnection()`,
+         * synchronously returning the created socket. The optional `callback` parameter in the
+         * signature is **not** used by this default implementation.
          *
-         * A socket/stream can be supplied in one of two ways: by returning the
-         * socket/stream from this function, or by passing the socket/stream to `callback`.
+         * However, custom agents may override this method to provide greater flexibility,
+         * for example, to create sockets asynchronously. When overriding `createConnection`:
          *
-         * This method is guaranteed to return an instance of the `net.Socket` class,
-         * a subclass of `stream.Duplex`, unless the user specifies a socket
-         * type other than `net.Socket`.
+         * 1. **Synchronous socket creation**: The overriding method can return the
+         *    socket/stream directly.
+         * 2. **Asynchronous socket creation**: The overriding method can accept the `callback`
+         *    and pass the created socket/stream to it (e.g., `callback(null, newSocket)`).
+         *    If an error occurs during socket creation, it should be passed as the first
+         *    argument to the `callback` (e.g., `callback(err)`).
          *
-         * `callback` has a signature of `(err, stream)`.
+         * The agent will call the provided `createConnection` function with `options` and
+         * this internal `callback`. The `callback` provided by the agent has a signature
+         * of `(err, stream)`.
          * @since v0.11.4
-         * @param options Options containing connection details. Check `createConnection` for the format of the options
-         * @param callback Callback function that receives the created socket
+         * @param options Options containing connection details. Check
+         * `net.createConnection` for the format of the options. For custom agents,
+         * this object is passed to the custom `createConnection` function.
+         * @param callback (Optional, primarily for custom agents) A function to be
+         * called by a custom `createConnection` implementation when the socket is
+         * created, especially for asynchronous operations.
+         * @returns The created socket. This is returned by the default
+         * implementation or by a custom synchronous `createConnection` implementation.
+         * If a custom `createConnection` uses the `callback` for asynchronous
+         * operation, this return value might not be the primary way to obtain the socket.
          */
         createConnection(
             options: ClientRequestArgs,
@@ -2058,6 +2095,27 @@ declare module "http" {
      * @param [max=1000]
      */
     function setMaxIdleHTTPParsers(max: number): void;
+    /**
+     * Dynamically resets the global configurations to enable built-in proxy support for
+     * `fetch()` and `http.request()`/`https.request()` at runtime, as an alternative
+     * to using the `--use-env-proxy` flag or `NODE_USE_ENV_PROXY` environment variable.
+     * It can also be used to override settings configured from the environment variables.
+     *
+     * As this function resets the global configurations, any previously configured
+     * `http.globalAgent`, `https.globalAgent` or undici global dispatcher would be
+     * overridden after this function is invoked. It's recommended to invoke it before any
+     * requests are made and avoid invoking it in the middle of any requests.
+     *
+     * See [Built-in Proxy Support](https://nodejs.org/docs/latest-v25.x/api/http.html#built-in-proxy-support) for details on proxy URL formats and `NO_PROXY`
+     * syntax.
+     * @since v25.4.0
+     * @param proxyEnv An object containing proxy configuration. This accepts the
+     * same options as the `proxyEnv` option accepted by {@link Agent}. **Default:**
+     * `process.env`.
+     * @returns A function that restores the original agent and dispatcher
+     * settings to the state before this `http.setGlobalProxyFromEnv()` is invoked.
+     */
+    function setGlobalProxyFromEnv(proxyEnv?: ProxyEnv): () => void;
     /**
      * Global instance of `Agent` which is used as the default for all HTTP client
      * requests. Diverges from a default `Agent` configuration by having `keepAlive`
@@ -2084,6 +2142,6 @@ declare module "http" {
      */
     const MessageEvent: typeof import("undici-types").MessageEvent;
 }
-declare module "node:http" {
-    export * from "http";
+declare module "http" {
+    export * from "node:http";
 }