@types/node 18.19.47 → 18.19.49

node v18.19/https.d.ts

@@ -10,7 +10,9 @@ declare module "https" {
     import { URL } from "node:url";
     type ServerOptions<
         Request extends typeof http.IncomingMessage = typeof http.IncomingMessage,
-        Response extends typeof http.ServerResponse = typeof http.ServerResponse,
+        Response extends typeof http.ServerResponse<InstanceType<Request>> = typeof http.ServerResponse<
+            InstanceType<Request>
+        >,
     > = tls.SecureContextOptions & tls.TlsOptions & http.ServerOptions<Request, Response>;
     type RequestOptions =
         & http.RequestOptions
@@ -34,7 +36,9 @@ declare module "https" {
     }
     interface Server<
         Request extends typeof http.IncomingMessage = typeof http.IncomingMessage,
-        Response extends typeof http.ServerResponse = typeof http.ServerResponse,
+        Response extends typeof http.ServerResponse<InstanceType<Request>> = typeof http.ServerResponse<
+            InstanceType<Request>
+        >,
     > extends http.Server<Request, Response> {}
     /**
      * See `http.Server` for more information.
@@ -42,7 +46,9 @@ declare module "https" {
      */
     class Server<
         Request extends typeof http.IncomingMessage = typeof http.IncomingMessage,
-        Response extends typeof http.ServerResponse = typeof http.ServerResponse,
+        Response extends typeof http.ServerResponse<InstanceType<Request>> = typeof http.ServerResponse<
+            InstanceType<Request>
+        >,
     > extends tls.Server {
         constructor(requestListener?: http.RequestListener<Request, Response>);
         constructor(
@@ -119,19 +125,19 @@ declare module "https" {
         emit(
             event: "checkContinue",
             req: InstanceType<Request>,
-            res: InstanceType<Response> & { req: InstanceType<Request> },
+            res: InstanceType<Response>,
         ): boolean;
         emit(
             event: "checkExpectation",
             req: InstanceType<Request>,
-            res: InstanceType<Response> & { req: InstanceType<Request> },
+            res: InstanceType<Response>,
         ): boolean;
         emit(event: "clientError", err: Error, socket: Duplex): boolean;
         emit(event: "connect", req: InstanceType<Request>, socket: Duplex, head: Buffer): boolean;
         emit(
             event: "request",
             req: InstanceType<Request>,
-            res: InstanceType<Response> & { req: InstanceType<Request> },
+            res: InstanceType<Response>,
         ): boolean;
         emit(event: "upgrade", req: InstanceType<Request>, socket: Duplex, head: Buffer): boolean;
         on(event: string, listener: (...args: any[]) => void): this;
@@ -306,11 +312,15 @@ declare module "https" {
      */
     function createServer<
         Request extends typeof http.IncomingMessage = typeof http.IncomingMessage,
-        Response extends typeof http.ServerResponse = typeof http.ServerResponse,
+        Response extends typeof http.ServerResponse<InstanceType<Request>> = typeof http.ServerResponse<
+            InstanceType<Request>
+        >,
     >(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,
+        Response extends typeof http.ServerResponse<InstanceType<Request>> = typeof http.ServerResponse<
+            InstanceType<Request>
+        >,
     >(
         options: ServerOptions<Request, Response>,
         requestListener?: http.RequestListener<Request, Response>,

node v18.19/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@types/node",
-    "version": "18.19.47",
+    "version": "18.19.49",
     "description": "TypeScript definitions for node",
     "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/node",
     "license": "MIT",
@@ -217,6 +217,6 @@
     "dependencies": {
         "undici-types": "~5.26.4"
     },
-    "typesPublisherContentHash": "d1f247a2b67ea5d8676a67452a9d6d88919b6c5938bf06bf1e6f689cf3b02713",
+    "typesPublisherContentHash": "24d0a779b9e50f4a93468e6f68fe1dd999036f683818b114d727cd86ee1d0391",
     "typeScriptVersion": "4.8"
 }

node v18.19/stream/web.d.ts

@@ -1,3 +1,38 @@
+type _ByteLengthQueuingStrategy = typeof globalThis extends { onmessage: any } ? {}
+    : import("stream/web").ByteLengthQueuingStrategy;
+type _CompressionStream = typeof globalThis extends { onmessage: any; ReportingObserver: any } ? {}
+    : import("stream/web").CompressionStream;
+type _CountQueuingStrategy = typeof globalThis extends { onmessage: any } ? {}
+    : import("stream/web").CountQueuingStrategy;
+type _DecompressionStream = typeof globalThis extends { onmessage: any; ReportingObserver: any } ? {}
+    : import("stream/web").DecompressionStream;
+type _ReadableByteStreamController = typeof globalThis extends { onmessage: any } ? {}
+    : import("stream/web").ReadableByteStreamController;
+type _ReadableStream<R = any> = typeof globalThis extends { onmessage: any } ? {}
+    : import("stream/web").ReadableStream<R>;
+type _ReadableStreamBYOBReader = typeof globalThis extends { onmessage: any } ? {}
+    : import("stream/web").ReadableStreamBYOBReader;
+type _ReadableStreamBYOBRequest = typeof globalThis extends { onmessage: any } ? {}
+    : import("stream/web").ReadableStreamBYOBRequest;
+type _ReadableStreamDefaultController<R = any> = typeof globalThis extends { onmessage: any } ? {}
+    : import("stream/web").ReadableStreamDefaultController<R>;
+type _ReadableStreamDefaultReader<R = any> = typeof globalThis extends { onmessage: any } ? {}
+    : import("stream/web").ReadableStreamDefaultReader<R>;
+type _TextDecoderStream = typeof globalThis extends { onmessage: any } ? {}
+    : import("stream/web").TextDecoderStream;
+type _TextEncoderStream = typeof globalThis extends { onmessage: any } ? {}
+    : import("stream/web").TextEncoderStream;
+type _TransformStream<I = any, O = any> = typeof globalThis extends { onmessage: any } ? {}
+    : import("stream/web").TransformStream<I, O>;
+type _TransformStreamDefaultController<O = any> = typeof globalThis extends { onmessage: any } ? {}
+    : import("stream/web").TransformStreamDefaultController<O>;
+type _WritableStream<W = any> = typeof globalThis extends { onmessage: any } ? {}
+    : import("stream/web").WritableStream<W>;
+type _WritableStreamDefaultController = typeof globalThis extends { onmessage: any } ? {}
+    : import("stream/web").WritableStreamDefaultController;
+type _WritableStreamDefaultWriter<W = any> = typeof globalThis extends { onmessage: any } ? {}
+    : import("stream/web").WritableStreamDefaultWriter<W>;
+
 declare module "stream/web" {
     // stub module, pending copy&paste from .d.ts or manual impl
     // copy from lib.dom.d.ts
@@ -65,18 +100,16 @@ declare module "stream/web" {
         readonly closed: Promise<undefined>;
         cancel(reason?: any): Promise<void>;
     }
-    interface ReadableStreamDefaultReadValueResult<T> {
+    type ReadableStreamController<T> = ReadableStreamDefaultController<T>;
+    interface ReadableStreamReadValueResult<T> {
         done: false;
         value: T;
     }
-    interface ReadableStreamDefaultReadDoneResult {
+    interface ReadableStreamReadDoneResult<T> {
         done: true;
-        value?: undefined;
+        value?: T;
     }
-    type ReadableStreamController<T> = ReadableStreamDefaultController<T>;
-    type ReadableStreamDefaultReadResult<T> =
-        | ReadableStreamDefaultReadValueResult<T>
-        | ReadableStreamDefaultReadDoneResult;
+    type ReadableStreamReadResult<T> = ReadableStreamReadValueResult<T> | ReadableStreamReadDoneResult<T>;
     interface ReadableByteStreamControllerCallback {
         (controller: ReadableByteStreamController): void | PromiseLike<void>;
     }
@@ -137,7 +170,9 @@ declare module "stream/web" {
     interface ReadableStream<R = any> {
         readonly locked: boolean;
         cancel(reason?: any): Promise<void>;
+        getReader(options: { mode: "byob" }): ReadableStreamBYOBReader;
         getReader(): ReadableStreamDefaultReader<R>;
+        getReader(options?: ReadableStreamGetReaderOptions): ReadableStreamReader<R>;
         pipeThrough<T>(transform: ReadableWritablePair<T, R>, options?: StreamPipeOptions): ReadableStream<T>;
         pipeTo(destination: WritableStream<R>, options?: StreamPipeOptions): Promise<void>;
         tee(): [ReadableStream<R>, ReadableStream<R>];
@@ -149,16 +184,48 @@ declare module "stream/web" {
         new(underlyingSource: UnderlyingByteSource, strategy?: QueuingStrategy<Uint8Array>): ReadableStream<Uint8Array>;
         new<R = any>(underlyingSource?: UnderlyingSource<R>, strategy?: QueuingStrategy<R>): ReadableStream<R>;
     };
+    type ReadableStreamReaderMode = "byob";
+    interface ReadableStreamGetReaderOptions {
+        /**
+         * Creates a ReadableStreamBYOBReader and locks the stream to the new reader.
+         *
+         * This call behaves the same way as the no-argument variant, except that it only works on readable byte streams, i.e. streams which were constructed specifically with the ability to handle "bring your own buffer" reading. The returned BYOB reader provides the ability to directly read individual chunks from the stream via its read() method, into developer-supplied buffers, allowing more precise control over allocation.
+         */
+        mode?: ReadableStreamReaderMode;
+    }
+    type ReadableStreamReader<T> = ReadableStreamDefaultReader<T> | ReadableStreamBYOBReader;
     interface ReadableStreamDefaultReader<R = any> extends ReadableStreamGenericReader {
-        read(): Promise<ReadableStreamDefaultReadResult<R>>;
+        read(): Promise<ReadableStreamReadResult<R>>;
+        releaseLock(): void;
+    }
+    /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ReadableStreamBYOBReader) */
+    interface ReadableStreamBYOBReader extends ReadableStreamGenericReader {
+        /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ReadableStreamBYOBReader/read) */
+        read<T extends ArrayBufferView>(view: T): Promise<ReadableStreamReadResult<T>>;
+        /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ReadableStreamBYOBReader/releaseLock) */
         releaseLock(): void;
     }
     const ReadableStreamDefaultReader: {
         prototype: ReadableStreamDefaultReader;
         new<R = any>(stream: ReadableStream<R>): ReadableStreamDefaultReader<R>;
     };
-    const ReadableStreamBYOBReader: any;
-    const ReadableStreamBYOBRequest: any;
+    const ReadableStreamBYOBReader: {
+        prototype: ReadableStreamBYOBReader;
+        new(stream: ReadableStream): ReadableStreamBYOBReader;
+    };
+    /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ReadableStreamBYOBRequest) */
+    interface ReadableStreamBYOBRequest {
+        /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ReadableStreamBYOBRequest/view) */
+        readonly view: ArrayBufferView | null;
+        /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ReadableStreamBYOBRequest/respond) */
+        respond(bytesWritten: number): void;
+        /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ReadableStreamBYOBRequest/respondWithNewView) */
+        respondWithNewView(view: ArrayBufferView): void;
+    }
+    const ReadableStreamBYOBRequest: {
+        prototype: ReadableStreamBYOBRequest;
+        new(): ReadableStreamBYOBRequest;
+    };
     interface ReadableByteStreamController {
         readonly byobRequest: undefined;
         readonly desiredSize: number | null;
@@ -330,22 +397,123 @@ declare module "stream/web" {
         prototype: TextDecoderStream;
         new(encoding?: string, options?: TextDecoderOptions): TextDecoderStream;
     };
-    interface CompressionStream<R = any, W = any> {
-        readonly readable: ReadableStream<R>;
-        readonly writable: WritableStream<W>;
+    interface CompressionStream {
+        readonly readable: ReadableStream;
+        readonly writable: WritableStream;
     }
     const CompressionStream: {
         prototype: CompressionStream;
-        new<R = any, W = any>(format: string): CompressionStream<R, W>;
+        new(format: "deflate" | "deflate-raw" | "gzip"): CompressionStream;
     };
-    interface DecompressionStream<R = any, W = any> {
-        readonly readable: ReadableStream<R>;
-        readonly writable: WritableStream<W>;
+    interface DecompressionStream {
+        readonly writable: WritableStream;
+        readonly readable: ReadableStream;
     }
     const DecompressionStream: {
         prototype: DecompressionStream;
-        new<R = any, W = any>(format: string): DecompressionStream<R, W>;
+        new(format: "deflate" | "deflate-raw" | "gzip"): DecompressionStream;
     };
+
+    global {
+        interface ByteLengthQueuingStrategy extends _ByteLengthQueuingStrategy {}
+        var ByteLengthQueuingStrategy: typeof globalThis extends { onmessage: any; ByteLengthQueuingStrategy: infer T }
+            ? T
+            : typeof import("stream/web").ByteLengthQueuingStrategy;
+
+        interface CompressionStream extends _CompressionStream {}
+        var CompressionStream: typeof globalThis extends {
+            onmessage: any;
+            // CompressionStream, DecompressionStream and ReportingObserver was introduced in the same commit.
+            // If ReportingObserver check is removed, the type here will form a circular reference in TS5.0+lib.dom.d.ts
+            ReportingObserver: any;
+            CompressionStream: infer T;
+        } ? T
+            // TS 4.8, 4.9, 5.0
+            : typeof globalThis extends { onmessage: any; TransformStream: { prototype: infer T } } ? {
+                    prototype: T;
+                    new(format: "deflate" | "deflate-raw" | "gzip"): T;
+                }
+            : typeof import("stream/web").CompressionStream;
+
+        interface CountQueuingStrategy extends _CountQueuingStrategy {}
+        var CountQueuingStrategy: typeof globalThis extends { onmessage: any; CountQueuingStrategy: infer T } ? T
+            : typeof import("stream/web").CountQueuingStrategy;
+
+        interface DecompressionStream extends _DecompressionStream {}
+        var DecompressionStream: typeof globalThis extends {
+            onmessage: any;
+            // CompressionStream, DecompressionStream and ReportingObserver was introduced in the same commit.
+            // If ReportingObserver check is removed, the type here will form a circular reference in TS5.0+lib.dom.d.ts
+            ReportingObserver: any;
+            DecompressionStream: infer T;
+        } ? T
+            // TS 4.8, 4.9, 5.0
+            : typeof globalThis extends { onmessage: any; TransformStream: { prototype: infer T } } ? {
+                    prototype: T;
+                    new(format: "deflate" | "deflate-raw" | "gzip"): T;
+                }
+            : typeof import("stream/web").DecompressionStream;
+
+        interface ReadableByteStreamController extends _ReadableByteStreamController {}
+        var ReadableByteStreamController: typeof globalThis extends
+            { onmessage: any; ReadableByteStreamController: infer T } ? T
+            : typeof import("stream/web").ReadableByteStreamController;
+
+        interface ReadableStream<R = any> extends _ReadableStream<R> {}
+        var ReadableStream: typeof globalThis extends { onmessage: any; ReadableStream: infer T } ? T
+            : typeof import("stream/web").ReadableStream;
+
+        interface ReadableStreamBYOBReader extends _ReadableStreamBYOBReader {}
+        var ReadableStreamBYOBReader: typeof globalThis extends { onmessage: any; ReadableStreamBYOBReader: infer T }
+            ? T
+            : typeof import("stream/web").ReadableStreamBYOBReader;
+
+        interface ReadableStreamBYOBRequest extends _ReadableStreamBYOBRequest {}
+        var ReadableStreamBYOBRequest: typeof globalThis extends { onmessage: any; ReadableStreamBYOBRequest: infer T }
+            ? T
+            : typeof import("stream/web").ReadableStreamBYOBRequest;
+
+        interface ReadableStreamDefaultController<R = any> extends _ReadableStreamDefaultController<R> {}
+        var ReadableStreamDefaultController: typeof globalThis extends
+            { onmessage: any; ReadableStreamDefaultController: infer T } ? T
+            : typeof import("stream/web").ReadableStreamDefaultController;
+
+        interface ReadableStreamDefaultReader<R = any> extends _ReadableStreamDefaultReader<R> {}
+        var ReadableStreamDefaultReader: typeof globalThis extends
+            { onmessage: any; ReadableStreamDefaultReader: infer T } ? T
+            : typeof import("stream/web").ReadableStreamDefaultReader;
+
+        interface TextDecoderStream extends _TextDecoderStream {}
+        var TextDecoderStream: typeof globalThis extends { onmessage: any; TextDecoderStream: infer T } ? T
+            : typeof import("stream/web").TextDecoderStream;
+
+        interface TextEncoderStream extends _TextEncoderStream {}
+        var TextEncoderStream: typeof globalThis extends { onmessage: any; TextEncoderStream: infer T } ? T
+            : typeof import("stream/web").TextEncoderStream;
+
+        interface TransformStream<I = any, O = any> extends _TransformStream<I, O> {}
+        var TransformStream: typeof globalThis extends { onmessage: any; TransformStream: infer T } ? T
+            : typeof import("stream/web").TransformStream;
+
+        interface TransformStreamDefaultController<O = any> extends _TransformStreamDefaultController<O> {}
+        var TransformStreamDefaultController: typeof globalThis extends
+            { onmessage: any; TransformStreamDefaultController: infer T } ? T
+            : typeof import("stream/web").TransformStreamDefaultController;
+
+        interface WritableStream<W = any> extends _WritableStream<W> {}
+        var WritableStream: typeof globalThis extends { onmessage: any; WritableStream: infer T } ? T
+            : typeof import("stream/web").WritableStream;
+
+        interface WritableStreamDefaultController extends _WritableStreamDefaultController {}
+        var WritableStreamDefaultController: typeof globalThis extends
+            { onmessage: any; WritableStreamDefaultController: infer T } ? T
+            : typeof import("stream/web").WritableStreamDefaultController;
+
+        interface WritableStreamDefaultWriter<W = any> extends _WritableStreamDefaultWriter<W> {}
+        var WritableStreamDefaultWriter: typeof globalThis extends
+            { onmessage: any; WritableStreamDefaultWriter: infer T } ? T
+            : typeof import("stream/web").WritableStreamDefaultWriter;
+    }
 }
 declare module "node:stream/web" {
     export * from "stream/web";

node v18.19/test.d.ts

@@ -315,39 +315,39 @@ declare module "node:test" {
     export interface TestContext {
         /**
          * This function is used to create a hook running before subtest of the current test.
-         * @param fn The hook function. If the hook uses callbacks, the callback function is passed as
-         *    the second argument. Default: A no-op function.
+         * @param fn The hook function. The first argument to this function is a `TestContext` object.
+         *    If the hook uses callbacks, the callback function is passed as the second argument.
          * @param options Configuration options for the hook.
          * @since v18.17.0
          */
-        before: typeof before;
+        before(fn?: TestContextHookFn, options?: HookOptions): void;
 
         /**
          * This function is used to create a hook running before each subtest of the current test.
-         * @param fn The hook function. If the hook uses callbacks, the callback function is passed as
-         *    the second argument. Default: A no-op function.
+         * @param fn The hook function. The first argument to this function is a `TestContext` object.
+         *    If the hook uses callbacks, the callback function is passed as the second argument.
          * @param options Configuration options for the hook.
          * @since v18.8.0
          */
-        beforeEach: typeof beforeEach;
+        beforeEach(fn?: TestContextHookFn, options?: HookOptions): void;
 
         /**
          * This function is used to create a hook that runs after the current test finishes.
-         * @param fn The hook function. If the hook uses callbacks, the callback function is passed as
-         *    the second argument. Default: A no-op function.
+         * @param fn The hook function. The first argument to this function is a `TestContext` object.
+         *    If the hook uses callbacks, the callback function is passed as the second argument.
          * @param options Configuration options for the hook.
          * @since v18.13.0
          */
-        after: typeof after;
+        after(fn?: TestContextHookFn, options?: HookOptions): void;
 
         /**
          * This function is used to create a hook running after each subtest of the current test.
-         * @param fn The hook function. If the hook uses callbacks, the callback function is passed as
-         *    the second argument. Default: A no-op function.
+         * @param fn The hook function. The first argument to this function is a `TestContext` object.
+         *    If the hook uses callbacks, the callback function is passed as the second argument.
          * @param options Configuration options for the hook.
          * @since v18.8.0
          */
-        afterEach: typeof afterEach;
+        afterEach(fn?: TestContextHookFn, options?: HookOptions): void;
 
         /**
          * This function is used to write diagnostics to the output. Any diagnostic information is
@@ -517,10 +517,16 @@ declare module "node:test" {
     function afterEach(fn?: HookFn, options?: HookOptions): void;
 
     /**
-     * The hook function. If the hook uses callbacks, the callback function is passed as the
-     * second argument.
+     * The hook function. The first argument is the context in which the hook is called.
+     * If the hook uses callbacks, the callback function is passed as the second argument.
      */
-    type HookFn = (s: SuiteContext, done: (result?: any) => void) => any;
+    type HookFn = (c: TestContext | SuiteContext, done: (result?: any) => void) => any;
+
+    /**
+     * The hook function. The first argument is a `TestContext` object.
+     * If the hook uses callbacks, the callback function is passed as the second argument.
+     */
+    type TestContextHookFn = (t: TestContext, done: (result?: any) => void) => any;
 
     /**
      * Configuration options for hooks.