cloudstructs 0.9.13 → 0.9.15

package/node_modules/{undici-types → @types/cacheable-request/node_modules/undici-types}/fetch.d.ts

@@ -27,12 +27,29 @@ export type BodyInit =
   | null
   | string
 
-export interface BodyMixin {
+export class BodyMixin {
   readonly body: ReadableStream | null
   readonly bodyUsed: boolean
 
   readonly arrayBuffer: () => Promise<ArrayBuffer>
   readonly blob: () => Promise<Blob>
+  /**
+   * @deprecated This method is not recommended for parsing multipart/form-data bodies in server environments.
+   * It is recommended to use a library such as [@fastify/busboy](https://www.npmjs.com/package/@fastify/busboy) as follows:
+   * 
+   * @example
+   * ```js
+   * import { Busboy } from '@fastify/busboy'
+   * import { Readable } from 'node:stream'
+   * 
+   * const response = await fetch('...')
+   * const busboy = new Busboy({ headers: { 'content-type': response.headers.get('content-type') } })
+   * 
+   * // handle events emitted from `busboy`
+   * 
+   * Readable.fromWeb(response.body).pipe(busboy)
+   * ```
+   */
   readonly formData: () => Promise<FormData>
   readonly json: () => Promise<unknown>
   readonly text: () => Promise<string>
@@ -68,7 +85,7 @@ export declare class Headers implements SpecIterable<[string, string]> {
   readonly keys: () => SpecIterableIterator<string>
   readonly values: () => SpecIterableIterator<string>
   readonly entries: () => SpecIterableIterator<[string, string]>
-  readonly [Symbol.iterator]: () => SpecIterator<[string, string]>
+  readonly [Symbol.iterator]: () => SpecIterableIterator<[string, string]>
 }
 
 export type RequestCache =
@@ -105,10 +122,10 @@ export interface RequestInit {
   method?: string
   keepalive?: boolean
   headers?: HeadersInit
-  body?: BodyInit
+  body?: BodyInit | null
   redirect?: RequestRedirect
   integrity?: string
-  signal?: AbortSignal
+  signal?: AbortSignal | null
   credentials?: RequestCredentials
   mode?: RequestMode
   referrer?: string
@@ -135,7 +152,7 @@ export type RequestRedirect = 'error' | 'follow' | 'manual'
 
 export type RequestDuplex = 'half'
 
-export declare class Request implements BodyMixin {
+export declare class Request extends BodyMixin {
   constructor (input: RequestInfo, init?: RequestInit)
 
   readonly cache: RequestCache
@@ -146,22 +163,14 @@ export declare class Request implements BodyMixin {
   readonly method: string
   readonly mode: RequestMode
   readonly redirect: RequestRedirect
-  readonly referrerPolicy: string
+  readonly referrer: string
+  readonly referrerPolicy: ReferrerPolicy
   readonly url: string
 
   readonly keepalive: boolean
   readonly signal: AbortSignal
   readonly duplex: RequestDuplex
 
-  readonly body: ReadableStream | null
-  readonly bodyUsed: boolean
-
-  readonly arrayBuffer: () => Promise<ArrayBuffer>
-  readonly blob: () => Promise<Blob>
-  readonly formData: () => Promise<FormData>
-  readonly json: () => Promise<unknown>
-  readonly text: () => Promise<string>
-
   readonly clone: () => Request
 }
 
@@ -181,7 +190,7 @@ export type ResponseType =
 
 export type ResponseRedirectStatus = 301 | 302 | 303 | 307 | 308
 
-export declare class Response implements BodyMixin {
+export declare class Response extends BodyMixin {
   constructor (body?: BodyInit, init?: ResponseInit)
 
   readonly headers: Headers
@@ -192,15 +201,6 @@ export declare class Response implements BodyMixin {
   readonly url: string
   readonly redirected: boolean
 
-  readonly body: ReadableStream | null
-  readonly bodyUsed: boolean
-
-  readonly arrayBuffer: () => Promise<ArrayBuffer>
-  readonly blob: () => Promise<Blob>
-  readonly formData: () => Promise<FormData>
-  readonly json: () => Promise<unknown>
-  readonly text: () => Promise<string>
-
   readonly clone: () => Response
 
   static error (): Response

package/node_modules/{undici-types → @types/cacheable-request/node_modules/undici-types}/formdata.d.ts

@@ -2,7 +2,7 @@
 /// <reference types="node" />
 
 import { File } from './file'
-import { SpecIterator, SpecIterableIterator } from './fetch'
+import { SpecIterableIterator } from './fetch'
 
 /**
  * A `string` or `File` that represents a single value from a set of `FormData` key-value pairs.

package/node_modules/@types/cacheable-request/node_modules/undici-types/handlers.d.ts

@@ -0,0 +1,15 @@
+import Dispatcher from "./dispatcher";
+
+export declare class RedirectHandler implements Dispatcher.DispatchHandlers {
+  constructor(
+    dispatch: Dispatcher,
+    maxRedirections: number,
+    opts: Dispatcher.DispatchOptions,
+    handler: Dispatcher.DispatchHandlers,
+    redirectionLimitReached: boolean
+  );
+}
+
+export declare class DecoratorHandler implements Dispatcher.DispatchHandlers {
+  constructor(handler: Dispatcher.DispatchHandlers);
+}

package/node_modules/{undici-types → @types/cacheable-request/node_modules/undici-types}/index.d.ts

@@ -14,9 +14,15 @@ import MockPool from'./mock-pool'
 import MockAgent from'./mock-agent'
 import mockErrors from'./mock-errors'
 import ProxyAgent from'./proxy-agent'
+import EnvHttpProxyAgent from './env-http-proxy-agent'
+import RetryHandler from'./retry-handler'
+import RetryAgent from'./retry-agent'
 import { request, pipeline, stream, connect, upgrade } from './api'
+import interceptors from './interceptors'
 
+export * from './util'
 export * from './cookies'
+export * from './eventsource'
 export * from './fetch'
 export * from './file'
 export * from './filereader'
@@ -27,7 +33,7 @@ export * from './content-type'
 export * from './cache'
 export { Interceptable } from './mock-interceptor'
 
-export { Dispatcher, BalancedPool, Pool, Client, buildConnector, errors, Agent, request, stream, pipeline, connect, upgrade, setGlobalDispatcher, getGlobalDispatcher, setGlobalOrigin, getGlobalOrigin, MockClient, MockPool, MockAgent, mockErrors, ProxyAgent, RedirectHandler, DecoratorHandler }
+export { Dispatcher, BalancedPool, Pool, Client, buildConnector, errors, Agent, request, stream, pipeline, connect, upgrade, setGlobalDispatcher, getGlobalDispatcher, setGlobalOrigin, getGlobalOrigin, interceptors, MockClient, MockPool, MockAgent, mockErrors, ProxyAgent, EnvHttpProxyAgent, RedirectHandler, DecoratorHandler, RetryHandler, RetryAgent }
 export default Undici
 
 declare namespace Undici {
@@ -35,7 +41,8 @@ declare namespace Undici {
   var Pool: typeof import('./pool').default;
   var RedirectHandler: typeof import ('./handlers').RedirectHandler
   var DecoratorHandler: typeof import ('./handlers').DecoratorHandler
-  var createRedirectInterceptor: typeof import ('./interceptors').createRedirectInterceptor
+  var RetryHandler: typeof import ('./retry-handler').default
+  var createRedirectInterceptor: typeof import ('./interceptors').default.createRedirectInterceptor
   var BalancedPool: typeof import('./balanced-pool').default;
   var Client: typeof import('./client').default;
   var buildConnector: typeof import('./connector').default;
@@ -60,4 +67,5 @@ declare namespace Undici {
   var File: typeof import('./file').File;
   var FileReader: typeof import('./filereader').FileReader;
   var caches: typeof import('./cache').caches;
+  var interceptors: typeof import('./interceptors').default;
 }

package/node_modules/@types/cacheable-request/node_modules/undici-types/interceptors.d.ts

@@ -0,0 +1,15 @@
+import Dispatcher from "./dispatcher";
+import RetryHandler from "./retry-handler";
+
+export default Interceptors;
+
+declare namespace Interceptors {
+  export type DumpInterceptorOpts = { maxSize?: number }
+  export type RetryInterceptorOpts = RetryHandler.RetryOptions
+  export type RedirectInterceptorOpts = { maxRedirections?: number }
+  
+  export function createRedirectInterceptor(opts: RedirectInterceptorOpts): Dispatcher.DispatcherComposeInterceptor
+  export function dump(opts?: DumpInterceptorOpts): Dispatcher.DispatcherComposeInterceptor
+  export function retry(opts?: RetryInterceptorOpts): Dispatcher.DispatcherComposeInterceptor
+  export function redirect(opts?: RedirectInterceptorOpts): Dispatcher.DispatcherComposeInterceptor
+}

package/node_modules/{undici-types → @types/cacheable-request/node_modules/undici-types}/mock-interceptor.d.ts

@@ -71,11 +71,11 @@ declare namespace MockInterceptor {
 
   export interface MockResponseCallbackOptions {
     path: string;
-    origin: string;
     method: string;
-    body?: BodyInit | Dispatcher.DispatchOptions['body'];
-    headers: Headers | Record<string, string>;
-    maxRedirections: number;
+    headers?: Headers | Record<string, string>;
+    origin?: string;
+    body?: BodyInit | Dispatcher.DispatchOptions['body'] | null;
+    maxRedirections?: number;
   }
 
   export type MockResponseDataHandler<TData extends object = object> = (

package/node_modules/{undici-types → @types/cacheable-request/node_modules/undici-types}/package.json

@@ -1,6 +1,6 @@
 {
   "name": "undici-types",
-  "version": "5.26.5",
+  "version": "6.19.8",
   "description": "A stand-alone types package for Undici",
   "homepage": "https://undici.nodejs.org",
   "bugs": {

package/node_modules/{undici-types → @types/cacheable-request/node_modules/undici-types}/pool.d.ts

@@ -5,6 +5,8 @@ import Dispatcher from "./dispatcher";
 
 export default Pool
 
+type PoolConnectOptions = Omit<Dispatcher.ConnectOptions, "origin">;
+
 declare class Pool extends Dispatcher {
   constructor(url: string | URL, options?: Pool.Options)
   /** `true` after `pool.close()` has been called. */
@@ -13,6 +15,15 @@ declare class Pool extends Dispatcher {
   destroyed: boolean;
   /** Aggregate stats for a Pool. */
   readonly stats: TPoolStats;
+
+  // Override dispatcher APIs.
+  override connect(
+    options: PoolConnectOptions
+  ): Promise<Dispatcher.ConnectData>;
+  override connect(
+    options: PoolConnectOptions,
+    callback: (err: Error | null, data: Dispatcher.ConnectData) => void
+  ): void;
 }
 
 declare namespace Pool {

package/node_modules/{undici-types → @types/cacheable-request/node_modules/undici-types}/proxy-agent.d.ts

@@ -1,9 +1,7 @@
 import Agent from './agent'
 import buildConnector from './connector';
-import Client from './client'
 import Dispatcher from './dispatcher'
 import { IncomingHttpHeaders } from './header'
-import Pool from './pool'
 
 export default ProxyAgent
 

package/node_modules/{undici-types → @types/cacheable-request/node_modules/undici-types}/readable.d.ts

@@ -44,9 +44,8 @@ declare class BodyReadable extends Readable {
    */
   readonly bodyUsed: boolean
 
-  /** Throws on node 16.6.0
-   *
-   *  If body is null, it should return null as the body
+  /** 
+   * If body is null, it should return null as the body
    *
    *  If body is not null, should return the body as a ReadableStream
    *

package/node_modules/@types/cacheable-request/node_modules/undici-types/retry-agent.d.ts

@@ -0,0 +1,8 @@
+import Dispatcher from './dispatcher'
+import RetryHandler from './retry-handler'
+
+export default RetryAgent
+
+declare class RetryAgent extends Dispatcher {
+  constructor(dispatcher: Dispatcher, options?: RetryHandler.RetryOptions)
+}

package/node_modules/@types/cacheable-request/node_modules/undici-types/retry-handler.d.ts

@@ -0,0 +1,116 @@
+import Dispatcher from "./dispatcher";
+
+export default RetryHandler;
+
+declare class RetryHandler implements Dispatcher.DispatchHandlers {
+  constructor(
+    options: Dispatcher.DispatchOptions & {
+      retryOptions?: RetryHandler.RetryOptions;
+    },
+    retryHandlers: RetryHandler.RetryHandlers
+  );
+}
+
+declare namespace RetryHandler {
+  export type RetryState = { counter: number; };
+
+  export type RetryContext = {
+    state: RetryState;
+    opts: Dispatcher.DispatchOptions & {
+      retryOptions?: RetryHandler.RetryOptions;
+    };
+  }
+
+  export type OnRetryCallback = (result?: Error | null) => void;
+
+  export type RetryCallback = (
+    err: Error,
+    context: {
+      state: RetryState;
+      opts: Dispatcher.DispatchOptions & {
+        retryOptions?: RetryHandler.RetryOptions;
+      };
+    },
+    callback: OnRetryCallback
+  ) => number | null;
+
+  export interface RetryOptions {
+    /**
+     * Callback to be invoked on every retry iteration.
+     * It receives the error, current state of the retry object and the options object
+     * passed when instantiating the retry handler.
+     *
+     * @type {RetryCallback}
+     * @memberof RetryOptions
+     */
+    retry?: RetryCallback;
+    /**
+     * Maximum number of retries to allow.
+     *
+     * @type {number}
+     * @memberof RetryOptions
+     * @default 5
+     */
+    maxRetries?: number;
+    /**
+     * Max number of milliseconds allow between retries
+     *
+     * @type {number}
+     * @memberof RetryOptions
+     * @default 30000
+     */
+    maxTimeout?: number;
+    /**
+     * Initial number of milliseconds to wait before retrying for the first time.
+     *
+     * @type {number}
+     * @memberof RetryOptions
+     * @default 500
+     */
+    minTimeout?: number;
+    /**
+     * Factior to multiply the timeout factor between retries.
+     *
+     * @type {number}
+     * @memberof RetryOptions
+     * @default 2
+     */
+    timeoutFactor?: number;
+    /**
+     * It enables to automatically infer timeout between retries based on the `Retry-After` header.
+     *
+     * @type {boolean}
+     * @memberof RetryOptions
+     * @default true
+     */
+    retryAfter?: boolean;
+    /**
+     * HTTP methods to retry.
+     *
+     * @type {Dispatcher.HttpMethod[]}
+     * @memberof RetryOptions
+     * @default ['GET', 'HEAD', 'OPTIONS', 'PUT', 'DELETE', 'TRACE'],
+     */
+    methods?: Dispatcher.HttpMethod[];
+    /**
+     * Error codes to be retried. e.g. `ECONNRESET`, `ENOTFOUND`, `ETIMEDOUT`, `ECONNREFUSED`, etc.
+     *
+     * @type {string[]}
+     * @default ['ECONNRESET','ECONNREFUSED','ENOTFOUND','ENETDOWN','ENETUNREACH','EHOSTDOWN','EHOSTUNREACH','EPIPE']
+     */
+    errorCodes?: string[];
+    /**
+     * HTTP status codes to be retried.
+     *
+     * @type {number[]}
+     * @memberof RetryOptions
+     * @default [500, 502, 503, 504, 429],
+     */
+    statusCodes?: number[];
+  }
+
+  export interface RetryHandlers {
+    dispatch: Dispatcher["dispatch"];
+    handler: Dispatcher.DispatchHandlers;
+  }
+}

package/node_modules/@types/cacheable-request/node_modules/undici-types/util.d.ts

@@ -0,0 +1,18 @@
+export namespace util {
+  /**
+   * Retrieves a header name and returns its lowercase value.
+   * @param value Header name
+   */
+  export function headerNameToString(value: string | Buffer): string;
+
+  /**
+   * Receives a header object and returns the parsed value.
+   * @param headers Header object
+   * @param obj Object to specify a proxy object. Used to assign parsed values.
+   * @returns If `obj` is specified, it is equivalent to `obj`.
+   */
+  export function parseHeaders(
+    headers: (Buffer | string | (Buffer | string)[])[],
+    obj?: Record<string, string | string[]>
+  ): Record<string, string | string[]>;
+}

package/node_modules/{undici-types → @types/cacheable-request/node_modules/undici-types}/webidl.d.ts

@@ -5,7 +5,7 @@
  */
 type Converter<T> = (object: unknown) => T
 
-type SequenceConverter<T> = (object: unknown) => T[]
+type SequenceConverter<T> = (object: unknown, iterable?: IterableIterator<T>) => T[]
 
 type RecordConverter<K extends string, V> = (object: unknown) => Record<K, V>
 
@@ -62,20 +62,25 @@ interface WebidlUtil {
    * @see https://webidl.spec.whatwg.org/#abstract-opdef-converttoint
    */
   IntegerPart (N: number): number
+
+  /**
+   * Stringifies {@param V}
+   */
+  Stringify (V: any): string
 }
 
 interface WebidlConverters {
   /**
    * @see https://webidl.spec.whatwg.org/#es-DOMString
    */
-  DOMString (V: unknown, opts?: {
+  DOMString (V: unknown, prefix: string, argument: string, opts?: {
     legacyNullToEmptyString: boolean
   }): string
 
   /**
    * @see https://webidl.spec.whatwg.org/#es-ByteString
    */
-  ByteString (V: unknown): string
+  ByteString (V: unknown, prefix: string, argument: string): string
 
   /**
    * @see https://webidl.spec.whatwg.org/#es-USVString
@@ -199,7 +204,7 @@ export interface Webidl {
    */
   dictionaryConverter (converters: {
     key: string,
-    defaultValue?: unknown,
+    defaultValue?: () => unknown,
     required?: boolean,
     converter: (...args: unknown[]) => unknown,
     allowedValues?: unknown[]
@@ -213,8 +218,5 @@ export interface Webidl {
     converter: Converter<T>
   ): (V: unknown) => ReturnType<typeof converter> | null
 
-  argumentLengthCheck (args: { length: number }, min: number, context: {
-    header: string
-    message?: string
-  }): void
+  argumentLengthCheck (args: { length: number }, min: number, context: string): void
 }

package/node_modules/{undici-types → @types/cacheable-request/node_modules/undici-types}/websocket.d.ts

@@ -17,7 +17,7 @@ export type BinaryType = 'blob' | 'arraybuffer'
 
 interface WebSocketEventMap {
   close: CloseEvent
-  error: Event
+  error: ErrorEvent
   message: MessageEvent
   open: Event
 }
@@ -124,6 +124,27 @@ export declare const MessageEvent: {
   new<T>(type: string, eventInitDict?: MessageEventInit<T>): MessageEvent<T>
 }
 
+interface ErrorEventInit extends EventInit {
+  message?: string
+  filename?: string
+  lineno?: number
+  colno?: number
+  error?: any
+}
+
+interface ErrorEvent extends Event {
+  readonly message: string
+  readonly filename: string
+  readonly lineno: number
+  readonly colno: number
+  readonly error: any
+}
+
+export declare const ErrorEvent: {
+  prototype: ErrorEvent
+  new (type: string, eventInitDict?: ErrorEventInit): ErrorEvent
+}
+
 interface WebSocketInit {
   protocols?: string | string[],
   dispatcher?: Dispatcher,

package/node_modules/@types/keyv/node_modules/@types/node/README.md

@@ -8,7 +8,7 @@ This package contains type definitions for node (https://nodejs.org/).
 Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/node.
 
 ### Additional Details
- * Last updated: Tue, 23 Jul 2024 18:09:25 GMT
+ * Last updated: Wed, 04 Sep 2024 21:35:57 GMT
  * Dependencies: [undici-types](https://npmjs.com/package/undici-types)
 
 # Credits

package/node_modules/@types/keyv/node_modules/@types/node/assert.d.ts

@@ -1,7 +1,7 @@
 /**
  * The `node:assert` module provides a set of assertion functions for verifying
  * invariants.
- * @see [source](https://github.com/nodejs/node/blob/v20.13.1/lib/assert.js)
+ * @see [source](https://github.com/nodejs/node/blob/v22.x/lib/assert.js)
  */
 declare module "assert" {
     /**
@@ -796,7 +796,7 @@ declare module "assert" {
          * check that the promise is rejected.
          *
          * If `asyncFn` is a function and it throws an error synchronously, `assert.rejects()` will return a rejected `Promise` with that error. If the
-         * function does not return a promise, `assert.rejects()` will return a rejected `Promise` with an [ERR_INVALID_RETURN_VALUE](https://nodejs.org/docs/latest-v20.x/api/errors.html#err_invalid_return_value)
+         * function does not return a promise, `assert.rejects()` will return a rejected `Promise` with an [ERR_INVALID_RETURN_VALUE](https://nodejs.org/docs/latest-v22.x/api/errors.html#err_invalid_return_value)
          * error. In both cases the error handler is skipped.
          *
          * Besides the async nature to await the completion behaves identically to {@link throws}.
@@ -866,7 +866,7 @@ declare module "assert" {
          *
          * If `asyncFn` is a function and it throws an error synchronously, `assert.doesNotReject()` will return a rejected `Promise` with that error. If
          * the function does not return a promise, `assert.doesNotReject()` will return a
-         * rejected `Promise` with an [ERR_INVALID_RETURN_VALUE](https://nodejs.org/docs/latest-v20.x/api/errors.html#err_invalid_return_value) error. In both cases
+         * rejected `Promise` with an [ERR_INVALID_RETURN_VALUE](https://nodejs.org/docs/latest-v22.x/api/errors.html#err_invalid_return_value) error. In both cases
          * the error handler is skipped.
          *
          * Using `assert.doesNotReject()` is actually not useful because there is little
@@ -929,7 +929,7 @@ declare module "assert" {
          * If the values do not match, or if the `string` argument is of another type than `string`, an `{@link AssertionError}` is thrown with a `message` property set equal
          * to the value of the `message` parameter. If the `message` parameter is
          * undefined, a default error message is assigned. If the `message` parameter is an
-         * instance of an [Error](https://nodejs.org/docs/latest-v20.x/api/errors.html#class-error) then it will be thrown instead of the `{@link AssertionError}`.
+         * instance of an [Error](https://nodejs.org/docs/latest-v22.x/api/errors.html#class-error) then it will be thrown instead of the `{@link AssertionError}`.
          * @since v13.6.0, v12.16.0
          */
         function match(value: string, regExp: RegExp, message?: string | Error): void;
@@ -952,7 +952,7 @@ declare module "assert" {
          * If the values do match, or if the `string` argument is of another type than `string`, an `{@link AssertionError}` is thrown with a `message` property set equal
          * to the value of the `message` parameter. If the `message` parameter is
          * undefined, a default error message is assigned. If the `message` parameter is an
-         * instance of an [Error](https://nodejs.org/docs/latest-v20.x/api/errors.html#class-error) then it will be thrown instead of the `{@link AssertionError}`.
+         * instance of an [Error](https://nodejs.org/docs/latest-v22.x/api/errors.html#class-error) then it will be thrown instead of the `{@link AssertionError}`.
          * @since v13.6.0, v12.16.0
          */
         function doesNotMatch(value: string, regExp: RegExp, message?: string | Error): void;

package/node_modules/@types/keyv/node_modules/@types/node/async_hooks.d.ts

@@ -2,8 +2,8 @@
  * We strongly discourage the use of the `async_hooks` API.
  * Other APIs that can cover most of its use cases include:
  *
- * * [`AsyncLocalStorage`](https://nodejs.org/docs/latest-v20.x/api/async_context.html#class-asynclocalstorage) tracks async context
- * * [`process.getActiveResourcesInfo()`](https://nodejs.org/docs/latest-v20.x/api/process.html#processgetactiveresourcesinfo) tracks active resources
+ * * [`AsyncLocalStorage`](https://nodejs.org/docs/latest-v22.x/api/async_context.html#class-asynclocalstorage) tracks async context
+ * * [`process.getActiveResourcesInfo()`](https://nodejs.org/docs/latest-v22.x/api/process.html#processgetactiveresourcesinfo) tracks active resources
  *
  * The `node:async_hooks` module provides an API to track asynchronous resources.
  * It can be accessed using:
@@ -12,7 +12,7 @@
  * import async_hooks from 'node:async_hooks';
  * ```
  * @experimental
- * @see [source](https://github.com/nodejs/node/blob/v20.13.1/lib/async_hooks.js)
+ * @see [source](https://github.com/nodejs/node/blob/v22.x/lib/async_hooks.js)
  */
 declare module "async_hooks" {
     /**
@@ -44,7 +44,7 @@ declare module "async_hooks" {
      * ```
      *
      * Promise contexts may not get precise `executionAsyncIds` by default.
-     * See the section on [promise execution tracking](https://nodejs.org/docs/latest-v20.x/api/async_hooks.html#promise-execution-tracking).
+     * See the section on [promise execution tracking](https://nodejs.org/docs/latest-v22.x/api/async_hooks.html#promise-execution-tracking).
      * @since v8.1.0
      * @return The `asyncId` of the current execution context. Useful to track when something calls.
      */
@@ -117,7 +117,7 @@ declare module "async_hooks" {
      * ```
      *
      * Promise contexts may not get valid `triggerAsyncId`s by default. See
-     * the section on [promise execution tracking](https://nodejs.org/docs/latest-v20.x/api/async_hooks.html#promise-execution-tracking).
+     * the section on [promise execution tracking](https://nodejs.org/docs/latest-v22.x/api/async_hooks.html#promise-execution-tracking).
      * @return The ID of the resource responsible for calling the callback that is currently being executed.
      */
     function triggerAsyncId(): number;