@interfere/react 12.0.1 → 12.0.3

package/dist/tracking/registration.fixture.d.mts

@@ -0,0 +1,3112 @@
+import { t as SessionTracker } from "../api-DEVCOKkJ.mjs";
+//#region ../../../../node_modules/.bun/vitest@5.0.1+3a20bcfa24daf8e9/node_modules/vitest/optional-runtime-types.d.ts
+/* eslint-disable ts/ban-ts-comment */
+interface Disposable {
+  // @ts-ignore -- Symbol.dispose might not be in user types
+  [Symbol.dispose]: () => void;
+}
+//#endregion
+//#region ../../../../node_modules/.bun/tinybench@6.1.4/node_modules/tinybench/dist/index.d.ts
+//#region src/task.d.ts
+/**
+ * A class that represents each benchmark task in Tinybench. It keeps track of the
+ * results, name, the task function, the number times the task function has been executed, ...
+ */
+declare class Task$1 extends EventTarget {
+  #private;
+  addEventListener: (<K extends TaskEvents>(type: K, listener: EventListener<K, 'task'> | EventListenerObject<K, 'task'> | null, options?: AddEventListenerOptionsArgument) => void) & EventTarget['addEventListener'];
+  removeEventListener: (<K extends TaskEvents>(type: K, listener: EventListener<K, 'task'> | EventListenerObject<K, 'task'> | null, options?: RemoveEventListenerOptionsArgument) => void) & EventTarget['removeEventListener'];
+  /**
+   * The estimated effective timer resolution observed during the last run,
+   * computed as the smallest strictly positive latency sample that repeats
+   * among the timer-measured samples, or the smallest strictly positive
+   * sample when none repeats (samples supplied via `overriddenDuration` are
+   * excluded). When `subtractTimerOverhead` is enabled the value is derived
+   * from the overhead-corrected samples rather than the raw timer grain.
+   * @returns The resolution in milliseconds, or `undefined` when no
+   *   timer-measured strictly positive sample was observed (e.g. every
+   *   sample was supplied via `overriddenDuration`)
+   */
+  get detectedResolution(): number | undefined;
+  /**
+   * The name of the task.
+   * @returns The task name as a string
+   */
+  get name(): string;
+  /**
+   * The result of the task.
+   * @returns The task result including state, statistics, and runtime information
+   */
+  get result(): TaskResult$1 & TaskResultRuntimeInfo & TaskResultTimestampProviderInfo;
+  /**
+   * The number of times the task function has been executed.
+   * @returns The total number of executions performed
+   */
+  get runs(): number;
+  constructor(bench: BenchLike, name: string, fn: Fn, fnOpts?: FnOptions);
+  /**
+   * Resets the task to make the `Task.runs` a zero-value and remove the `Task.result` object property.
+   * @param emit - whether to emit the `reset` event or not
+   */
+  reset(emit?: boolean): void;
+  /**
+   * Runs the current task and writes the results in `Task.result` object property.
+   * @returns the current task
+   */
+  run(): Promise<Task$1>;
+  /**
+   * Runs the current task synchronously and writes the results in `Task.result` object property.
+   * @returns the current task
+   */
+  runSync(): this;
+  /**
+   * Warms up the current task.
+   */
+  warmup(): Promise<void>;
+  /**
+   * Warms up the current task synchronously.
+   */
+  warmupSync(): void;
+}
+//#endregion
+//#region src/event.d.ts
+/**
+ * The BenchEvent class represents events that occur during the benchmarking
+ * process.
+ */
+declare class BenchEvent<K extends BenchEvents = BenchEvents, M extends 'bench' | 'task' = 'bench'> extends globalThis.Event {
+  #private;
+  type: K;
+  /**
+   * The error associated with the event.
+   * @returns The error if the event type is one that includes an error; otherwise, undefined
+   */
+  get error(): K extends BenchEventsWithError ? Error : undefined;
+  /**
+   * The reason a `'warning'` event was dispatched.
+   * @returns The {@link TimerSaturationReason} for `'warning'` events;
+   *   `undefined` for every other event type and for `'warning'` events
+   *   dispatched without a reason
+   */
+  get reason(): K extends 'warning' ? TimerSaturationReason | undefined : undefined;
+  /**
+   * The task associated with the event.
+   * @returns The task if the event type is one that includes a task; otherwise, undefined
+   */
+  get task(): M extends 'task' ? Task$1 : K extends BenchEventsWithTask ? Task$1 : undefined;
+  constructor(type: 'warning', task: Task$1, reason?: TimerSaturationReason);
+  constructor(type: BenchEventsWithError, task: Task$1, error: Error);
+  constructor(type: BenchEventsWithTask, task: Task$1);
+  constructor(type: BenchEventsOptionalTask, task?: Task$1);
+}
+//#endregion
+//#region src/types.d.ts
+/**
+ * Options for adding an event listener
+ */
+type AddEventListenerOptionsArgument = Parameters<EventTarget['addEventListener']>[2];
+/**
+ * Bench events
+ */
+type BenchEvents = 'abort' | 'add' | 'complete' | 'cycle' | 'error' | 'remove' | 'reset' | 'start' | 'warmup' | 'warning';
+/**
+ * Bench events that may have an associated Task
+ */
+type BenchEventsOptionalTask = Exclude<BenchEvents, 'add' | 'cycle' | 'error' | 'remove'>;
+/**
+ * Bench events that have an associated error
+ */
+type BenchEventsWithError = Extract<BenchEvents, 'error'>;
+/**
+ * Bench events that have an associated Task
+ */
+type BenchEventsWithTask = Extract<BenchEvents, 'add' | 'cycle' | 'error' | 'remove' | 'warning'>;
+/**
+ * Used to decouple Bench and Task
+ */
+interface BenchLike extends EventTarget {
+  /**
+   * Adds a listener for the specified event type.
+   */
+  addEventListener: (<K extends BenchEvents>(type: K, listener: EventListener<K> | EventListenerObject<K> | null, options?: AddEventListenerOptionsArgument) => void) & EventTarget['addEventListener'];
+  /**
+   * Executes tasks concurrently based on the specified concurrency mode, if set.
+   *
+   * - When `mode` is set to `null` (default), concurrency is disabled.
+   * - When `mode` is set to 'task', each task's iterations (calls of a task function) run concurrently.
+   * - When `mode` is set to 'bench', different tasks within the bench run concurrently.
+   */
+  concurrency: Concurrency;
+  /**
+   * The amount of executions per task.
+   */
+  iterations: number;
+  /**
+   * A function to get a timestamp.
+   */
+  now: NowFn;
+  /**
+   * Removes a previously registered event listener.
+   */
+  removeEventListener: (<K extends BenchEvents>(type: K, listener: EventListener<K> | EventListenerObject<K> | null, options?: RemoveEventListenerOptionsArgument) => void) & EventTarget['removeEventListener'];
+  /**
+   * Should samples be retained for further custom processing
+   */
+  retainSamples: boolean;
+  /**
+   * The JavaScript runtime environment.
+   */
+  runtime: JSRuntime;
+  /**
+   * The JavaScript runtime version.
+   */
+  runtimeVersion: string;
+  /**
+   * A setup function that runs before each task execution.
+   */
+  setup: (task: Task$1, mode: HookMode) => Promise<void> | void;
+  /**
+   * An AbortSignal to cancel the benchmark
+   */
+  signal?: AbortSignal;
+  /**
+   * A teardown function that runs after each task execution.
+   */
+  teardown: (task: Task$1, mode: HookMode) => Promise<void> | void;
+  /**
+   * The maximum number of concurrent tasks to run
+   */
+  threshold: number;
+  /**
+   * Whether to throw an error if a task function throws
+   */
+  throws: boolean;
+  /**
+   * The amount of time to run each task.
+   */
+  time: number;
+  /**
+   * The estimated cost of one timestamp provider call in milliseconds.
+   *
+   * Calibrated once at construction; `undefined` (or omitted) when timer
+   * overhead subtraction is disabled or unsupported by the implementation.
+   */
+  readonly timerOverhead?: number;
+  /**
+   * The timestamp provider used by the benchmark.
+   */
+  timestampProvider: TimestampProvider;
+  /**
+   * Whether to warmup the tasks before running them
+   */
+  warmup: boolean;
+  /**
+   * The amount of warmup iterations per task.
+   */
+  warmupIterations: number;
+  /**
+   * The amount of time to warmup each task.
+   */
+  warmupTime: number;
+}
+/**
+ * Bench options
+ */
+interface BenchOptions$1 {
+  /**
+   * Executes tasks concurrently based on the specified concurrency mode.
+   *
+   * - When `mode` is set to `null` (default), concurrency is disabled.
+   * - When `mode` is set to 'task', each task's iterations (calls of a task function) run concurrently.
+   * - When `mode` is set to 'bench', different tasks within the bench run concurrently.
+   */
+  concurrency?: Concurrency;
+  /**
+   * The number of times that a task should run if even the time option is finished.
+   * @default 64
+   */
+  iterations?: number;
+  /**
+   * Benchmark name.
+   */
+  name?: string;
+  /**
+   * Function to get the current timestamp in milliseconds.
+   */
+  now?: NowFn;
+  /**
+   * Keep samples for statistics calculation
+   * @default false
+   */
+  retainSamples?: boolean;
+  /**
+   * Setup function to run before each benchmark task (cycle)
+   */
+  setup?: Hook;
+  /**
+   * An AbortSignal for aborting the benchmark.
+   */
+  signal?: AbortSignal;
+  /**
+   * Whether to subtract an estimated timestamp provider call overhead from
+   * each raw latency sample.
+   *
+   * Each sample is measured as `t1 - t0` around a single call to the task
+   * function, so every raw sample is inflated by approximately one
+   * timestamp provider call cost `C`. When this option is `true`, an
+   * estimate `Ĉ` is computed once at construction time via
+   * {@link calibrateTimerOverhead}, and `max(0, raw_sample - Ĉ)` is used
+   * in place of each non-overridden sample before statistics are computed.
+   *
+   * **Statistics after correction.** All fields of {@link Statistics} are
+   * derived from the clamped corrected samples, not from the raw
+   * distribution. With `M` denoting the raw-sample mean:
+   *
+   * - **Clean-shift regime (`X >> Ĉ`).** The clamp `max(0, …)` rarely
+   *   triggers, so the correction acts as a translation by `Ĉ`. Location
+   *   statistics (`mean`, `min`, `max`, all percentiles) decrease by `Ĉ`;
+   *   absolute-unit dispersion (`vr`, `sd`, `sem`, `moe`, `mad`, `aad`)
+   *   is essentially unchanged. Because `rme = moe / mean`, it inflates
+   *   by the deterministic factor `M / (M − Ĉ)` whenever `Ĉ > 0`.
+   * - **Sub-overhead regime (`X ≈ Ĉ`).** A non-trivial fraction of
+   *   samples clamp to `0`, biasing the corrected mean upward,
+   *   contracting `vr`/`sd`/`sem`/`moe`/`aad`, and compounding the
+   *   `M / (M − Ĉ)` factor in `rme`. Once the cumulative mass of raw
+   *   samples at or below `Ĉ` reaches a given quantile, that percentile
+   *   collapses to `0`; in particular `p50` collapses once at least half
+   *   of the raw samples satisfy `raw_sample ≤ Ĉ`, which then forces
+   *   `mad` and `aad` toward `0`. Prefer `overriddenDuration` for
+   *   sub-overhead measurements.
+   *
+   * **Three observable consequences of the clamp.**
+   *
+   * 1. `latency.min` may be exactly `0` even when no zero-duration sample
+   *    was actually observed.
+   * 2. The throughput estimator substitutes `1000 / latency.mean` (or `0`
+   *    when `mean === 0`) for every clamped sample.
+   * 3. {@link detectTimerSaturation} criterion `'zero-dominated'` cannot
+   *    distinguish clamped samples from genuine zero-duration timer
+   *    reads, so a `'warning'` event may be dispatched in the
+   *    sub-overhead regime even when the timer itself is not saturated.
+   *
+   * **Caveat — `concurrency: "task"`.** The overhead is calibrated once
+   * at construction time with sequential timer calls. Setting both
+   * options causes the constructor (and `run()`) to throw, since the
+   * sequentially-calibrated estimate would not reflect the per-iteration
+   * timer call cost under concurrent execution.
+   *
+   * **Caveat — `overriddenDuration`.** Samples returned by the task
+   * function via `overriddenDuration` are intentional user values and
+   * are never modified by the correction. They are also excluded from
+   * {@link Task.detectedResolution} and from timer-saturation detection.
+   *
+   * On runtimes with a coarse timer (resolution >= 1 ms), the
+   * calibration returns `0` and this option becomes a no-op.
+   * @default false
+   */
+  subtractTimerOverhead?: boolean;
+  /**
+   * Teardown function to run after each benchmark task (cycle).
+   */
+  teardown?: Hook;
+  /**
+   * The maximum number of concurrent tasks to run
+   * @default Number.POSITIVE_INFINITY
+   */
+  threshold?: number;
+  /**
+   * Throws if a task fails.
+   * @default false
+   */
+  throws?: boolean;
+  /**
+   * Time needed for running a benchmark task in milliseconds.
+   * @default 1000
+   */
+  time?: number;
+  /**
+   * The timestamp provider used by the benchmark. By default 'performance.now'
+   * will be used.
+   */
+  timestampProvider?: TimestampFns | TimestampProvider;
+  /**
+   * Warmup benchmark.
+   * @default true
+   */
+  warmup?: boolean;
+  /**
+   * Warmup iterations.
+   * @default 16
+   */
+  warmupIterations?: number;
+  /**
+   * Warmup time in milliseconds.
+   * @default 250
+   */
+  warmupTime?: number;
+}
+/**
+ * - When `mode` is set to `null` (default), concurrency is disabled.
+ * - When `mode` is set to 'task', each task's iterations (calls of a task function) run concurrently.
+ * - When `mode` is set to 'bench', different tasks within the bench run concurrently.
+ */
+type Concurrency = 'bench' | 'task' | null;
+/**
+ * Event listener
+ */
+type EventListener<E extends BenchEvents, M extends 'bench' | 'task' = 'bench'> = (evt: BenchEvent<E, M>) => void;
+/**
+ * Both the `Task` and `Bench` objects extend the `EventTarget` object.
+ * So you can attach a listeners to different types of events to each class instance
+ * using the universal `addEventListener` and `removeEventListener` methods.
+ */
+interface EventListenerObject<E extends BenchEvents, M extends 'bench' | 'task' = 'bench'> {
+  /**
+   * A method called when the event is dispatched.
+   */
+  handleEvent(evt: BenchEvent<E, M>): void;
+}
+/**
+ * The task function.
+ *
+ * If you need to provide a custom duration for the task (e.g.: because
+ * you want to measure a specific part of its execution), you can return an
+ * object with a `overriddenDuration` field. You should still use
+ * `bench.opts.now()` to measure that duration.
+ */
+type Fn = () => FnReturnedObject | Promise<FnReturnedObject | unknown> | unknown;
+/**
+ * The task hook function signature.
+ * If warmup is enabled, the hook will be called twice, once for the warmup and once for the run.
+ * @param mode the mode where the hook is being called
+ */
+type FnHook = (this: Task$1, mode?: HookMode) => Promise<void> | void;
+/**
+ * The task function options
+ */
+interface FnOptions {
+  /**
+   * An optional function that is run after all iterations of this task end
+   */
+  afterAll?: FnHook;
+  /**
+   * An optional function that is run after each iteration of this task
+   */
+  afterEach?: FnHook;
+  /**
+   * Whether the provided task function is asynchronous, otherwise it is
+   * determined automatically.
+   *
+   * Measuring an async task awaits it inside the timed window, so each sample
+   * includes one microtask-turn overhead that `subtractTimerOverhead` does not
+   * remove. For sub-resolution timings, prefer `overriddenDuration`.
+   */
+  async?: boolean;
+  /**
+   * An optional function that is run before iterations of this task begin
+   */
+  beforeAll?: FnHook;
+  /**
+   * An optional function that is run before each iteration of this task
+   */
+  beforeEach?: FnHook;
+  /**
+   * Retain samples for this task, overriding the bench-level retainSamples option
+   */
+  retainSamples?: boolean;
+  /**
+   * An AbortSignal for aborting this specific task
+   *
+   * If not provided, falls back to {@link BenchOptions.signal}
+   */
+  signal?: AbortSignal;
+}
+/**
+ * A possible object returned by task functions to override default behaviors,
+ * like the duration of the function itself.
+ */
+interface FnReturnedObject {
+  /**
+   * An overridden duration for the task function, to be used instead of the
+   * duration measured by tinybench when running the benchmark.
+   *
+   * This can be useful to measure parts of the execution of a function that are
+   * hard to execute independently.
+   */
+  overriddenDuration?: number;
+}
+/**
+ * The hook function signature.
+ * If warmup is enabled, the hook will be called twice, once for the warmup and once for the run.
+ * @param task the task instance
+ * @param mode the mode where the hook is being called
+ */
+type Hook = (task?: Task$1, mode?: HookMode) => Promise<void> | void;
+/**
+ * The mode in which a task hook is invoked ('warmup' or 'run').
+ */
+type HookMode = 'run' | 'warmup';
+/**
+ * The JavaScript runtime environment.
+ * @see https://runtime-keys.proposal.wintercg.org/
+ */
+type JSRuntime = 'browser' | 'bun' | 'deno' | 'edge-light' | 'fastly' | 'hermes' | 'jsc' | 'lagon' | 'moddable' | 'netlify' | 'node' | 'quickjs-ng' | 'spidermonkey' | 'unknown' | 'v8' | 'workerd';
+/**
+ * A function that returns the current timestamp.
+ */
+type NowFn = () => number;
+type RemoveEventListenerOptionsArgument = Parameters<EventTarget['removeEventListener']>[2];
+/**
+ * A type representing a samples-array with at least one number.
+ */
+type Samples = [number, ...number[]];
+/**
+ * A type representing a sorted samples-array with at least one number.
+ */
+type SortedSamples = Samples & {
+  /**
+   * A unique symbol to identify sorted samples
+   */
+  readonly __sorted__: unique symbol;
+};
+/**
+ * The statistics object
+ */
+interface Statistics {
+  /**
+   * mean/average absolute deviation
+   */
+  aad: number;
+  /**
+   * critical value
+   */
+  critical: number;
+  /**
+   * degrees of freedom
+   */
+  df: number;
+  /**
+   * median absolute deviation, not scaled by the 1.4826 normal-consistency factor
+   */
+  mad: number;
+  /**
+   * the maximum value
+   */
+  max: number;
+  /**
+   * mean/average
+   */
+  mean: number;
+  /**
+   * the minimum value
+   */
+  min: number;
+  /**
+   * margin of error
+   */
+  moe: number;
+  /**
+   * p50/median percentile
+   */
+  p50: number;
+  /**
+   * p75 percentile
+   */
+  p75: number;
+  /**
+   * p99 percentile
+   */
+  p99: number;
+  /**
+   * p995 percentile
+   */
+  p995: number;
+  /**
+   * p999 percentile
+   */
+  p999: number;
+  /**
+   * relative margin of error
+   */
+  rme: number;
+  /**
+   * samples used to calculate the statistics
+   */
+  samples: SortedSamples | undefined;
+  /**
+   * samples count
+   */
+  samplesCount: number;
+  /**
+   * standard deviation
+   */
+  sd: number;
+  /**
+   * standard error of the mean/average (a.k.a. the standard deviation of the distribution of the sample mean/average)
+   */
+  sem: number;
+  /**
+   * variance
+   */
+  variance: number;
+}
+/**
+ * Task events
+ */
+type TaskEvents = Extract<BenchEvents, 'abort' | 'complete' | 'cycle' | 'error' | 'reset' | 'start' | 'warmup' | 'warning'>;
+/**
+ * The task result
+ */
+type TaskResult$1 = TaskResultAborted | TaskResultAbortedWithStatistics | TaskResultCompleted | TaskResultErrored | TaskResultNotStarted | TaskResultStarted;
+/**
+ * The task result for aborted tasks.
+ */
+interface TaskResultAborted {
+  /**
+   * the task state
+   */
+  state: 'aborted';
+}
+/**
+ * The task result for aborted tasks, having also statistical data.
+ */
+interface TaskResultAbortedWithStatistics extends TaskResultWithStatistics {
+  /**
+   * the task state
+   */
+  state: 'aborted-with-statistics';
+}
+/**
+ * The task result for completed tasks with statistical data.
+ */
+interface TaskResultCompleted extends TaskResultWithStatistics {
+  /**
+   * the task state
+   */
+  state: 'completed';
+}
+/**
+ * The task result for errored tasks
+ */
+interface TaskResultErrored {
+  /**
+   * the error that caused the task to fail
+   */
+  error: Error;
+  /**
+   * the task state
+   */
+  state: 'errored';
+}
+/**
+ * The task result for not started tasks
+ */
+interface TaskResultNotStarted {
+  /**
+   * the task state
+   */
+  state: 'not-started';
+}
+/**
+ * The additional runtime information for task results
+ */
+interface TaskResultRuntimeInfo {
+  /**
+   * the JavaScript runtime environment
+   */
+  runtime: JSRuntime;
+  /**
+   * the JavaScript runtime version
+   */
+  runtimeVersion: string;
+}
+/**
+ * The task result for started tasks
+ */
+interface TaskResultStarted {
+  /**
+   * the task state
+   */
+  state: 'started';
+}
+/**
+ * The timestamp provider information for task results
+ */
+interface TaskResultTimestampProviderInfo {
+  /**
+   * the name of the timestamp provider used during the benchmark
+   */
+  timestampProviderName: TimestampProviderName;
+}
+/**
+ * The statistical data for task results
+ */
+interface TaskResultWithStatistics {
+  /**
+   * the task latency statistics
+   */
+  latency: Statistics;
+  /**
+   * how long each operation takes (ms)
+   */
+  period: number;
+  /**
+   * the task throughput statistics
+   */
+  throughput: Statistics;
+  /**
+   * the time to run the task benchmark cycle (ms)
+   */
+  totalTime: number;
+}
+/**
+ * Reason a sample set is classified as timer-saturated.
+ *
+ * - `'zero-dominated'` — more than half of the samples are exactly zero.
+ * - `'low-distinct'` — distinct sample count is below
+ *   `max(3, min(10, ⌊n / 1000⌋))`.
+ * - `'zero-mad'` — median absolute deviation is zero with more than 100
+ *   samples.
+ */
+type TimerSaturationReason = 'low-distinct' | 'zero-dominated' | 'zero-mad';
+/**
+ * A timestamp function that returns either a number or bigint.
+ */
+type TimestampFn = () => TimestampValue;
+/**
+ * Possible timestamp provider names.
+ * 'custom' is used when a custom timestamp function is provided.
+ */
+type TimestampFns = 'auto' | 'bunNanoseconds' | 'custom' | 'hrtimeNow' | 'performanceNow';
+/**
+ * A timestamp provider and its related functions.
+ */
+interface TimestampProvider {
+  /**
+   * The actual function of the timestamp provider.
+   * @returns the timestamp value
+   */
+  fn: TimestampFn;
+  /**
+   * Converts milliseconds to the timestamp value.
+   * @param value - the milliseconds value
+   * @returns the timestamp value
+   */
+  fromMs: (value: number) => TimestampValue;
+  /**
+   * The name of the timestamp provider.
+   */
+  name: TimestampProviderName;
+  /**
+   * Converts the timestamp value to milliseconds.
+   * @param value - the timestamp value
+   * @returns the milliseconds
+   */
+  toMs: (value: TimestampValue) => number;
+}
+/**
+ * The name of a timestamp provider: a known provider name or any custom string.
+ */
+type TimestampProviderName = (string & {}) | TimestampFns;
+/**
+ * A timestamp value, either number or bigint. Internally timestamps can use
+ * either representation depending on the environment and the chosen timestamp
+ * function.
+ */
+type TimestampValue = bigint | number;
+//#endregion
+//#region ../../../../node_modules/.bun/vitest@5.0.1+3a20bcfa24daf8e9/node_modules/vitest/dist/chunks/config.d.CU_b-wJj.d.ts
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+interface Colors {
+  comment: {
+    close: string;
+    open: string;
+  };
+  content: {
+    close: string;
+    open: string;
+  };
+  prop: {
+    close: string;
+    open: string;
+  };
+  tag: {
+    close: string;
+    open: string;
+  };
+  value: {
+    close: string;
+    open: string;
+  };
+}
+type Indent = (arg0: string) => string;
+type Refs = Array<unknown>;
+type Print = (arg0: unknown) => string;
+/**
+ * compare function used when sorting object keys, `null` can be used to skip over sorting.
+ */
+type CompareKeys = ((a: string, b: string) => number) | null | undefined;
+interface PrettyFormatOptions {
+  /**
+   * Call `toJSON` on objects before formatting them.
+   * Ignored after the formatter has already called `toJSON` once for a value.
+   * @default true
+   */
+  callToJSON?: boolean;
+  /**
+   * Whether to escape special characters in regular expressions.
+   * @default false
+   */
+  escapeRegex?: boolean;
+  /**
+   * Whether to escape special characters in strings.
+   * @default true
+   */
+  escapeString?: boolean;
+  /**
+   * Whether to highlight syntax using terminal colors.
+   * @default false
+   */
+  highlight?: boolean;
+  /**
+   * Number of spaces to use for each level of indentation.
+   * @default 2
+   */
+  indent?: number;
+  /**
+   * Maximum depth to recurse into nested values.
+   * @default Infinity
+   */
+  maxDepth?: number;
+  /**
+   * Maximum number of items to print in arrays, sets, maps, and similar collections.
+   * @default Infinity
+   */
+  maxWidth?: number;
+  /**
+   * Approximate per-depth-level budget for output length.
+   * When the accumulated output at any single depth level exceeds this value,
+   * further nesting is collapsed. This is a heuristic safety valve, not a hard
+   * limit — total output can reach up to roughly `maxDepth × maxOutputLength`.
+   * @default 1_000_000
+   */
+  maxOutputLength?: number;
+  /**
+   * Whether to minimize added whitespace, including indentation and line breaks.
+   *
+   * When `true`, pretty-format defaults `spacingInner` to `' '`, `spacingOuter` to `''`,
+   * and ignores indentation. It also changes the default for `printBasicPrototype`
+   * from `true` to `false`, although an explicit `printBasicPrototype` still wins.
+   * Explicit `spacingInner` / `spacingOuter` overrides still apply.
+   * @default false
+   */
+  min?: boolean;
+  /**
+   * Whether to print `Object` / `Array` prefixes for plain objects and arrays.
+   *
+   * Defaults to `true`, unless `min` is `true`, in which case it defaults to `false`.
+   * An explicit `printBasicPrototype` value always overrides the `min` default.
+   */
+  printBasicPrototype?: boolean;
+  /**
+   * Whether to include the function name when formatting functions.
+   * @default true
+   */
+  printFunctionName?: boolean;
+  /**
+   * Whether to include shadow-root contents when formatting DOM nodes.
+   * @default true
+   */
+  printShadowRoot?: boolean;
+  /**
+   * Compare function used when sorting object keys. Set to `null` to disable sorting.
+   */
+  compareKeys?: CompareKeys;
+  /**
+   * Plugins used to serialize application-specific data types.
+   * @default []
+   */
+  plugins?: Plugins;
+  /**
+   * Whitespace inserted after commas between items or entries.
+   *
+   * For example, in `{a: 1, b: 2}` or `[1, 2]`, this controls the gap after each comma:
+   * `{a: 1,${spacingInner}b: 2}`
+   * `[1,${spacingInner}2]`
+   *
+   * Defaults to `'\n'` in regular mode and `' '` when `min` is `true`.
+   * Can be overridden independently of `min`.
+   */
+  spacingInner?: string;
+  /**
+   * Whitespace inserted immediately inside collection/object delimiters.
+   *
+   * For example, this controls the space or newline right after the opening delimiter
+   * and right before the closing delimiter:
+   * `{${spacingOuter}a: 1${spacingOuter}}`
+   * `[${spacingOuter}1${spacingOuter}]`
+   *
+   * Defaults to `'\n'` in regular mode and `''` when `min` is `true`.
+   * Can be overridden independently of `min`.
+   */
+  spacingOuter?: string;
+  /**
+   * Whether to print strings using single quotes instead of double quotes.
+   *
+   * For example:
+   * `"hello"` when `false`
+   * `'hello'` when `true`
+   *
+   * @default false
+   */
+  singleQuote?: boolean;
+  /**
+   * Whether to always quote object property keys.
+   *
+   * For example:
+   * `{"a": 1}` when `true`
+   * `{a: 1}` when `false` and the key is a valid identifier
+   * `{"my-key": 1}` still stays quoted because it is not a valid identifier
+   *
+   * @default true
+   */
+  quoteKeys?: boolean;
+}
+type OptionsReceived = PrettyFormatOptions;
+interface Config {
+  callToJSON: boolean;
+  compareKeys: CompareKeys;
+  colors: Colors;
+  escapeRegex: boolean;
+  escapeString: boolean;
+  indent: string;
+  maxDepth: number;
+  maxWidth: number;
+  min: boolean;
+  plugins: Plugins;
+  printBasicPrototype: boolean;
+  printFunctionName: boolean;
+  printShadowRoot: boolean;
+  spacingInner: string;
+  spacingOuter: string;
+  singleQuote: boolean;
+  quoteKeys: boolean;
+  maxOutputLength: number;
+}
+type Printer = (val: unknown, config: Config, indentation: string, depth: number, refs: Refs, hasCalledToJSON?: boolean) => string;
+type Test$1 = (arg0: any) => boolean;
+interface NewPlugin {
+  serialize: (val: any, config: Config, indentation: string, depth: number, refs: Refs, printer: Printer) => string;
+  test: Test$1;
+}
+interface PluginOptions {
+  edgeSpacing: string;
+  min: boolean;
+  spacing: string;
+}
+interface OldPlugin {
+  print: (val: unknown, print: Print, indent: Indent, options: PluginOptions, colors: Colors) => string;
+  test: Test$1;
+}
+type Plugin = NewPlugin | OldPlugin;
+type Plugins = Array<Plugin>;
+interface StringifyOptions extends PrettyFormatOptions {
+  maxLength?: number;
+  filterNode?: string | ((node: any) => boolean);
+}
+declare function stringify(object: unknown, maxDepth?: number, { maxLength, filterNode, ...options }?: StringifyOptions): string;
+type Awaitable<T> = T | PromiseLike<T>;
+interface ParsedStack {
+  method: string;
+  file: string;
+  line: number;
+  column: number;
+}
+interface SerializedError {
+  message: string;
+  stacks?: ParsedStack[];
+  stack?: string;
+  name?: string;
+  cause?: SerializedError;
+  [key: string]: unknown;
+}
+interface TestError extends SerializedError {
+  cause?: TestError;
+  diff?: string;
+  actual?: string;
+  expected?: string;
+}
+interface DomainMatchResult {
+  pass: boolean;
+  message?: string;
+  /**
+   * The captured value viewed through the template's lens.
+   *
+   * Where the template uses patterns (e.g. regexes) or omits details,
+   * the resolved string adopts those patterns. Where the template doesn't
+   * match, the resolved string uses literal captured values instead.
+   *
+   * Used for two purposes:
+   * - **Diff display** (actual side): compared against `expected`
+   *   so the diff highlights only genuine mismatches, not pattern-vs-literal noise.
+   * - **Snapshot update** (`--update`): written as the new snapshot content,
+   *   preserving user-edited patterns from matched regions while incorporating
+   *   actual values for mismatched regions.
+   *
+   * When omitted, falls back to `render(capture(received))` (the raw rendered value).
+   */
+  resolved?: string;
+  /**
+   * The stored template re-rendered as a string, representing what the user
+   * originally wrote or last saved.
+   *
+   * Used as the expected side in diff display.
+   *
+   * When omitted, falls back to the raw snapshot string from the snap file
+   * or inline snapshot.
+   */
+  expected?: string;
+}
+interface RawSnapshotInfo {
+  file: string;
+  readonly?: boolean;
+  content?: string;
+}
+interface SnapshotEnvironment {
+  getVersion: () => string;
+  getHeader: () => string;
+  resolvePath: (filepath: string) => Promise<string>;
+  resolveRawPath: (testPath: string, rawPath: string) => Promise<string>;
+  saveSnapshotFile: (filepath: string, snapshot: string) => Promise<void>;
+  readSnapshotFile: (filepath: string) => Promise<string | null>;
+  readSnapshotFileData?: (filepath: string) => Promise<Record<string, string> | null>;
+  removeSnapshotFile: (filepath: string) => Promise<void>;
+  processStackTrace?: (stack: ParsedStack) => ParsedStack;
+}
+declare class DefaultMap<K, V> extends Map<K, V> {
+  private defaultFn;
+  constructor(defaultFn: (key: K) => V, entries?: Iterable<readonly [K, V]>);
+  override get(key: K): V;
+}
+declare class CounterMap<K> extends DefaultMap<K, number> {
+  constructor();
+  _total: number | undefined;
+  valueOf(): number;
+  increment(key: K): void;
+  total(): number;
+}
+interface SnapshotReturnOptions {
+  actual: string;
+  count: number;
+  expected?: string;
+  key: string;
+  pass: boolean;
+}
+interface SaveStatus {
+  deleted: boolean;
+  saved: boolean;
+}
+interface ExpectedSnapshot {
+  key: string;
+  count: number;
+  data?: string;
+  markAsChecked: () => void;
+}
+declare class SnapshotState {
+  testFilePath: string;
+  snapshotPath: string;
+  private _counters;
+  private _dirty;
+  private _updateSnapshot;
+  private _snapshotData;
+  private _initialData;
+  private _inlineSnapshots;
+  private _inlineSnapshotStacks;
+  private _testIdToKeys;
+  private _rawSnapshots;
+  private _uncheckedKeys;
+  private _snapshotFormat;
+  private _environment;
+  private _fileExists;
+  expand: boolean;
+  private _added;
+  private _matched;
+  private _unmatched;
+  private _updated;
+  get added(): CounterMap<string>;
+  set added(value: number);
+  get matched(): CounterMap<string>;
+  set matched(value: number);
+  get unmatched(): CounterMap<string>;
+  set unmatched(value: number);
+  get updated(): CounterMap<string>;
+  set updated(value: number);
+  private constructor();
+  static create(testFilePath: string, options: SnapshotStateOptions): Promise<SnapshotState>;
+  get snapshotUpdateState(): SnapshotUpdateState;
+  get environment(): SnapshotEnvironment;
+  markSnapshotsAsCheckedForTest(testName: string): void;
+  clearTest(testId: string): void;
+  protected _inferInlineSnapshotStack(stacks: ParsedStack[]): ParsedStack | null;
+  private _addSnapshot;
+  private _resolveKey;
+  private _resolveInlineStack;
+  private _reconcile;
+  save(): Promise<SaveStatus>;
+  getUncheckedCount(): number;
+  getUncheckedKeys(): Array<string>;
+  removeUncheckedKeys(): void;
+  probeExpectedSnapshot(options: Pick<SnapshotMatchOptions, "testName" | "testId" | "isInline" | "inlineSnapshot">): ExpectedSnapshot;
+  match({ testId, testName, received, key, inlineSnapshot, isInline, error, rawSnapshot, assertionName }: SnapshotMatchOptions): SnapshotReturnOptions;
+  processDomainSnapshot({ testId, received, expectedSnapshot, matchResult, isInline, error, assertionName }: ProcessDomainSnapshotOptions): SnapshotReturnOptions;
+  pack(): Promise<SnapshotResult>;
+}
+type SnapshotUpdateState = "all" | "new" | "none";
+interface SnapshotStateOptions {
+  updateSnapshot: SnapshotUpdateState;
+  snapshotEnvironment: SnapshotEnvironment;
+  expand?: boolean;
+  snapshotFormat?: OptionsReceived;
+  resolveSnapshotPath?: (path: string, extension: string, context?: any) => string;
+}
+interface SnapshotMatchOptions {
+  testId: string;
+  testName: string;
+  received: unknown;
+  key?: string;
+  inlineSnapshot?: string;
+  isInline: boolean;
+  error?: Error;
+  rawSnapshot?: RawSnapshotInfo;
+  assertionName?: string;
+}
+interface ProcessDomainSnapshotOptions {
+  testId: string;
+  received: string;
+  expectedSnapshot: ExpectedSnapshot;
+  matchResult?: DomainMatchResult;
+  isInline?: boolean;
+  assertionName?: string;
+  error?: Error;
+}
+interface SnapshotResult {
+  filepath: string;
+  added: number;
+  fileDeleted: boolean;
+  matched: number;
+  unchecked: number;
+  uncheckedKeys: Array<string>;
+  unmatched: number;
+  updated: number;
+}
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+type DiffOptionsColor = (arg: string) => string;
+interface DiffOptions {
+  aAnnotation?: string;
+  aColor?: DiffOptionsColor;
+  aIndicator?: string;
+  bAnnotation?: string;
+  bColor?: DiffOptionsColor;
+  bIndicator?: string;
+  changeColor?: DiffOptionsColor;
+  changeLineTrailingSpaceColor?: DiffOptionsColor;
+  commonColor?: DiffOptionsColor;
+  commonIndicator?: string;
+  commonLineTrailingSpaceColor?: DiffOptionsColor;
+  contextLines?: number;
+  emptyFirstOrLastLinePlaceholder?: string;
+  expand?: boolean;
+  includeChangeCounts?: boolean;
+  omitAnnotationLines?: boolean;
+  patchColor?: DiffOptionsColor;
+  printBasicPrototype?: boolean;
+  maxDepth?: number;
+  compareKeys?: CompareKeys;
+  truncateThreshold?: number;
+  truncateAnnotation?: string;
+  truncateAnnotationColor?: DiffOptionsColor;
+}
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+interface StringifiedMemory {
+  expected?: string;
+  actual?: string;
+}
+interface Memorize {
+  (pointer: "expected" | "actual", stringifiedValue: string): string;
+}
+/**
+ * @param a Expected value
+ * @param b Received value
+ * @param options Diff options
+ * @returns {string | null} a string diff
+ */
+declare function diff(a: any, b: any, options?: DiffOptions, memorize?: Memorize): string | undefined;
+declare function printDiffOrStringify(received: unknown, expected: unknown, options?: DiffOptions, memory?: StringifiedMemory): string | undefined;
+interface UserConsoleLog {
+  content: string;
+  origin?: string;
+  browser?: boolean;
+  type: "stdout" | "stderr";
+  taskId?: string;
+  time: number;
+  size: number;
+}
+interface MockResultReturn<T> {
+  type: "return";
+  /**
+   * The value that was returned from the function. If function returned a Promise, then this will be a resolved value.
+   */
+  value: T;
+}
+interface MockResultIncomplete {
+  type: "incomplete";
+  value: undefined;
+}
+interface MockResultThrow {
+  type: "throw";
+  /**
+   * An error that was thrown during function execution.
+   */
+  value: any;
+}
+interface MockSettledResultIncomplete {
+  type: "incomplete";
+  value: undefined;
+}
+interface MockSettledResultFulfilled<T> {
+  type: "fulfilled";
+  value: T;
+}
+interface MockSettledResultRejected {
+  type: "rejected";
+  value: any;
+}
+type MockResult<T> = MockResultReturn<T> | MockResultThrow | MockResultIncomplete;
+type MockSettledResult<T> = MockSettledResultFulfilled<T> | MockSettledResultRejected | MockSettledResultIncomplete;
+type MockParameters<T extends Procedure | Constructable> = T extends Constructable ? ConstructorParameters<T> : T extends Procedure ? Parameters<T> : never;
+type MockReturnType<T extends Procedure | Constructable> = T extends Constructable ? InstanceType<T> : T extends Procedure ? ReturnType<T> : never;
+type MockProcedureContext<T extends Procedure | Constructable> = T extends Constructable ? InstanceType<T> : ThisParameterType<T>;
+interface MockContext<T extends Procedure | Constructable = Procedure> {
+  /**
+   * This is an array containing all arguments for each call. One item of the array is the arguments of that call.
+   *
+   * @see https://vitest.dev/api/mock#mock-calls
+   * @example
+   * const fn = vi.fn()
+   *
+   * fn('arg1', 'arg2')
+   * fn('arg3')
+   *
+   * fn.mock.calls === [
+   *   ['arg1', 'arg2'], // first call
+   *   ['arg3'], // second call
+   * ]
+   */
+  calls: MockParameters<T>[];
+  /**
+   * This is an array containing all instances that were instantiated when mock was called with a `new` keyword. Note that this is an actual context (`this`) of the function, not a return value.
+   * @see https://vitest.dev/api/mock#mock-instances
+   */
+  instances: MockProcedureContext<T>[];
+  /**
+   * An array of `this` values that were used during each call to the mock function.
+   * @see https://vitest.dev/api/mock#mock-contexts
+   */
+  contexts: MockProcedureContext<T>[];
+  /**
+   * The order of mock's execution. This returns an array of numbers which are shared between all defined mocks.
+   *
+   * @see https://vitest.dev/api/mock#mock-invocationcallorder
+   * @example
+   * const fn1 = vi.fn()
+   * const fn2 = vi.fn()
+   *
+   * fn1()
+   * fn2()
+   * fn1()
+   *
+   * fn1.mock.invocationCallOrder === [1, 3]
+   * fn2.mock.invocationCallOrder === [2]
+   */
+  invocationCallOrder: number[];
+  /**
+   * This is an array containing all values that were `returned` from the function.
+   *
+   * The `value` property contains the returned value or thrown error. If the function returned a `Promise`, then `result` will always be `'return'` even if the promise was rejected.
+   *
+   * @see https://vitest.dev/api/mock#mock-results
+   * @example
+   * const fn = vi.fn()
+   *   .mockReturnValueOnce('result')
+   *   .mockImplementationOnce(() => { throw new Error('thrown error') })
+   *
+   * const result = fn()
+   *
+   * try {
+   *   fn()
+   * }
+   * catch {}
+   *
+   * fn.mock.results === [
+   *   {
+   *     type: 'return',
+   *     value: 'result',
+   *   },
+   *   {
+   *     type: 'throw',
+   *     value: Error,
+   *   },
+   * ]
+   */
+  results: MockResult<MockReturnType<T>>[];
+  /**
+   * An array containing all values that were `resolved` or `rejected` from the function.
+   *
+   * This array will be empty if the function was never resolved or rejected.
+   *
+   * @see https://vitest.dev/api/mock#mock-settledresults
+   * @example
+   * const fn = vi.fn().mockResolvedValueOnce('result')
+   *
+   * const result = fn()
+   *
+   * fn.mock.settledResults === [
+   *   {
+   *     type: 'incomplete',
+   *     value: undefined,
+   *   }
+   * ]
+   * fn.mock.results === [
+   *   {
+   *     type: 'return',
+   *     value: Promise<'result'>,
+   *   },
+   * ]
+   *
+   * await result
+   *
+   * fn.mock.settledResults === [
+   *   {
+   *     type: 'fulfilled',
+   *     value: 'result',
+   *   },
+   * ]
+   */
+  settledResults: MockSettledResult<Awaited<MockReturnType<T>>>[];
+  /**
+   * This contains the arguments of the last call. If spy wasn't called, will return `undefined`.
+   * @see https://vitest.dev/api/mock#mock-lastcall
+   */
+  lastCall: MockParameters<T> | undefined;
+}
+type Procedure = (...args: any[]) => any;
+type NormalizedProcedure<T extends Procedure | Constructable> = T extends Constructable ? ({
+  new (...args: ConstructorParameters<T>): InstanceType<T>;
+}) | ({
+  (this: InstanceType<T>, ...args: ConstructorParameters<T>): void;
+}) : T extends Procedure ? (...args: Parameters<T>) => ReturnType<T> : never;
+interface MockInstance<T extends Procedure | Constructable = Procedure> extends Disposable {
+  /**
+   * Use it to return the name assigned to the mock with the `.mockName(name)` method. By default, it will return `vi.fn()`.
+   * @see https://vitest.dev/api/mock#getmockname
+   */
+  getMockName(): string;
+  /**
+   * Sets the internal mock name. This is useful for identifying the mock when an assertion fails.
+   * @see https://vitest.dev/api/mock#mockname
+   */
+  mockName(name: string): this;
+  /**
+   * Current context of the mock. It stores information about all invocation calls, instances, and results.
+   */
+  mock: MockContext<T>;
+  /**
+   * Clears all information about every call. After calling it, all properties on `.mock` will return to their initial state. This method does not reset implementations. It is useful for cleaning up mocks between different assertions.
+   *
+   * To automatically call this method before each test, enable the [`clearMocks`](https://vitest.dev/config/clearmocks) setting in the configuration.
+   * @see https://vitest.dev/api/mock#mockclear
+   */
+  mockClear(): this;
+  /**
+   * Does what `mockClear` does and resets inner implementation to the original function. This also resets all "once" implementations.
+   *
+   * Note that resetting a mock from `vi.fn()` will set implementation to an empty function that returns `undefined`.
+   * Resetting a mock from `vi.fn(impl)` will set implementation to `impl`. It is useful for completely resetting a mock to its default state.
+   *
+   * To automatically call this method before each test, enable the [`mockReset`](https://vitest.dev/config/mockreset) setting in the configuration.
+   * @see https://vitest.dev/api/mock#mockreset
+   */
+  mockReset(): this;
+  /**
+   * Does what `mockReset` does and restores original descriptors of spied-on objects.
+   * @see https://vitest.dev/api/mock#mockrestore
+   */
+  mockRestore(): void;
+  /**
+   * Returns current permanent mock implementation if there is one.
+   *
+   * If mock was created with `vi.fn`, it will consider passed down method as a mock implementation.
+   *
+   * If mock was created with `vi.spyOn`, it will return `undefined` unless a custom implementation was provided.
+   */
+  getMockImplementation(): NormalizedProcedure<T> | undefined;
+  /**
+   * Accepts a function to be used as the mock implementation. TypeScript expects the arguments and return type to match those of the original function.
+   * @see https://vitest.dev/api/mock#mockimplementation
+   * @example
+   * const increment = vi.fn().mockImplementation(count => count + 1);
+   * expect(increment(3)).toBe(4);
+   */
+  mockImplementation(fn: NormalizedProcedure<T>): this;
+  /**
+   * Accepts a function to be used as the mock implementation. TypeScript expects the arguments and return type to match those of the original function. This method can be chained to produce different results for multiple function calls.
+   *
+   * When the mocked function runs out of implementations, it will invoke the default implementation set with `vi.fn(() => defaultValue)` or `.mockImplementation(() => defaultValue)` if they were called.
+   * @see https://vitest.dev/api/mock#mockimplementationonce
+   * @example
+   * const fn = vi.fn(count => count).mockImplementationOnce(count => count + 1);
+   * expect(fn(3)).toBe(4);
+   * expect(fn(3)).toBe(3);
+   */
+  mockImplementationOnce(fn: NormalizedProcedure<T>): this;
+  /**
+   * Overrides the original mock implementation temporarily while the callback is being executed.
+   *
+   * Note that this method takes precedence over the [`mockImplementationOnce`](https://vitest.dev/api/mock#mockimplementationonce).
+   * @see https://vitest.dev/api/mock#withimplementation
+   * @example
+   * const myMockFn = vi.fn(() => 'original')
+   *
+   * myMockFn.withImplementation(() => 'temp', () => {
+   *   myMockFn() // 'temp'
+   * })
+   *
+   * myMockFn() // 'original'
+   */
+  withImplementation(fn: NormalizedProcedure<T>, cb: () => Promise<unknown>): Promise<this>;
+  withImplementation(fn: NormalizedProcedure<T>, cb: () => unknown): this;
+  /**
+   * Use this if you need to return the `this` context from the method without invoking the actual implementation.
+   * @see https://vitest.dev/api/mock#mockreturnthis
+   */
+  mockReturnThis(): this;
+  /**
+   * Accepts a value that will be returned whenever the mock function is called. TypeScript will only accept values that match the return type of the original function.
+   * @see https://vitest.dev/api/mock#mockreturnvalue
+   * @example
+   * const mock = vi.fn()
+   * mock.mockReturnValue(42)
+   * mock() // 42
+   * mock.mockReturnValue(43)
+   * mock() // 43
+   */
+  mockReturnValue(value: MockReturnType<T>): this;
+  /**
+   * Accepts a value that will be returned whenever the mock function is called. TypeScript will only accept values that match the return type of the original function.
+   *
+   * When the mocked function runs out of implementations, it will invoke the default implementation set with `vi.fn(() => defaultValue)` or `.mockImplementation(() => defaultValue)` if they were called.
+   * @example
+   * const myMockFn = vi
+   *   .fn()
+   *   .mockReturnValue('default')
+   *   .mockReturnValueOnce('first call')
+   *   .mockReturnValueOnce('second call')
+   *
+   * // 'first call', 'second call', 'default'
+   * console.log(myMockFn(), myMockFn(), myMockFn())
+   */
+  mockReturnValueOnce(value: MockReturnType<T>): this;
+  /**
+   * Accepts a value that will be thrown whenever the mock function is called.
+   * @see https://vitest.dev/api/mock#mockthrow
+   * @example
+   * const myMockFn = vi.fn().mockThrow(new Error('error'))
+   * myMockFn() // throws 'error'
+   */
+  mockThrow(value: unknown): this;
+  /**
+   * Accepts a value that will be thrown during the next function call. If chained, every consecutive call will throw the specified value.
+   * @example
+   * const myMockFn = vi
+   *   .fn()
+   *   .mockReturnValue('default')
+   *   .mockThrowOnce(new Error('first call error'))
+   *   .mockThrowOnce('second call error')
+   *
+   * expect(() => myMockFn()).toThrowError('first call error')
+   * expect(() => myMockFn()).toThrowError('second call error')
+   * expect(myMockFn()).toEqual('default')
+   */
+  mockThrowOnce(value: unknown): this;
+  /**
+   * Accepts a value that will be resolved when the async function is called. TypeScript will only accept values that match the return type of the original function.
+   * @example
+   * const asyncMock = vi.fn().mockResolvedValue(42)
+   * asyncMock() // Promise<42>
+   */
+  mockResolvedValue(value: Awaited<MockReturnType<T>>): this;
+  /**
+   * Accepts a value that will be resolved during the next function call. TypeScript will only accept values that match the return type of the original function. If chained, each consecutive call will resolve the specified value.
+   * @example
+   * const myMockFn = vi
+   *   .fn()
+   *   .mockResolvedValue('default')
+   *   .mockResolvedValueOnce('first call')
+   *   .mockResolvedValueOnce('second call')
+   *
+   * // Promise<'first call'>, Promise<'second call'>, Promise<'default'>
+   * console.log(myMockFn(), myMockFn(), myMockFn())
+   */
+  mockResolvedValueOnce(value: Awaited<MockReturnType<T>>): this;
+  /**
+   * Accepts an error that will be rejected when async function is called.
+   * @example
+   * const asyncMock = vi.fn().mockRejectedValue(new Error('Async error'))
+   * await asyncMock() // throws Error<'Async error'>
+   */
+  mockRejectedValue(error: unknown): this;
+  /**
+   * Accepts a value that will be rejected during the next function call. If chained, each consecutive call will reject the specified value.
+   * @example
+   * const asyncMock = vi
+   *   .fn()
+   *   .mockResolvedValueOnce('first call')
+   *   .mockRejectedValueOnce(new Error('Async error'))
+   *
+   * await asyncMock() // first call
+   * await asyncMock() // throws Error<'Async error'>
+   */
+  mockRejectedValueOnce(error: unknown): this;
+}
+type Mock<T extends Procedure | Constructable = Procedure> = MockInstance<T> & (T extends Constructable ? (T extends Procedure ? {
+  new (...args: ConstructorParameters<T>): InstanceType<T>;
+  (...args: Parameters<T>): ReturnType<T>;
+} : {
+  new (...args: ConstructorParameters<T>): InstanceType<T>;
+}) : {
+  new (...args: MockParameters<T>): MockReturnType<T>;
+  (...args: MockParameters<T>): MockReturnType<T>;
+}) & { [P in keyof T]: T[P]; };
+interface Constructable {
+  new (...args: any[]): any;
+}
+interface Formatter {
+  (input?: unknown): string;
+  open: string;
+  close: string;
+}
+interface AsymmetricMatcherInterface {
+  asymmetricMatch: (other: unknown, customTesters?: Array<Tester>) => boolean;
+  toString: () => string;
+  getExpectedType?: () => string;
+  toAsymmetricMatcher?: () => string;
+}
+declare abstract class AsymmetricMatcher<T, State extends MatcherState = MatcherState> implements AsymmetricMatcherInterface {
+  protected sample: T;
+  protected inverse: boolean;
+  $$typeof: symbol;
+  constructor(sample: T, inverse?: boolean);
+  protected getMatcherContext(expect?: Chai.ExpectStatic): State;
+  abstract asymmetricMatch(other: unknown, customTesters?: Array<Tester>): boolean;
+  abstract toString(): string;
+  getExpectedType?(): string;
+  toAsymmetricMatcher?(): string;
+}
+declare function matcherHint(matcherName: string, received?: string, expected?: string, options?: MatcherHintOptions): string;
+declare function printReceived(object: unknown): string;
+declare function printExpected(value: unknown): string;
+declare function getMatcherUtils(): {
+  EXPECTED_COLOR: Formatter;
+  RECEIVED_COLOR: Formatter;
+  INVERTED_COLOR: Formatter;
+  BOLD_WEIGHT: Formatter;
+  DIM_COLOR: Formatter;
+  diff: typeof diff;
+  matcherHint: typeof matcherHint;
+  printReceived: typeof printReceived;
+  printExpected: typeof printExpected;
+  printDiffOrStringify: typeof printDiffOrStringify;
+  printWithType: typeof printWithType;
+};
+declare function printWithType<T>(name: string, value: T, print: (value: T) => string): string;
+type Tester = (this: TesterContext, a: any, b: any, customTesters: Array<Tester>) => boolean | undefined;
+interface TesterContext {
+  equals: (a: unknown, b: unknown, customTesters?: Array<Tester>, strictCheck?: boolean) => boolean;
+}
+interface MatcherHintOptions {
+  comment?: string;
+  expectedColor?: Formatter;
+  isDirectExpectCall?: boolean;
+  isNot?: boolean;
+  promise?: string;
+  receivedColor?: Formatter;
+  secondArgument?: string;
+  secondArgumentColor?: Formatter;
+}
+interface MatcherState {
+  customTesters: Array<Tester>;
+  assertionCalls: number;
+  currentTestName?: string;
+  /**
+   * @deprecated exists only in types
+   */
+  dontThrow?: () => void;
+  /**
+   * @deprecated exists only in types
+   */
+  error?: Error;
+  equals: (a: unknown, b: unknown, customTesters?: Array<Tester>, strictCheck?: boolean) => boolean;
+  /**
+   * @deprecated exists only in types
+   */
+  expand?: boolean;
+  expectedAssertionsNumber?: number | null;
+  expectedAssertionsNumberErrorGen?: (() => Error) | null;
+  isExpectingAssertions?: boolean;
+  isExpectingAssertionsError?: Error | null;
+  isNot: boolean;
+  promise: string;
+  /**
+   * @deprecated exists only in types
+   */
+  suppressedErrors: Array<Error>;
+  testPath?: string;
+  utils: ReturnType<typeof getMatcherUtils> & {
+    diff: typeof diff;
+    stringify: typeof stringify;
+    iterableEquality: Tester;
+    subsetEquality: Tester;
+  };
+  soft?: boolean;
+  poll?: boolean;
+  /**
+   * The same assertion instance that chai plugins receive.
+   * @experimental
+   * @see {@link https://www.chaijs.com/guide/plugins/} Core Plugin Concepts
+   */
+  readonly assertion: Assertion$1;
+}
+interface SyncExpectationResult {
+  pass: boolean;
+  message: () => string;
+  actual?: any;
+  expected?: any;
+  meta?: object;
+}
+type AsyncExpectationResult = Promise<SyncExpectationResult>;
+type ExpectationResult = SyncExpectationResult | AsyncExpectationResult;
+interface RawMatcherFn<T extends MatcherState = MatcherState, E extends Array<any> = Array<any>> {
+  (this: T, received: any, ...expected: E): ExpectationResult;
+}
+interface Matchers<R extends void | Promise<void> = void | Promise<void>, T = unknown> {}
+type MatchersObject<T extends MatcherState = MatcherState> = Record<string, RawMatcherFn<T>> & ThisType<T> & { [K in keyof Matchers]?: RawMatcherFn<T, Parameters<Matchers[K]>>; };
+interface ExpectStatic extends Chai.ExpectStatic, Matchers<any>, AsymmetricMatchersContaining {
+  <T>(actual: T, message?: string): Assertion$1<void, T>;
+  extend: (expects: MatchersObject) => void;
+  anything: () => any;
+  any: (constructor: unknown) => any;
+  getState: () => MatcherState;
+  setState: (state: Partial<MatcherState>) => void;
+  not: AsymmetricMatchersContaining;
+}
+interface CustomMatcher<R = any> {
+  /**
+   * Checks that a value satisfies a custom matcher function.
+   *
+   * @param matcher - A function returning a boolean based on the custom condition
+   * @param message - Optional custom error message on failure
+   *
+   * @example
+   * expect(age).toSatisfy(val => val >= 18, 'Age must be at least 18');
+   * expect(age).toEqual(expect.toSatisfy(val => val >= 18, 'Age must be at least 18'));
+   */
+  toSatisfy: (matcher: (value: any) => boolean, message?: string) => R;
+  /**
+   * Matches if the received value is one of the values in the expected array or set.
+   *
+   * @example
+   * expect(1).toBeOneOf([1, 2, 3])
+   * expect('foo').toBeOneOf([expect.any(String)])
+   * expect({ a: 1 }).toEqual({ a: expect.toBeOneOf(['1', '2', '3']) })
+   */
+  toBeOneOf: <T>(sample: ReadonlyArray<T> | ReadonlySet<T>) => R;
+}
+interface AsymmetricMatchersContaining extends Matchers<any>, CustomMatcher {
+  /**
+   * Matches if the received string contains the expected substring.
+   *
+   * @example
+   * expect('I have an apple').toEqual(expect.stringContaining('apple'));
+   * expect({ a: 'test string' }).toEqual({ a: expect.stringContaining('test') });
+   */
+  stringContaining: (expected: string) => any;
+  /**
+   * Matches if the received object contains all properties of the expected object.
+   *
+   * @example
+   * expect({ a: '1', b: 2 }).toEqual(expect.objectContaining({ a: '1' }))
+   */
+  objectContaining: <T = any>(expected: DeeplyAllowMatchers<T>) => any;
+  /**
+   * Matches if the received array contains all elements in the expected array.
+   *
+   * @example
+   * expect(['a', 'b', 'c']).toEqual(expect.arrayContaining(['b', 'a']));
+   */
+  arrayContaining: <T = unknown>(expected: Array<DeeplyAllowMatchers<T>>) => any;
+  /**
+   * Matches if the received string or regex matches the expected pattern.
+   *
+   * @example
+   * expect('hello world').toEqual(expect.stringMatching(/^hello/));
+   * expect('hello world').toEqual(expect.stringMatching('hello'));
+   */
+  stringMatching: (expected: string | RegExp) => any;
+  /**
+   * Matches if the received number is within a certain precision of the expected number.
+   *
+   * @example
+   * expect(10.45).toEqual(expect.closeTo(10.5, 1));
+   * expect(5.11).toEqual(expect.closeTo(5.12)); // with default precision
+   */
+  closeTo: (expected: number, precision?: number) => any;
+  /**
+   * Matches if the received value validates against a Standard Schema.
+   *
+   * @param schema - A Standard Schema V1 compatible schema object
+   *
+   * @example
+   * expect(user).toEqual(expect.schemaMatching(z.object({ name: z.string() })))
+   * expect(['hello', 'world']).toEqual([expect.schemaMatching(z.string()), expect.schemaMatching(z.string())])
+   */
+  schemaMatching: (schema: unknown) => any;
+}
+type WithAsymmetricMatcher<T> = T | AsymmetricMatcher<unknown>;
+type DeeplyAllowMatchers<T> = T extends Array<infer Element> ? WithAsymmetricMatcher<T> | DeeplyAllowMatchers<Element>[] : T extends object ? WithAsymmetricMatcher<T> | { [K in keyof T]: DeeplyAllowMatchers<T[K]>; } : WithAsymmetricMatcher<T>;
+interface JestAssertion<R extends void | Promise<void>, T = unknown> extends CustomMatcher<R> {
+  /**
+   * Used when you want to check that two objects have the same value.
+   * This matcher recursively checks the equality of all fields, rather than checking for object identity.
+   *
+   * @example
+   * expect(user).toEqual({ name: 'Alice', age: 30 });
+   */
+  toEqual: <E>(expected: E) => R;
+  /**
+   * Use to test that objects have the same types as well as structure.
+   *
+   * @example
+   * expect(user).toStrictEqual({ name: 'Alice', age: 30 });
+   */
+  toStrictEqual: <E>(expected: E) => R;
+  /**
+   * Checks that a value is what you expect. It calls `Object.is` to compare values.
+   * Don't use `toBe` with floating-point numbers.
+   *
+   * @example
+   * expect(result).toBe(42);
+   * expect(status).toBe(true);
+   */
+  toBe: <E>(expected: E) => R;
+  /**
+   * Check that a string matches a regular expression.
+   *
+   * @example
+   * expect(message).toMatch(/hello/);
+   * expect(greeting).toMatch('world');
+   */
+  toMatch: (expected: string | RegExp) => R;
+  /**
+   * Used to check that a JavaScript object matches a subset of the properties of an object
+   *
+   * @example
+   * expect(user).toMatchObject({
+   *   name: 'Alice',
+   *   address: { city: 'Wonderland' }
+   * });
+   */
+  toMatchObject: <E extends object | any[]>(expected: E) => R;
+  /**
+   * Used when you want to check that an item is in a list.
+   * For testing the items in the list, this uses `===`, a strict equality check.
+   *
+   * @example
+   * expect(items).toContain('apple');
+   * expect(numbers).toContain(5);
+   */
+  toContain: <E>(item: E) => R;
+  /**
+   * Used when you want to check that an item is in a list.
+   * For testing the items in the list, this matcher recursively checks the
+   * equality of all fields, rather than checking for object identity.
+   *
+   * @example
+   * expect(items).toContainEqual({ name: 'apple', quantity: 1 });
+   */
+  toContainEqual: <E>(item: E) => R;
+  /**
+   * Use when you don't care what a value is, you just want to ensure a value
+   * is true in a boolean context. In JavaScript, there are six falsy values:
+   * `false`, `0`, `''`, `null`, `undefined`, and `NaN`. Everything else is truthy.
+   *
+   * @example
+   * expect(user.isActive).toBeTruthy();
+   */
+  toBeTruthy: () => R;
+  /**
+   * When you don't care what a value is, you just want to
+   * ensure a value is false in a boolean context.
+   *
+   * @example
+   * expect(user.isActive).toBeFalsy();
+   */
+  toBeFalsy: () => R;
+  /**
+   * For comparing floating point numbers.
+   *
+   * @example
+   * expect(score).toBeGreaterThan(10);
+   */
+  toBeGreaterThan: (num: number | bigint) => R;
+  /**
+   * For comparing floating point numbers.
+   *
+   * @example
+   * expect(score).toBeGreaterThanOrEqual(10);
+   */
+  toBeGreaterThanOrEqual: (num: number | bigint) => R;
+  /**
+   * For comparing floating point numbers.
+   *
+   * @example
+   * expect(score).toBeLessThan(10);
+   */
+  toBeLessThan: (num: number | bigint) => R;
+  /**
+   * For comparing floating point numbers.
+   *
+   * @example
+   * expect(score).toBeLessThanOrEqual(10);
+   */
+  toBeLessThanOrEqual: (num: number | bigint) => R;
+  /**
+   * Used to check that a variable is NaN.
+   *
+   * @example
+   * expect(value).toBeNaN();
+   */
+  toBeNaN: () => R;
+  /**
+   * Used to check that a variable is undefined.
+   *
+   * @example
+   * expect(value).toBeUndefined();
+   */
+  toBeUndefined: () => R;
+  /**
+   * This is the same as `.toBe(null)` but the error messages are a bit nicer.
+   * So use `.toBeNull()` when you want to check that something is null.
+   *
+   * @example
+   * expect(value).toBeNull();
+   */
+  toBeNull: () => R;
+  /**
+   * Used to check that a variable is nullable (null or undefined).
+   *
+   * @example
+   * expect(value).toBeNullable();
+   */
+  toBeNullable: () => R;
+  /**
+   * Ensure that a variable is not undefined.
+   *
+   * @example
+   * expect(value).toBeDefined();
+   */
+  toBeDefined: () => R;
+  /**
+   * Ensure that an object is an instance of a class.
+   * This matcher uses `instanceof` underneath.
+   *
+   * @example
+   * expect(new Date()).toBeInstanceOf(Date);
+   */
+  toBeInstanceOf: <E>(expected: E) => R;
+  /**
+   * Used to check that an object has a `.length` property
+   * and it is set to a certain numeric value.
+   *
+   * @example
+   * expect([1, 2, 3]).toHaveLength(3);
+   * expect('hello').toHaveLength(5);
+   */
+  toHaveLength: (length: number) => R;
+  /**
+   * Use to check if a property at the specified path exists on an object.
+   * For checking deeply nested properties, you may use dot notation or an array containing
+   * the path segments for deep references.
+   *
+   * Optionally, you can provide a value to check if it matches the value present at the path
+   * on the target object. This matcher uses 'deep equality' (like `toEqual()`) and recursively checks
+   * the equality of all fields.
+   *
+   * @example
+   * expect(user).toHaveProperty('address.city', 'New York');
+   * expect(config).toHaveProperty(['settings', 'theme'], 'dark');
+   */
+  toHaveProperty: <E>(property: string | (string | number)[], value?: E) => R;
+  /**
+   * Using exact equality with floating point numbers is a bad idea.
+   * Rounding means that intuitive things fail.
+   * The default for `numDigits` is 2.
+   *
+   * @example
+   * expect(price).toBeCloseTo(9.99, 2);
+   */
+  toBeCloseTo: (number: number, numDigits?: number) => R;
+  /**
+   * Ensures that a mock function is called an exact number of times.
+   *
+   * Also under the alias `expect.toBeCalledTimes`.
+   *
+   * @example
+   * expect(mockFunc).toHaveBeenCalledTimes(2);
+   */
+  toHaveBeenCalledTimes: (times: number) => R;
+  /**
+   * Ensures that a mock function is called an exact number of times.
+   *
+   * Alias for `expect.toHaveBeenCalledTimes`.
+   *
+   * @example
+   * expect(mockFunc).toBeCalledTimes(2);
+   * @deprecated Use `toHaveBeenCalledTimes` instead
+   */
+  toBeCalledTimes: (times: number) => R;
+  /**
+   * Ensures that a mock function is called.
+   *
+   * Also under the alias `expect.toBeCalled`.
+   *
+   * @example
+   * expect(mockFunc).toHaveBeenCalled();
+   */
+  toHaveBeenCalled: () => R;
+  /**
+   * Ensures that a mock function is called.
+   *
+   * Alias for `expect.toHaveBeenCalled`.
+   *
+   * @example
+   * expect(mockFunc).toBeCalled();
+   * @deprecated Use `toHaveBeenCalled` instead
+   */
+  toBeCalled: () => R;
+  /**
+   * Ensure that a mock function is called with specific arguments.
+   *
+   * Also under the alias `expect.toBeCalledWith`.
+   *
+   * @example
+   * expect(mockFunc).toHaveBeenCalledWith('arg1', 42);
+   */
+  toHaveBeenCalledWith: <E extends any[]>(...args: E) => R;
+  /**
+   * Ensure that a mock function is called with specific arguments.
+   *
+   * Alias for `expect.toHaveBeenCalledWith`.
+   *
+   * @example
+   * expect(mockFunc).toBeCalledWith('arg1', 42);
+   * @deprecated Use `toHaveBeenCalledWith` instead
+   */
+  toBeCalledWith: <E extends any[]>(...args: E) => R;
+  /**
+   * Ensure that a mock function is called with specific arguments on an Nth call.
+   *
+   * Also under the alias `expect.nthCalledWith`.
+   *
+   * @example
+   * expect(mockFunc).toHaveBeenNthCalledWith(2, 'secondArg');
+   */
+  toHaveBeenNthCalledWith: <E extends any[]>(n: number, ...args: E) => R;
+  /**
+   * If you have a mock function, you can use `.toHaveBeenLastCalledWith`
+   * to test what arguments it was last called with.
+   *
+   * Also under the alias `expect.lastCalledWith`.
+   *
+   * @example
+   * expect(mockFunc).toHaveBeenLastCalledWith('lastArg');
+   */
+  toHaveBeenLastCalledWith: <E extends any[]>(...args: E) => R;
+  /**
+   * Used to test that a function throws when it is called.
+   *
+   * Also under the alias `expect.toThrowError`.
+   *
+   * @example
+   * expect(() => functionWithError()).toThrow('Error message');
+   * expect(() => parseJSON('invalid')).toThrow(SyntaxError);
+   * expect(() => { throw 42 }).toThrow(42);
+   */
+  toThrow: (expected?: any) => R;
+  /**
+   * Used to test that a function throws when it is called.
+   *
+   * Alias for `expect.toThrow`.
+   *
+   * @example
+   * expect(() => functionWithError()).toThrowError('Error message');
+   * expect(() => parseJSON('invalid')).toThrowError(SyntaxError);
+   * expect(() => { throw 42 }).toThrowError(42);
+   * @deprecated Use `toThrow` instead
+   */
+  toThrowError: (expected?: any) => R;
+  /**
+   * Use to test that the mock function successfully returned (i.e., did not throw an error) at least one time
+   *
+   * Alias for `expect.toHaveReturned`.
+   *
+   * @example
+   * expect(mockFunc).toReturn();
+   * @deprecated Use `toHaveReturned` instead
+   */
+  toReturn: () => R;
+  /**
+   * Use to test that the mock function successfully returned (i.e., did not throw an error) at least one time
+   *
+   * Also under the alias `expect.toReturn`.
+   *
+   * @example
+   * expect(mockFunc).toHaveReturned();
+   */
+  toHaveReturned: () => R;
+  /**
+   * Use to ensure that a mock function returned successfully (i.e., did not throw an error) an exact number of times.
+   * Any calls to the mock function that throw an error are not counted toward the number of times the function returned.
+   *
+   * Alias for `expect.toHaveReturnedTimes`.
+   *
+   * @example
+   * expect(mockFunc).toReturnTimes(3);
+   * @deprecated Use `toHaveReturnedTimes` instead
+   */
+  toReturnTimes: (times: number) => R;
+  /**
+   * Use to ensure that a mock function returned successfully (i.e., did not throw an error) an exact number of times.
+   * Any calls to the mock function that throw an error are not counted toward the number of times the function returned.
+   *
+   * Also under the alias `expect.toReturnTimes`.
+   *
+   * @example
+   * expect(mockFunc).toHaveReturnedTimes(3);
+   */
+  toHaveReturnedTimes: (times: number) => R;
+  /**
+   * Use to ensure that a mock function returned a specific value.
+   *
+   * Alias for `expect.toHaveReturnedWith`.
+   *
+   * @example
+   * expect(mockFunc).toReturnWith('returnValue');
+   * @deprecated Use `toHaveReturnedWith` instead
+   */
+  toReturnWith: <E>(value: E) => R;
+  /**
+   * Use to ensure that a mock function returned a specific value.
+   *
+   * Also under the alias `expect.toReturnWith`.
+   *
+   * @example
+   * expect(mockFunc).toHaveReturnedWith('returnValue');
+   */
+  toHaveReturnedWith: <E>(value: E) => R;
+  /**
+   * Use to test the specific value that a mock function last returned.
+   * If the last call to the mock function threw an error, then this matcher will fail
+   * no matter what value you provided as the expected return value.
+   *
+   * Also under the alias `expect.lastReturnedWith`.
+   *
+   * @example
+   * expect(mockFunc).toHaveLastReturnedWith('lastValue');
+   */
+  toHaveLastReturnedWith: <E>(value: E) => R;
+  /**
+   * Use to test the specific value that a mock function returned for the nth call.
+   * If the nth call to the mock function threw an error, then this matcher will fail
+   * no matter what value you provided as the expected return value.
+   *
+   * Also under the alias `expect.nthReturnedWith`.
+   *
+   * @example
+   * expect(mockFunc).toHaveNthReturnedWith(2, 'nthValue');
+   */
+  toHaveNthReturnedWith: <E>(nthCall: number, value: E) => R;
+}
+type VitestAssertion<A, R extends void | Promise<void>, T = unknown> = { [K in keyof A]: A[K] extends Chai.Assertion ? Assertion$1<R, T> : A[K] extends ((...args: any[]) => any) ? R extends Promise<void> ? PromisifyFunction<A[K]> : A[K] : VitestAssertion<A[K], R, T>; } & ((type: string, message?: string) => Assertion$1<R, T>);
+type Promisify<O> = { [K in keyof O]: PromisifyFunction<O[K]>; };
+type PromisifyFunction<T> = T extends ((...args: infer A) => infer R) ? Promisify<T> & ((...args: A) => R extends Promise<any> ? R : Promise<R>) : T;
+type PromisifyAssertion<T> = Assertion$1<Promise<void>, Awaited<T>>;
+interface Assertion$1<R extends void | Promise<void> = void, T = unknown> extends VitestAssertion<Chai.Assertion, R, T>, JestAssertion<R, T>, ChaiMockAssertion<R, T>, Matchers<R, T> {
+  /**
+   * Ensures a value is of a specific type.
+   *
+   * @example
+   * expect(value).toBeTypeOf('string');
+   * expect(number).toBeTypeOf('number');
+   */
+  toBeTypeOf: (expected: "bigint" | "boolean" | "function" | "number" | "object" | "string" | "symbol" | "undefined") => R;
+  /**
+   * Asserts that a mock function was called exactly once.
+   *
+   * @example
+   * expect(mockFunc).toHaveBeenCalledOnce();
+   */
+  toHaveBeenCalledOnce: () => R;
+  /**
+   * Ensure that a mock function is called with specific arguments and called
+   * exactly once.
+   *
+   * @example
+   * expect(mockFunc).toHaveBeenCalledExactlyOnceWith('arg1', 42);
+   */
+  toHaveBeenCalledExactlyOnceWith: <E extends any[]>(...args: E) => R;
+  /**
+   * This assertion checks if a `Mock` was called before another `Mock`.
+   * @param mock - A mock function created by `vi.spyOn` or `vi.fn`
+   * @param failIfNoFirstInvocation - Fail if the first mock was never called
+   * @example
+   * const mock1 = vi.fn()
+   * const mock2 = vi.fn()
+   *
+   * mock1()
+   * mock2()
+   * mock1()
+   *
+   * expect(mock1).toHaveBeenCalledBefore(mock2)
+   */
+  toHaveBeenCalledBefore: (mock: MockInstance, failIfNoFirstInvocation?: boolean) => R;
+  /**
+   * This assertion checks if a `Mock` was called after another `Mock`.
+   * @param mock - A mock function created by `vi.spyOn` or `vi.fn`
+   * @param failIfNoFirstInvocation - Fail if the first mock was never called
+   * @example
+   * const mock1 = vi.fn()
+   * const mock2 = vi.fn()
+   *
+   * mock2()
+   * mock1()
+   * mock2()
+   *
+   * expect(mock1).toHaveBeenCalledAfter(mock2)
+   */
+  toHaveBeenCalledAfter: (mock: MockInstance, failIfNoFirstInvocation?: boolean) => R;
+  /**
+   * Checks that at least one of the mock function's calls has resolved.
+   *
+   * @example
+   * expect(mockAsyncFunc).toHaveResolved();
+   */
+  toHaveResolved: () => R;
+  /**
+   * Checks that at least one of the mock function's calls has resolved to a specific value.
+   *
+   * @example
+   * expect(mockAsyncFunc).toHaveResolvedWith('success');
+   */
+  toHaveResolvedWith: <E>(value: E) => R;
+  /**
+   * Ensures a promise resolves a specific number of times.
+   *
+   * @example
+   * expect(mockAsyncFunc).toHaveResolvedTimes(3);
+   */
+  toHaveResolvedTimes: (times: number) => R;
+  /**
+   * Asserts that the last resolved value of a promise matches an expected value.
+   *
+   * @example
+   * await expect(mockAsyncFunc).toHaveLastResolvedWith('finalResult');
+   */
+  toHaveLastResolvedWith: <E>(value: E) => R;
+  /**
+   * Ensures a specific value was returned by a promise on the nth resolution.
+   *
+   * @example
+   * await expect(mockAsyncFunc).toHaveNthResolvedWith(2, 'secondResult');
+   */
+  toHaveNthResolvedWith: <E>(nthCall: number, value: E) => R;
+  /**
+   * Verifies that a promise resolves.
+   *
+   * @example
+   * await expect(someAsyncFunc).resolves.toBe(42);
+   */
+  resolves: PromisifyAssertion<T>;
+  /**
+   * Verifies that a promise rejects.
+   *
+   * @example
+   * await expect(someAsyncFunc).rejects.toThrow('error');
+   */
+  rejects: PromisifyAssertion<unknown>;
+}
+/**
+ * Chai-style assertions for spy/mock testing.
+ * These provide sinon-chai compatible assertion names that delegate to Jest-style implementations.
+ */
+interface ChaiMockAssertion<R extends void | Promise<void>, T = unknown> {
+  /**
+   * Checks that a spy was called at least once.
+   * Chai-style equivalent of `toHaveBeenCalled`.
+   *
+   * @example
+   * expect(spy).to.have.been.called
+   */
+  readonly called: Assertion$1<R, T>;
+  /**
+   * Checks that a spy was called a specific number of times.
+   * Chai-style equivalent of `toHaveBeenCalledTimes`.
+   *
+   * @example
+   * expect(spy).to.have.callCount(3)
+   */
+  callCount: (count: number) => R;
+  /**
+   * Checks that a spy was called with specific arguments at least once.
+   * Chai-style equivalent of `toHaveBeenCalledWith`.
+   *
+   * @example
+   * expect(spy).to.have.been.calledWith('arg1', 'arg2')
+   */
+  calledWith: <E extends any[]>(...args: E) => R;
+  /**
+   * Checks that a spy was called exactly once.
+   * Chai-style equivalent of `toHaveBeenCalledOnce`.
+   *
+   * @example
+   * expect(spy).to.have.been.calledOnce
+   */
+  readonly calledOnce: Assertion$1<R, T>;
+  /**
+   * Checks that a spy was called exactly once with specific arguments.
+   * Chai-style equivalent of `toHaveBeenCalledExactlyOnceWith`.
+   *
+   * @example
+   * expect(spy).to.have.been.calledOnceWith('arg1', 'arg2')
+   */
+  calledOnceWith: <E extends any[]>(...args: E) => R;
+  /**
+   * Checks that the last call to a spy was made with specific arguments.
+   * Chai-style equivalent of `toHaveBeenLastCalledWith`.
+   *
+   * @example
+   * expect(spy).to.have.been.lastCalledWith('arg1', 'arg2')
+   */
+  lastCalledWith: <E extends any[]>(...args: E) => R;
+  /**
+   * Checks that the nth call to a spy was made with specific arguments.
+   * Chai-style equivalent of `toHaveBeenNthCalledWith`.
+   *
+   * @example
+   * expect(spy).to.have.been.nthCalledWith(2, 'arg1', 'arg2')
+   */
+  nthCalledWith: <E extends any[]>(n: number, ...args: E) => R;
+  /**
+   * Checks that a spy returned a specific value at least once.
+   * Chai-style equivalent of `toHaveReturnedWith`.
+   *
+   * @example
+   * expect(spy).to.have.returned('value')
+   */
+  returned: <E>(value: E) => R;
+  /**
+   * Checks that a spy returned a specific value at least once.
+   * Chai-style equivalent of `toHaveReturnedWith`.
+   *
+   * @example
+   * expect(spy).to.have.returnedWith('value')
+   */
+  returnedWith: <E>(value: E) => R;
+  /**
+   * Checks that a spy returned successfully a specific number of times.
+   * Chai-style equivalent of `toHaveReturnedTimes`.
+   *
+   * @example
+   * expect(spy).to.have.returnedTimes(3)
+   */
+  returnedTimes: (count: number) => R;
+  /**
+   * Checks that the last return value of a spy matches the expected value.
+   * Chai-style equivalent of `toHaveLastReturnedWith`.
+   *
+   * @example
+   * expect(spy).to.have.lastReturnedWith('value')
+   */
+  lastReturnedWith: <E>(value: E) => R;
+  /**
+   * Checks that the nth return value of a spy matches the expected value.
+   * Chai-style equivalent of `toHaveNthReturnedWith`.
+   *
+   * @example
+   * expect(spy).to.have.nthReturnedWith(2, 'value')
+   */
+  nthReturnedWith: <E>(n: number, value: E) => R;
+  /**
+   * Checks that a spy was called before another spy.
+   * Chai-style equivalent of `toHaveBeenCalledBefore`.
+   *
+   * @example
+   * expect(spy1).to.have.been.calledBefore(spy2)
+   */
+  calledBefore: (mock: MockInstance, failIfNoFirstInvocation?: boolean) => R;
+  /**
+   * Checks that a spy was called after another spy.
+   * Chai-style equivalent of `toHaveBeenCalledAfter`.
+   *
+   * @example
+   * expect(spy1).to.have.been.calledAfter(spy2)
+   */
+  calledAfter: (mock: MockInstance, failIfNoFirstInvocation?: boolean) => R;
+  /**
+   * Checks that a spy was called exactly twice.
+   * Chai-style equivalent of `toHaveBeenCalledTimes(2)`.
+   *
+   * @example
+   * expect(spy).to.have.been.calledTwice
+   */
+  readonly calledTwice: Assertion$1<R, T>;
+  /**
+   * Checks that a spy was called exactly three times.
+   * Chai-style equivalent of `toHaveBeenCalledTimes(3)`.
+   *
+   * @example
+   * expect(spy).to.have.been.calledThrice
+   */
+  readonly calledThrice: Assertion$1<R, T>;
+}
+type ExtractBenchNames<T extends BenchRegistration<any>[]> = Exclude<{ [K in keyof T]: T[K] extends BenchRegistration<infer N> ? N : never; }[number], never>;
+/**
+ * A benchmarked function. Vitest-owned and engine-agnostic.
+ */
+type BenchFn = Fn;
+/**
+ * Per-benchmark initialization options passed to `bench(name, options, fn)`.
+ */
+type BenchOptions = FnOptions;
+/**
+ * Engine-neutral run options forwarded to a {@link BenchmarkProvider}. These
+ * come from the optional trailing options argument of `bench.compare()` and
+ * `registration.run()`.
+ */
+type BenchRunOptions = BenchOptions$1;
+/**
+ * The result of a single benchmark, produced by a {@link BenchmarkProvider}.
+ * Structurally compatible with tinybench's task statistics so it flows
+ * unchanged into the reporter, `bench.from()` baselines and comparison tables.
+ * The `name` matches the corresponding {@link BenchRegistration}.
+ */
+interface BenchResult extends TaskResultCompleted, TaskResultRuntimeInfo, TaskResultTimestampProviderInfo {
+  /** The registered benchmark name this result belongs to. */
+  name: string;
+}
+interface BenchStorage<T extends string> {
+  get: (name: T) => BenchResult;
+}
+/**
+ * Options accepted by `bench(name, options, fn)`. Extends the per-benchmark
+ * lifecycle hooks with Vitest-specific fields.
+ */
+interface BenchFnOptions extends BenchOptions {
+  /**
+   * Path (relative to the project root) where the benchmark result is written
+   * after a successful run. The string `${projectName}` is substituted with
+   * the current project name. Absolute paths are accepted as long as they
+   * resolve inside the project root.
+   */
+  writeResult?: string;
+  /**
+   * Mark this benchmark as a per-project entry. Per-project tasks still appear
+   * in the inline comparison table for the current run, and Vitest additionally
+   * collects them across projects and prints a single cross-project table at
+   * the end of the run.
+   */
+  perProject?: boolean;
+}
+interface BenchRegistration<Name extends string> {
+  name: Name;
+  /**
+   * The benchmark function. Absent for registrations created via `bench.from()`.
+   */
+  fn?: BenchFn;
+  /**
+   * Per-benchmark options (`beforeEach`, `beforeAll`, etc.). Absent for
+   * registrations created via `bench.from()`.
+   */
+  fnOpts?: BenchOptions;
+  run: (options?: BenchRunOptions) => Promise<BenchResult>;
+}
+interface BenchCompare {
+  <Args extends BenchRegistration<any>[]>(...args: Args): Promise<BenchStorage<ExtractBenchNames<Args>>>;
+  <Args extends BenchRegistration<any>[]>(...args: [...Args, BenchRunOptions]): Promise<BenchStorage<ExtractBenchNames<Args>>>;
+}
+interface BenchFactory {
+  <Name extends string>(name: Name | Function, fn: BenchFn): BenchRegistration<Name>;
+  <Name extends string>(name: Name | Function, options: BenchFnOptions, fn: BenchFn): BenchRegistration<Name>;
+}
+interface BenchFromSource {
+  (): BaselineData | Promise<BaselineData>;
+}
+interface BenchFrom {
+  <Name extends string>(name: Name | Function, source: string | BenchFromSource): BenchRegistration<Name>;
+}
+interface Bench extends BenchFactory {
+  compare: BenchCompare;
+  from: BenchFrom;
+}
+type RunMode = "run" | "skip" | "only" | "todo" | "queued";
+type TaskState = RunMode | "pass" | "fail";
+interface TaskBase {
+  /**
+   * Unique task identifier. Based on the file id and the position of the task.
+   * The id of the file task is based on the file path relative to root and project name.
+   * It will not change between runs.
+   * @example `1201091390`, `1201091390_0`, `1201091390_0_1`
+   */
+  id: string;
+  /**
+   * Task name provided by the user. If no name was provided, it will be an empty string.
+   */
+  name: string;
+  /**
+   * Full name including the file path, any parent suites, and this task's name.
+   *
+   * Uses ` > ` as the separator between levels.
+   *
+   * @example
+   * // file
+   * 'test/task-names.test.ts'
+   * @example
+   * // suite
+   * 'test/task-names.test.ts > meal planning'
+   * 'test/task-names.test.ts > meal planning > grocery lists'
+   * @example
+   * // test
+   * 'test/task-names.test.ts > meal planning > grocery lists > calculates ingredients'
+   */
+  fullName: string;
+  /**
+   * Full name excluding the file path, including any parent suites and this task's name. `undefined` for file tasks.
+   *
+   * Uses ` > ` as the separator between levels.
+   *
+   * @example
+   * // file
+   * undefined
+   * @example
+   * // suite
+   * 'meal planning'
+   * 'meal planning > grocery lists'
+   * @example
+   * // test
+   * 'meal planning > grocery lists > calculates ingredients'
+   */
+  fullTestName?: string;
+  /**
+   * Task mode.
+   * - **skip**: task is skipped
+   * - **only**: only this task and other tasks with `only` mode will run
+   * - **todo**: task is marked as a todo, alias for `skip`
+   * - **run**: task will run or already ran
+   * - **queued**: task will start running next. It can only exist on the File
+   */
+  mode: RunMode;
+  /**
+   * Custom metadata for the task. JSON reporter will save this data.
+   */
+  meta: TaskMeta;
+  /**
+   * Whether the task was produced with `.each()` method.
+   */
+  each?: boolean;
+  /**
+   * Whether the task should run concurrently with other tasks.
+   */
+  concurrent?: boolean;
+  /**
+   * Whether the tasks of the suite run in a random order.
+   */
+  shuffle?: boolean;
+  /**
+   * Suite that this task is part of. File task or the global suite will have no parent.
+   */
+  suite?: Suite;
+  /**
+   * Result of the task. Suite and file tasks will only have the result if there
+   * was an error during collection or inside `afterAll`/`beforeAll`.
+   */
+  result?: TaskResult;
+  /**
+   * Retry configuration for the task.
+   * - If a number, specifies how many times to retry
+   * - If an object, allows fine-grained retry control
+   * @default 0
+   */
+  retry?: Retry;
+  /**
+   * The amount of times the task should be repeated after the successful run.
+   * If the task fails, it will not be retried unless `retry` is specified.
+   * @default 0
+   */
+  repeats?: number;
+  /**
+   * Location of the task in the file. This field is populated only if
+   * `includeTaskLocation` option is set. It is generated by calling `new Error`
+   * and parsing the stack trace, so the location might differ depending on the runtime.
+   */
+  location?: Location;
+  /**
+   * If the test was collected by parsing the file AST, and the name
+   * is not a static string, this property will be set to `true`.
+   * @experimental
+   */
+  dynamic?: boolean;
+  /**
+   * Custom tags of the task. Useful for filtering tasks.
+   */
+  tags?: string[];
+  logs?: UserConsoleLog[];
+}
+interface TaskPopulated extends TaskBase {
+  /**
+   * File task. It's the root task of the file.
+   */
+  file: File;
+  /**
+   * Whether the task should succeed if it fails. If the task fails, it will be marked as passed.
+   */
+  fails?: boolean;
+  /**
+   * Store promises (from async expects) to wait for them before finishing the test
+   */
+  promises?: Promise<any>[];
+}
+/**
+ * Custom metadata that can be used in reporters.
+ */
+interface TaskMeta {
+  typecheck?: boolean;
+  benchmark?: boolean;
+  __vitest_label__?: string;
+}
+/**
+ * The result of calling a task.
+ */
+interface TaskResult {
+  /**
+   * State of the task. Inherits the `task.mode` during collection.
+   * When the task has finished, it will be changed to `pass` or `fail`.
+   * - **pass**: task ran successfully
+   * - **fail**: task failed
+   */
+  state: TaskState;
+  /**
+   * Errors that occurred during the task execution. It is possible to have several errors
+   * if `expect.soft()` failed multiple times or `retry` was triggered.
+   */
+  errors?: TestError[];
+  /**
+   * How long in milliseconds the task took to run.
+   */
+  duration?: number;
+  /**
+   * Time in milliseconds when the task started running.
+   */
+  startTime?: number;
+  /**
+   * Heap size in bytes after the task finished.
+   * Only available if `logHeapUsage` option is set and `process.memoryUsage` is defined.
+   */
+  heap?: number;
+  /**
+   * State of related to this task hooks. Useful during reporting.
+   */
+  hooks?: Partial<Record<keyof SuiteHooks, TaskState>>;
+  /**
+   * The amount of times the task was retried. The task is retried only if it
+   * failed and `retry` option is set.
+   */
+  retryCount?: number;
+  /**
+   * The amount of times the task was repeated. The task is repeated only if
+   * `repeats` option is set. This number also contains `retryCount`.
+   */
+  repeatCount?: number;
+}
+/** The time spent importing & executing a non-externalized file. */
+interface ImportDuration {
+  /** The time spent importing & executing the file itself, not counting all non-externalized imports that the file does. */
+  selfTime: number;
+  /** The time spent importing & executing the file and all its imports. */
+  totalTime: number;
+  /** Will be set to `true`, if the module was externalized. In this case totalTime and selfTime are identical. */
+  external?: boolean;
+  /** Which module imported this module first. All subsequent imports are cached. */
+  importer?: string;
+}
+interface Suite extends TaskBase {
+  type: "suite";
+  /**
+   * File task. It's the root task of the file.
+   */
+  file: File;
+  /**
+   * An array of tasks that are part of the suite.
+   */
+  tasks: Task[];
+}
+interface File extends Suite {
+  /**
+   * The name of the pool that the file belongs to.
+   * @default 'forks'
+   */
+  pool?: string;
+  /**
+   * The environment that processes the file on the server.
+   */
+  viteEnvironment?: string;
+  /**
+   * The path to the file in UNIX format.
+   */
+  filepath: string;
+  /**
+   * The name of the workspace project the file belongs to.
+   */
+  projectName: string | undefined;
+  /**
+   * The time it took to collect all tests in the file.
+   * This time also includes importing all the file dependencies.
+   */
+  collectDuration?: number;
+  /**
+   * The portion of `collectDuration` the worker spent waiting for the server
+   * to resolve and transform modules.
+   */
+  collectFetchDuration?: number;
+  /**
+   * The time it took to import the setup file.
+   */
+  setupDuration?: number;
+  /**
+   * The portion of `setupDuration` the worker spent waiting for the server
+   * to resolve and transform modules.
+   */
+  setupFetchDuration?: number;
+  /** The time spent importing every non-externalized dependency that Vitest has processed. */
+  importDurations?: Record<string, ImportDuration>;
+  prepareDuration?: number;
+  environmentLoad?: number;
+  concurrencyId: number;
+  workerId: number;
+}
+interface Test<ExtraContext = object> extends TaskPopulated {
+  type: "test";
+  /**
+   * Test context that will be passed to the test function.
+   */
+  context: TestContext & ExtraContext;
+  /**
+   * The test timeout in milliseconds.
+   */
+  timeout: number;
+  /**
+   * An array of custom annotations.
+   */
+  annotations: TestAnnotation[];
+  /**
+   * An array of artifacts produced by the test.
+   *
+   * @experimental
+   */
+  artifacts: TestArtifact[];
+  fullTestName: string;
+  /**
+   * An array of benchmark results generated by `context.bench` function.
+   * The benchmark is added only after `bench().run` or `bench.compare` is resolved.
+   *
+   * @experimental
+   */
+  benchmarks: TestBenchmark[];
+}
+interface TestBenchmark {
+  name: string;
+  tasks: TestBenchmarkTask[];
+}
+type TestBenchmarkStatistics = Statistics;
+interface BaselineData {
+  latency: TestBenchmarkStatistics;
+  throughput: TestBenchmarkStatistics;
+  period: number;
+  totalTime: number;
+}
+interface TestBenchmarkTask {
+  name: string;
+  latency: TestBenchmarkStatistics;
+  throughput: TestBenchmarkStatistics;
+  period: number;
+  totalTime: number;
+  rank: number;
+  perProject?: boolean;
+  /**
+   * `true` when the task was produced by `bench.from()` rather than by
+   * executing a function. Reporters can use this to render the row as a
+   * static reference (no margin of error, no samples).
+   */
+  fromStore?: boolean;
+}
+type Task = Test | Suite | File;
+/**
+ * Retry configuration for tests.
+ * Can be a number for simple retry count, or an object for advanced retry control.
+ */
+type Retry = number | {
+  /**
+   * The number of times to retry the test if it fails.
+   * @default 0
+   */
+  count?: number;
+  /**
+   * Delay in milliseconds between retry attempts.
+   * @default 0
+   */
+  delay?: number;
+  /**
+   * Condition to determine if a test should be retried based on the error.
+   * - If a RegExp, it is tested against the error message
+   * - If a function, called with the TestError object; return true to retry
+   *
+   * NOTE: Functions can only be used in test files, not in vitest.config.ts,
+   * because the configuration is serialized when passed to worker threads.
+   *
+   * @default undefined (retry on all errors)
+   */
+  condition?: RegExp | ((error: TestError) => boolean);
+};
+interface BeforeEachListener<ExtraContext = object> {
+  (context: TestContext & ExtraContext, suite: Readonly<Suite>): Awaitable<unknown>;
+}
+interface AfterEachListener<ExtraContext = object> {
+  (context: TestContext & ExtraContext, suite: Readonly<Suite>): Awaitable<unknown>;
+}
+interface AroundEachListener<ExtraContext = object> {
+  (runTest: () => Promise<void>, context: TestContext & ExtraContext, suite: Readonly<Suite>): Awaitable<unknown>;
+}
+interface RegisteredAllListener {
+  (suite: Readonly<Suite | File>): Awaitable<unknown>;
+}
+interface RegisteredAroundAllListener {
+  (runSuite: () => Promise<void>, suite: Readonly<Suite | File>): Awaitable<unknown>;
+}
+interface SuiteHooks<ExtraContext = object> {
+  beforeAll: RegisteredAllListener[];
+  afterAll: RegisteredAllListener[];
+  aroundAll: RegisteredAroundAllListener[];
+  beforeEach: BeforeEachListener<ExtraContext>[];
+  afterEach: AfterEachListener<ExtraContext>[];
+  aroundEach: AroundEachListener<ExtraContext>[];
+}
+/**
+ * User's custom test context.
+ */
+interface TestContext {
+  /**
+   * Metadata of the current test
+   */
+  readonly task: Readonly<Test>;
+  /**
+   * An [`AbortSignal`](https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal) that will be aborted if the test times out or
+   * the test run was cancelled.
+   * @see {@link https://vitest.dev/guide/test-context#signal}
+   */
+  readonly signal: AbortSignal;
+  /**
+   * Register a callback to run when this specific test fails.
+   * Useful when tests run concurrently.
+   * @see {@link https://vitest.dev/guide/test-context#ontestfailed}
+   */
+  readonly onTestFailed: (fn: OnTestFailedHandler, timeout?: number) => void;
+  /**
+   * Register a callback to run when this specific test finishes.
+   * Useful when tests run concurrently.
+   * @see {@link https://vitest.dev/guide/test-context#ontestfinished}
+   */
+  readonly onTestFinished: (fn: OnTestFinishedHandler, timeout?: number) => void;
+  /**
+   * Mark tests as skipped. All execution after this call will be skipped.
+   * This function throws an error, so make sure you are not catching it accidentally.
+   * @see {@link https://vitest.dev/guide/test-context#skip}
+   */
+  readonly skip: {
+    (note?: string): never;
+    (condition: boolean, note?: string): void;
+  };
+  /**
+   * Add a test annotation that will be displayed by your reporter.
+   * @see {@link https://vitest.dev/guide/test-context#annotate}
+   */
+  readonly annotate: {
+    (message: string, type?: string, attachment?: TestAttachment): Promise<TestAnnotation>;
+    (message: string, attachment?: TestAttachment): Promise<TestAnnotation>;
+  };
+  /**
+   * `expect` instance bound to the current test.
+   *
+   * This API is useful for running snapshot tests concurrently because global expect cannot track them.
+   */
+  readonly expect: ExpectStatic;
+  /**
+   * Create a benchmark to run. It will be reported after the test is finished.
+   * @see {@link https://vitest.dev/guide/benchmarking}
+   */
+  readonly bench: Bench;
+}
+type OnTestFailedHandler = (context: TestContext) => Awaitable<void>;
+type OnTestFinishedHandler = (context: TestContext) => Awaitable<void>;
+/**
+ * Represents a file or data attachment associated with a test artifact.
+ *
+ * Attachments can be either path-based (via `path`) or inline content (via `body`).
+ * The `contentType` helps consumers understand how to interpret the attachment data.
+ */
+interface TestAttachment {
+  /** MIME type of the attachment (e.g., 'image/png', 'text/plain') */
+  contentType?: string;
+  /** Local file path or external HTTP(S) URL to the attachment. Relative paths are resolved from the project root. */
+  path?: string;
+  /** Inline attachment content as a string or raw binary data */
+  body?: string | Uint8Array | undefined;
+  /**
+   * @experimental
+   * How the string `body` is encoded.
+   * - `'base64'` (default): body is already base64-encoded
+   * - `'utf-8'`: body is a utf8 string
+   *
+   * `body: Uint8Array` is always auto-encoded to string with `bodyEncoding: 'base64'`
+   * regardless of this option.
+   */
+  bodyEncoding?: "base64" | "utf-8";
+}
+interface Location {
+  /** Line number in the source file (1-indexed) */
+  line: number;
+  /** Column number in the line (1-indexed) */
+  column: number;
+}
+interface FileLocation extends Location {
+  /** Line number in the source file (1-indexed) */
+  line: number;
+  /** Column number in the line (1-indexed) */
+  column: number;
+  /** Path to the source file */
+  file: string;
+}
+/**
+ * Source code location information for a test artifact.
+ *
+ * Indicates where in the source code the artifact originated from.
+ */
+interface TestArtifactLocation extends FileLocation {}
+/**
+ * @experimental
+ *
+ * Base interface for all test artifacts.
+ *
+ * Extend this interface when creating custom test artifacts. Vitest automatically manages the `attachments` array and injects the `location` property to indicate where the artifact was created in your test code.
+ *
+ * **Important**: when running with [`api.allowWrite`](https://vitest.dev/config/api#api-allowwrite) disabled, Vitest empties the `attachments` array on every artifact before reporting it.
+ */
+interface TestArtifactBase {
+  /** File or data attachments associated with this artifact */
+  attachments?: TestAttachment[];
+  /** Source location where this artifact was created */
+  location?: TestArtifactLocation;
+}
+interface TestAnnotation {
+  message: string;
+  type: string;
+  location?: TestArtifactLocation;
+  attachment?: TestAttachment;
+}
+/**
+ * @experimental
+ *
+ * Artifact type for test annotations.
+ */
+interface TestAnnotationArtifact extends TestArtifactBase {
+  type: "internal:annotation";
+  annotation: TestAnnotation;
+}
+interface VisualRegressionArtifactAttachment extends TestAttachment {
+  name: "reference" | "actual" | "diff";
+  width: number;
+  height: number;
+}
+/**
+ * @experimental
+ *
+ * Artifact type for visual regressions.
+ */
+interface VisualRegressionArtifact extends TestArtifactBase {
+  type: "internal:toMatchScreenshot";
+  kind: "visual-regression";
+  message: string;
+  attachments: VisualRegressionArtifactAttachment[];
+}
+/**
+ * @experimental
+ */
+interface BrowserTraceArtifact extends TestArtifactBase {
+  type: "internal:browserTrace";
+  data: unknown;
+}
+interface FailureScreenshotArtifactAttachment extends TestAttachment {
+  path: string;
+  /** Original file system path to the screenshot, before attachment resolution */
+  originalPath: string;
+  body?: undefined;
+}
+/**
+ * @experimental
+ *
+ * Artifact type for failure screenshots.
+ */
+interface FailureScreenshotArtifact extends TestArtifactBase {
+  type: "internal:failureScreenshot";
+  attachments: [FailureScreenshotArtifactAttachment] | [];
+}
+/**
+ * @experimental
+ * @advanced
+ *
+ * Registry for custom test artifact types.
+ *
+ * Augment this interface to register custom artifact types that your tests can produce.
+ *
+ * Each custom artifact should extend {@linkcode TestArtifactBase} and include a unique `type` discriminator property.
+ *
+ * @remarks
+ * - Use a `Symbol` as the **registry key** to guarantee uniqueness
+ * - The `type` property should follow the pattern `'package-name:artifact-name'`, `'internal:'` is a reserved prefix
+ * - Use `attachments` to include files or data; extend {@linkcode TestAttachment} for custom metadata
+ * - `location` property is automatically injected to indicate where the artifact was created
+ *
+ * @example
+ *  ```ts
+ * // Define custom attachment type for generated PDF
+ * interface PDFAttachment extends TestAttachment {
+ *   contentType: 'application/pdf'
+ *   body: Uint8Array
+ *   pageCount: number
+ *   fileSize: number
+ * }
+ *
+ * interface PDFGenerationArtifact extends TestArtifactBase {
+ *   type: 'my-plugin:pdf-generation'
+ *   templateName: string
+ *   isValid: boolean
+ *   attachments: [PDFAttachment]
+ * }
+ *
+ * // Use a symbol to guarantee key uniqueness
+ * const pdfKey = Symbol('pdf-generation')
+ *
+ * declare module 'vitest' {
+ *   interface TestArtifactRegistry {
+ *     [pdfKey]: PDFGenerationArtifact
+ *   }
+ * }
+ *
+ * // Custom assertion for PDF generation
+ * async function toGenerateValidPDF(
+ *   this: MatcherState,
+ *   actual: PDFTemplate,
+ *   data: Record<string, unknown>
+ * ): AsyncExpectationResult {
+ *   const pdfBuffer = await actual.render(data)
+ *   const validation = await validatePDF(pdfBuffer)
+ *
+ *   await recordArtifact(this.task, {
+ *     type: 'my-plugin:pdf-generation',
+ *     templateName: actual.name,
+ *     isValid: validation.success,
+ *     attachments: [{
+ *       contentType: 'application/pdf',
+ *       body: pdfBuffer,
+ *       pageCount: validation.pageCount,
+ *       fileSize: pdfBuffer.byteLength
+ *     }]
+ *   })
+ *
+ *   return {
+ *     pass: validation.success,
+ *     message: () => validation.success
+ *       ? `Generated valid PDF with ${validation.pageCount} pages`
+ *       : `Invalid PDF: ${validation.error}`
+ *   }
+ * }
+ * ```
+ */
+interface TestArtifactRegistry {}
+/**
+ * @experimental
+ *
+ * Union type of all test artifacts, including built-in and custom registered artifacts.
+ *
+ * This type automatically includes all artifacts registered via {@link TestArtifactRegistry}.
+ */
+type TestArtifact = BrowserTraceArtifact | FailureScreenshotArtifact | TestAnnotationArtifact | VisualRegressionArtifact | TestArtifactRegistry[keyof TestArtifactRegistry];
+//#endregion
+//#region ../../../../node_modules/.bun/vitest@5.0.1+3a20bcfa24daf8e9/node_modules/vitest/dist/chunks/task-utils.d.BZm4GSQD.d.ts
+interface SnapshotMatcher<R extends void | Promise<void>, T = unknown> {
+  <U extends { [P in keyof T]: any; }>(snapshot: Partial<U>, hint?: string): R;
+  (hint?: string): R;
+}
+interface InlineSnapshotMatcher<R extends void | Promise<void>, T = unknown> {
+  <U extends { [P in keyof T]: any; }>(properties: Partial<U>, snapshot?: string, hint?: string): R;
+  (hint?: string): R;
+}
+declare module "vitest" {
+  interface MatcherState {
+    environment: string;
+    snapshotState: SnapshotState;
+    task?: Readonly<Test>;
+  }
+  interface ExpectPollOptions {
+    interval?: number;
+    timeout?: number;
+    message?: string;
+  }
+  interface ExpectStatic {
+    assert: Chai.AssertStatic;
+    unreachable: (message?: string) => never;
+    soft: <T>(actual: T, message?: string) => Assertion<void, T>;
+    poll: <T>(actual: (options: {
+      signal: AbortSignal;
+    }) => T, options?: ExpectPollOptions) => PromisifyAssertion<Awaited<T>>;
+    addEqualityTesters: (testers: Array<Tester>) => void;
+    assertions: (expected: number) => void;
+    hasAssertions: () => void;
+    addSnapshotSerializer: (plugin: Plugin) => void;
+  }
+  interface Assertion<R, T> {
+    matchSnapshot: SnapshotMatcher<R, T>;
+    toMatchSnapshot: SnapshotMatcher<R, T>;
+    toMatchInlineSnapshot: InlineSnapshotMatcher<R, T>;
+    /**
+     * Checks that an error thrown by a function matches a previously recorded snapshot.
+     *
+     * @param hint - Optional custom error message.
+     *
+     * @example
+     * expect(functionWithError).toThrowErrorMatchingSnapshot();
+     */
+    toThrowErrorMatchingSnapshot: (hint?: string) => R;
+    /**
+     * Checks that an error thrown by a function matches an inline snapshot within the test file.
+     * Useful for keeping snapshots close to the test code.
+     *
+     * @param snapshot - Optional inline snapshot string to match.
+     * @param hint - Optional custom error message.
+     *
+     * @example
+     * const throwError = () => { throw new Error('Error occurred') };
+     * expect(throwError).toThrowErrorMatchingInlineSnapshot(`"Error occurred"`);
+     */
+    toThrowErrorMatchingInlineSnapshot: (snapshot?: string, hint?: string) => R;
+    /**
+     * Compares the received value to a snapshot saved in a specified file.
+     * Useful for cases where snapshot content is large or needs to be shared across tests.
+     *
+     * @param filepath - Path to the snapshot file.
+     * @param hint - Optional custom error message.
+     *
+     * @example
+     * await expect(largeData).toMatchFileSnapshot('path/to/snapshot.json');
+     */
+    toMatchFileSnapshot: (filepath: string, hint?: string) => Promise<void>;
+    /**
+     * Asserts that a benchmark result is faster than another benchmark result.
+     * Compares mean latency — lower is faster.
+     *
+     * @example
+     * const result = await bench.compare(
+     *   bench('lib1', () => { lib1() }),
+     *   bench('lib2', () => { lib2() }),
+     * )
+     * expect(result.get('lib1')).toBeFasterThan(result.get('lib2'))
+     * expect(result.get('lib1')).toBeFasterThan(result.get('lib2'), { delta: 0.1 })
+     */
+    toBeFasterThan: (expected: BenchResult, options?: {
+      delta?: number;
+    }) => R;
+    /**
+     * Asserts that a benchmark result is slower than another benchmark result.
+     * Compares mean latency — higher is slower.
+     *
+     * @example
+     * const result = await bench.compare(
+     *   bench('lib1', () => { lib1() }),
+     *   bench('lib2', () => { lib2() }),
+     * )
+     * expect(result.get('lib2')).toBeSlowerThan(result.get('lib1'))
+     * expect(result.get('lib2')).toBeSlowerThan(result.get('lib1'), { delta: 0.2 })
+     */
+    toBeSlowerThan: (expected: BenchResult, options?: {
+      delta?: number;
+    }) => R;
+    /**
+     * Ensures a `vi.when` chain has been exhausted.
+     *
+     * A chain is exhausted when at least one `calledWith` with an associated action (`then*`) has been registered
+     * and every registered behavior has been fully consumed. A chain with no registered
+     * behaviors, or with `calledWith` entries that have no associated `then*` actions, is never considered exhausted.
+     *
+     * @see {@link https://vitest.dev/api/expect#tohavebeenexhausted}
+     *
+     * @example
+     * const w = vi.when(spy).calledWith('hello').thenReturnOnce('HELLO')
+     *
+     * expect(w).not.toHaveBeenExhausted()
+     *
+     * expect(spy('hello')).toBe('HELLO')
+     *
+     * expect(w).toHaveBeenExhausted()
+     */
+    toHaveBeenExhausted: () => R;
+  }
+}
+//#endregion
+//#region src/tracking/registration.fixture.d.ts
+export declare function registration(): {
+  fetcher: Mock<typeof fetch>;
+  tracker: SessionTracker;
+};
+//#endregion