@chainlink/external-adapter-framework 2.8.0 → 2.9.0

package/generator-adapter/node_modules/@types/node/stream.d.ts

@@ -2,10 +2,10 @@
  * A stream is an abstract interface for working with streaming data in Node.js.
  * The `node:stream` module provides an API for implementing the stream interface.
  *
- * There are many stream objects provided by Node.js. For instance, a [request to an HTTP server](https://nodejs.org/docs/latest-v22.x/api/http.html#class-httpincomingmessage)
- * and [`process.stdout`](https://nodejs.org/docs/latest-v22.x/api/process.html#processstdout) are both stream instances.
+ * There are many stream objects provided by Node.js. For instance, a [request to an HTTP server](https://nodejs.org/docs/latest-v24.x/api/http.html#class-httpincomingmessage)
+ * and [`process.stdout`](https://nodejs.org/docs/latest-v24.x/api/process.html#processstdout) are both stream instances.
  *
- * Streams can be readable, writable, or both. All streams are instances of [`EventEmitter`](https://nodejs.org/docs/latest-v22.x/api/events.html#class-eventemitter).
+ * Streams can be readable, writable, or both. All streams are instances of [`EventEmitter`](https://nodejs.org/docs/latest-v24.x/api/events.html#class-eventemitter).
  *
  * To access the `node:stream` module:
  *
@@ -15,7 +15,7 @@
  *
  * The `node:stream` module is useful for creating new types of stream instances.
  * It is usually not necessary to use the `node:stream` module to consume streams.
- * @see [source](https://github.com/nodejs/node/blob/v22.x/lib/stream.js)
+ * @see [source](https://github.com/nodejs/node/blob/v24.x/lib/stream.js)
  */
 declare module "stream" {
     import { Abortable, EventEmitter } from "node:events";
@@ -45,22 +45,22 @@ declare module "stream" {
             emitClose?: boolean | undefined;
             highWaterMark?: number | undefined;
             objectMode?: boolean | undefined;
-            construct?(this: T, callback: (error?: Error | null) => void): void;
-            destroy?(this: T, error: Error | null, callback: (error?: Error | null) => void): void;
+            construct?: ((this: T, callback: (error?: Error | null) => void) => void) | undefined;
+            destroy?: ((this: T, error: Error | null, callback: (error?: Error | null) => void) => void) | undefined;
             autoDestroy?: boolean | undefined;
         }
         interface ReadableOptions<T extends Readable = Readable> extends StreamOptions<T> {
             encoding?: BufferEncoding | undefined;
-            read?(this: T, size: number): void;
+            read?: ((this: T, size: number) => void) | undefined;
         }
         interface ArrayOptions {
             /**
              * The maximum concurrent invocations of `fn` to call on the stream at once.
              * @default 1
              */
-            concurrency?: number;
+            concurrency?: number | undefined;
             /** Allows destroying the stream if the signal is aborted. */
-            signal?: AbortSignal;
+            signal?: AbortSignal | undefined;
         }
         /**
          * @since v0.9.4
@@ -118,13 +118,13 @@ declare module "stream" {
              */
             readonly readableEncoding: BufferEncoding | null;
             /**
-             * Becomes `true` when [`'end'`](https://nodejs.org/docs/latest-v22.x/api/stream.html#event-end) event is emitted.
+             * Becomes `true` when [`'end'`](https://nodejs.org/docs/latest-v24.x/api/stream.html#event-end) event is emitted.
              * @since v12.9.0
              */
             readonly readableEnded: boolean;
             /**
              * This property reflects the current state of a `Readable` stream as described
-             * in the [Three states](https://nodejs.org/docs/latest-v22.x/api/stream.html#three-states) section.
+             * in the [Three states](https://nodejs.org/docs/latest-v24.x/api/stream.html#three-states) section.
              * @since v9.4.0
              */
             readonly readableFlowing: boolean | null;
@@ -615,6 +615,17 @@ declare module "stream" {
              * @param error Error which will be passed as payload in `'error'` event
              */
             destroy(error?: Error): this;
+            /**
+             * @returns `AsyncIterator` to fully consume the stream.
+             * @since v10.0.0
+             */
+            [Symbol.asyncIterator](): NodeJS.AsyncIterator<any>;
+            /**
+             * Calls `readable.destroy()` with an `AbortError` and returns
+             * a promise that fulfills when the stream is finished.
+             * @since v20.4.0
+             */
+            [Symbol.asyncDispose](): Promise<void>;
             /**
              * Event emitter
              * The defined events on documents including:
@@ -682,31 +693,29 @@ declare module "stream" {
             removeListener(event: "readable", listener: () => void): this;
             removeListener(event: "resume", listener: () => void): this;
             removeListener(event: string | symbol, listener: (...args: any[]) => void): this;
-            [Symbol.asyncIterator](): NodeJS.AsyncIterator<any>;
-            /**
-             * Calls `readable.destroy()` with an `AbortError` and returns a promise that fulfills when the stream is finished.
-             * @since v20.4.0
-             */
-            [Symbol.asyncDispose](): Promise<void>;
         }
         interface WritableOptions<T extends Writable = Writable> extends StreamOptions<T> {
             decodeStrings?: boolean | undefined;
             defaultEncoding?: BufferEncoding | undefined;
-            write?(
-                this: T,
-                chunk: any,
-                encoding: BufferEncoding,
-                callback: (error?: Error | null) => void,
-            ): void;
-            writev?(
-                this: T,
-                chunks: Array<{
-                    chunk: any;
-                    encoding: BufferEncoding;
-                }>,
-                callback: (error?: Error | null) => void,
-            ): void;
-            final?(this: T, callback: (error?: Error | null) => void): void;
+            write?:
+                | ((
+                    this: T,
+                    chunk: any,
+                    encoding: BufferEncoding,
+                    callback: (error?: Error | null) => void,
+                ) => void)
+                | undefined;
+            writev?:
+                | ((
+                    this: T,
+                    chunks: Array<{
+                        chunk: any;
+                        encoding: BufferEncoding;
+                    }>,
+                    callback: (error?: Error | null) => void,
+                ) => void)
+                | undefined;
+            final?: ((this: T, callback: (error?: Error | null) => void) => void) | undefined;
         }
         /**
          * @since v0.9.4
@@ -957,6 +966,12 @@ declare module "stream" {
              * @param error Optional, an error to emit with `'error'` event.
              */
             destroy(error?: Error): this;
+            /**
+             * Calls `writable.destroy()` with an `AbortError` and returns
+             * a promise that fulfills when the stream is finished.
+             * @since v22.4.0, v20.16.0
+             */
+            [Symbol.asyncDispose](): Promise<void>;
             /**
              * Event emitter
              * The defined events on documents including:
@@ -1224,8 +1239,10 @@ declare module "stream" {
         function duplexPair(options?: DuplexOptions): [Duplex, Duplex];
         type TransformCallback = (error?: Error | null, data?: any) => void;
         interface TransformOptions<T extends Transform = Transform> extends DuplexOptions<T> {
-            transform?(this: T, chunk: any, encoding: BufferEncoding, callback: TransformCallback): void;
-            flush?(this: T, callback: TransformCallback): void;
+            transform?:
+                | ((this: T, chunk: any, encoding: BufferEncoding, callback: TransformCallback) => void)
+                | undefined;
+            flush?: ((this: T, callback: TransformCallback) => void) | undefined;
         }
         /**
          * Transform streams are `Duplex` streams where the output is in some way
@@ -1371,7 +1388,7 @@ declare module "stream" {
          * Especially useful in error handling scenarios where a stream is destroyed
          * prematurely (like an aborted HTTP request), and will not emit `'end'` or `'finish'`.
          *
-         * The `finished` API provides [`promise version`](https://nodejs.org/docs/latest-v22.x/api/stream.html#streamfinishedstream-options).
+         * The `finished` API provides [`promise version`](https://nodejs.org/docs/latest-v24.x/api/stream.html#streamfinishedstream-options).
          *
          * `stream.finished()` leaves dangling event listeners (in particular `'error'`, `'end'`, `'finish'` and `'close'`) after `callback` has been
          * invoked. The reason for this is so that unexpected `'error'` events (due to
@@ -1459,7 +1476,7 @@ declare module "stream" {
          * );
          * ```
          *
-         * The `pipeline` API provides a [`promise version`](https://nodejs.org/docs/latest-v22.x/api/stream.html#streampipelinesource-transforms-destination-options).
+         * The `pipeline` API provides a [`promise version`](https://nodejs.org/docs/latest-v24.x/api/stream.html#streampipelinesource-transforms-destination-options).
          *
          * `stream.pipeline()` will call `stream.destroy(err)` on all streams except:
          *
@@ -1632,12 +1649,14 @@ declare module "stream" {
                 ...streams: Array<NodeJS.ReadWriteStream | NodeJS.WritableStream | PipelineOptions>
             ): Promise<void>;
         }
+        // TODO: this interface never existed; remove in next major
         interface Pipe {
             close(): void;
             hasRef(): boolean;
             ref(): void;
             unref(): void;
         }
+        // TODO: these should all take webstream arguments
         /**
          * Returns whether the stream has encountered an error.
          * @since v17.3.0, v16.14.0
@@ -1646,8 +1665,15 @@ declare module "stream" {
         /**
          * Returns whether the stream is readable.
          * @since v17.4.0, v16.14.0
+         * @returns Only returns `null` if `stream` is not a valid `Readable`, `Duplex` or `ReadableStream`.
+         */
+        function isReadable(stream: Readable | NodeJS.ReadableStream): boolean | null;
+        /**
+         * Returns whether the stream is writable.
+         * @since v20.0.0
+         * @returns Only returns `null` if `stream` is not a valid `Writable`, `Duplex` or `WritableStream`.
          */
-        function isReadable(stream: Readable | NodeJS.ReadableStream): boolean;
+        function isWritable(stream: Writable | NodeJS.WritableStream): boolean | null;
     }
     export = Stream;
 }

package/generator-adapter/node_modules/@types/node/string_decoder.d.ts

@@ -36,7 +36,7 @@
  * decoder.write(Buffer.from([0x82]));
  * console.log(decoder.end(Buffer.from([0xAC]))); // Prints: €
  * ```
- * @see [source](https://github.com/nodejs/node/blob/v22.x/lib/string_decoder.js)
+ * @see [source](https://github.com/nodejs/node/blob/v24.x/lib/string_decoder.js)
  */
 declare module "string_decoder" {
     class StringDecoder {
@@ -48,7 +48,7 @@ declare module "string_decoder" {
          * @since v0.1.99
          * @param buffer The bytes to decode.
          */
-        write(buffer: string | Buffer | NodeJS.ArrayBufferView): string;
+        write(buffer: string | NodeJS.ArrayBufferView): string;
         /**
          * Returns any remaining input stored in the internal buffer as a string. Bytes
          * representing incomplete UTF-8 and UTF-16 characters will be replaced with
@@ -59,7 +59,7 @@ declare module "string_decoder" {
          * @since v0.9.3
          * @param buffer The bytes to decode.
          */
-        end(buffer?: string | Buffer | NodeJS.ArrayBufferView): string;
+        end(buffer?: string | NodeJS.ArrayBufferView): string;
     }
 }
 declare module "node:string_decoder" {

package/generator-adapter/node_modules/@types/node/test.d.ts

@@ -76,9 +76,10 @@
  *
  * If any tests fail, the process exit code is set to `1`.
  * @since v18.0.0, v16.17.0
- * @see [source](https://github.com/nodejs/node/blob/v22.x/lib/test.js)
+ * @see [source](https://github.com/nodejs/node/blob/v24.x/lib/test.js)
  */
 declare module "node:test" {
+    import { AssertMethodNames } from "node:assert";
     import { Readable } from "node:stream";
     import TestFn = test.TestFn;
     import TestOptions = test.TestOptions;
@@ -239,9 +240,17 @@ declare module "node:test" {
              * @default false
              */
             concurrency?: number | boolean | undefined;
+            /**
+             * Specifies the current working directory to be used by the test runner.
+             * Serves as the base path for resolving files according to the
+             * [test runner execution model](https://nodejs.org/docs/latest-v24.x/api/test.html#test-runner-execution-model).
+             * @since v23.0.0
+             * @default process.cwd()
+             */
+            cwd?: string | undefined;
             /**
              * An array containing the list of files to run. If omitted, files are run according to the
-             * [test runner execution model](https://nodejs.org/docs/latest-v22.x/api/test.html#test-runner-execution-model).
+             * [test runner execution model](https://nodejs.org/docs/latest-v24.x/api/test.html#test-runner-execution-model).
              */
             files?: readonly string[] | undefined;
             /**
@@ -254,7 +263,7 @@ declare module "node:test" {
             /**
              * An array containing the list of glob patterns to match test files.
              * This option cannot be used together with `files`. If omitted, files are run according to the
-             * [test runner execution model](https://nodejs.org/docs/latest-v22.x/api/test.html#test-runner-execution-model).
+             * [test runner execution model](https://nodejs.org/docs/latest-v24.x/api/test.html#test-runner-execution-model).
              * @since v22.6.0
              */
             globPatterns?: readonly string[] | undefined;
@@ -335,7 +344,14 @@ declare module "node:test" {
              */
             shard?: TestShard | undefined;
             /**
-             * enable [code coverage](https://nodejs.org/docs/latest-v22.x/api/test.html#collecting-code-coverage) collection.
+             * A file path where the test runner will
+             * store the state of the tests to allow rerunning only the failed tests on a next run.
+             * @since v24.7.0
+             * @default undefined
+             */
+            rerunFailuresFilePath?: string | undefined;
+            /**
+             * enable [code coverage](https://nodejs.org/docs/latest-v24.x/api/test.html#collecting-code-coverage) collection.
              * @since v22.10.0
              * @default false
              */
@@ -402,6 +418,7 @@ declare module "node:test" {
             addListener(event: "test:stdout", listener: (data: EventData.TestStdout) => void): this;
             addListener(event: "test:summary", listener: (data: EventData.TestSummary) => void): this;
             addListener(event: "test:watch:drained", listener: () => void): this;
+            addListener(event: "test:watch:restarted", listener: () => void): this;
             addListener(event: string, listener: (...args: any[]) => void): this;
             emit(event: "test:coverage", data: EventData.TestCoverage): boolean;
             emit(event: "test:complete", data: EventData.TestComplete): boolean;
@@ -416,6 +433,7 @@ declare module "node:test" {
             emit(event: "test:stdout", data: EventData.TestStdout): boolean;
             emit(event: "test:summary", data: EventData.TestSummary): boolean;
             emit(event: "test:watch:drained"): boolean;
+            emit(event: "test:watch:restarted"): boolean;
             emit(event: string | symbol, ...args: any[]): boolean;
             on(event: "test:coverage", listener: (data: EventData.TestCoverage) => void): this;
             on(event: "test:complete", listener: (data: EventData.TestComplete) => void): this;
@@ -430,6 +448,7 @@ declare module "node:test" {
             on(event: "test:stdout", listener: (data: EventData.TestStdout) => void): this;
             on(event: "test:summary", listener: (data: EventData.TestSummary) => void): this;
             on(event: "test:watch:drained", listener: () => void): this;
+            on(event: "test:watch:restarted", listener: () => void): this;
             on(event: string, listener: (...args: any[]) => void): this;
             once(event: "test:coverage", listener: (data: EventData.TestCoverage) => void): this;
             once(event: "test:complete", listener: (data: EventData.TestComplete) => void): this;
@@ -444,6 +463,7 @@ declare module "node:test" {
             once(event: "test:stdout", listener: (data: EventData.TestStdout) => void): this;
             once(event: "test:summary", listener: (data: EventData.TestSummary) => void): this;
             once(event: "test:watch:drained", listener: () => void): this;
+            once(event: "test:watch:restarted", listener: () => void): this;
             once(event: string, listener: (...args: any[]) => void): this;
             prependListener(event: "test:coverage", listener: (data: EventData.TestCoverage) => void): this;
             prependListener(event: "test:complete", listener: (data: EventData.TestComplete) => void): this;
@@ -458,6 +478,7 @@ declare module "node:test" {
             prependListener(event: "test:stdout", listener: (data: EventData.TestStdout) => void): this;
             prependListener(event: "test:summary", listener: (data: EventData.TestSummary) => void): this;
             prependListener(event: "test:watch:drained", listener: () => void): this;
+            prependListener(event: "test:watch:restarted", listener: () => void): this;
             prependListener(event: string, listener: (...args: any[]) => void): this;
             prependOnceListener(event: "test:coverage", listener: (data: EventData.TestCoverage) => void): this;
             prependOnceListener(event: "test:complete", listener: (data: EventData.TestComplete) => void): this;
@@ -472,6 +493,7 @@ declare module "node:test" {
             prependOnceListener(event: "test:stdout", listener: (data: EventData.TestStdout) => void): this;
             prependOnceListener(event: "test:summary", listener: (data: EventData.TestSummary) => void): this;
             prependOnceListener(event: "test:watch:drained", listener: () => void): this;
+            prependOnceListener(event: "test:watch:restarted", listener: () => void): this;
             prependOnceListener(event: string, listener: (...args: any[]) => void): this;
         }
         namespace EventData {
@@ -696,7 +718,7 @@ declare module "node:test" {
                     /**
                      * The type of the test, used to denote whether this is a suite.
                      */
-                    type?: "suite";
+                    type?: "suite" | "test";
                 };
                 /**
                  * The test name.
@@ -766,7 +788,13 @@ declare module "node:test" {
                      * The type of the test, used to denote whether this is a suite.
                      * @since v20.0.0, v19.9.0, v18.17.0
                      */
-                    type?: "suite";
+                    type?: "suite" | "test";
+                    /**
+                     * The attempt number of the test run,
+                     * present only when using the `--test-rerun-failures` flag.
+                     * @since v24.7.0
+                     */
+                    attempt?: number;
                 };
                 /**
                  * The test name.
@@ -802,7 +830,19 @@ declare module "node:test" {
                      * The type of the test, used to denote whether this is a suite.
                      * @since 20.0.0, 19.9.0, 18.17.0
                      */
-                    type?: "suite";
+                    type?: "suite" | "test";
+                    /**
+                     * The attempt number of the test run,
+                     * present only when using the `--test-rerun-failures` flag.
+                     * @since v24.7.0
+                     */
+                    attempt?: number;
+                    /**
+                     * The attempt number the test passed on,
+                     * present only when using the `--test-rerun-failures` flag.
+                     * @since v24.7.0
+                     */
+                    passed_on_attempt?: number;
                 };
                 /**
                  * The test name.
@@ -947,6 +987,7 @@ declare module "node:test" {
              * @since v22.2.0, v20.15.0
              */
             readonly assert: TestContextAssert;
+            readonly attempt: number;
             /**
              * This function is used to create a hook running before subtest of the current test.
              * @param fn The hook function. The first argument to this function is a `TestContext` object.
@@ -1157,29 +1198,7 @@ declare module "node:test" {
              */
             readonly mock: MockTracker;
         }
-        interface TestContextAssert extends
-            Pick<
-                typeof import("assert"),
-                | "deepEqual"
-                | "deepStrictEqual"
-                | "doesNotMatch"
-                | "doesNotReject"
-                | "doesNotThrow"
-                | "equal"
-                | "fail"
-                | "ifError"
-                | "match"
-                | "notDeepEqual"
-                | "notDeepStrictEqual"
-                | "notEqual"
-                | "notStrictEqual"
-                | "ok"
-                | "partialDeepStrictEqual"
-                | "rejects"
-                | "strictEqual"
-                | "throws"
-            >
-        {
+        interface TestContextAssert extends Pick<typeof import("assert"), AssertMethodNames> {
             /**
              * This function serializes `value` and writes it to the file specified by `path`.
              *
@@ -1199,7 +1218,7 @@ declare module "node:test" {
              * highlighting.
              * @since v22.14.0
              * @param value A value to serialize to a string. If Node.js was started with
-             * the [`--test-update-snapshots`](https://nodejs.org/docs/latest-v22.x/api/cli.html#--test-update-snapshots)
+             * the [`--test-update-snapshots`](https://nodejs.org/docs/latest-v24.x/api/cli.html#--test-update-snapshots)
              * flag, the serialized value is written to
              * `path`. Otherwise, the serialized value is compared to the contents of the
              * existing snapshot file.
@@ -1222,7 +1241,7 @@ declare module "node:test" {
              * ```
              * @since v22.3.0
              * @param value A value to serialize to a string. If Node.js was started with
-             * the [`--test-update-snapshots`](https://nodejs.org/docs/latest-v22.x/api/cli.html#--test-update-snapshots)
+             * the [`--test-update-snapshots`](https://nodejs.org/docs/latest-v24.x/api/cli.html#--test-update-snapshots)
              * flag, the serialized value is written to
              * the snapshot file. Otherwise, the serialized value is compared to the
              * corresponding value in the existing snapshot file.
@@ -1650,16 +1669,89 @@ declare module "node:test" {
                 options?: MockFunctionOptions,
             ): Mock<((value: MockedObject[MethodName]) => void) | Implementation>;
             /**
-             * This function is used to mock the exports of ECMAScript modules, CommonJS modules, and Node.js builtin modules.
-             * Any references to the original module prior to mocking are not impacted.
+             * This function is used to mock the exports of ECMAScript modules, CommonJS modules, JSON modules, and
+             * Node.js builtin modules. Any references to the original module prior to mocking are not impacted. In
+             * order to enable module mocking, Node.js must be started with the
+             * [`--experimental-test-module-mocks`](https://nodejs.org/docs/latest-v24.x/api/cli.html#--experimental-test-module-mocks)
+             * command-line flag.
+             *
+             * The following example demonstrates how a mock is created for a module.
+             *
+             * ```js
+             * test('mocks a builtin module in both module systems', async (t) => {
+             *   // Create a mock of 'node:readline' with a named export named 'fn', which
+             *   // does not exist in the original 'node:readline' module.
+             *   const mock = t.mock.module('node:readline', {
+             *     namedExports: { fn() { return 42; } },
+             *   });
              *
-             * Only available through the [--experimental-test-module-mocks](https://nodejs.org/api/cli.html#--experimental-test-module-mocks) flag.
+             *   let esmImpl = await import('node:readline');
+             *   let cjsImpl = require('node:readline');
+             *
+             *   // cursorTo() is an export of the original 'node:readline' module.
+             *   assert.strictEqual(esmImpl.cursorTo, undefined);
+             *   assert.strictEqual(cjsImpl.cursorTo, undefined);
+             *   assert.strictEqual(esmImpl.fn(), 42);
+             *   assert.strictEqual(cjsImpl.fn(), 42);
+             *
+             *   mock.restore();
+             *
+             *   // The mock is restored, so the original builtin module is returned.
+             *   esmImpl = await import('node:readline');
+             *   cjsImpl = require('node:readline');
+             *
+             *   assert.strictEqual(typeof esmImpl.cursorTo, 'function');
+             *   assert.strictEqual(typeof cjsImpl.cursorTo, 'function');
+             *   assert.strictEqual(esmImpl.fn, undefined);
+             *   assert.strictEqual(cjsImpl.fn, undefined);
+             * });
+             * ```
              * @since v22.3.0
              * @experimental
              * @param specifier A string identifying the module to mock.
              * @param options Optional configuration options for the mock module.
              */
             module(specifier: string, options?: MockModuleOptions): MockModuleContext;
+            /**
+             * Creates a mock for a property value on an object. This allows you to track and control access to a specific property,
+             * including how many times it is read (getter) or written (setter), and to restore the original value after mocking.
+             *
+             * ```js
+             * test('mocks a property value', (t) => {
+             *   const obj = { foo: 42 };
+             *   const prop = t.mock.property(obj, 'foo', 100);
+             *
+             *   assert.strictEqual(obj.foo, 100);
+             *   assert.strictEqual(prop.mock.accessCount(), 1);
+             *   assert.strictEqual(prop.mock.accesses[0].type, 'get');
+             *   assert.strictEqual(prop.mock.accesses[0].value, 100);
+             *
+             *   obj.foo = 200;
+             *   assert.strictEqual(prop.mock.accessCount(), 2);
+             *   assert.strictEqual(prop.mock.accesses[1].type, 'set');
+             *   assert.strictEqual(prop.mock.accesses[1].value, 200);
+             *
+             *   prop.mock.restore();
+             *   assert.strictEqual(obj.foo, 42);
+             * });
+             * ```
+             * @since v24.3.0
+             * @param object The object whose value is being mocked.
+             * @param propertyName The identifier of the property on `object` to mock.
+             * @param value An optional value used as the mock value
+             * for `object[propertyName]`. **Default:** The original property value.
+             * @returns A proxy to the mocked object. The mocked object contains a
+             * special `mock` property, which is an instance of [`MockPropertyContext`][], and
+             * can be used for inspecting and changing the behavior of the mocked property.
+             */
+            property<
+                MockedObject extends object,
+                PropertyName extends keyof MockedObject,
+            >(
+                object: MockedObject,
+                property: PropertyName,
+                value?: MockedObject[PropertyName],
+            ): MockedObject & { mock: MockPropertyContext<MockedObject[PropertyName]> };
             /**
              * This function restores the default behavior of all mocks that were previously
              * created by this `MockTracker` and disassociates the mocks from the `MockTracker` instance. Once disassociated, the mocks can still be used, but the `MockTracker` instance can no longer be
@@ -1829,6 +1921,70 @@ declare module "node:test" {
              */
             restore(): void;
         }
+        /**
+         * @since v24.3.0
+         */
+        class MockPropertyContext<PropertyType = any> {
+            /**
+             * A getter that returns a copy of the internal array used to track accesses (get/set) to
+             * the mocked property. Each entry in the array is an object with the following properties:
+             */
+            readonly accesses: Array<{
+                type: "get" | "set";
+                value: PropertyType;
+                stack: Error;
+            }>;
+            /**
+             * This function returns the number of times that the property was accessed.
+             * This function is more efficient than checking `ctx.accesses.length` because
+             * `ctx.accesses` is a getter that creates a copy of the internal access tracking array.
+             * @returns The number of times that the property was accessed (read or written).
+             */
+            accessCount(): number;
+            /**
+             * This function is used to change the value returned by the mocked property getter.
+             * @param value The new value to be set as the mocked property value.
+             */
+            mockImplementation(value: PropertyType): void;
+            /**
+             * This function is used to change the behavior of an existing mock for a single
+             * invocation. Once invocation `onAccess` has occurred, the mock will revert to
+             * whatever behavior it would have used had `mockImplementationOnce()` not been
+             * called.
+             *
+             * The following example creates a mock function using `t.mock.property()`, calls the
+             * mock property, changes the mock implementation to a different value for the
+             * next invocation, and then resumes its previous behavior.
+             *
+             * ```js
+             * test('changes a mock behavior once', (t) => {
+             *   const obj = { foo: 1 };
+             *
+             *   const prop = t.mock.property(obj, 'foo', 5);
+             *
+             *   assert.strictEqual(obj.foo, 5);
+             *   prop.mock.mockImplementationOnce(25);
+             *   assert.strictEqual(obj.foo, 25);
+             *   assert.strictEqual(obj.foo, 5);
+             * });
+             * ```
+             * @param value The value to be used as the mock's
+             * implementation for the invocation number specified by `onAccess`.
+             * @param onAccess The invocation number that will use `value`. If
+             * the specified invocation has already occurred then an exception is thrown.
+             * **Default:** The number of the next invocation.
+             */
+            mockImplementationOnce(value: PropertyType, onAccess?: number): void;
+            /**
+             * Resets the access history of the mocked property.
+             */
+            resetAccesses(): void;
+            /**
+             * Resets the implementation of the mock property to its original behavior. The
+             * mock can still be used after calling this function.
+             */
+            restore(): void;
+        }
         interface MockTimersOptions {
             apis: ReadonlyArray<"setInterval" | "setTimeout" | "setImmediate" | "Date">;
             now?: number | Date | undefined;
@@ -1844,7 +2000,6 @@ declare module "node:test" {
          * The `MockTracker` provides a top-level `timers` export
          * which is a `MockTimers` instance.
          * @since v20.4.0
-         * @experimental
          */
         interface MockTimers {
             /**
@@ -2117,7 +2272,7 @@ declare module "node:test" {
  * import test from 'node:test/reporters';
  * ```
  * @since v19.9.0
- * @see [source](https://github.com/nodejs/node/blob/v22.x/lib/test/reporters.js)
+ * @see [source](https://github.com/nodejs/node/blob/v24.x/lib/test/reporters.js)
  */
 declare module "node:test/reporters" {
     import { Transform, TransformOptions } from "node:stream";
@@ -2136,7 +2291,8 @@ declare module "node:test/reporters" {
         | { type: "test:stderr"; data: EventData.TestStderr }
         | { type: "test:stdout"; data: EventData.TestStdout }
         | { type: "test:summary"; data: EventData.TestSummary }
-        | { type: "test:watch:drained"; data: undefined };
+        | { type: "test:watch:drained"; data: undefined }
+        | { type: "test:watch:restarted"; data: undefined };
     type TestEventGenerator = AsyncGenerator<TestEvent, void>;
 
     interface ReporterConstructorWrapper<T extends new(...args: any[]) => Transform> {
@@ -2174,10 +2330,10 @@ declare module "node:test/reporters" {
     }
     /**
      * The `lcov` reporter outputs test coverage when used with the
-     * [`--experimental-test-coverage`](https://nodejs.org/docs/latest-v22.x/api/cli.html#--experimental-test-coverage) flag.
+     * [`--experimental-test-coverage`](https://nodejs.org/docs/latest-v24.x/api/cli.html#--experimental-test-coverage) flag.
      * @since v22.0.0
      */
-    const lcov: LcovReporter;
+    const lcov: ReporterConstructorWrapper<typeof LcovReporter>;
 
     export { dot, junit, lcov, spec, tap, TestEvent };
 }

package/generator-adapter/node_modules/@types/node/timers/promises.d.ts

@@ -11,7 +11,7 @@
  * } from 'node:timers/promises';
  * ```
  * @since v15.0.0
- * @see [source](https://github.com/nodejs/node/blob/v22.x/lib/timers/promises.js)
+ * @see [source](https://github.com/nodejs/node/blob/v24.x/lib/timers/promises.js)
  */
 declare module "timers/promises" {
     import { TimerOptions } from "node:timers";