cdk-ecr-deployment 2.5.5 → 2.5.21

package/node_modules/@types/cacheable-request/node_modules/@types/node/http2.d.ts

@@ -1,12 +1,12 @@
 /**
- * The `http2` module provides an implementation of the [HTTP/2](https://tools.ietf.org/html/rfc7540) protocol. It
- * can be accessed using:
+ * The `node:http2` module provides an implementation of the [HTTP/2](https://tools.ietf.org/html/rfc7540) protocol.
+ * It can be accessed using:
  *
  * ```js
- * const http2 = require('http2');
+ * const http2 = require('node:http2');
  * ```
  * @since v8.4.0
- * @see [source](https://github.com/nodejs/node/blob/v17.0.0/lib/http2.js)
+ * @see [source](https://github.com/nodejs/node/blob/v20.2.0/lib/http2.js)
  */
 declare module 'http2' {
     import EventEmitter = require('node:events');
@@ -83,7 +83,7 @@ declare module 'http2' {
          */
         readonly destroyed: boolean;
         /**
-         * Set the `true` if the `END_STREAM` flag was set in the request or response
+         * Set to `true` if the `END_STREAM` flag was set in the request or response
          * HEADERS frame received, indicating that no additional data should be received
          * and the readable side of the `Http2Stream` will be closed.
          * @since v10.11.0
@@ -151,7 +151,7 @@ declare module 'http2' {
         priority(options: StreamPriorityOptions): void;
         /**
          * ```js
-         * const http2 = require('http2');
+         * const http2 = require('node:http2');
          * const client = http2.connect('http://example.org:8000');
          * const { NGHTTP2_CANCEL } = http2.constants;
          * const req = client.request({ ':path': '/' });
@@ -171,7 +171,7 @@ declare module 'http2' {
          * trailers can be sent.
          *
          * ```js
-         * const http2 = require('http2');
+         * const http2 = require('node:http2');
          * const server = http2.createServer();
          * server.on('stream', (stream) => {
          *   stream.respond(undefined, { waitForTrailers: true });
@@ -332,7 +332,7 @@ declare module 'http2' {
          * Initiates a push stream. The callback is invoked with the new `Http2Stream`instance created for the push stream passed as the second argument, or an`Error` passed as the first argument.
          *
          * ```js
-         * const http2 = require('http2');
+         * const http2 = require('node:http2');
          * const server = http2.createServer();
          * server.on('stream', (stream) => {
          *   stream.respond({ ':status': 200 });
@@ -357,7 +357,7 @@ declare module 'http2' {
         pushStream(headers: OutgoingHttpHeaders, options?: StreamPriorityOptions, callback?: (err: Error | null, pushStream: ServerHttp2Stream, headers: OutgoingHttpHeaders) => void): void;
         /**
          * ```js
-         * const http2 = require('http2');
+         * const http2 = require('node:http2');
          * const server = http2.createServer();
          * server.on('stream', (stream) => {
          *   stream.respond({ ':status': 200 });
@@ -365,16 +365,15 @@ declare module 'http2' {
          * });
          * ```
          *
-         * When the `options.waitForTrailers` option is set, the `'wantTrailers'` event
-         * will be emitted immediately after queuing the last chunk of payload data to be
-         * sent. The `http2stream.sendTrailers()` method can then be used to sent trailing
-         * header fields to the peer.
+         * Initiates a response. When the `options.waitForTrailers` option is set, the`'wantTrailers'` event will be emitted immediately after queuing the last chunk
+         * of payload data to be sent. The `http2stream.sendTrailers()` method can then be
+         * used to sent trailing header fields to the peer.
          *
          * When `options.waitForTrailers` is set, the `Http2Stream` will not automatically
          * close when the final `DATA` frame is transmitted. User code must call either`http2stream.sendTrailers()` or `http2stream.close()` to close the`Http2Stream`.
          *
          * ```js
-         * const http2 = require('http2');
+         * const http2 = require('node:http2');
          * const server = http2.createServer();
          * server.on('stream', (stream) => {
          *   stream.respond({ ':status': 200 }, { waitForTrailers: true });
@@ -397,8 +396,8 @@ declare module 'http2' {
          * automatically.
          *
          * ```js
-         * const http2 = require('http2');
-         * const fs = require('fs');
+         * const http2 = require('node:http2');
+         * const fs = require('node:fs');
          *
          * const server = http2.createServer();
          * server.on('stream', (stream) => {
@@ -408,7 +407,7 @@ declare module 'http2' {
          *   const headers = {
          *     'content-length': stat.size,
          *     'last-modified': stat.mtime.toUTCString(),
-         *     'content-type': 'text/plain; charset=utf-8'
+         *     'content-type': 'text/plain; charset=utf-8',
          *   };
          *   stream.respondWithFD(fd, headers);
          *   stream.on('close', () => fs.closeSync(fd));
@@ -439,8 +438,8 @@ declare module 'http2' {
          * close when the final `DATA` frame is transmitted. User code _must_ call either`http2stream.sendTrailers()` or `http2stream.close()` to close the`Http2Stream`.
          *
          * ```js
-         * const http2 = require('http2');
-         * const fs = require('fs');
+         * const http2 = require('node:http2');
+         * const fs = require('node:fs');
          *
          * const server = http2.createServer();
          * server.on('stream', (stream) => {
@@ -450,7 +449,7 @@ declare module 'http2' {
          *   const headers = {
          *     'content-length': stat.size,
          *     'last-modified': stat.mtime.toUTCString(),
-         *     'content-type': 'text/plain; charset=utf-8'
+         *     'content-type': 'text/plain; charset=utf-8',
          *   };
          *   stream.respondWithFD(fd, headers, { waitForTrailers: true });
          *   stream.on('wantTrailers', () => {
@@ -482,7 +481,7 @@ declare module 'http2' {
          * Example using a file path:
          *
          * ```js
-         * const http2 = require('http2');
+         * const http2 = require('node:http2');
          * const server = http2.createServer();
          * server.on('stream', (stream) => {
          *   function statCheck(stat, headers) {
@@ -500,7 +499,7 @@ declare module 'http2' {
          *       }
          *     } catch (err) {
          *       // Perform actual error handling.
-         *       console.log(err);
+         *       console.error(err);
          *     }
          *     stream.end();
          *   }
@@ -516,7 +515,7 @@ declare module 'http2' {
          * results to determine if the file has been modified to return an appropriate`304` response:
          *
          * ```js
-         * const http2 = require('http2');
+         * const http2 = require('node:http2');
          * const server = http2.createServer();
          * server.on('stream', (stream) => {
          *   function statCheck(stat, headers) {
@@ -549,7 +548,7 @@ declare module 'http2' {
          * close when the final `DATA` frame is transmitted. User code must call either`http2stream.sendTrailers()` or `http2stream.close()` to close the`Http2Stream`.
          *
          * ```js
-         * const http2 = require('http2');
+         * const http2 = require('node:http2');
          * const server = http2.createServer();
          * server.on('stream', (stream) => {
          *   stream.respondWithFile('/some/file',
@@ -748,7 +747,7 @@ declare module 'http2' {
          * the delta.
          *
          * ```js
-         * const http2 = require('http2');
+         * const http2 = require('node:http2');
          *
          * const server = http2.createServer();
          * const expectedWindowSize = 2 ** 20;
@@ -780,7 +779,7 @@ declare module 'http2' {
          * @since v8.4.0
          * @param callback Callback that is called once the session is connected or right away if the session is already connected.
          */
-        settings(settings: Settings): void;
+        settings(settings: Settings, callback?: (err: Error | null, settings: Settings, duration: number) => void): void;
         /**
          * Calls `unref()` on this `Http2Session`instance's underlying `net.Socket`.
          * @since v9.4.0
@@ -846,14 +845,19 @@ declare module 'http2' {
          * For HTTP/2 Client `Http2Session` instances only, the `http2session.request()`creates and returns an `Http2Stream` instance that can be used to send an
          * HTTP/2 request to the connected server.
          *
+         * When a `ClientHttp2Session` is first created, the socket may not yet be
+         * connected. if `clienthttp2session.request()` is called during this time, the
+         * actual request will be deferred until the socket is ready to go.
+         * If the `session` is closed before the actual request be executed, an`ERR_HTTP2_GOAWAY_SESSION` is thrown.
+         *
          * This method is only available if `http2session.type` is equal to`http2.constants.NGHTTP2_SESSION_CLIENT`.
          *
          * ```js
-         * const http2 = require('http2');
+         * const http2 = require('node:http2');
          * const clientSession = http2.connect('https://localhost:1234');
          * const {
          *   HTTP2_HEADER_PATH,
-         *   HTTP2_HEADER_STATUS
+         *   HTTP2_HEADER_STATUS,
          * } = http2.constants;
          *
          * const req = clientSession.request({ [HTTP2_HEADER_PATH]: '/' });
@@ -923,7 +927,7 @@ declare module 'http2' {
          * Submits an `ALTSVC` frame (as defined by [RFC 7838](https://tools.ietf.org/html/rfc7838)) to the connected client.
          *
          * ```js
-         * const http2 = require('http2');
+         * const http2 = require('node:http2');
          *
          * const server = http2.createServer();
          * server.on('session', (session) => {
@@ -964,7 +968,7 @@ declare module 'http2' {
          * authoritative responses.
          *
          * ```js
-         * const http2 = require('http2');
+         * const http2 = require('node:http2');
          * const options = getSecureOptionsSomehow();
          * const server = http2.createSecureServer(options);
          * server.on('stream', (stream) => {
@@ -990,7 +994,7 @@ declare module 'http2' {
          * server using the `http2.createSecureServer()` method:
          *
          * ```js
-         * const http2 = require('http2');
+         * const http2 = require('node:http2');
          * const options = getSecureOptionsSomehow();
          * options.origins = ['https://example.com', 'https://example.org'];
          * const server = http2.createSecureServer(options);
@@ -1048,7 +1052,6 @@ declare module 'http2' {
          */
         unknownProtocolTimeout?: number | undefined;
         selectPadding?(frameLen: number, maxFrameLen: number): number;
-        createConnection?(authority: url.URL, option: SessionOptions): stream.Duplex;
     }
     export interface ClientSessionOptions extends SessionOptions {
         maxReservedRemoteStreams?: number | undefined;
@@ -1432,7 +1435,7 @@ declare module 'http2' {
          */
         readonly headersSent: boolean;
         /**
-         * A reference to the original HTTP2 request object.
+         * A reference to the original HTTP2 `request` object.
          * @since v15.7.0
          */
         readonly req: Http2ServerRequest;
@@ -1453,7 +1456,7 @@ declare module 'http2' {
          * All other interactions will be routed directly to the socket.
          *
          * ```js
-         * const http2 = require('http2');
+         * const http2 = require('node:http2');
          * const server = http2.createServer((req, res) => {
          *   const ip = req.socket.remoteAddress;
          *   const port = req.socket.remotePort;
@@ -1636,8 +1639,8 @@ declare module 'http2' {
          * This sends a chunk of the response body. This method may
          * be called multiple times to provide successive parts of the body.
          *
-         * In the `http` module, the response body is omitted when the
-         * request is a HEAD request. Similarly, the `204` and `304` responses_must not_ include a message body.
+         * In the `node:http` module, the response body is omitted when the
+         * request is a HEAD request. Similarly, the `204` and `304` responses _must not_ include a message body.
          *
          * `chunk` can be a string or a buffer. If `chunk` is a string,
          * the second parameter specifies how to encode it into a byte stream.
@@ -1665,6 +1668,31 @@ declare module 'http2' {
          * @since v8.4.0
          */
         writeContinue(): void;
+        /**
+         * Sends a status `103 Early Hints` to the client with a Link header,
+         * indicating that the user agent can preload/preconnect the linked resources.
+         * The `hints` is an object containing the values of headers to be sent with
+         * early hints message.
+         *
+         * **Example**
+         *
+         * ```js
+         * const earlyHintsLink = '</styles.css>; rel=preload; as=style';
+         * response.writeEarlyHints({
+         *   'link': earlyHintsLink,
+         * });
+         *
+         * const earlyHintsLinks = [
+         *   '</styles.css>; rel=preload; as=style',
+         *   '</scripts.js>; rel=preload; as=script',
+         * ];
+         * response.writeEarlyHints({
+         *   'link': earlyHintsLinks,
+         * });
+         * ```
+         * @since v18.11.0
+         */
+        writeEarlyHints(hints: Record<string, string | string[]>): void;
         /**
          * Sends a response header to the request. The status code is a 3-digit HTTP
          * status code, like `404`. The last argument, `headers`, are the response headers.
@@ -1995,7 +2023,7 @@ declare module 'http2' {
      * for use with the `HTTP2-Settings` header field.
      *
      * ```js
-     * const http2 = require('http2');
+     * const http2 = require('node:http2');
      *
      * const packed = http2.getPackedSettings({ enablePush: false });
      *
@@ -2020,7 +2048,7 @@ declare module 'http2' {
      * with browser clients.
      *
      * ```js
-     * const http2 = require('http2');
+     * const http2 = require('node:http2');
      *
      * // Create an unencrypted HTTP/2 server.
      * // Since there are no browsers known that support
@@ -2031,12 +2059,12 @@ declare module 'http2' {
      * server.on('stream', (stream, headers) => {
      *   stream.respond({
      *     'content-type': 'text/html; charset=utf-8',
-     *     ':status': 200
+     *     ':status': 200,
      *   });
      *   stream.end('<h1>Hello World</h1>');
      * });
      *
-     * server.listen(80);
+     * server.listen(8000);
      * ```
      * @since v8.4.0
      * @param onRequestHandler See `Compatibility API`
@@ -2047,12 +2075,12 @@ declare module 'http2' {
      * Returns a `tls.Server` instance that creates and manages `Http2Session`instances.
      *
      * ```js
-     * const http2 = require('http2');
-     * const fs = require('fs');
+     * const http2 = require('node:http2');
+     * const fs = require('node:fs');
      *
      * const options = {
      *   key: fs.readFileSync('server-key.pem'),
-     *   cert: fs.readFileSync('server-cert.pem')
+     *   cert: fs.readFileSync('server-cert.pem'),
      * };
      *
      * // Create a secure HTTP/2 server
@@ -2061,12 +2089,12 @@ declare module 'http2' {
      * server.on('stream', (stream, headers) => {
      *   stream.respond({
      *     'content-type': 'text/html; charset=utf-8',
-     *     ':status': 200
+     *     ':status': 200,
      *   });
      *   stream.end('<h1>Hello World</h1>');
      * });
      *
-     * server.listen(80);
+     * server.listen(8443);
      * ```
      * @since v8.4.0
      * @param onRequestHandler See `Compatibility API`
@@ -2077,7 +2105,7 @@ declare module 'http2' {
      * Returns a `ClientHttp2Session` instance.
      *
      * ```js
-     * const http2 = require('http2');
+     * const http2 = require('node:http2');
      * const client = http2.connect('https://localhost:1234');
      *
      * // Use the client

package/node_modules/@types/cacheable-request/node_modules/@types/node/https.d.ts

@@ -1,16 +1,20 @@
 /**
  * HTTPS is the HTTP protocol over TLS/SSL. In Node.js this is implemented as a
  * separate module.
- * @see [source](https://github.com/nodejs/node/blob/v17.0.0/lib/https.js)
+ * @see [source](https://github.com/nodejs/node/blob/v20.2.0/lib/https.js)
  */
 declare module 'https' {
     import { Duplex } from 'node:stream';
     import * as tls from 'node:tls';
     import * as http from 'node:http';
     import { URL } from 'node:url';
-    type ServerOptions = tls.SecureContextOptions & tls.TlsOptions & http.ServerOptions;
+    type ServerOptions<
+        Request extends typeof http.IncomingMessage = typeof http.IncomingMessage,
+        Response extends typeof http.ServerResponse = typeof http.ServerResponse,
+    > = tls.SecureContextOptions & tls.TlsOptions & http.ServerOptions<Request, Response>;
     type RequestOptions = http.RequestOptions &
         tls.SecureContextOptions & {
+            checkServerIdentity?: typeof tls.checkServerIdentity | undefined;
             rejectUnauthorized?: boolean | undefined; // Defaults to true
             servername?: string | undefined; // SNI TLS Extension
         };
@@ -26,14 +30,33 @@ declare module 'https' {
         constructor(options?: AgentOptions);
         options: AgentOptions;
     }
-    interface Server extends http.Server {}
+    interface Server<
+        Request extends typeof http.IncomingMessage = typeof http.IncomingMessage,
+        Response extends typeof http.ServerResponse = typeof http.ServerResponse,
+    > extends http.Server<Request, Response> {}
     /**
      * See `http.Server` for more information.
      * @since v0.3.4
      */
-    class Server extends tls.Server {
-        constructor(requestListener?: http.RequestListener);
-        constructor(options: ServerOptions, requestListener?: http.RequestListener);
+    class Server<
+        Request extends typeof http.IncomingMessage = typeof http.IncomingMessage,
+        Response extends typeof http.ServerResponse = typeof http.ServerResponse,
+    > extends tls.Server {
+        constructor(requestListener?: http.RequestListener<Request, Response>);
+        constructor(
+            options: ServerOptions<Request, Response>,
+            requestListener?: http.RequestListener<Request, Response>,
+        );
+        /**
+         * Closes all connections connected to this server.
+         * @since v18.2.0
+         */
+        closeAllConnections(): void;
+        /**
+         * Closes all connections connected to this server which are not sending a request or waiting for a response.
+         * @since v18.2.0
+         */
+        closeIdleConnections(): void;
         addListener(event: string, listener: (...args: any[]) => void): this;
         addListener(event: 'keylog', listener: (line: Buffer, tlsSocket: tls.TLSSocket) => void): this;
         addListener(event: 'newSession', listener: (sessionId: Buffer, sessionData: Buffer, callback: (err: Error, resp: Buffer) => void) => void): this;
@@ -45,12 +68,12 @@ declare module 'https' {
         addListener(event: 'connection', listener: (socket: Duplex) => void): this;
         addListener(event: 'error', listener: (err: Error) => void): this;
         addListener(event: 'listening', listener: () => void): this;
-        addListener(event: 'checkContinue', listener: http.RequestListener): this;
-        addListener(event: 'checkExpectation', listener: http.RequestListener): this;
+        addListener(event: 'checkContinue', listener: http.RequestListener<Request, Response>): this;
+        addListener(event: 'checkExpectation', listener: http.RequestListener<Request, Response>): this;
         addListener(event: 'clientError', listener: (err: Error, socket: Duplex) => void): this;
-        addListener(event: 'connect', listener: (req: http.IncomingMessage, socket: Duplex, head: Buffer) => void): this;
-        addListener(event: 'request', listener: http.RequestListener): this;
-        addListener(event: 'upgrade', listener: (req: http.IncomingMessage, socket: Duplex, head: Buffer) => void): this;
+        addListener(event: 'connect', listener: (req: InstanceType<Request>, socket: Duplex, head: Buffer) => void): this;
+        addListener(event: 'request', listener: http.RequestListener<Request, Response>): this;
+        addListener(event: 'upgrade', listener: (req: InstanceType<Request>, socket: Duplex, head: Buffer) => void): this;
         emit(event: string, ...args: any[]): boolean;
         emit(event: 'keylog', line: Buffer, tlsSocket: tls.TLSSocket): boolean;
         emit(event: 'newSession', sessionId: Buffer, sessionData: Buffer, callback: (err: Error, resp: Buffer) => void): boolean;
@@ -62,12 +85,30 @@ declare module 'https' {
         emit(event: 'connection', socket: Duplex): boolean;
         emit(event: 'error', err: Error): boolean;
         emit(event: 'listening'): boolean;
-        emit(event: 'checkContinue', req: http.IncomingMessage, res: http.ServerResponse): boolean;
-        emit(event: 'checkExpectation', req: http.IncomingMessage, res: http.ServerResponse): 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: Duplex): boolean;
-        emit(event: 'connect', req: http.IncomingMessage, socket: Duplex, head: Buffer): boolean;
-        emit(event: 'request', req: http.IncomingMessage, res: http.ServerResponse): boolean;
-        emit(event: 'upgrade', req: http.IncomingMessage, socket: Duplex, head: Buffer): boolean;
+        emit(event: 'connect', req: InstanceType<Request>, socket: Duplex, head: Buffer): boolean;
+        emit(
+            event: 'request',
+            req: InstanceType<Request>,
+            res: InstanceType<Response> & {
+                req: InstanceType<Request>;
+            }
+        ): boolean;
+        emit(event: 'upgrade', req: InstanceType<Request>, socket: Duplex, head: Buffer): boolean;
         on(event: string, listener: (...args: any[]) => void): this;
         on(event: 'keylog', listener: (line: Buffer, tlsSocket: tls.TLSSocket) => void): this;
         on(event: 'newSession', listener: (sessionId: Buffer, sessionData: Buffer, callback: (err: Error, resp: Buffer) => void) => void): this;
@@ -79,12 +120,12 @@ declare module 'https' {
         on(event: 'connection', listener: (socket: Duplex) => void): this;
         on(event: 'error', listener: (err: Error) => void): this;
         on(event: 'listening', listener: () => void): this;
-        on(event: 'checkContinue', listener: http.RequestListener): this;
-        on(event: 'checkExpectation', listener: http.RequestListener): this;
+        on(event: 'checkContinue', listener: http.RequestListener<Request, Response>): this;
+        on(event: 'checkExpectation', listener: http.RequestListener<Request, Response>): this;
         on(event: 'clientError', listener: (err: Error, socket: Duplex) => void): this;
-        on(event: 'connect', listener: (req: http.IncomingMessage, socket: Duplex, head: Buffer) => void): this;
-        on(event: 'request', listener: http.RequestListener): this;
-        on(event: 'upgrade', listener: (req: http.IncomingMessage, socket: Duplex, head: Buffer) => void): this;
+        on(event: 'connect', listener: (req: InstanceType<Request>, socket: Duplex, head: Buffer) => void): this;
+        on(event: 'request', listener: http.RequestListener<Request, Response>): this;
+        on(event: 'upgrade', listener: (req: InstanceType<Request>, socket: Duplex, head: Buffer) => void): this;
         once(event: string, listener: (...args: any[]) => void): this;
         once(event: 'keylog', listener: (line: Buffer, tlsSocket: tls.TLSSocket) => void): this;
         once(event: 'newSession', listener: (sessionId: Buffer, sessionData: Buffer, callback: (err: Error, resp: Buffer) => void) => void): this;
@@ -96,12 +137,12 @@ declare module 'https' {
         once(event: 'connection', listener: (socket: Duplex) => void): this;
         once(event: 'error', listener: (err: Error) => void): this;
         once(event: 'listening', listener: () => void): this;
-        once(event: 'checkContinue', listener: http.RequestListener): this;
-        once(event: 'checkExpectation', listener: http.RequestListener): this;
+        once(event: 'checkContinue', listener: http.RequestListener<Request, Response>): this;
+        once(event: 'checkExpectation', listener: http.RequestListener<Request, Response>): this;
         once(event: 'clientError', listener: (err: Error, socket: Duplex) => void): this;
-        once(event: 'connect', listener: (req: http.IncomingMessage, socket: Duplex, head: Buffer) => void): this;
-        once(event: 'request', listener: http.RequestListener): this;
-        once(event: 'upgrade', listener: (req: http.IncomingMessage, socket: Duplex, head: Buffer) => void): this;
+        once(event: 'connect', listener: (req: InstanceType<Request>, socket: Duplex, head: Buffer) => void): this;
+        once(event: 'request', listener: http.RequestListener<Request, Response>): this;
+        once(event: 'upgrade', listener: (req: InstanceType<Request>, socket: Duplex, head: Buffer) => void): this;
         prependListener(event: string, listener: (...args: any[]) => void): this;
         prependListener(event: 'keylog', listener: (line: Buffer, tlsSocket: tls.TLSSocket) => void): this;
         prependListener(event: 'newSession', listener: (sessionId: Buffer, sessionData: Buffer, callback: (err: Error, resp: Buffer) => void) => void): this;
@@ -113,12 +154,12 @@ declare module 'https' {
         prependListener(event: 'connection', listener: (socket: Duplex) => void): this;
         prependListener(event: 'error', listener: (err: Error) => void): this;
         prependListener(event: 'listening', listener: () => void): this;
-        prependListener(event: 'checkContinue', listener: http.RequestListener): this;
-        prependListener(event: 'checkExpectation', listener: http.RequestListener): this;
+        prependListener(event: 'checkContinue', listener: http.RequestListener<Request, Response>): this;
+        prependListener(event: 'checkExpectation', listener: http.RequestListener<Request, Response>): this;
         prependListener(event: 'clientError', listener: (err: Error, socket: Duplex) => void): this;
-        prependListener(event: 'connect', listener: (req: http.IncomingMessage, socket: Duplex, head: Buffer) => void): this;
-        prependListener(event: 'request', listener: http.RequestListener): this;
-        prependListener(event: 'upgrade', listener: (req: http.IncomingMessage, socket: Duplex, head: Buffer) => void): this;
+        prependListener(event: 'connect', listener: (req: InstanceType<Request>, socket: Duplex, head: Buffer) => void): this;
+        prependListener(event: 'request', listener: http.RequestListener<Request, Response>): this;
+        prependListener(event: 'upgrade', listener: (req: InstanceType<Request>, socket: Duplex, head: Buffer) => void): this;
         prependOnceListener(event: string, listener: (...args: any[]) => void): this;
         prependOnceListener(event: 'keylog', listener: (line: Buffer, tlsSocket: tls.TLSSocket) => void): this;
         prependOnceListener(event: 'newSession', listener: (sessionId: Buffer, sessionData: Buffer, callback: (err: Error, resp: Buffer) => void) => void): this;
@@ -130,22 +171,22 @@ declare module 'https' {
         prependOnceListener(event: 'connection', listener: (socket: Duplex) => void): this;
         prependOnceListener(event: 'error', listener: (err: Error) => void): this;
         prependOnceListener(event: 'listening', listener: () => void): this;
-        prependOnceListener(event: 'checkContinue', listener: http.RequestListener): this;
-        prependOnceListener(event: 'checkExpectation', listener: http.RequestListener): this;
+        prependOnceListener(event: 'checkContinue', listener: http.RequestListener<Request, Response>): this;
+        prependOnceListener(event: 'checkExpectation', listener: http.RequestListener<Request, Response>): this;
         prependOnceListener(event: 'clientError', listener: (err: Error, socket: Duplex) => void): this;
-        prependOnceListener(event: 'connect', listener: (req: http.IncomingMessage, socket: Duplex, head: Buffer) => void): this;
-        prependOnceListener(event: 'request', listener: http.RequestListener): this;
-        prependOnceListener(event: 'upgrade', listener: (req: http.IncomingMessage, socket: Duplex, head: Buffer) => void): this;
+        prependOnceListener(event: 'connect', listener: (req: InstanceType<Request>, socket: Duplex, head: Buffer) => void): this;
+        prependOnceListener(event: 'request', listener: http.RequestListener<Request, Response>): this;
+        prependOnceListener(event: 'upgrade', listener: (req: InstanceType<Request>, socket: Duplex, head: Buffer) => void): this;
     }
     /**
      * ```js
      * // curl -k https://localhost:8000/
-     * const https = require('https');
-     * const fs = require('fs');
+     * const https = require('node:https');
+     * const fs = require('node:fs');
      *
      * const options = {
      *   key: fs.readFileSync('test/fixtures/keys/agent2-key.pem'),
-     *   cert: fs.readFileSync('test/fixtures/keys/agent2-cert.pem')
+     *   cert: fs.readFileSync('test/fixtures/keys/agent2-cert.pem'),
      * };
      *
      * https.createServer(options, (req, res) => {
@@ -157,12 +198,12 @@ declare module 'https' {
      * Or
      *
      * ```js
-     * const https = require('https');
-     * const fs = require('fs');
+     * const https = require('node:https');
+     * const fs = require('node:fs');
      *
      * const options = {
      *   pfx: fs.readFileSync('test/fixtures/test_cert.pfx'),
-     *   passphrase: 'sample'
+     *   passphrase: 'sample',
      * };
      *
      * https.createServer(options, (req, res) => {
@@ -174,8 +215,17 @@ declare module 'https' {
      * @param options Accepts `options` from `createServer`, `createSecureContext` and `createServer`.
      * @param requestListener A listener to be added to the `'request'` event.
      */
-    function createServer(requestListener?: http.RequestListener): Server;
-    function createServer(options: ServerOptions, requestListener?: http.RequestListener): Server;
+    function createServer<
+        Request extends typeof http.IncomingMessage = typeof http.IncomingMessage,
+        Response extends typeof http.ServerResponse = typeof http.ServerResponse,
+    >(requestListener?: http.RequestListener<Request, Response>): Server<Request, Response>;
+    function createServer<
+        Request extends typeof http.IncomingMessage = typeof http.IncomingMessage,
+        Response extends typeof http.ServerResponse = typeof http.ServerResponse,
+    >(
+        options: ServerOptions<Request, Response>,
+        requestListener?: http.RequestListener<Request, Response>,
+    ): Server<Request, Response>;
     /**
      * Makes a request to a secure web server.
      *
@@ -189,13 +239,13 @@ declare module 'https' {
      * upload a file with a POST request, then write to the `ClientRequest` object.
      *
      * ```js
-     * const https = require('https');
+     * const https = require('node:https');
      *
      * const options = {
      *   hostname: 'encrypted.google.com',
      *   port: 443,
      *   path: '/',
-     *   method: 'GET'
+     *   method: 'GET',
      * };
      *
      * const req = https.request(options, (res) => {
@@ -222,7 +272,7 @@ declare module 'https' {
      *   path: '/',
      *   method: 'GET',
      *   key: fs.readFileSync('test/fixtures/keys/agent2-key.pem'),
-     *   cert: fs.readFileSync('test/fixtures/keys/agent2-cert.pem')
+     *   cert: fs.readFileSync('test/fixtures/keys/agent2-cert.pem'),
      * };
      * options.agent = new https.Agent(options);
      *
@@ -241,7 +291,7 @@ declare module 'https' {
      *   method: 'GET',
      *   key: fs.readFileSync('test/fixtures/keys/agent2-key.pem'),
      *   cert: fs.readFileSync('test/fixtures/keys/agent2-cert.pem'),
-     *   agent: false
+     *   agent: false,
      * };
      *
      * const req = https.request(options, (res) => {
@@ -262,9 +312,9 @@ declare module 'https' {
      * Example pinning on certificate fingerprint, or the public key (similar to`pin-sha256`):
      *
      * ```js
-     * const tls = require('tls');
-     * const https = require('https');
-     * const crypto = require('crypto');
+     * const tls = require('node:tls');
+     * const https = require('node:https');
+     * const crypto = require('node:crypto');
      *
      * function sha256(s) {
      *   return crypto.createHash('sha256').update(s).digest('base64');
@@ -281,7 +331,7 @@ declare module 'https' {
      *       return err;
      *     }
      *
-     *     // Pin the public key, similar to HPKP pin-sha25 pinning
+     *     // Pin the public key, similar to HPKP pin-sha256 pinning
      *     const pubkey256 = 'pL1+qb9HTMRZJmuC/bB/ZI9d302BYrrqiVuRyW+DGrU=';
      *     if (sha256(cert.pubkey) !== pubkey256) {
      *       const msg = 'Certificate verification error: ' +
@@ -365,7 +415,7 @@ declare module 'https' {
      * string, it is automatically parsed with `new URL()`. If it is a `URL` object, it will be automatically converted to an ordinary `options` object.
      *
      * ```js
-     * const https = require('https');
+     * const https = require('node:https');
      *
      * https.get('https://encrypted.google.com/', (res) => {
      *   console.log('statusCode:', res.statusCode);