@types/node 18.16.0 → 18.16.2

node/README.md

@@ -8,7 +8,7 @@ This package contains type definitions for Node.js (https://nodejs.org/).
 Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/node.
 
 ### Additional Details
- * Last updated: Sun, 23 Apr 2023 05:02:41 GMT
+ * Last updated: Thu, 27 Apr 2023 21:32:47 GMT
  * Dependencies: none
  * Global values: `AbortController`, `AbortSignal`, `__dirname`, `__filename`, `console`, `exports`, `gc`, `global`, `module`, `process`, `require`, `structuredClone`
 

node/globals.d.ts

@@ -159,7 +159,7 @@ declare namespace NodeJS {
         /**
          * Name of the script [if this function was defined in a script]
          */
-        getFileName(): string | null;
+        getFileName(): string | undefined;
 
         /**
          * Current line number [if this function was defined in a script]

node/http.d.ts

@@ -345,6 +345,7 @@ declare module 'http' {
             event: 'connect',
             listener: (req: InstanceType<Request>, socket: stream.Duplex, head: Buffer) => 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',
@@ -367,6 +368,7 @@ declare module 'http' {
         ): boolean;
         emit(event: 'clientError', err: Error, socket: stream.Duplex): boolean;
         emit(event: 'connect', req: InstanceType<Request>, socket: stream.Duplex, head: Buffer): boolean;
+        emit(event: 'dropRequest', req: InstanceType<Request>, socket: stream.Duplex): boolean;
         emit(
             event: 'request',
             req: InstanceType<Request>,
@@ -382,6 +384,7 @@ declare module 'http' {
         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: Buffer) => 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: Buffer) => void): this;
         once(event: string, listener: (...args: any[]) => void): this;
@@ -396,6 +399,7 @@ declare module 'http' {
             event: 'connect',
             listener: (req: InstanceType<Request>, socket: stream.Duplex, head: Buffer) => 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',
@@ -413,6 +417,10 @@ declare module 'http' {
             event: 'connect',
             listener: (req: InstanceType<Request>, socket: stream.Duplex, head: Buffer) => void,
         ): this;
+        prependListener(
+            event: 'dropRequest',
+            listener: (req: InstanceType<Request>, socket: stream.Duplex) => void,
+        ): this;
         prependListener(event: 'request', listener: RequestListener<Request, Response>): this;
         prependListener(
             event: 'upgrade',
@@ -430,6 +438,10 @@ declare module 'http' {
             event: 'connect',
             listener: (req: InstanceType<Request>, socket: stream.Duplex, head: Buffer) => 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',
@@ -479,11 +491,26 @@ declare module 'http' {
         setTimeout(msecs: number, callback?: () => void): this;
         /**
          * Sets a single header value for the header object.
+         * If the header already exists in the to-be-sent headers, its value will be replaced. Use an array of strings to send multiple headers with the same name.
          * @since v0.4.0
          * @param name Header name
          * @param value Header value
          */
         setHeader(name: string, value: number | string | ReadonlyArray<string>): this;
+        /**
+         * Append a single header value for the header object.
+         *
+         * If the value is an array, this is equivalent of calling this method multiple times.
+         *
+         * If there were no previous value for the header, this is equivalent of calling `outgoingMessage.setHeader(name, value)`.
+         *
+         * Depending of the value of `options.uniqueHeaders` when the client request or the server were created,
+         * this will end up in the header being sent multiple times or a single time with values joined using `; `.
+         * @since v18.3.0, v16.17.0
+         * @param name Header name
+         * @param value Header value
+         */
+        appendHeader(name: string, value: string | ReadonlyArray<string>): this;
         /**
          * Gets the value of HTTP header with the given name. If such a name doesn't
          * exist in message, it will be `undefined`.
@@ -610,6 +637,14 @@ declare module 'http' {
          * @since v0.11.8
          */
         statusMessage: string;
+        /**
+         * If set to `true`, Node.js will check whether the `Content-Length` header value
+         * and the size of the body, in bytes, are equal. Mismatching the
+         * `Content-Length` header value will result in an `Error` being thrown,
+         * identified by `code: 'ERR_HTTP_CONTENT_LENGTH_MISMATCH'`.
+         * @since v18.10.0, v16.18.0
+         */
+        strictContentLength: boolean;
         constructor(req: Request);
         assignSocket(socket: Socket): void;
         detachSocket(socket: Socket): void;
@@ -1090,6 +1125,20 @@ declare module 'http' {
          * @since v0.1.5
          */
         headers: IncomingHttpHeaders;
+        /**
+         * Similar to `message.headers`, but there is no join logic and the values are always arrays of strings, even for headers received just once.
+         *
+         * ```js
+         * // Prints something like:
+         * //
+         * // { 'user-agent': ['curl/7.22.0'],
+         * //   host: ['127.0.0.1:8000'],
+         * //   accept: ['*'] }
+         * console.log(request.headersDistinct);
+         * ```
+         * @since v18.3.0, v16.17.0
+         */
+        headersDistinct: NodeJS.Dict<string[]>;
         /**
          * The raw request/response headers list exactly as they were received.
          *
@@ -1120,6 +1169,12 @@ declare module 'http' {
          * @since v0.3.0
          */
         trailers: NodeJS.Dict<string>;
+        /**
+         * Similar to `message.trailers`, but there is no join logic and the values are always arrays of strings, even for headers received just once.
+         * Only populated at the `'end'` event.
+         * @since v18.3.0, v16.17.0
+         */
+        trailersDistinct: NodeJS.Dict<string[]>;
         /**
          * The raw request/response trailer keys and values exactly as they were
          * received. Only populated at the `'end'` event.

node/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@types/node",
-    "version": "18.16.0",
+    "version": "18.16.2",
     "description": "TypeScript definitions for Node.js",
     "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/node",
     "license": "MIT",
@@ -232,6 +232,6 @@
     },
     "scripts": {},
     "dependencies": {},
-    "typesPublisherContentHash": "a33ada7d817296d3a0955f57b75fdf38201a158b99b66db3bb81316dfddd470b",
+    "typesPublisherContentHash": "4a9603f50e5b72ce1a4b35ed8eae48f4e9a4179f00f36f502b322e60c56733df",
     "typeScriptVersion": "4.3"
 }

node/ts4.8/v8.d.ts

@@ -441,6 +441,100 @@ declare module 'v8' {
         spaceAvailableSize: number;
         physicalSpaceSize: number;
     }
+    /**
+     * Called when a promise is constructed. This does not mean that corresponding before/after events will occur, only that the possibility exists. This will
+     * happen if a promise is created without ever getting a continuation.
+     * @since v17.1.0, v16.14.0
+     * @param promise The promise being created.
+     * @param parent The promise continued from, if applicable.
+     */
+    interface Init {
+        (promise: Promise<unknown>, parent: Promise<unknown>): void;
+    }
+    /**
+     * Called before a promise continuation executes. This can be in the form of `then()`, `catch()`, or `finally()` handlers or an await resuming.
+     *
+     * The before callback will be called 0 to N times. The before callback will typically be called 0 times if no continuation was ever made for the promise.
+     * The before callback may be called many times in the case where many continuations have been made from the same promise.
+     * @since v17.1.0, v16.14.0
+     */
+    interface Before {
+        (promise: Promise<unknown>): void;
+    }
+    /**
+     * Called immediately after a promise continuation executes. This may be after a `then()`, `catch()`, or `finally()` handler or before an await after another await.
+     * @since v17.1.0, v16.14.0
+     */
+    interface After {
+        (promise: Promise<unknown>): void;
+    }
+    /**
+     * Called when the promise receives a resolution or rejection value. This may occur synchronously in the case of {@link Promise.resolve()} or
+     * {@link Promise.reject()}.
+     * @since v17.1.0, v16.14.0
+     */
+    interface Settled {
+        (promise: Promise<unknown>): void;
+    }
+    /**
+     * Key events in the lifetime of a promise have been categorized into four areas: creation of a promise, before/after a continuation handler is called or
+     * around an await, and when the promise resolves or rejects.
+     *
+     * Because promises are asynchronous resources whose lifecycle is tracked via the promise hooks mechanism, the `init()`, `before()`, `after()`, and
+     * `settled()` callbacks must not be async functions as they create more promises which would produce an infinite loop.
+     * @since v17.1.0, v16.14.0
+     */
+    interface HookCallbacks {
+        init?: Init;
+        before?: Before;
+        after?: After;
+        settled?: Settled;
+    }
+    interface PromiseHooks {
+        /**
+         * The `init` hook must be a plain function. Providing an async function will throw as it would produce an infinite microtask loop.
+         * @since v17.1.0, v16.14.0
+         * @param init The {@link Init | `init` callback} to call when a promise is created.
+         * @return Call to stop the hook.
+         */
+        onInit: (init: Init) => Function;
+        /**
+         * The `settled` hook must be a plain function. Providing an async function will throw as it would produce an infinite microtask loop.
+         * @since v17.1.0, v16.14.0
+         * @param settled The {@link Settled | `settled` callback} to call when a promise is created.
+         * @return Call to stop the hook.
+         */
+        onSettled: (settled: Settled) => Function;
+        /**
+         * The `before` hook must be a plain function. Providing an async function will throw as it would produce an infinite microtask loop.
+         * @since v17.1.0, v16.14.0
+         * @param before The {@link Before | `before` callback} to call before a promise continuation executes.
+         * @return Call to stop the hook.
+         */
+        onBefore: (before: Before) => Function;
+        /**
+         * The `after` hook must be a plain function. Providing an async function will throw as it would produce an infinite microtask loop.
+         * @since v17.1.0, v16.14.0
+         * @param after The {@link After | `after` callback} to call after a promise continuation executes.
+         * @return Call to stop the hook.
+         */
+        onAfter: (after: After) => Function;
+        /**
+         * Registers functions to be called for different lifetime events of each promise.
+         * The callbacks `init()`/`before()`/`after()`/`settled()` are called for the respective events during a promise's lifetime.
+         * All callbacks are optional. For example, if only promise creation needs to be tracked, then only the init callback needs to be passed.
+         * The hook callbacks must be plain functions. Providing async functions will throw as it would produce an infinite microtask loop.
+         * @since v17.1.0, v16.14.0
+         * @param callbacks The {@link HookCallbacks | Hook Callbacks} to register
+         * @return Used for disabling hooks
+         */
+        createHook: (callbacks: HookCallbacks) => Function;
+    }
+    /**
+     * The `promiseHooks` interface can be used to track promise lifecycle events.
+     * @since v17.1.0, v16.14.0
+     */
+    const promiseHooks: PromiseHooks;
 }
 declare module 'node:v8' {
     export * from 'v8';

node/v8.d.ts

@@ -441,6 +441,100 @@ declare module 'v8' {
         spaceAvailableSize: number;
         physicalSpaceSize: number;
     }
+    /**
+     * Called when a promise is constructed. This does not mean that corresponding before/after events will occur, only that the possibility exists. This will
+     * happen if a promise is created without ever getting a continuation.
+     * @since v17.1.0, v16.14.0
+     * @param promise The promise being created.
+     * @param parent The promise continued from, if applicable.
+     */
+    interface Init {
+        (promise: Promise<unknown>, parent: Promise<unknown>): void;
+    }
+    /**
+     * Called before a promise continuation executes. This can be in the form of `then()`, `catch()`, or `finally()` handlers or an await resuming.
+     *
+     * The before callback will be called 0 to N times. The before callback will typically be called 0 times if no continuation was ever made for the promise.
+     * The before callback may be called many times in the case where many continuations have been made from the same promise.
+     * @since v17.1.0, v16.14.0
+     */
+    interface Before {
+        (promise: Promise<unknown>): void;
+    }
+    /**
+     * Called immediately after a promise continuation executes. This may be after a `then()`, `catch()`, or `finally()` handler or before an await after another await.
+     * @since v17.1.0, v16.14.0
+     */
+    interface After {
+        (promise: Promise<unknown>): void;
+    }
+    /**
+     * Called when the promise receives a resolution or rejection value. This may occur synchronously in the case of {@link Promise.resolve()} or
+     * {@link Promise.reject()}.
+     * @since v17.1.0, v16.14.0
+     */
+    interface Settled {
+        (promise: Promise<unknown>): void;
+    }
+    /**
+     * Key events in the lifetime of a promise have been categorized into four areas: creation of a promise, before/after a continuation handler is called or
+     * around an await, and when the promise resolves or rejects.
+     *
+     * Because promises are asynchronous resources whose lifecycle is tracked via the promise hooks mechanism, the `init()`, `before()`, `after()`, and
+     * `settled()` callbacks must not be async functions as they create more promises which would produce an infinite loop.
+     * @since v17.1.0, v16.14.0
+     */
+    interface HookCallbacks {
+        init?: Init;
+        before?: Before;
+        after?: After;
+        settled?: Settled;
+    }
+    interface PromiseHooks {
+        /**
+         * The `init` hook must be a plain function. Providing an async function will throw as it would produce an infinite microtask loop.
+         * @since v17.1.0, v16.14.0
+         * @param init The {@link Init | `init` callback} to call when a promise is created.
+         * @return Call to stop the hook.
+         */
+        onInit: (init: Init) => Function;
+        /**
+         * The `settled` hook must be a plain function. Providing an async function will throw as it would produce an infinite microtask loop.
+         * @since v17.1.0, v16.14.0
+         * @param settled The {@link Settled | `settled` callback} to call when a promise is created.
+         * @return Call to stop the hook.
+         */
+        onSettled: (settled: Settled) => Function;
+        /**
+         * The `before` hook must be a plain function. Providing an async function will throw as it would produce an infinite microtask loop.
+         * @since v17.1.0, v16.14.0
+         * @param before The {@link Before | `before` callback} to call before a promise continuation executes.
+         * @return Call to stop the hook.
+         */
+        onBefore: (before: Before) => Function;
+        /**
+         * The `after` hook must be a plain function. Providing an async function will throw as it would produce an infinite microtask loop.
+         * @since v17.1.0, v16.14.0
+         * @param after The {@link After | `after` callback} to call after a promise continuation executes.
+         * @return Call to stop the hook.
+         */
+        onAfter: (after: After) => Function;
+        /**
+         * Registers functions to be called for different lifetime events of each promise.
+         * The callbacks `init()`/`before()`/`after()`/`settled()` are called for the respective events during a promise's lifetime.
+         * All callbacks are optional. For example, if only promise creation needs to be tracked, then only the init callback needs to be passed.
+         * The hook callbacks must be plain functions. Providing async functions will throw as it would produce an infinite microtask loop.
+         * @since v17.1.0, v16.14.0
+         * @param callbacks The {@link HookCallbacks | Hook Callbacks} to register
+         * @return Used for disabling hooks
+         */
+        createHook: (callbacks: HookCallbacks) => Function;
+    }
+    /**
+     * The `promiseHooks` interface can be used to track promise lifecycle events.
+     * @since v17.1.0, v16.14.0
+     */
+    const promiseHooks: PromiseHooks;
 }
 declare module 'node:v8' {
     export * from 'v8';