node-red-contrib-tak-registration 0.11.5 → 0.12.0

package/node_modules/@types/node/test.d.ts

@@ -18,14 +18,14 @@
  *
  * 1. A synchronous function that is considered failing if it throws an exception,
  * and is considered passing otherwise.
- * 2. A function that returns a `Promise` that is considered failing if the`Promise` rejects, and is considered passing if the `Promise` fulfills.
+ * 2. A function that returns a `Promise` that is considered failing if the `Promise` rejects, and is considered passing if the `Promise` fulfills.
  * 3. A function that receives a callback function. If the callback receives any
  * truthy value as its first argument, the test is considered failing. If a
  * falsy value is passed as the first argument to the callback, the test is
  * considered passing. If the test function receives a callback function and
  * also returns a `Promise`, the test will fail.
  *
- * The following example illustrates how tests are written using the`test` module.
+ * The following example illustrates how tests are written using the `test` module.
  *
  * ```js
  * test('synchronous passing test', (t) => {
@@ -76,12 +76,17 @@
  *
  * 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/v20.4.0/lib/test.js)
+ * @see [source](https://github.com/nodejs/node/blob/v20.13.1/lib/test.js)
  */
 declare module "node:test" {
     import { Readable } from "node:stream";
     import { AsyncResource } from "node:async_hooks";
     /**
+     * **Note:** `shard` is used to horizontally parallelize test running across
+     * machines or processes, ideal for large-scale executions across varied
+     * environments. It's incompatible with `watch` mode, tailored for rapid
+     * code iteration by automatically rerunning tests on file changes.
+     *
      * ```js
      * import { tap } from 'node:test/reporters';
      * import { run } from 'node:test';
@@ -105,7 +110,7 @@ declare module "node:test" {
      * additional diagnostic information, or creating subtests.
      *
      * `test()` returns a `Promise` that fulfills once the test completes.
-     * if `test()` is called within a `describe()` block, it fulfills immediately.
+     * if `test()` is called within a suite, it fulfills immediately.
      * The return value can usually be discarded for top level tests.
      * However, the return value from subtests should be used to prevent the parent
      * test from finishing first and cancelling the subtest
@@ -124,15 +129,15 @@ declare module "node:test" {
      * });
      * ```
      *
-     * The `timeout` option can be used to fail the test if it takes longer than`timeout` milliseconds to complete. However, it is not a reliable mechanism for
+     * The `timeout` option can be used to fail the test if it takes longer than `timeout` milliseconds to complete. However, it is not a reliable mechanism for
      * canceling tests because a running test might block the application thread and
      * thus prevent the scheduled cancellation.
      * @since v18.0.0, v16.17.0
      * @param [name='The name'] The name of the test, which is displayed when reporting test results.
      * @param options Configuration options for the test. The following properties are supported:
-     * @param [fn='A no-op function'] The function under test. The first argument to this function is a {@link TestContext} object. If the test uses callbacks, the callback function is passed as the
-     * second argument.
-     * @return Fulfilled with `undefined` once the test completes, or immediately if the test runs within {@link describe}.
+     * @param [fn='A no-op function'] The function under test. The first argument to this function is a {@link TestContext} object. If the test uses callbacks, the
+     * callback function is passed as the second argument.
+     * @return Fulfilled with `undefined` once the test completes, or immediately if the test runs within a suite.
      */
     function test(name?: string, fn?: TestFn): Promise<void>;
     function test(name?: string, options?: TestOptions, fn?: TestFn): Promise<void>;
@@ -142,14 +147,47 @@ declare module "node:test" {
         export { after, afterEach, before, beforeEach, describe, it, mock, only, run, skip, test, todo };
     }
     /**
-     * The `describe()` function imported from the `node:test` module. Each
-     * invocation of this function results in the creation of a Subtest.
-     * After invocation of top level `describe` functions,
-     * all top level tests and suites will execute.
-     * @param [name='The name'] The name of the suite, which is displayed when reporting test results.
-     * @param options Configuration options for the suite. supports the same options as `test([name][, options][, fn])`.
-     * @param [fn='A no-op function'] The function under suite declaring all subtests and subsuites. The first argument to this function is a {@link SuiteContext} object.
+     * The `suite()` function is imported from the `node:test` module.
+     * @param name The name of the suite, which is displayed when reporting test results. **Default:** The `name` property of `fn`, or `'<anonymous>'` if `fn` does not have a name.
+     * @param options Optional configuration options for the suite. This supports the same options as `test([name][, options][, fn])`.
+     * @param [fn='A no-op function'] The suite function declaring nested tests and suites. The first argument to this function is a `{@link SuiteContext}` object.
      * @return Immediately fulfilled with `undefined`.
+     * @since v20.13.0
+     */
+    function suite(name?: string, options?: TestOptions, fn?: SuiteFn): Promise<void>;
+    function suite(name?: string, fn?: SuiteFn): Promise<void>;
+    function suite(options?: TestOptions, fn?: SuiteFn): Promise<void>;
+    function suite(fn?: SuiteFn): Promise<void>;
+    namespace suite {
+        /**
+         * Shorthand for skipping a suite. This is the same as [`suite([name], { skip: true }[, fn])`](https://nodejs.org/docs/latest-v20.x/api/test.html#suitename-options-fn).
+         * @since v20.13.0
+         */
+        function skip(name?: string, options?: TestOptions, fn?: SuiteFn): Promise<void>;
+        function skip(name?: string, fn?: SuiteFn): Promise<void>;
+        function skip(options?: TestOptions, fn?: SuiteFn): Promise<void>;
+        function skip(fn?: SuiteFn): Promise<void>;
+        /**
+         * Shorthand for marking a suite as `TODO`. This is the same as [`suite([name], { todo: true }[, fn])`](https://nodejs.org/docs/latest-v20.x/api/test.html#suitename-options-fn).
+         * @since v20.13.0
+         */
+        function todo(name?: string, options?: TestOptions, fn?: SuiteFn): Promise<void>;
+        function todo(name?: string, fn?: SuiteFn): Promise<void>;
+        function todo(options?: TestOptions, fn?: SuiteFn): Promise<void>;
+        function todo(fn?: SuiteFn): Promise<void>;
+        /**
+         * Shorthand for marking a suite as `only`. This is the same as [`suite([name], { only: true }[, fn])`](https://nodejs.org/docs/latest-v20.x/api/test.html#suitename-options-fn).
+         * @since v20.13.0
+         */
+        function only(name?: string, options?: TestOptions, fn?: SuiteFn): Promise<void>;
+        function only(name?: string, fn?: SuiteFn): Promise<void>;
+        function only(options?: TestOptions, fn?: SuiteFn): Promise<void>;
+        function only(fn?: SuiteFn): Promise<void>;
+    }
+    /**
+     * Alias for `{@link suite}`.
+     *
+     * The `describe()` function is imported from the `node:test` module.
      */
     function describe(name?: string, options?: TestOptions, fn?: SuiteFn): Promise<void>;
     function describe(name?: string, fn?: SuiteFn): Promise<void>;
@@ -157,21 +195,23 @@ declare module "node:test" {
     function describe(fn?: SuiteFn): Promise<void>;
     namespace describe {
         /**
-         * Shorthand for skipping a suite, same as `describe([name], { skip: true }[, fn])`.
+         * Shorthand for skipping a suite. This is the same as [`describe([name], { skip: true }[, fn])`](https://nodejs.org/docs/latest-v20.x/api/test.html#describename-options-fn).
+         * @since v18.15.0
          */
         function skip(name?: string, options?: TestOptions, fn?: SuiteFn): Promise<void>;
         function skip(name?: string, fn?: SuiteFn): Promise<void>;
         function skip(options?: TestOptions, fn?: SuiteFn): Promise<void>;
         function skip(fn?: SuiteFn): Promise<void>;
         /**
-         * Shorthand for marking a suite as `TODO`, same as `describe([name], { todo: true }[, fn])`.
+         * Shorthand for marking a suite as `TODO`. This is the same as [`describe([name], { todo: true }[, fn])`](https://nodejs.org/docs/latest-v20.x/api/test.html#describename-options-fn).
+         * @since v18.15.0
          */
         function todo(name?: string, options?: TestOptions, fn?: SuiteFn): Promise<void>;
         function todo(name?: string, fn?: SuiteFn): Promise<void>;
         function todo(options?: TestOptions, fn?: SuiteFn): Promise<void>;
         function todo(fn?: SuiteFn): Promise<void>;
         /**
-         * Shorthand for marking a suite as `only`, same as `describe([name], { only: true }[, fn])`.
+         * Shorthand for marking a suite as `only`. This is the same as [`describe([name], { only: true }[, fn])`](https://nodejs.org/docs/latest-v20.x/api/test.html#describename-options-fn).
          * @since v18.15.0
          */
         function only(name?: string, options?: TestOptions, fn?: SuiteFn): Promise<void>;
@@ -180,7 +220,7 @@ declare module "node:test" {
         function only(fn?: SuiteFn): Promise<void>;
     }
     /**
-     * Shorthand for `test()`.
+     * Alias for `test()`.
      *
      * The `it()` function is imported from the `node:test` module.
      * @since v18.6.0, v16.17.0
@@ -259,49 +299,57 @@ declare module "node:test" {
     }
     interface RunOptions {
         /**
-         * If a number is provided, then that many files would run in parallel.
-         * If truthy, it would run (number of cpu cores - 1) files in parallel.
-         * If falsy, it would only run one file at a time.
-         * If unspecified, subtests inherit this value from their parent.
-         * @default true
+         * If a number is provided, then that many test processes would run in parallel, where each process corresponds to one test file.
+         * If `true`, it would run `os.availableParallelism() - 1` test files in parallel. If `false`, it would only run one test file at a time.
+         * @default false
          */
         concurrency?: number | boolean | undefined;
         /**
-         * An array containing the list of files to run.
-         * If unspecified, the test runner execution model will be used.
+         * An array containing the list of files to run. **Default** matching files from
+         * [test runner execution model](https://nodejs.org/docs/latest-v20.x/api/test.html#test-runner-execution-model).
          */
         files?: readonly string[] | undefined;
         /**
-         * Allows aborting an in-progress test execution.
-         * @default undefined
-         */
-        signal?: AbortSignal | undefined;
-        /**
-         * A number of milliseconds the test will fail after.
-         * If unspecified, subtests inherit this value from their parent.
-         * @default Infinity
+         * Configures the test runner to exit the process once all known
+         * tests have finished executing even if the event loop would
+         * otherwise remain active.
+         * @default false
          */
-        timeout?: number | undefined;
+        forceExit?: boolean | undefined;
         /**
          * Sets inspector port of test child process.
          * If a nullish value is provided, each process gets its own port,
          * incremented from the primary's `process.debugPort`.
+         * @default undefined
          */
         inspectPort?: number | (() => number) | undefined;
-        /**
-         * That can be used to only run tests whose name matches the provided pattern.
-         * Test name patterns are interpreted as JavaScript regular expressions.
-         * For each test that is executed, any corresponding test hooks, such as `beforeEach()`, are also run.
-         */
-        testNamePatterns?: string | RegExp | string[] | RegExp[];
         /**
          * If truthy, the test context will only run tests that have the `only` option set
          */
         only?: boolean;
         /**
-         * A function that accepts the TestsStream instance and can be used to setup listeners before any tests are run.
+         * A function that accepts the `TestsStream` instance and can be used to setup listeners before any tests are run.
+         * @default undefined
          */
         setup?: (root: Test) => void | Promise<void>;
+        /**
+         * Allows aborting an in-progress test execution.
+         */
+        signal?: AbortSignal | undefined;
+        /**
+         * A String, RegExp or a RegExp Array, that can be used to only run tests whose
+         * name matches the provided pattern. Test name patterns are interpreted as JavaScript
+         * regular expressions. For each test that is executed, any corresponding test hooks,
+         * such as `beforeEach()`, are also run.
+         * @default undefined
+         */
+        testNamePatterns?: string | RegExp | string[] | RegExp[];
+        /**
+         * A number of milliseconds the test execution will fail after.
+         * If unspecified, subtests inherit this value from their parent.
+         * @default Infinity
+         */
+        timeout?: number | undefined;
         /**
          * Whether to run in watch mode or not.
          * @default false
@@ -323,12 +371,18 @@ declare module "node:test" {
         timeout: number | null;
     }
     /**
-     * A successful call to `run()` method will return a new `TestsStream` object, streaming a series of events representing the execution of the tests.`TestsStream` will emit events, in the
+     * A successful call to `run()` method will return a new `TestsStream` object, streaming a series of events representing the execution of the tests. `TestsStream` will emit events, in the
      * order of the tests definition
+     *
+     * Some of the events are guaranteed to be emitted in the same order as the tests are defined, while others are emitted in the order that the tests execute.
      * @since v18.9.0, v16.19.0
      */
     class TestsStream extends Readable implements NodeJS.ReadableStream {
+        addListener(event: "test:coverage", listener: (data: TestCoverage) => void): this;
+        addListener(event: "test:complete", listener: (data: TestComplete) => void): this;
+        addListener(event: "test:dequeue", listener: (data: TestDequeue) => void): this;
         addListener(event: "test:diagnostic", listener: (data: DiagnosticData) => void): this;
+        addListener(event: "test:enqueue", listener: (data: TestEnqueue) => void): this;
         addListener(event: "test:fail", listener: (data: TestFail) => void): this;
         addListener(event: "test:pass", listener: (data: TestPass) => void): this;
         addListener(event: "test:plan", listener: (data: TestPlan) => void): this;
@@ -336,7 +390,11 @@ declare module "node:test" {
         addListener(event: "test:stderr", listener: (data: TestStderr) => void): this;
         addListener(event: "test:stdout", listener: (data: TestStdout) => void): this;
         addListener(event: string, listener: (...args: any[]) => void): this;
+        emit(event: "test:coverage", data: TestCoverage): boolean;
+        emit(event: "test:complete", data: TestComplete): boolean;
+        emit(event: "test:dequeue", data: TestDequeue): boolean;
         emit(event: "test:diagnostic", data: DiagnosticData): boolean;
+        emit(event: "test:enqueue", data: TestEnqueue): boolean;
         emit(event: "test:fail", data: TestFail): boolean;
         emit(event: "test:pass", data: TestPass): boolean;
         emit(event: "test:plan", data: TestPlan): boolean;
@@ -344,7 +402,11 @@ declare module "node:test" {
         emit(event: "test:stderr", data: TestStderr): boolean;
         emit(event: "test:stdout", data: TestStdout): boolean;
         emit(event: string | symbol, ...args: any[]): boolean;
+        on(event: "test:coverage", listener: (data: TestCoverage) => void): this;
+        on(event: "test:complete", listener: (data: TestComplete) => void): this;
+        on(event: "test:dequeue", listener: (data: TestDequeue) => void): this;
         on(event: "test:diagnostic", listener: (data: DiagnosticData) => void): this;
+        on(event: "test:enqueue", listener: (data: TestEnqueue) => void): this;
         on(event: "test:fail", listener: (data: TestFail) => void): this;
         on(event: "test:pass", listener: (data: TestPass) => void): this;
         on(event: "test:plan", listener: (data: TestPlan) => void): this;
@@ -352,7 +414,11 @@ declare module "node:test" {
         on(event: "test:stderr", listener: (data: TestStderr) => void): this;
         on(event: "test:stdout", listener: (data: TestStdout) => void): this;
         on(event: string, listener: (...args: any[]) => void): this;
+        once(event: "test:coverage", listener: (data: TestCoverage) => void): this;
+        once(event: "test:complete", listener: (data: TestComplete) => void): this;
+        once(event: "test:dequeue", listener: (data: TestDequeue) => void): this;
         once(event: "test:diagnostic", listener: (data: DiagnosticData) => void): this;
+        once(event: "test:enqueue", listener: (data: TestEnqueue) => void): this;
         once(event: "test:fail", listener: (data: TestFail) => void): this;
         once(event: "test:pass", listener: (data: TestPass) => void): this;
         once(event: "test:plan", listener: (data: TestPlan) => void): this;
@@ -360,7 +426,11 @@ declare module "node:test" {
         once(event: "test:stderr", listener: (data: TestStderr) => void): this;
         once(event: "test:stdout", listener: (data: TestStdout) => void): this;
         once(event: string, listener: (...args: any[]) => void): this;
+        prependListener(event: "test:coverage", listener: (data: TestCoverage) => void): this;
+        prependListener(event: "test:complete", listener: (data: TestComplete) => void): this;
+        prependListener(event: "test:dequeue", listener: (data: TestDequeue) => void): this;
         prependListener(event: "test:diagnostic", listener: (data: DiagnosticData) => void): this;
+        prependListener(event: "test:enqueue", listener: (data: TestEnqueue) => void): this;
         prependListener(event: "test:fail", listener: (data: TestFail) => void): this;
         prependListener(event: "test:pass", listener: (data: TestPass) => void): this;
         prependListener(event: "test:plan", listener: (data: TestPlan) => void): this;
@@ -368,7 +438,11 @@ declare module "node:test" {
         prependListener(event: "test:stderr", listener: (data: TestStderr) => void): this;
         prependListener(event: "test:stdout", listener: (data: TestStdout) => void): this;
         prependListener(event: string, listener: (...args: any[]) => void): this;
+        prependOnceListener(event: "test:coverage", listener: (data: TestCoverage) => void): this;
+        prependOnceListener(event: "test:complete", listener: (data: TestComplete) => void): this;
+        prependOnceListener(event: "test:dequeue", listener: (data: TestDequeue) => void): this;
         prependOnceListener(event: "test:diagnostic", listener: (data: DiagnosticData) => void): this;
+        prependOnceListener(event: "test:enqueue", listener: (data: TestEnqueue) => void): this;
         prependOnceListener(event: "test:fail", listener: (data: TestFail) => void): this;
         prependOnceListener(event: "test:pass", listener: (data: TestPass) => void): this;
         prependOnceListener(event: "test:plan", listener: (data: TestPlan) => void): this;
@@ -387,7 +461,7 @@ declare module "node:test" {
         /**
          * 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.
+         *    the second argument. **Default:** A no-op function.
          * @param options Configuration options for the hook.
          * @since v20.1.0
          */
@@ -395,14 +469,14 @@ declare module "node:test" {
         /**
          * 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.
+         *    the second argument. **Default:** A no-op function.
          * @param options Configuration options for the hook.
          * @since v18.8.0
          */
         beforeEach: typeof beforeEach;
         /**
          * 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
+         * @param [fn='A no-op function'] The hook function. If the hook uses callbacks, the callback function is passed as
          *    the second argument. Default: A no-op function.
          * @param options Configuration options for the hook.
          * @since v18.13.0
@@ -411,7 +485,7 @@ declare module "node:test" {
         /**
          * 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.
+         *    the second argument. **Default:** A no-op function.
          * @param options Configuration options for the hook.
          * @since v18.8.0
          */
@@ -465,7 +539,7 @@ declare module "node:test" {
          */
         readonly signal: AbortSignal;
         /**
-         * This function causes the test's output to indicate the test as skipped. If`message` is provided, it is included in the output. Calling `skip()` does
+         * This function causes the test's output to indicate the test as skipped. If `message` is provided, it is included in the output. Calling `skip()` does
          * not terminate execution of the test function. This function does not return a
          * value.
          *
@@ -503,7 +577,7 @@ declare module "node:test" {
          * @param options Configuration options for the test
          * @param fn The function under test. This first argument to this function is a
          *    {@link TestContext} object. If the test uses callbacks, the callback function is
-         *    passed as the second argument. Default: A no-op function.
+         *    passed as the second argument. **Default:** A no-op function.
          * @returns A {@link Promise} resolved with `undefined` once the test completes.
          */
         test: typeof test;
@@ -512,6 +586,7 @@ declare module "node:test" {
          */
         readonly mock: MockTracker;
     }
+
     /**
      * An instance of `SuiteContext` is passed to each suite function in order to
      * interact with the test runner. However, the `SuiteContext` constructor is not
@@ -572,7 +647,7 @@ declare module "node:test" {
         todo?: boolean | string | undefined;
     }
     /**
-     * This function is used to create a hook running before running a suite.
+     * This function creates a hook that runs before executing a suite.
      *
      * ```js
      * describe('tests', async () => {
@@ -588,7 +663,7 @@ declare module "node:test" {
      */
     function before(fn?: HookFn, options?: HookOptions): void;
     /**
-     * This function is used to create a hook running after  running a suite.
+     * This function creates a hook that runs after executing a suite.
      *
      * ```js
      * describe('tests', async () => {
@@ -604,8 +679,7 @@ declare module "node:test" {
      */
     function after(fn?: HookFn, options?: HookOptions): void;
     /**
-     * This function is used to create a hook running
-     * before each subtest of the current suite.
+     * This function creates a hook that runs before each test in the current suite.
      *
      * ```js
      * describe('tests', async () => {
@@ -621,8 +695,8 @@ declare module "node:test" {
      */
     function beforeEach(fn?: HookFn, options?: HookOptions): void;
     /**
-     * This function is used to create a hook running
-     * after each subtest of the current test.
+     * This function creates a hook that runs after each test in the current suite.
+     * The `afterEach()` hook is run even if the test fails.
      *
      * ```js
      * describe('tests', async () => {
@@ -690,7 +764,7 @@ declare module "node:test" {
     /**
      * The `MockTracker` class is used to manage mocking functionality. The test runner
      * module provides a top level `mock` export which is a `MockTracker` instance.
-     * Each test also provides its own `MockTracker` instance via the test context's`mock` property.
+     * Each test also provides its own `MockTracker` instance via the test context's `mock` property.
      * @since v19.1.0, v18.13.0
      */
     class MockTracker {
@@ -806,7 +880,7 @@ declare module "node:test" {
         ): Mock<Function>;
 
         /**
-         * This function is syntax sugar for `MockTracker.method` with `options.getter`set to `true`.
+         * This function is syntax sugar for `MockTracker.method` with `options.getter` set to `true`.
          * @since v19.3.0, v18.13.0
          */
         getter<
@@ -828,7 +902,7 @@ declare module "node:test" {
             options?: MockFunctionOptions,
         ): Mock<(() => MockedObject[MethodName]) | Implementation>;
         /**
-         * This function is syntax sugar for `MockTracker.method` with `options.setter`set to `true`.
+         * This function is syntax sugar for `MockTracker.method` with `options.setter` set to `true`.
          * @since v19.3.0, v18.13.0
          */
         setter<
@@ -851,11 +925,11 @@ declare module "node:test" {
         ): Mock<((value: MockedObject[MethodName]) => void) | Implementation>;
         /**
          * 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
+         * 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
          * used to reset their behavior or
          * otherwise interact with them.
          *
-         * After each test completes, this function is called on the test context's`MockTracker`. If the global `MockTracker` is used extensively, calling this
+         * After each test completes, this function is called on the test context's `MockTracker`. If the global `MockTracker` is used extensively, calling this
          * function manually is recommended.
          * @since v19.1.0, v18.13.0
          */
@@ -921,7 +995,7 @@ declare module "node:test" {
         readonly calls: Array<MockFunctionCall<F>>;
         /**
          * This function returns the number of times that this mock has been invoked. This
-         * function is more efficient than checking `ctx.calls.length` because `ctx.calls`is a getter that creates a copy of the internal call tracking array.
+         * function is more efficient than checking `ctx.calls.length` because `ctx.calls` is a getter that creates a copy of the internal call tracking array.
          * @since v19.1.0, v18.13.0
          * @return The number of times that this mock has been invoked.
          */
@@ -957,7 +1031,7 @@ declare module "node:test" {
          * @since v19.1.0, v18.13.0
          * @param implementation The function to be used as the mock's new implementation.
          */
-        mockImplementation(implementation: Function): void;
+        mockImplementation(implementation: F): void;
         /**
          * This function is used to change the behavior of an existing mock for a single
          * invocation. Once invocation `onCall` has occurred, the mock will revert to
@@ -994,7 +1068,7 @@ declare module "node:test" {
          * @param implementation The function to be used as the mock's implementation for the invocation number specified by `onCall`.
          * @param onCall The invocation number that will use `implementation`. If the specified invocation has already occurred then an exception is thrown.
          */
-        mockImplementationOnce(implementation: Function, onCall?: number): void;
+        mockImplementationOnce(implementation: F, onCall?: number): void;
         /**
          * Resets the call history of the mock function.
          * @since v19.3.0, v18.13.0
@@ -1007,12 +1081,20 @@ declare module "node:test" {
          */
         restore(): void;
     }
-    type Timer = "setInterval" | "clearInterval" | "setTimeout" | "clearTimeout";
+    type Timer = "setInterval" | "setTimeout" | "setImmediate" | "Date";
+
+    interface MockTimersOptions {
+        apis: Timer[];
+        now?: number | Date;
+    }
     /**
      * Mocking timers is a technique commonly used in software testing to simulate and
      * control the behavior of timers, such as `setInterval` and `setTimeout`,
      * without actually waiting for the specified time intervals.
      *
+     * The MockTimers API also allows for mocking of the `Date` constructor and
+     * `setImmediate`/`clearImmediate` functions.
+     *
      * The `MockTracker` provides a top-level `timers` export
      * which is a `MockTimers` instance.
      * @since v20.4.0
@@ -1025,24 +1107,68 @@ declare module "node:test" {
          * **Note:** When you enable mocking for a specific timer, its associated
          * clear function will also be implicitly mocked.
          *
-         * Example usage:
+         * **Note:** Mocking `Date` will affect the behavior of the mocked timers
+         * as they use the same internal clock.
+         *
+         * Example usage without setting initial time:
+         *
+         * ```js
+         * import { mock } from 'node:test';
+         * mock.timers.enable({ apis: ['setInterval', 'Date'], now: 1234 });
+         * ```
+         *
+         * The above example enables mocking for the `Date` constructor, `setInterval` timer and
+         * implicitly mocks the `clearInterval` function. Only the `Date` constructor from `globalThis`,
+         * `setInterval` and `clearInterval` functions from `node:timers`, `node:timers/promises`, and `globalThis` will be mocked.
+         *
+         * Example usage with initial time set
          *
          * ```js
          * import { mock } from 'node:test';
-         * mock.timers.enable(['setInterval']);
+         * mock.timers.enable({ apis: ['Date'], now: 1000 });
          * ```
          *
-         * The above example enables mocking for the `setInterval` timer and
-         * implicitly mocks the `clearInterval` function. Only the `setInterval`and `clearInterval` functions from `node:timers`,`node:timers/promises`, and`globalThis` will be mocked.
+         * Example usage with initial Date object as time set
+         *
+         * ```js
+         * import { mock } from 'node:test';
+         * mock.timers.enable({ apis: ['Date'], now: new Date() });
+         * ```
          *
          * Alternatively, if you call `mock.timers.enable()` without any parameters:
          *
-         * All timers (`'setInterval'`, `'clearInterval'`, `'setTimeout'`, and `'clearTimeout'`)
-         * will be mocked. The `setInterval`, `clearInterval`, `setTimeout`, and `clearTimeout`functions from `node:timers`, `node:timers/promises`,
+         * All timers (`'setInterval'`, `'clearInterval'`, `'Date'`, `'setImmediate'`, `'clearImmediate'`, `'setTimeout'`, and `'clearTimeout'`)
+         * will be mocked.
+         *
+         * The `setInterval`, `clearInterval`, `setTimeout`, and `clearTimeout` functions from `node:timers`, `node:timers/promises`,
          * and `globalThis` will be mocked.
+         * The `Date` constructor from `globalThis` will be mocked.
+         *
+         * If there is no initial epoch set, the initial date will be based on 0 in the Unix epoch. This is `January 1st, 1970, 00:00:00 UTC`. You can
+         * set an initial date by passing a now property to the `.enable()` method. This value will be used as the initial date for the mocked Date
+         * object. It can either be a positive integer, or another Date object.
          * @since v20.4.0
          */
-        enable(timers?: Timer[]): void;
+        enable(options?: MockTimersOptions): void;
+        /**
+         * You can use the `.setTime()` method to manually move the mocked date to another time. This method only accepts a positive integer.
+         * Note: This method will execute any mocked timers that are in the past from the new time.
+         * In the below example we are setting a new time for the mocked date.
+         * ```js
+         * import assert from 'node:assert';
+         * import { test } from 'node:test';
+         * test('sets the time of a date object', (context) => {
+         *   // Optionally choose what to mock
+         *   context.mock.timers.enable({ apis: ['Date'], now: 100 });
+         *   assert.strictEqual(Date.now(), 100);
+         *   // Advance in time will also advance the date
+         *   context.mock.timers.setTime(1000);
+         *   context.mock.timers.tick(200);
+         *   assert.strictEqual(Date.now(), 1200);
+         * });
+         * ```
+         */
+        setTime(time: number): void;
         /**
          * This function restores the default behavior of all mocks that were previously
          * created by this `MockTimers` instance and disassociates the mocks
@@ -1076,7 +1202,7 @@ declare module "node:test" {
          * test('mocks setTimeout to be executed synchronously without having to actually wait for it', (context) => {
          *   const fn = context.mock.fn();
          *
-         *   context.mock.timers.enable(['setTimeout']);
+         *   context.mock.timers.enable({ apis: ['setTimeout'] });
          *
          *   setTimeout(fn, 9999);
          *
@@ -1097,7 +1223,7 @@ declare module "node:test" {
          *
          * test('mocks setTimeout to be executed synchronously without having to actually wait for it', (context) => {
          *   const fn = context.mock.fn();
-         *   context.mock.timers.enable(['setTimeout']);
+         *   context.mock.timers.enable({ apis: ['setTimeout'] });
          *   const nineSecs = 9000;
          *   setTimeout(fn, nineSecs);
          *
@@ -1109,11 +1235,35 @@ declare module "node:test" {
          *   assert.strictEqual(fn.mock.callCount(), 1);
          * });
          * ```
+         *
+         * Advancing time using `.tick` will also advance the time for any `Date` object
+         * created after the mock was enabled (if `Date` was also set to be mocked).
+         *
+         * ```js
+         * import assert from 'node:assert';
+         * import { test } from 'node:test';
+         *
+         * test('mocks setTimeout to be executed synchronously without having to actually wait for it', (context) => {
+         *   const fn = context.mock.fn();
+         *
+         *   context.mock.timers.enable({ apis: ['setTimeout', 'Date'] });
+         *   setTimeout(fn, 9999);
+         *
+         *   assert.strictEqual(fn.mock.callCount(), 0);
+         *   assert.strictEqual(Date.now(), 0);
+         *
+         *   // Advance in time
+         *   context.mock.timers.tick(9999);
+         *   assert.strictEqual(fn.mock.callCount(), 1);
+         *   assert.strictEqual(Date.now(), 9999);
+         * });
+         * ```
          * @since v20.4.0
          */
         tick(milliseconds: number): void;
         /**
-         * Triggers all pending mocked timers immediately.
+         * Triggers all pending mocked timers immediately. If the `Date` object is also
+         * mocked, it will also advance the `Date` object to the furthest timer's time.
          *
          * The example below triggers all pending timers immediately,
          * causing them to execute without any delay.
@@ -1123,7 +1273,7 @@ declare module "node:test" {
          * import { test } from 'node:test';
          *
          * test('runAll functions following the given order', (context) => {
-         *   context.mock.timers.enable(['setTimeout']);
+         *   context.mock.timers.enable({ apis: ['setTimeout', 'Date'] });
          *   const results = [];
          *   setTimeout(() => results.push(1), 9999);
          *
@@ -1135,8 +1285,9 @@ declare module "node:test" {
          *   assert.deepStrictEqual(results, []);
          *
          *   context.mock.timers.runAll();
-         *
          *   assert.deepStrictEqual(results, [3, 2, 1]);
+         *   // The Date object is also advanced to the furthest timer's time
+         *   assert.strictEqual(Date.now(), 9999);
          * });
          * ```
          *
@@ -1164,8 +1315,10 @@ declare module "node:test" {
         only,
         run,
         skip,
+        SuiteContext,
         test,
         test as default,
+        TestContext,
         todo,
     };
 }
@@ -1177,12 +1330,11 @@ interface TestLocationInfo {
      */
     column?: number;
     /**
-     * The path of the test file, `undefined` if test is not ran through a file.
+     * The path of the test file, `undefined` if test was run through the REPL.
      */
     file?: string;
     /**
-     * The line number where the test is defined, or
-     * `undefined` if the test was run through the REPL.
+     * The line number where the test is defined, or `undefined` if the test was run through the REPL.
      */
     line?: number;
 }
@@ -1196,6 +1348,202 @@ interface DiagnosticData extends TestLocationInfo {
      */
     nesting: number;
 }
+interface TestCoverage {
+    /**
+     * An object containing the coverage report.
+     */
+    summary: {
+        /**
+         * An array of coverage reports for individual files. Each report is an object with the following schema:
+         */
+        files: Array<{
+            /**
+             * The absolute path of the file.
+             */
+            path: string;
+            /**
+             * The total number of lines.
+             */
+            totalLineCount: number;
+            /**
+             * The total number of branches.
+             */
+            totalBranchCount: number;
+            /**
+             * The total number of functions.
+             */
+            totalFunctionCount: number;
+            /**
+             * The number of covered lines.
+             */
+            coveredLineCount: number;
+            /**
+             * The number of covered branches.
+             */
+            coveredBranchCount: number;
+            /**
+             * The number of covered functions.
+             */
+            coveredFunctionCount: number;
+            /**
+             * The percentage of lines covered.
+             */
+            coveredLinePercent: number;
+            /**
+             * The percentage of branches covered.
+             */
+            coveredBranchPercent: number;
+            /**
+             * The percentage of functions covered.
+             */
+            coveredFunctionPercent: number;
+            /**
+             * An array of functions representing function coverage.
+             */
+            functions: Array<{
+                /**
+                 * The name of the function.
+                 */
+                name: string;
+                /**
+                 * The line number where the function is defined.
+                 */
+                line: number;
+                /**
+                 * The number of times the function was called.
+                 */
+                count: number;
+            }>;
+            /**
+             * An array of lines representing line numbers and the number of times they were covered.
+             */
+            lines: Array<{
+                /**
+                 * The line number.
+                 */
+                line: number;
+                /**
+                 * The number of times the line was covered.
+                 */
+                count: number;
+            }>;
+        }>;
+        /**
+         * An object containing a summary of coverage for all files.
+         */
+        totals: {
+            /**
+             * The total number of lines.
+             */
+            totalLineCount: number;
+            /**
+             * The total number of branches.
+             */
+            totalBranchCount: number;
+            /**
+             * The total number of functions.
+             */
+            totalFunctionCount: number;
+            /**
+             * The number of covered lines.
+             */
+            coveredLineCount: number;
+            /**
+             * The number of covered branches.
+             */
+            coveredBranchCount: number;
+            /**
+             * The number of covered functions.
+             */
+            coveredFunctionCount: number;
+            /**
+             * The percentage of lines covered.
+             */
+            coveredLinePercent: number;
+            /**
+             * The percentage of branches covered.
+             */
+            coveredBranchPercent: number;
+            /**
+             * The percentage of functions covered.
+             */
+            coveredFunctionPercent: number;
+        };
+        /**
+         * The working directory when code coverage began. This
+         * is useful for displaying relative path names in case
+         * the tests changed the working directory of the Node.js process.
+         */
+        workingDirectory: string;
+    };
+    /**
+     * The nesting level of the test.
+     */
+    nesting: number;
+}
+interface TestComplete extends TestLocationInfo {
+    /**
+     * Additional execution metadata.
+     */
+    details: {
+        /**
+         * Whether the test passed or not.
+         */
+        passed: boolean;
+        /**
+         * The duration of the test in milliseconds.
+         */
+        duration_ms: number;
+        /**
+         * An error wrapping the error thrown by the test if it did not pass.
+         */
+        error: Error;
+        /**
+         * The type of the test, used to denote whether this is a suite.
+         */
+        type?: "suite";
+    };
+    /**
+     * The test name.
+     */
+    name: string;
+    /**
+     * The nesting level of the test.
+     */
+    nesting: number;
+    /**
+     * The ordinal number of the test.
+     */
+    testNumber: number;
+    /**
+     * Present if `context.todo` is called.
+     */
+    todo?: string | boolean;
+    /**
+     * Present if `context.skip` is called.
+     */
+    skip?: string | boolean;
+}
+interface TestDequeue extends TestLocationInfo {
+    /**
+     * The test name.
+     */
+    name: string;
+    /**
+     * The nesting level of the test.
+     */
+    nesting: number;
+}
+interface TestEnqueue extends TestLocationInfo {
+    /**
+     * The test name.
+     */
+    name: string;
+    /**
+     * The nesting level of the test.
+     */
+    nesting: number;
+}
 interface TestFail extends TestLocationInfo {
     /**
      * Additional execution metadata.
@@ -1206,12 +1554,12 @@ interface TestFail extends TestLocationInfo {
          */
         duration_ms: number;
         /**
-         * The error thrown by the test.
+         * An error wrapping the error thrown by the test if it did not pass.
          */
         error: Error;
         /**
          * The type of the test, used to denote whether this is a suite.
-         * @since 20.0.0, 19.9.0, 18.17.0
+         * @since v20.0.0, v19.9.0, v18.17.0
          */
         type?: "suite";
     };
@@ -1294,36 +1642,16 @@ interface TestStart extends TestLocationInfo {
 }
 interface TestStderr extends TestLocationInfo {
     /**
-     * The message written to `stderr`
+     * The message written to `stderr`.
      */
     message: string;
 }
 interface TestStdout extends TestLocationInfo {
     /**
-     * The message written to `stdout`
+     * The message written to `stdout`.
      */
     message: string;
 }
-interface TestEnqueue extends TestLocationInfo {
-    /**
-     * The test name
-     */
-    name: string;
-    /**
-     * The nesting level of the test.
-     */
-    nesting: number;
-}
-interface TestDequeue extends TestLocationInfo {
-    /**
-     * The test name
-     */
-    name: string;
-    /**
-     * The nesting level of the test.
-     */
-    nesting: number;
-}
 
 /**
  * The `node:test/reporters` module exposes the builtin-reporters for `node:test`.
@@ -1340,21 +1668,23 @@ interface TestDequeue extends TestLocationInfo {
  * import test from 'test/reporters';
  * ```
  * @since v19.9.0
- * @see [source](https://github.com/nodejs/node/blob/v20.2.0/lib/test/reporters.js)
+ * @see [source](https://github.com/nodejs/node/blob/v20.13.1/lib/test/reporters.js)
  */
 declare module "node:test/reporters" {
-    import { Transform } from "node:stream";
+    import { Transform, TransformOptions } from "node:stream";
 
     type TestEvent =
+        | { type: "test:coverage"; data: TestCoverage }
+        | { type: "test:complete"; data: TestComplete }
+        | { type: "test:dequeue"; data: TestDequeue }
         | { type: "test:diagnostic"; data: DiagnosticData }
+        | { type: "test:enqueue"; data: TestEnqueue }
         | { type: "test:fail"; data: TestFail }
         | { type: "test:pass"; data: TestPass }
         | { type: "test:plan"; data: TestPlan }
         | { type: "test:start"; data: TestStart }
         | { type: "test:stderr"; data: TestStderr }
         | { type: "test:stdout"; data: TestStdout }
-        | { type: "test:enqueue"; data: TestEnqueue }
-        | { type: "test:dequeue"; data: TestDequeue }
         | { type: "test:watch:drained" };
     type TestEventGenerator = AsyncGenerator<TestEvent, void>;
 
@@ -1375,8 +1705,14 @@ declare module "node:test/reporters" {
         constructor();
     }
     /**
-     * The `junit` reporter outputs test results in a jUnit XML format
+     * The `junit` reporter outputs test results in a jUnit XML format.
      */
     function junit(source: TestEventGenerator): AsyncGenerator<string, void>;
-    export { dot, junit, Spec as spec, tap, TestEvent };
+    /**
+     * The `lcov` reporter outputs test coverage when used with the [`--experimental-test-coverage`](https://nodejs.org/docs/latest-v20.x/api/cli.html#--experimental-test-coverage) flag.
+     */
+    class Lcov extends Transform {
+        constructor(opts?: TransformOptions);
+    }
+    export { dot, junit, Lcov as lcov, Spec as spec, tap, TestEvent };
 }