vitest 3.2.4 → 4.0.0-beta.10

package/dist/chunks/{reporters.d.BFLkQcL6.d.ts → reporters.d.BUWjmRYq.d.ts}

@@ -1,387 +1,398 @@
-import { Task, TaskMeta, Suite, File, TestAnnotation, ImportDuration, TaskResultPack, TaskEventPack, SequenceSetupFiles, SequenceHooks, CancelReason } from '@vitest/runner';
-import { b as Awaitable, U as UserConsoleLog, c as Arrayable$1, A as AfterSuiteRunMeta, L as LabelColor, f as EnvironmentOptions, P as ProvidedContext } from './environment.d.cL3nLXbE.js';
-import { ParsedStack, TestError, SerializedError, ErrorWithDiff, Arrayable, Awaitable as Awaitable$1 } from '@vitest/utils';
+import { CancelReason, TaskMeta, Suite, File, TestAnnotation, ImportDuration, Test, Task, TaskResultPack, SequenceSetupFiles, SequenceHooks } from '@vitest/runner';
+import { Awaitable, ParsedStack, TestError, SerializedError, Arrayable as Arrayable$1 } from '@vitest/utils';
+import { P as ProvidedContext, c as Arrayable, A as AfterSuiteRunMeta, U as UserConsoleLog, b as Awaitable$1, L as LabelColor } from './environment.d.BsToaxti.js';
 import { Writable } from 'node:stream';
-import { TransformResult as TransformResult$1, UserConfig as UserConfig$1, DepOptimizationConfig, ServerOptions, ConfigEnv, AliasOptions, ViteDevServer, ModuleNode } from 'vite';
-import { Console } from 'node:console';
+import { ViteDevServer, TransformResult as TransformResult$1, UserConfig as UserConfig$1, DepOptimizationConfig, ServerOptions, ConfigEnv, AliasOptions } from 'vite';
 import { MockedModule } from '@vitest/mocker';
 import { StackTraceParserOptions } from '@vitest/utils/source-map';
-import { T as TestExecutionMethod } from './worker.d.1GmBbd7G.js';
-import { a as SerializedConfig, F as FakeTimerInstallOpts } from './config.d.D2ROskhv.js';
+import { B as BrowserTesterOptions, S as SerializedTestSpecification } from './browser.d.yFAklsD1.js';
+import { a as SerializedConfig, F as FakeTimerInstallOpts } from './config.d.B_LthbQq.js';
 import { PrettyFormatOptions } from '@vitest/pretty-format';
 import { SnapshotSummary, SnapshotStateOptions } from '@vitest/snapshot';
 import { SerializedDiffOptions } from '@vitest/utils/diff';
-import { ViteNodeServerOptions } from 'vite-node';
-import * as chai from 'chai';
-import { B as BenchmarkResult } from './benchmark.d.BwvBVTda.js';
-import { a as RuntimeCoverageProviderModule } from './coverage.d.S9RMNXIe.js';
+import { chai } from '@vitest/expect';
+import { happyDomTypes, jsdomTypes } from 'vitest/optional-types.js';
+import { B as BenchmarkResult } from './benchmark.d.DAaHLpsq.js';
+import { a as RuntimeCoverageProviderModule } from './coverage.d.BZtK59WP.js';
 import { SnapshotManager } from '@vitest/snapshot/manager';
 import { Stats } from 'node:fs';
+import { Console } from 'node:console';
 
-declare class TypeCheckError extends Error {
-	message: string;
-	stacks: ParsedStack[];
-	name: string;
-	constructor(message: string, stacks: ParsedStack[]);
-}
-
-interface ErrorOptions {
-	type?: string;
-	fullStack?: boolean;
-	project?: TestProject;
-	verbose?: boolean;
-	screenshotPaths?: string[];
-	task?: Task;
-	showCodeFrame?: boolean;
-}
-type Listener = () => void;
-declare class Logger {
-	ctx: Vitest;
-	outputStream: NodeJS.WriteStream | Writable;
-	errorStream: NodeJS.WriteStream | Writable;
-	private _clearScreenPending;
-	private _highlights;
-	private cleanupListeners;
-	console: Console;
-	constructor(ctx: Vitest, outputStream?: NodeJS.WriteStream | Writable, errorStream?: NodeJS.WriteStream | Writable);
-	log(...args: any[]): void;
-	error(...args: any[]): void;
-	warn(...args: any[]): void;
-	clearFullScreen(message?: string): void;
-	clearScreen(message: string, force?: boolean): void;
-	private _clearScreen;
-	printError(err: unknown, options?: ErrorOptions): void;
-	deprecate(message: string): void;
-	clearHighlightCache(filename?: string): void;
-	highlight(filename: string, source: string): string;
-	printNoTestFound(filters?: string[]): void;
-	printBanner(): void;
-	printBrowserBanner(project: TestProject): void;
-	printUnhandledErrors(errors: unknown[]): void;
-	printSourceTypeErrors(errors: TypeCheckError[]): void;
-	getColumns(): number;
-	onTerminalCleanup(listener: Listener): void;
-	private addCleanupListeners;
-	private registerUnhandledRejection;
-}
+type ChaiConfig = Omit<Partial<typeof chai.config>, "useProxy" | "proxyExcludedKeys">;
 
-type SerializedTestSpecification = [project: {
-	name: string | undefined
-	root: string
-}, file: string, options: {
-	pool: string
-	testLines?: number[] | undefined
-}];
+type HappyDOMOptions = Omit<NonNullable<ConstructorParameters<typeof happyDomTypes.Window>[0]>, "console">;
 
-declare class ReportedTaskImplementation {
-	/**
-	* The project associated with the test or suite.
-	*/
-	readonly project: TestProject;
-	/**
-	* Unique identifier.
-	* This ID is deterministic and will be the same for the same test across multiple runs.
-	* The ID is based on the project name, module url and test order.
-	*/
-	readonly id: string;
-	/**
-	* Location in the module where the test or suite is defined.
-	*/
-	readonly location: {
-		line: number
-		column: number
-	} | undefined;
+type JSDOMOptions = ConstructorOptionsOverride & Omit<jsdomTypes.ConstructorOptions, keyof ConstructorOptionsOverride>;
+interface ConstructorOptionsOverride {
 	/**
-	* Checks if the test did not fail the suite.
-	* If the test is not finished yet or was skipped, it will return `true`.
-	*/
-	ok(): boolean;
-	/**
-	* Custom metadata that was attached to the test during its execution.
-	*/
-	meta(): TaskMeta;
-}
-declare class TestCase extends ReportedTaskImplementation {
-	#private;
-	readonly type = "test";
-	/**
-	* Direct reference to the test module where the test or suite is defined.
+	* The html content for the test.
+	*
+	* @default '<!DOCTYPE html>'
 	*/
-	readonly module: TestModule;
+	html?: string | ArrayBufferLike;
 	/**
-	* Name of the test.
+	* userAgent affects the value read from navigator.userAgent, as well as the User-Agent header sent while fetching subresources.
+	*
+	* @default `Mozilla/5.0 (${process.platform}) AppleWebKit/537.36 (KHTML, like Gecko) jsdom/${jsdomVersion}`
 	*/
-	readonly name: string;
+	userAgent?: string;
 	/**
-	* Options that the test was initiated with.
+	* url sets the value returned by window.location, document.URL, and document.documentURI,
+	* and affects things like resolution of relative URLs within the document
+	* and the same-origin restrictions and referrer used while fetching subresources.
+	*
+	* @default 'http://localhost:3000'.
 	*/
-	readonly options: TaskOptions;
+	url?: string;
 	/**
-	* Parent suite. If the test was called directly inside the module, the parent will be the module itself.
+	* Enable console?
+	*
+	* @default false
 	*/
-	readonly parent: TestSuite | TestModule;
+	console?: boolean;
 	/**
-	* Full name of the test including all parent suites separated with `>`.
+	* jsdom does not have the capability to render visual content, and will act like a headless browser by default.
+	* It provides hints to web pages through APIs such as document.hidden that their content is not visible.
+	*
+	* When the `pretendToBeVisual` option is set to `true`, jsdom will pretend that it is rendering and displaying
+	* content.
+	*
+	* @default true
 	*/
-	get fullName(): string;
+	pretendToBeVisual?: boolean;
 	/**
-	* Test results.
-	* - **pending**: Test was collected, but didn't finish running yet.
-	* - **passed**: Test passed successfully
-	* - **failed**: Test failed to execute
-	* - **skipped**: Test was skipped during collection or dynamically with `ctx.skip()`.
+	* Enable CookieJar
+	*
+	* @default false
 	*/
-	result(): TestResult;
+	cookieJar?: boolean;
+	resources?: "usable";
+}
+
+interface CDPSession {
+	send: (method: string, params?: Record<string, unknown>) => Promise<unknown>;
+	on: (event: string, listener: (...args: unknown[]) => void) => void;
+	once: (event: string, listener: (...args: unknown[]) => void) => void;
+	off: (event: string, listener: (...args: unknown[]) => void) => void;
+}
+interface BrowserModuleMocker {
+	register: (sessionId: string, module: MockedModule) => Promise<void>;
+	delete: (sessionId: string, url: string) => Promise<void>;
+	clear: (sessionId: string) => Promise<void>;
+}
+interface BrowserProviderOption {
+	name: string;
+	supportedBrowser?: ReadonlyArray<string>;
+	factory: (project: TestProject) => BrowserProvider;
+}
+interface BrowserProvider {
+	name: string;
+	mocker?: BrowserModuleMocker;
 	/**
-	* Test annotations added via the `task.annotate` API during the test execution.
+	* @experimental opt-in into file parallelisation
 	*/
-	annotations(): ReadonlyArray<TestAnnotation>;
+	supportsParallelism: boolean;
+	getCommandsContext: (sessionId: string) => Record<string, unknown>;
+	openPage: (sessionId: string, url: string) => Promise<void>;
+	getCDPSession?: (sessionId: string) => Promise<CDPSession>;
+	close: () => Awaitable<void>;
+}
+type BrowserBuiltinProvider = "webdriverio" | "playwright" | "preview";
+type UnsupportedProperties = "browser" | "typecheck" | "alias" | "sequence" | "root" | "pool" | "poolOptions" | "runner" | "api" | "deps" | "environment" | "environmentOptions" | "server" | "benchmark" | "name";
+interface BrowserInstanceOption extends Omit<ProjectConfig, UnsupportedProperties>, Pick<BrowserConfigOptions, "headless" | "locators" | "viewport" | "testerHtmlPath" | "screenshotDirectory" | "screenshotFailures" | "provider"> {
 	/**
-	* Useful information about the test like duration, memory usage, etc.
-	* Diagnostic is only available after the test has finished.
+	* Name of the browser
 	*/
-	diagnostic(): TestDiagnostic | undefined;
+	browser: string;
+	name?: string;
 }
-declare class TestCollection {
-	#private;
-	constructor(task: Suite | File, project: TestProject);
+interface BrowserConfigOptions {
 	/**
-	* Returns the test or suite at a specific index.
+	* if running tests in the browser should be the default
+	*
+	* @default false
 	*/
-	at(index: number): TestCase | TestSuite | undefined;
+	enabled?: boolean;
 	/**
-	* The number of tests and suites in the collection.
+	* Configurations for different browser setups
 	*/
-	get size(): number;
+	instances: BrowserInstanceOption[];
 	/**
-	* Returns the collection in array form for easier manipulation.
+	* Browser provider
 	*/
-	array(): (TestCase | TestSuite)[];
+	provider?: BrowserProviderOption;
 	/**
-	* Filters all tests that are part of this collection and its children.
+	* enable headless mode
+	*
+	* @default process.env.CI
 	*/
-	allTests(state?: TestState): Generator<TestCase, undefined, void>;
+	headless?: boolean;
 	/**
-	* Filters only the tests that are part of this collection.
+	* Serve API options.
+	*
+	* The default port is 63315.
 	*/
-	tests(state?: TestState): Generator<TestCase, undefined, void>;
+	api?: ApiConfig | number;
 	/**
-	* Filters only the suites that are part of this collection.
+	* Isolate test environment after each test
+	*
+	* @default true
 	*/
-	suites(): Generator<TestSuite, undefined, void>;
+	isolate?: boolean;
 	/**
-	* Filters all suites that are part of this collection and its children.
+	* Run test files in parallel if provider supports this option
+	* This option only has effect in headless mode (enabled in CI by default)
+	*
+	* @default // Same as "test.fileParallelism"
 	*/
-	allSuites(): Generator<TestSuite, undefined, void>;
-	[Symbol.iterator](): Generator<TestSuite | TestCase, undefined, void>;
-}
-
-type ReportedHookContext = {
-	readonly name: "beforeAll" | "afterAll"
-	readonly entity: TestSuite | TestModule
-} | {
-	readonly name: "beforeEach" | "afterEach"
-	readonly entity: TestCase
-};
-declare abstract class SuiteImplementation extends ReportedTaskImplementation {
+	fileParallelism?: boolean;
 	/**
-	* Collection of suites and tests that are part of this suite.
+	* Show Vitest UI
+	*
+	* @default !process.env.CI
 	*/
-	readonly children: TestCollection;
+	ui?: boolean;
 	/**
-	* Errors that happened outside of the test run during collection, like syntax errors.
+	* Default viewport size
 	*/
-	errors(): SerializedError[];
-}
-declare class TestSuite extends SuiteImplementation {
-	#private;
-	readonly type = "suite";
+	viewport?: {
+		/**
+		* Width of the viewport
+		* @default 414
+		*/
+		width: number;
+		/**
+		* Height of the viewport
+		* @default 896
+		*/
+		height: number;
+	};
 	/**
-	* Name of the test or the suite.
+	* Locator options
 	*/
-	readonly name: string;
+	locators?: {
+		/**
+		* Attribute used to locate elements by test id
+		* @default 'data-testid'
+		*/
+		testIdAttribute?: string;
+	};
 	/**
-	* Direct reference to the test module where the test or suite is defined.
+	* Directory where screenshots will be saved when page.screenshot() is called
+	* If not set, all screenshots are saved to __screenshots__ directory in the same folder as the test file.
+	* If this is set, it will be resolved relative to the project root.
+	* @default __screenshots__
 	*/
-	readonly module: TestModule;
+	screenshotDirectory?: string;
 	/**
-	* Parent suite. If suite was called directly inside the module, the parent will be the module itself.
+	* Should Vitest take screenshots if the test fails
+	* @default !browser.ui
 	*/
-	readonly parent: TestSuite | TestModule;
+	screenshotFailures?: boolean;
 	/**
-	* Options that suite was initiated with.
+	* Path to the index.html file that will be used to run tests.
 	*/
-	readonly options: TaskOptions;
+	testerHtmlPath?: string;
 	/**
-	* Checks if the suite has any failed tests.
-	* This will also return `false` if suite failed during collection.
+	* Scripts injected into the main window.
 	*/
-	ok: () => boolean;
+	orchestratorScripts?: BrowserScript[];
 	/**
-	* The meta information attached to the suite during its collection or execution.
+	* Commands that will be executed on the server
+	* via the browser `import("@vitest/browser/context").commands` API.
+	* @see {@link https://vitest.dev/guide/browser/commands}
 	*/
-	meta: () => TaskMeta;
+	commands?: Record<string, BrowserCommand<any>>;
 	/**
-	* Checks the running state of the suite.
+	* Timeout for connecting to the browser
+	* @default 30000
 	*/
-	state(): TestSuiteState;
+	connectTimeout?: number;
+	expect?: {
+		toMatchScreenshot?: { [ComparatorName in keyof ToMatchScreenshotComparators] : {
+			/**
+			* The name of the comparator to use for visual diffing.
+			*
+			* @defaultValue `'pixelmatch'`
+			*/
+			comparatorName?: ComparatorName;
+			comparatorOptions?: ToMatchScreenshotComparators[ComparatorName];
+		} }[keyof ToMatchScreenshotComparators] & ToMatchScreenshotOptions;
+	};
 	/**
-	* Full name of the suite including all parent suites separated with `>`.
+	* Enables tracking uncaught errors and exceptions so they can be reported by Vitest.
+	*
+	* If you need to hide certain errors, it is recommended to use [`onUnhandledError`](https://vitest.dev/config/#onunhandlederror) option instead.
+	*
+	* Disabling this will completely remove all Vitest error handlers, which can help debugging with the "Pause on exceptions" checkbox turned on.
+	* @default true
 	*/
-	get fullName(): string;
+	trackUnhandledErrors?: boolean;
 }
-declare class TestModule extends SuiteImplementation {
-	readonly location: undefined;
-	readonly type = "module";
-	/**
-	* This is usually an absolute UNIX file path.
-	* It can be a virtual ID if the file is not on the disk.
-	* This value corresponds to the ID in the Vite's module graph.
-	*/
-	readonly moduleId: string;
-	/**
-	* Checks the running state of the test file.
-	*/
-	state(): TestModuleState;
-	/**
-	* Checks if the module has any failed tests.
-	* This will also return `false` if module failed during collection.
-	*/
-	ok: () => boolean;
-	/**
-	* The meta information attached to the module during its collection or execution.
-	*/
-	meta: () => TaskMeta;
-	/**
-	* Useful information about the module like duration, memory usage, etc.
-	* If the module was not executed yet, all diagnostic values will return `0`.
-	*/
-	diagnostic(): ModuleDiagnostic;
+interface BrowserCommandContext {
+	testPath: string | undefined;
+	provider: BrowserProvider;
+	project: TestProject;
+	sessionId: string;
 }
-interface TaskOptions {
-	readonly each: boolean | undefined;
-	readonly fails: boolean | undefined;
-	readonly concurrent: boolean | undefined;
-	readonly shuffle: boolean | undefined;
-	readonly retry: number | undefined;
-	readonly repeats: number | undefined;
-	readonly mode: "run" | "only" | "skip" | "todo";
+interface BrowserServerStateSession {
+	project: TestProject;
+	connected: () => void;
+	fail: (v: Error) => void;
 }
-type TestSuiteState = "skipped" | "pending" | "failed" | "passed";
-type TestModuleState = TestSuiteState | "queued";
-type TestState = TestResult["state"];
-type TestResult = TestResultPassed | TestResultFailed | TestResultSkipped | TestResultPending;
-interface TestResultPending {
-	/**
-	* The test was collected, but didn't finish running yet.
-	*/
-	readonly state: "pending";
-	/**
-	* Pending tests have no errors.
-	*/
-	readonly errors: undefined;
+interface BrowserOrchestrator {
+	cleanupTesters: () => Promise<void>;
+	createTesters: (options: BrowserTesterOptions) => Promise<void>;
+	onCancel: (reason: CancelReason) => Promise<void>;
+	$close: () => void;
 }
-interface TestResultPassed {
-	/**
-	* The test passed successfully.
-	*/
-	readonly state: "passed";
-	/**
-	* Errors that were thrown during the test execution.
-	*
-	* **Note**: If test was retried successfully, errors will still be reported.
-	*/
-	readonly errors: ReadonlyArray<TestError> | undefined;
+interface BrowserServerState {
+	orchestrators: Map<string, BrowserOrchestrator>;
 }
-interface TestResultFailed {
-	/**
-	* The test failed to execute.
-	*/
-	readonly state: "failed";
-	/**
-	* Errors that were thrown during the test execution.
-	*/
-	readonly errors: ReadonlyArray<TestError>;
+interface ParentProjectBrowser {
+	spawn: (project: TestProject) => ProjectBrowser;
 }
-interface TestResultSkipped {
+interface ProjectBrowser {
+	vite: ViteDevServer;
+	state: BrowserServerState;
+	provider: BrowserProvider;
+	close: () => Promise<void>;
+	initBrowserProvider: (project: TestProject) => Promise<void>;
+	parseStacktrace: (stack: string) => ParsedStack[];
+	parseErrorStacktrace: (error: TestError, options?: StackTraceParserOptions) => ParsedStack[];
+}
+interface BrowserCommand<Payload extends unknown[]> {
+	(context: BrowserCommandContext, ...payload: Payload): Awaitable<any>;
+}
+interface BrowserScript {
 	/**
-	* The test was skipped with `only` (on another test), `skip` or `todo` flag.
-	* You can see which one was used in the `options.mode` option.
+	* If "content" is provided and type is "module", this will be its identifier.
+	*
+	* If you are using TypeScript, you can add `.ts` extension here for example.
+	* @default `injected-${index}.js`
 	*/
-	readonly state: "skipped";
+	id?: string;
 	/**
-	* Skipped tests have no errors.
+	* JavaScript content to be injected. This string is processed by Vite plugins if type is "module".
+	*
+	* You can use `id` to give Vite a hint about the file extension.
 	*/
-	readonly errors: undefined;
+	content?: string;
 	/**
-	* A custom note passed down to `ctx.skip(note)`.
+	* Path to the script. This value is resolved by Vite so it can be a node module or a file path.
 	*/
-	readonly note: string | undefined;
-}
-interface TestDiagnostic {
+	src?: string;
 	/**
-	* If the duration of the test is above `slowTestThreshold`.
+	* If the script should be loaded asynchronously.
 	*/
-	readonly slow: boolean;
+	async?: boolean;
 	/**
-	* The amount of memory used by the test in bytes.
-	* This value is only available if the test was executed with `logHeapUsage` flag.
+	* Script type.
+	* @default 'module'
 	*/
-	readonly heap: number | undefined;
+	type?: string;
+}
+interface ResolvedBrowserOptions extends BrowserConfigOptions {
+	name: string;
+	enabled: boolean;
+	headless: boolean;
+	isolate: boolean;
+	fileParallelism: boolean;
+	api: ApiConfig;
+	ui: boolean;
+	viewport: {
+		width: number;
+		height: number;
+	};
+	screenshotFailures: boolean;
+	locators: {
+		testIdAttribute: string;
+	};
+}
+type ToMatchScreenshotResolvePath = (data: {
 	/**
-	* The time it takes to execute the test in ms.
+	* Path **without** extension, sanitized and relative to the test file.
+	*
+	* This comes from the arguments passed to `toMatchScreenshot`; if called
+	* without arguments this will be the auto-generated name.
+	*
+	* @example
+	* test('calls `onClick`', () => {
+	*   expect(locator).toMatchScreenshot()
+	*   // arg = "calls-onclick-1"
+	* })
+	*
+	* @example
+	* expect(locator).toMatchScreenshot('foo/bar/baz.png')
+	* // arg = "foo/bar/baz"
+	*
+	* @example
+	* expect(locator).toMatchScreenshot('../foo/bar/baz.png')
+	* // arg = "foo/bar/baz"
 	*/
-	readonly duration: number;
+	arg: string;
 	/**
-	* The time in ms when the test started.
+	* Screenshot extension, with leading dot.
+	*
+	* This can be set through the arguments passed to `toMatchScreenshot`, but
+	* the value will fall back to `'.png'` if an unsupported extension is used.
 	*/
-	readonly startTime: number;
+	ext: string;
 	/**
-	* The amount of times the test was retried.
+	* The instance's browser name.
 	*/
-	readonly retryCount: number;
+	browserName: string;
 	/**
-	* The amount of times the test was repeated as configured by `repeats` option.
-	* This value can be lower if the test failed during the repeat and no `retry` is configured.
+	* The value of {@linkcode process.platform}.
 	*/
-	readonly repeatCount: number;
+	platform: NodeJS.Platform;
 	/**
-	* If test passed on a second retry.
+	* The value provided to
+	* {@linkcode https://vitest.dev/guide/browser/config#browser-screenshotdirectory|browser.screenshotDirectory},
+	* if none is provided, its default value.
 	*/
-	readonly flaky: boolean;
-}
-interface ModuleDiagnostic {
+	screenshotDirectory: string;
 	/**
-	* The time it takes to import and initiate an environment.
+	* Absolute path to the project's
+	* {@linkcode https://vitest.dev/config/#root|root}.
 	*/
-	readonly environmentSetupDuration: number;
+	root: string;
 	/**
-	* The time it takes Vitest to setup test harness (runner, mocks, etc.).
+	* Path to the test file, relative to the project's
+	* {@linkcode https://vitest.dev/config/#root|root}.
 	*/
-	readonly prepareDuration: number;
+	testFileDirectory: string;
 	/**
-	* The time it takes to import the test module.
-	* This includes importing everything in the module and executing suite callbacks.
+	* The test's filename.
 	*/
-	readonly collectDuration: number;
+	testFileName: string;
 	/**
-	* The time it takes to import the setup module.
+	* The {@linkcode https://vitest.dev/api/#test|test}'s name, including
+	* parent {@linkcode https://vitest.dev/api/#describe|describe}, sanitized.
 	*/
-	readonly setupDuration: number;
+	testName: string;
 	/**
-	* Accumulated duration of all tests and hooks in the module.
+	* The value provided to
+	* {@linkcode https://vitest.dev/config/#attachmentsdir|attachmentsDir},
+	* if none is provided, its default value.
 	*/
-	readonly duration: number;
+	attachmentsDir: string;
+}) => string;
+interface ToMatchScreenshotOptions {
 	/**
-	* The amount of memory used by the test module in bytes.
-	* This value is only available if the test was executed with `logHeapUsage` flag.
+	* Overrides default reference screenshot path.
+	*
+	* @default `${root}/${testFileDirectory}/${screenshotDirectory}/${testFileName}/${arg}-${browserName}-${platform}${ext}`
 	*/
-	readonly heap: number | undefined;
+	resolveScreenshotPath?: ToMatchScreenshotResolvePath;
 	/**
-	* The time spent importing every non-externalized dependency that Vitest has processed.
+	* Overrides default screenshot path used for diffs.
+	*
+	* @default `${root}/${attachmentsDir}/${testFileDirectory}/${testFileName}/${arg}-${browserName}-${platform}${ext}`
 	*/
-	readonly importDurations: Record<string, ImportDuration>;
+	resolveDiffPath?: ToMatchScreenshotResolvePath;
 }
+interface ToMatchScreenshotComparators {}
 
 type BuiltinPool = "browser" | "threads" | "forks" | "vmThreads" | "vmForks" | "typescript";
 type Pool = BuiltinPool | (string & {});
@@ -423,8 +434,6 @@ interface ResolvedPoolOptions extends PoolOptions {
 	vmForks?: ResolvedForksOptions & VmOptions;
 }
 interface ThreadsOptions {
-	/** Minimum amount of threads to use */
-	minThreads?: number | string;
 	/** Maximum amount of threads to use */
 	maxThreads?: number | string;
 	/**
@@ -443,12 +452,9 @@ interface ThreadsOptions {
 	useAtomics?: boolean;
 }
 interface ResolvedThreadsOptions extends ThreadsOptions {
-	minThreads?: number;
 	maxThreads?: number;
 }
 interface ForksOptions {
-	/** Minimum amount of child processes to use */
-	minForks?: number | string;
 	/** Maximum amount of child processes to use */
 	maxForks?: number | string;
 	/**
@@ -459,7 +465,6 @@ interface ForksOptions {
 	singleFork?: boolean;
 }
 interface ResolvedForksOptions extends ForksOptions {
-	minForks?: number;
 	maxForks?: number;
 }
 interface WorkerContextOptions {
@@ -505,20 +510,6 @@ interface VmOptions {
 }
 
 declare class TestSpecification {
-	/**
-	* @deprecated use `project` instead
-	*/
-	readonly 0: TestProject;
-	/**
-	* @deprecated use `moduleId` instead
-	*/
-	readonly 1: string;
-	/**
-	* @deprecated use `pool` instead
-	*/
-	readonly 2: {
-		pool: Pool
-	};
 	/**
 	* The task ID associated with the test module.
 	*/
@@ -546,195 +537,444 @@ declare class TestSpecification {
 	*/
 	get testModule(): TestModule | undefined;
 	toJSON(): SerializedTestSpecification;
-	/**
-	* for backwards compatibility
-	* @deprecated
-	*/
-	[Symbol.iterator](): Generator<string | TestProject, void, unknown>;
 }
 
-type TestRunEndReason = "passed" | "interrupted" | "failed";
-interface Reporter {
-	onInit?: (vitest: Vitest) => void;
-	/**
-	* Called when the project initiated the browser instance.
-	* project.browser will always be defined.
-	* @experimental
-	*/
-	onBrowserInit?: (project: TestProject) => Awaitable<void>;
+declare class TestProject {
+	options?: InitializeProjectOptions | undefined;
 	/**
-	* @deprecated use `onTestRunStart` instead
+	* The global Vitest instance.
+	* @experimental The public Vitest API is experimental and does not follow semver.
 	*/
-	onPathsCollected?: (paths?: string[]) => Awaitable<void>;
+	readonly vitest: Vitest;
 	/**
-	* @deprecated use `onTestRunStart` instead
+	* Resolved global configuration. If there are no workspace projects, this will be the same as `config`.
 	*/
-	onSpecsCollected?: (specs?: SerializedTestSpecification[]) => Awaitable<void>;
+	readonly globalConfig: ResolvedConfig;
 	/**
-	* @deprecated use `onTestModuleCollected` instead
+	* Browser instance if the browser is enabled. This is initialized when the tests run for the first time.
 	*/
-	onCollected?: (files: File[]) => Awaitable<void>;
+	browser?: ProjectBrowser;
 	/**
-	* @deprecated use `onTestRunEnd` instead
+	* Temporary directory for the project. This is unique for each project. Vitest stores transformed content here.
 	*/
-	onFinished?: (files: File[], errors: unknown[], coverage?: unknown) => Awaitable<void>;
+	readonly tmpDir: string;
+	/** @inetrnal */ testFilesList: string[] | null;
+	private runner;
+	private closingPromise;
+	private typecheckFilesList;
+	private _globalSetups?;
+	private _provided;
+	constructor(vitest: Vitest, options?: InitializeProjectOptions | undefined);
 	/**
-	* @deprecated use `onTestModuleQueued`, `onTestModuleStart`, `onTestModuleEnd`, `onTestCaseReady`, `onTestCaseResult` instead
+	* The unique hash of this project. This value is consistent between the reruns.
+	*
+	* It is based on the root of the project (not consistent between OS) and its name.
 	*/
-	onTaskUpdate?: (packs: TaskResultPack[], events: TaskEventPack[]) => Awaitable<void>;
-	onTestRemoved?: (trigger?: string) => Awaitable<void>;
-	onWatcherStart?: (files?: File[], errors?: unknown[]) => Awaitable<void>;
-	onWatcherRerun?: (files: string[], trigger?: string) => Awaitable<void>;
-	onServerRestart?: (reason?: string) => Awaitable<void>;
-	onUserConsoleLog?: (log: UserConsoleLog) => Awaitable<void>;
-	onProcessTimeout?: () => Awaitable<void>;
+	get hash(): string;
 	/**
-	* Called when the new test run starts.
+	* Provide a value to the test context. This value will be available to all tests with `inject`.
 	*/
-	onTestRunStart?: (specifications: ReadonlyArray<TestSpecification>) => Awaitable<void>;
+	provide: <T extends keyof ProvidedContext & string>(key: T, value: ProvidedContext[T]) => void;
 	/**
-	* Called when the test run is finished.
+	* Get the provided context. The project context is merged with the global context.
 	*/
-	onTestRunEnd?: (testModules: ReadonlyArray<TestModule>, unhandledErrors: ReadonlyArray<SerializedError>, reason: TestRunEndReason) => Awaitable<void>;
+	getProvidedContext(): ProvidedContext;
 	/**
-	* Called when the module is enqueued for testing. The file itself is not loaded yet.
+	* Creates a new test specification. Specifications describe how to run tests.
+	* @param moduleId The file path
 	*/
-	onTestModuleQueued?: (testModule: TestModule) => Awaitable<void>;
+	createSpecification(moduleId: string, locations?: number[] | undefined, pool?: string): TestSpecification;
+	toJSON(): SerializedTestProject;
 	/**
-	* Called when the test file is loaded and the module is ready to run tests.
+	* Vite's dev server instance. Every workspace project has its own server.
 	*/
-	onTestModuleCollected?: (testModule: TestModule) => Awaitable<void>;
+	get vite(): ViteDevServer;
 	/**
-	* Called when starting to run tests of the test file
+	* Resolved project configuration.
 	*/
-	onTestModuleStart?: (testModule: TestModule) => Awaitable<void>;
+	get config(): ResolvedConfig;
 	/**
-	* Called when all tests of the test file have finished running.
+	* The name of the project or an empty string if not set.
 	*/
-	onTestModuleEnd?: (testModule: TestModule) => Awaitable<void>;
+	get name(): string;
 	/**
-	* Called when test case is ready to run.
-	* Called before the `beforeEach` hooks for the test are run.
+	* The color used when reporting tasks of this project.
 	*/
-	onTestCaseReady?: (testCase: TestCase) => Awaitable<void>;
+	get color(): ProjectName["color"];
 	/**
-	* Called after the test and its hooks are finished running.
-	* The `result()` cannot be `pending`.
+	* Serialized project configuration. This is the config that tests receive.
 	*/
-	onTestCaseResult?: (testCase: TestCase) => Awaitable<void>;
+	get serializedConfig(): SerializedConfig;
 	/**
-	* Called when annotation is added via the `task.annotate` API.
+	* Check if this is the root project. The root project is the one that has the root config.
 	*/
-	onTestCaseAnnotate?: (testCase: TestCase, annotation: TestAnnotation) => Awaitable<void>;
+	isRootProject(): boolean;
+	onTestsRerun(cb: OnTestsRerunHandler): void;
 	/**
-	* Called when test suite is ready to run.
-	* Called before the `beforeAll` hooks for the test are run.
+	* Get all files in the project that match the globs in the config and the filters.
+	* @param filters String filters to match the test files.
 	*/
-	onTestSuiteReady?: (testSuite: TestSuite) => Awaitable<void>;
+	globTestFiles(filters?: string[]): Promise<{
+		/**
+		* Test files that match the filters.
+		*/
+		testFiles: string[];
+		/**
+		* Typecheck test files that match the filters. This will be empty unless `typecheck.enabled` is `true`.
+		*/
+		typecheckTestFiles: string[];
+	}>;
+	private globAllTestFiles;
+	isBrowserEnabled(): boolean;
+	private markTestFile;
 	/**
-	* Called after the test suite and its hooks are finished running.
-	* The `state` cannot be `pending`.
+	* Test if a file matches the test globs. This does the actual glob matching if the test is not cached, unlike `isCachedTestFile`.
 	*/
-	onTestSuiteResult?: (testSuite: TestSuite) => Awaitable<void>;
+	matchesTestGlob(moduleId: string, source?: () => string): boolean;
+	private isInSourceTestCode;
+	private filterFiles;
+	private _parentBrowser?;
 	/**
-	* Called before the hook starts to run.
+	* Closes the project and all associated resources. This can only be called once; the closing promise is cached until the server restarts.
+	* If the resources are needed again, create a new project.
 	*/
-	onHookStart?: (hook: ReportedHookContext) => Awaitable<void>;
+	close(): Promise<void>;
 	/**
-	* Called after the hook finished running.
+	* Import a file using Vite module runner.
+	* @param moduleId The ID of the module in Vite module graph
 	*/
-	onHookEnd?: (hook: ReportedHookContext) => Awaitable<void>;
-	onCoverage?: (coverage: unknown) => Awaitable<void>;
+	import<T>(moduleId: string): Promise<T>;
+	private _setHash;
+	private _serializeOverriddenConfig;
+	private clearTmpDir;
 }
-
-interface BaseOptions {
-	isTTY?: boolean;
+interface SerializedTestProject {
+	name: string;
+	serializedConfig: SerializedConfig;
+	context: ProvidedContext;
 }
-declare abstract class BaseReporter implements Reporter {
-	start: number;
-	end: number;
-	watchFilters?: string[];
-	failedUnwatchedFiles: TestModule[];
-	isTTY: boolean;
-	ctx: Vitest;
-	renderSucceed: boolean;
-	protected verbose: boolean;
-	private _filesInWatchMode;
-	private _timeStart;
-	constructor(options?: BaseOptions);
-	onInit(ctx: Vitest): void;
-	log(...messages: any): void;
-	error(...messages: any): void;
-	relative(path: string): string;
-	onFinished(files?: File[], errors?: unknown[]): void;
-	onTestCaseResult(testCase: TestCase): void;
-	onTestSuiteResult(testSuite: TestSuite): void;
-	onTestModuleEnd(testModule: TestModule): void;
-	private logFailedTask;
-	protected printTestModule(testModule: TestModule): void;
-	protected printTestCase(moduleState: TestModuleState, test: TestCase): void;
-	private getModuleLog;
-	protected printTestSuite(_suite: TestSuite): void;
-	protected getTestName(test: Task, separator?: string): string;
-	protected getFullName(test: Task, separator?: string): string;
-	protected formatShortError(error: ErrorWithDiff): string;
-	protected getTestIndentation(_test: Task): string;
-	protected printAnnotations(test: TestCase, console: "log" | "error", padding?: number): void;
-	protected getDurationPrefix(task: Task): string;
-	onWatcherStart(files?: File[], errors?: unknown[]): void;
-	onWatcherRerun(files: string[], trigger?: string): void;
-	onUserConsoleLog(log: UserConsoleLog, taskState?: TestResult["state"]): void;
-	onTestRemoved(trigger?: string): void;
-	shouldLog(log: UserConsoleLog, taskState?: TestResult["state"]): boolean;
-	onServerRestart(reason?: string): void;
-	reportSummary(files: File[], errors: unknown[]): void;
-	reportTestSummary(files: File[], errors: unknown[]): void;
-	private printErrorsSummary;
-	reportBenchmarkSummary(files: File[]): void;
-	private printTaskErrors;
+interface InitializeProjectOptions extends TestProjectInlineConfiguration {
+	configFile: string | false;
 }
 
-interface BlobOptions {
-	outputFile?: string;
+declare class ReportedTaskImplementation {
+	/**
+	* The project associated with the test or suite.
+	*/
+	readonly project: TestProject;
+	/**
+	* Unique identifier.
+	* This ID is deterministic and will be the same for the same test across multiple runs.
+	* The ID is based on the project name, module url and test order.
+	*/
+	readonly id: string;
+	/**
+	* Location in the module where the test or suite is defined.
+	*/
+	readonly location: {
+		line: number;
+		column: number;
+	} | undefined;
+	/**
+	* Checks if the test did not fail the suite.
+	* If the test is not finished yet or was skipped, it will return `true`.
+	*/
+	ok(): boolean;
+	/**
+	* Custom metadata that was attached to the test during its execution.
+	*/
+	meta(): TaskMeta;
 }
-declare class BlobReporter implements Reporter {
-	start: number;
-	ctx: Vitest;
-	options: BlobOptions;
-	constructor(options: BlobOptions);
-	onInit(ctx: Vitest): void;
-	onFinished(files: File[] | undefined, errors: unknown[] | undefined, coverage: unknown): Promise<void>;
+declare class TestCase extends ReportedTaskImplementation {
+	#private;
+	readonly type = "test";
+	/**
+	* Direct reference to the test module where the test or suite is defined.
+	*/
+	readonly module: TestModule;
+	/**
+	* Name of the test.
+	*/
+	readonly name: string;
+	/**
+	* Options that the test was initiated with.
+	*/
+	readonly options: TaskOptions;
+	/**
+	* Parent suite. If the test was called directly inside the module, the parent will be the module itself.
+	*/
+	readonly parent: TestSuite | TestModule;
+	/**
+	* Full name of the test including all parent suites separated with `>`.
+	*/
+	get fullName(): string;
+	/**
+	* Test results.
+	* - **pending**: Test was collected, but didn't finish running yet.
+	* - **passed**: Test passed successfully
+	* - **failed**: Test failed to execute
+	* - **skipped**: Test was skipped during collection or dynamically with `ctx.skip()`.
+	*/
+	result(): TestResult;
+	/**
+	* Test annotations added via the `task.annotate` API during the test execution.
+	*/
+	annotations(): ReadonlyArray<TestAnnotation>;
+	/**
+	* Useful information about the test like duration, memory usage, etc.
+	* Diagnostic is only available after the test has finished.
+	*/
+	diagnostic(): TestDiagnostic | undefined;
 }
-interface MergedBlobs {
-	files: File[];
-	errors: unknown[];
-	coverages: unknown[];
-	executionTimes: number[];
+declare class TestCollection {
+	#private;
+	constructor(task: Suite | File, project: TestProject);
+	/**
+	* Returns the test or suite at a specific index.
+	*/
+	at(index: number): TestCase | TestSuite | undefined;
+	/**
+	* The number of tests and suites in the collection.
+	*/
+	get size(): number;
+	/**
+	* Returns the collection in array form for easier manipulation.
+	*/
+	array(): (TestCase | TestSuite)[];
+	/**
+	* Filters all tests that are part of this collection and its children.
+	*/
+	allTests(state?: TestState): Generator<TestCase, undefined, void>;
+	/**
+	* Filters only the tests that are part of this collection.
+	*/
+	tests(state?: TestState): Generator<TestCase, undefined, void>;
+	/**
+	* Filters only the suites that are part of this collection.
+	*/
+	suites(): Generator<TestSuite, undefined, void>;
+	/**
+	* Filters all suites that are part of this collection and its children.
+	*/
+	allSuites(): Generator<TestSuite, undefined, void>;
+	[Symbol.iterator](): Generator<TestSuite | TestCase, undefined, void>;
 }
 
-interface DefaultReporterOptions extends BaseOptions {
-	summary?: boolean;
-}
-declare class DefaultReporter extends BaseReporter {
-	private options;
-	private summary?;
-	constructor(options?: DefaultReporterOptions);
-	onTestRunStart(specifications: ReadonlyArray<TestSpecification>): void;
-	onTestModuleQueued(file: TestModule): void;
-	onTestModuleCollected(module: TestModule): void;
-	onTestModuleEnd(module: TestModule): void;
-	onTestCaseReady(test: TestCase): void;
-	onTestCaseResult(test: TestCase): void;
-	onHookStart(hook: ReportedHookContext): void;
-	onHookEnd(hook: ReportedHookContext): void;
-	onInit(ctx: Vitest): void;
-	onTestRunEnd(): void;
+type ReportedHookContext = {
+	readonly name: "beforeAll" | "afterAll";
+	readonly entity: TestSuite | TestModule;
+} | {
+	readonly name: "beforeEach" | "afterEach";
+	readonly entity: TestCase;
+};
+declare abstract class SuiteImplementation extends ReportedTaskImplementation {
+	/**
+	* Collection of suites and tests that are part of this suite.
+	*/
+	readonly children: TestCollection;
+	/**
+	* Errors that happened outside of the test run during collection, like syntax errors.
+	*/
+	errors(): SerializedError[];
 }
-
-interface HTMLOptions {
-	outputFile?: string;
+declare class TestSuite extends SuiteImplementation {
+	#private;
+	readonly type = "suite";
+	/**
+	* Name of the test or the suite.
+	*/
+	readonly name: string;
+	/**
+	* Direct reference to the test module where the test or suite is defined.
+	*/
+	readonly module: TestModule;
+	/**
+	* Parent suite. If suite was called directly inside the module, the parent will be the module itself.
+	*/
+	readonly parent: TestSuite | TestModule;
+	/**
+	* Options that suite was initiated with.
+	*/
+	readonly options: TaskOptions;
+	/**
+	* Checks if the suite has any failed tests.
+	* This will also return `false` if suite failed during collection.
+	*/
+	ok: () => boolean;
+	/**
+	* The meta information attached to the suite during its collection or execution.
+	*/
+	meta: () => TaskMeta;
+	/**
+	* Checks the running state of the suite.
+	*/
+	state(): TestSuiteState;
+	/**
+	* Full name of the suite including all parent suites separated with `>`.
+	*/
+	get fullName(): string;
 }
-
+declare class TestModule extends SuiteImplementation {
+	readonly location: undefined;
+	readonly type = "module";
+	/**
+	* This is usually an absolute UNIX file path.
+	* It can be a virtual ID if the file is not on the disk.
+	* This value corresponds to the ID in the Vite's module graph.
+	*/
+	readonly moduleId: string;
+	/**
+	* Module id relative to the project. This is the same as `task.name`.
+	*/
+	readonly relativeModuleId: string;
+	/**
+	* Checks the running state of the test file.
+	*/
+	state(): TestModuleState;
+	/**
+	* Checks if the module has any failed tests.
+	* This will also return `false` if module failed during collection.
+	*/
+	ok: () => boolean;
+	/**
+	* The meta information attached to the module during its collection or execution.
+	*/
+	meta: () => TaskMeta;
+	/**
+	* Useful information about the module like duration, memory usage, etc.
+	* If the module was not executed yet, all diagnostic values will return `0`.
+	*/
+	diagnostic(): ModuleDiagnostic;
+}
+interface TaskOptions {
+	readonly each: boolean | undefined;
+	readonly fails: boolean | undefined;
+	readonly concurrent: boolean | undefined;
+	readonly shuffle: boolean | undefined;
+	readonly retry: number | undefined;
+	readonly repeats: number | undefined;
+	readonly mode: "run" | "only" | "skip" | "todo";
+}
+type TestSuiteState = "skipped" | "pending" | "failed" | "passed";
+type TestModuleState = TestSuiteState | "queued";
+type TestState = TestResult["state"];
+type TestResult = TestResultPassed | TestResultFailed | TestResultSkipped | TestResultPending;
+interface TestResultPending {
+	/**
+	* The test was collected, but didn't finish running yet.
+	*/
+	readonly state: "pending";
+	/**
+	* Pending tests have no errors.
+	*/
+	readonly errors: undefined;
+}
+interface TestResultPassed {
+	/**
+	* The test passed successfully.
+	*/
+	readonly state: "passed";
+	/**
+	* Errors that were thrown during the test execution.
+	*
+	* **Note**: If test was retried successfully, errors will still be reported.
+	*/
+	readonly errors: ReadonlyArray<TestError> | undefined;
+}
+interface TestResultFailed {
+	/**
+	* The test failed to execute.
+	*/
+	readonly state: "failed";
+	/**
+	* Errors that were thrown during the test execution.
+	*/
+	readonly errors: ReadonlyArray<TestError>;
+}
+interface TestResultSkipped {
+	/**
+	* The test was skipped with `only` (on another test), `skip` or `todo` flag.
+	* You can see which one was used in the `options.mode` option.
+	*/
+	readonly state: "skipped";
+	/**
+	* Skipped tests have no errors.
+	*/
+	readonly errors: undefined;
+	/**
+	* A custom note passed down to `ctx.skip(note)`.
+	*/
+	readonly note: string | undefined;
+}
+interface TestDiagnostic {
+	/**
+	* If the duration of the test is above `slowTestThreshold`.
+	*/
+	readonly slow: boolean;
+	/**
+	* The amount of memory used by the test in bytes.
+	* This value is only available if the test was executed with `logHeapUsage` flag.
+	*/
+	readonly heap: number | undefined;
+	/**
+	* The time it takes to execute the test in ms.
+	*/
+	readonly duration: number;
+	/**
+	* The time in ms when the test started.
+	*/
+	readonly startTime: number;
+	/**
+	* The amount of times the test was retried.
+	*/
+	readonly retryCount: number;
+	/**
+	* The amount of times the test was repeated as configured by `repeats` option.
+	* This value can be lower if the test failed during the repeat and no `retry` is configured.
+	*/
+	readonly repeatCount: number;
+	/**
+	* If test passed on a second retry.
+	*/
+	readonly flaky: boolean;
+}
+interface ModuleDiagnostic {
+	/**
+	* The time it takes to import and initiate an environment.
+	*/
+	readonly environmentSetupDuration: number;
+	/**
+	* The time it takes Vitest to setup test harness (runner, mocks, etc.).
+	*/
+	readonly prepareDuration: number;
+	/**
+	* The time it takes to import the test module.
+	* This includes importing everything in the module and executing suite callbacks.
+	*/
+	readonly collectDuration: number;
+	/**
+	* The time it takes to import the setup module.
+	*/
+	readonly setupDuration: number;
+	/**
+	* Accumulated duration of all tests and hooks in the module.
+	*/
+	readonly duration: number;
+	/**
+	* The amount of memory used by the test module in bytes.
+	* This value is only available if the test was executed with `logHeapUsage` flag.
+	*/
+	readonly heap: number | undefined;
+	/**
+	* The time spent importing every non-externalized dependency that Vitest has processed.
+	*/
+	readonly importDurations: Record<string, ImportDuration>;
+}
+declare function experimental_getRunnerTask(entity: TestCase): Test;
+declare function experimental_getRunnerTask(entity: TestSuite): Suite;
+declare function experimental_getRunnerTask(entity: TestModule): File;
+declare function experimental_getRunnerTask(entity: TestCase | TestSuite | TestModule): Suite | File | Test;
+
 interface CoverageSummaryData {
     lines: Totals;
     statements: Totals;
@@ -839,366 +1079,65 @@ declare class FileCoverage implements FileCoverageData {
     b: { [key: string]: number[] };
 }
 
-// for compatibility reasons, the reporter produces a JSON similar to the one produced by the Jest JSON reporter
-// the following types are extracted from the Jest repository (and simplified)
-// the commented-out fields are the missing ones
-type Status = "passed" | "failed" | "skipped" | "pending" | "todo" | "disabled";
-type Milliseconds = number;
-interface Callsite {
-	line: number;
-	column: number;
+interface Node {
+    isRoot(): boolean;
+    visit(visitor: Visitor, state: any): void;
 }
-interface JsonAssertionResult {
-	ancestorTitles: Array<string>;
-	fullName: string;
-	status: Status;
-	title: string;
-	meta: TaskMeta;
-	duration?: Milliseconds | null;
-	failureMessages: Array<string> | null;
-	location?: Callsite | null;
+
+interface Visitor<N extends Node = Node> {
+    onStart(root: N, state: any): void;
+    onSummary(root: N, state: any): void;
+    onDetail(root: N, state: any): void;
+    onSummaryEnd(root: N, state: any): void;
+    onEnd(root: N, state: any): void;
 }
-interface JsonTestResult {
-	message: string;
-	name: string;
-	status: "failed" | "passed";
-	startTime: number;
-	endTime: number;
-	assertionResults: Array<JsonAssertionResult>;
+
+interface FileOptions {
+    file: string;
 }
-interface JsonTestResults {
-	numFailedTests: number;
-	numFailedTestSuites: number;
-	numPassedTests: number;
-	numPassedTestSuites: number;
-	numPendingTests: number;
-	numPendingTestSuites: number;
-	numTodoTests: number;
-	numTotalTests: number;
-	numTotalTestSuites: number;
-	startTime: number;
-	success: boolean;
-	testResults: Array<JsonTestResult>;
-	snapshot: SnapshotSummary;
-	coverageMap?: CoverageMap | null | undefined;
+
+interface ProjectOptions {
+    projectRoot: string;
 }
-interface JsonOptions$1 {
-	outputFile?: string;
+
+interface ReportOptions {
+    clover: CloverOptions;
+    cobertura: CoberturaOptions;
+    "html-spa": HtmlSpaOptions;
+    html: HtmlOptions;
+    json: JsonOptions$1;
+    "json-summary": JsonSummaryOptions;
+    lcov: LcovOptions;
+    lcovonly: LcovOnlyOptions;
+    none: never;
+    teamcity: TeamcityOptions;
+    text: TextOptions;
+    "text-lcov": TextLcovOptions;
+    "text-summary": TextSummaryOptions;
 }
-declare class JsonReporter implements Reporter {
-	start: number;
-	ctx: Vitest;
-	options: JsonOptions$1;
-	constructor(options: JsonOptions$1);
-	onInit(ctx: Vitest): void;
-	protected logTasks(files: File[], coverageMap?: CoverageMap | null): Promise<void>;
-	onFinished(files?: File[], _errors?: unknown[], coverageMap?: unknown): Promise<void>;
-	/**
-	* Writes the report to an output file if specified in the config,
-	* or logs it to the console otherwise.
-	* @param report
-	*/
-	writeReport(report: string): Promise<void>;
+
+interface CloverOptions extends FileOptions, ProjectOptions {}
+
+interface CoberturaOptions extends FileOptions, ProjectOptions {}
+
+interface HtmlSpaOptions extends HtmlOptions {
+    metricsToShow: Array<"lines" | "branches" | "functions" | "statements">;
+}
+interface HtmlOptions {
+    verbose: boolean;
+    skipEmpty: boolean;
+    subdir: string;
+    linkMapper: LinkMapper;
 }
 
-interface ClassnameTemplateVariables {
-	filename: string;
-	filepath: string;
-}
-interface JUnitOptions {
-	outputFile?: string;
-	/** @deprecated Use `classnameTemplate` instead. */
-	classname?: string;
-	/**
-	* Template for the classname attribute. Can be either a string or a function. The string can contain placeholders {filename} and {filepath}.
-	*/
-	classnameTemplate?: string | ((classnameVariables: ClassnameTemplateVariables) => string);
-	suiteName?: string;
-	/**
-	* Write <system-out> and <system-err> for console output
-	* @default true
-	*/
-	includeConsoleOutput?: boolean;
-	/**
-	* Add <testcase file="..."> attribute (validated on CIRCLE CI and GitLab CI)
-	* @default false
-	*/
-	addFileAttribute?: boolean;
-}
-declare class JUnitReporter implements Reporter {
-	private ctx;
-	private reportFile?;
-	private baseLog;
-	private logger;
-	private _timeStart;
-	private fileFd?;
-	private options;
-	constructor(options: JUnitOptions);
-	onInit(ctx: Vitest): Promise<void>;
-	writeElement(name: string, attrs: Record<string, any>, children: () => Promise<void>): Promise<void>;
-	writeLogs(task: Task, type: "err" | "out"): Promise<void>;
-	writeTasks(tasks: Task[], filename: string): Promise<void>;
-	onFinished(files?: File[]): Promise<void>;
-}
-
-declare class BasicReporter extends BaseReporter {
-	constructor();
-	onInit(ctx: Vitest): void;
-	reportSummary(files: File[], errors: unknown[]): void;
-}
-
-declare class DotReporter extends BaseReporter {
-	private renderer?;
-	private tests;
-	private finishedTests;
-	onInit(ctx: Vitest): void;
-	// Ignore default logging of base reporter
-	printTestModule(): void;
-	onWatcherRerun(files: string[], trigger?: string): void;
-	onFinished(files?: File[], errors?: unknown[]): void;
-	onTestModuleCollected(module: TestModule): void;
-	onTestCaseReady(test: TestCase): void;
-	onTestCaseResult(test: TestCase): void;
-	onTestModuleEnd(testModule: TestModule): void;
-	private createSummary;
-}
-
-interface GithubActionsReporterOptions {
-	onWritePath?: (path: string) => string;
-}
-declare class GithubActionsReporter implements Reporter {
-	ctx: Vitest;
-	options: GithubActionsReporterOptions;
-	constructor(options?: GithubActionsReporterOptions);
-	onInit(ctx: Vitest): void;
-	onTestCaseAnnotate(testCase: TestCase, annotation: TestAnnotation): void;
-	onFinished(files?: File[], errors?: unknown[]): void;
-}
-
-declare class HangingProcessReporter implements Reporter {
-	whyRunning: (() => void) | undefined;
-	onInit(): void;
-	onProcessTimeout(): void;
-}
-
-declare class TapReporter implements Reporter {
-	protected ctx: Vitest;
-	private logger;
-	onInit(ctx: Vitest): void;
-	static getComment(task: Task): string;
-	private logErrorDetails;
-	protected logTasks(tasks: Task[]): void;
-	onFinished(files?: File[]): void;
-}
-
-declare class TapFlatReporter extends TapReporter {
-	onInit(ctx: Vitest): void;
-	onFinished(files?: File[]): void;
-}
-
-declare class VerboseReporter extends DefaultReporter {
-	protected verbose: boolean;
-	renderSucceed: boolean;
-	printTestModule(module: TestModule): void;
-	onTestCaseResult(test: TestCase): void;
-	protected printTestSuite(testSuite: TestSuite): void;
-	protected getTestName(test: Task): string;
-	protected getTestIndentation(test: Task): string;
-	protected formatShortError(): string;
-}
-
-type FormattedBenchmarkResult = BenchmarkResult & {
-	id: string
-};
-
-declare function renderTable(options: {
-	tasks: Task[]
-	level: number
-	shallow?: boolean
-	showHeap: boolean
-	columns: number
-	slowTestThreshold: number
-	compare?: Record<Task["id"], FormattedBenchmarkResult>
-}): string;
-
-declare class BenchmarkReporter extends DefaultReporter {
-	compare?: Parameters<typeof renderTable>[0]["compare"];
-	onInit(ctx: Vitest): Promise<void>;
-	onTaskUpdate(packs: TaskResultPack[]): void;
-	onTestSuiteResult(testSuite: TestSuite): void;
-	protected printTestModule(testModule: TestModule): void;
-	private printSuiteTable;
-	onFinished(files?: File[], errors?: unknown[]): Promise<void>;
-}
-
-declare class VerboseBenchmarkReporter extends BenchmarkReporter {
-	protected verbose: boolean;
-}
-
-declare const BenchmarkReportsMap: {
-	default: typeof BenchmarkReporter
-	verbose: typeof VerboseBenchmarkReporter
-};
-type BenchmarkBuiltinReporters = keyof typeof BenchmarkReportsMap;
-
-declare const ReportersMap: {
-	default: typeof DefaultReporter
-	basic: typeof BasicReporter
-	blob: typeof BlobReporter
-	verbose: typeof VerboseReporter
-	dot: typeof DotReporter
-	json: typeof JsonReporter
-	tap: typeof TapReporter
-	"tap-flat": typeof TapFlatReporter
-	junit: typeof JUnitReporter
-	"hanging-process": typeof HangingProcessReporter
-	"github-actions": typeof GithubActionsReporter
-};
-type BuiltinReporters = keyof typeof ReportersMap;
-interface BuiltinReporterOptions {
-	"default": DefaultReporterOptions;
-	"basic": BaseOptions;
-	"verbose": DefaultReporterOptions;
-	"dot": BaseOptions;
-	"json": JsonOptions$1;
-	"blob": BlobOptions;
-	"tap": never;
-	"tap-flat": never;
-	"junit": JUnitOptions;
-	"hanging-process": never;
-	"html": HTMLOptions;
-}
-
-interface BrowserTesterOptions {
-	method: TestExecutionMethod;
-	files: string[];
-	providedContext: string;
-	startTime: number;
-}
-
-type ChaiConfig = Omit<Partial<typeof chai.config>, "useProxy" | "proxyExcludedKeys">;
-
-interface TestSequencer {
-	/**
-	* Slicing tests into shards. Will be run before `sort`.
-	* Only run, if `shard` is defined.
-	*/
-	shard: (files: TestSpecification[]) => Awaitable<TestSpecification[]>;
-	sort: (files: TestSpecification[]) => Awaitable<TestSpecification[]>;
-}
-interface TestSequencerConstructor {
-	new (ctx: Vitest): TestSequencer;
-}
-
-interface WatcherTriggerPattern {
-	pattern: RegExp;
-	testsToRun: (file: string, match: RegExpMatchArray) => string[] | string | null | undefined | void;
-}
-
-interface BenchmarkUserOptions {
-	/**
-	* Include globs for benchmark test files
-	*
-	* @default ['**\/*.{bench,benchmark}.?(c|m)[jt]s?(x)']
-	*/
-	include?: string[];
-	/**
-	* Exclude globs for benchmark test files
-	* @default ['**\/node_modules/**', '**\/dist/**', '**\/cypress/**', '**\/.{idea,git,cache,output,temp}/**', '**\/{karma,rollup,webpack,vite,vitest,jest,ava,babel,nyc,cypress,tsup,build,eslint,prettier}.config.*']
-	*/
-	exclude?: string[];
-	/**
-	* Include globs for in-source benchmark test files
-	*
-	* @default []
-	*/
-	includeSource?: string[];
-	/**
-	* Custom reporter for output. Can contain one or more built-in report names, reporter instances,
-	* and/or paths to custom reporters
-	*
-	* @default ['default']
-	*/
-	reporters?: Arrayable<BenchmarkBuiltinReporters | Reporter>;
-	/**
-	* @deprecated Use `benchmark.outputJson` instead
-	*/
-	outputFile?: string | (Partial<Record<BenchmarkBuiltinReporters, string>> & Record<string, string>);
-	/**
-	* benchmark output file to compare against
-	*/
-	compare?: string;
-	/**
-	* benchmark output file
-	*/
-	outputJson?: string;
-	/**
-	* Include `samples` array of benchmark results for API or custom reporter usages.
-	* This is disabled by default to reduce memory usage.
-	* @default false
-	*/
-	includeSamples?: boolean;
-}
-
-interface Node {
-    isRoot(): boolean;
-    visit(visitor: Visitor, state: any): void;
-}
-
-interface Visitor<N extends Node = Node> {
-    onStart(root: N, state: any): void;
-    onSummary(root: N, state: any): void;
-    onDetail(root: N, state: any): void;
-    onSummaryEnd(root: N, state: any): void;
-    onEnd(root: N, state: any): void;
-}
-
-interface FileOptions {
-    file: string;
-}
-
-interface ProjectOptions {
-    projectRoot: string;
-}
-
-interface ReportOptions {
-    clover: CloverOptions;
-    cobertura: CoberturaOptions;
-    "html-spa": HtmlSpaOptions;
-    html: HtmlOptions;
-    json: JsonOptions;
-    "json-summary": JsonSummaryOptions;
-    lcov: LcovOptions;
-    lcovonly: LcovOnlyOptions;
-    none: never;
-    teamcity: TeamcityOptions;
-    text: TextOptions;
-    "text-lcov": TextLcovOptions;
-    "text-summary": TextSummaryOptions;
-}
-
-interface CloverOptions extends FileOptions, ProjectOptions {}
-
-interface CoberturaOptions extends FileOptions, ProjectOptions {}
-
-interface HtmlSpaOptions extends HtmlOptions {
-    metricsToShow: Array<"lines" | "branches" | "functions" | "statements">;
-}
-interface HtmlOptions {
-    verbose: boolean;
-    skipEmpty: boolean;
-    subdir: string;
-    linkMapper: LinkMapper;
-}
-
-type JsonOptions = FileOptions;
-type JsonSummaryOptions = FileOptions;
-
-interface LcovOptions extends FileOptions, ProjectOptions {}
-interface LcovOnlyOptions extends FileOptions, ProjectOptions {}
-
-interface TeamcityOptions extends FileOptions {
-    blockName: string;
+type JsonOptions$1 = FileOptions;
+type JsonSummaryOptions = FileOptions;
+
+interface LcovOptions extends FileOptions, ProjectOptions {}
+interface LcovOnlyOptions extends FileOptions, ProjectOptions {}
+
+interface TeamcityOptions extends FileOptions {
+    blockName: string;
 }
 
 interface TextOptions extends FileOptions {
@@ -1237,6 +1176,8 @@ interface CoverageProvider {
 	mergeReports?: (coverages: CoverageResults[]) => void | Promise<void>;
 	/** Callback called for instrumenting files with coverage counters. */
 	onFileTransform?: (sourceCode: string, id: string, pluginCtx: any) => TransformResult | Promise<TransformResult>;
+	/** Callback that's called when the coverage is enabled via a programmatic `enableCoverage` API. */
+	onEnabled?: () => void | Promise<void>;
 }
 interface ReportContext {
 	/** Indicates whether all tests were run. False when only specific tests were run. */
@@ -1252,23 +1193,23 @@ type CoverageReporter = keyof ReportOptions | (string & {});
 type CoverageReporterWithOptions<ReporterName extends CoverageReporter = CoverageReporter> = ReporterName extends keyof ReportOptions ? ReportOptions[ReporterName] extends never ? [ReporterName, object] : [ReporterName, Partial<ReportOptions[ReporterName]>] : [ReporterName, Record<string, unknown>];
 type CoverageProviderName = "v8" | "istanbul" | "custom" | undefined;
 type CoverageOptions<T extends CoverageProviderName = CoverageProviderName> = T extends "istanbul" ? {
-	provider: T
+	provider: T;
 } & CoverageIstanbulOptions : T extends "v8" ? {
 	/**
 	* Provider to use for coverage collection.
 	*
 	* @default 'v8'
 	*/
-	provider: T
+	provider: T;
 } & CoverageV8Options : T extends "custom" ? {
-	provider: T
+	provider: T;
 } & CustomProviderOptions : {
-	provider?: T
+	provider?: T;
 } & CoverageV8Options;
 /** Fields that have default values. Internally these will always be defined. */
-type FieldsWithDefaultValues = "enabled" | "clean" | "cleanOnRerun" | "reportsDirectory" | "exclude" | "extension" | "reportOnFailure" | "allowExternal" | "processingConcurrency";
+type FieldsWithDefaultValues = "enabled" | "clean" | "cleanOnRerun" | "reportsDirectory" | "exclude" | "reportOnFailure" | "allowExternal" | "processingConcurrency";
 type ResolvedCoverageOptions<T extends CoverageProviderName = CoverageProviderName> = CoverageOptions<T> & Required<Pick<CoverageOptions<T>, FieldsWithDefaultValues>> & {
-	reporter: CoverageReporterWithOptions[]
+	reporter: CoverageReporterWithOptions[];
 };
 interface BaseCoverageOptions {
 	/**
@@ -1278,35 +1219,25 @@ interface BaseCoverageOptions {
 	*/
 	enabled?: boolean;
 	/**
-	* List of files included in coverage as glob patterns
+	* List of files included in coverage as glob patterns.
+	* By default only files covered by tests are included.
 	*
-	* @default ['**']
+	* See [Including and excluding files from coverage report](https://vitest.dev/guide/coverage.html#including-and-excluding-files-from-coverage-report) for examples.
 	*/
 	include?: string[];
 	/**
-	* Extensions for files to be included in coverage
-	*
-	* @default ['.js', '.cjs', '.mjs', '.ts', '.tsx', '.jsx', '.vue', '.svelte', '.marko']
-	*/
-	extension?: string | string[];
-	/**
-	* List of files excluded from coverage as glob patterns
+	* List of files excluded from coverage as glob patterns.
+	* Files are first checked against `coverage.include`.
 	*
-	* @default ['coverage/**', 'dist/**', '**\/[.]**', 'packages/*\/test?(s)/**', '**\/*.d.ts', '**\/virtual:*', '**\/__x00__*', '**\/\x00*', 'cypress/**', 'test?(s)/**', 'test?(-*).?(c|m)[jt]s?(x)', '**\/*{.,-}{test,spec}?(-d).?(c|m)[jt]s?(x)', '**\/__tests__/**', '**\/{karma,rollup,webpack,vite,vitest,jest,ava,babel,nyc,cypress,tsup,build}.config.*', '**\/vitest.{workspace,projects}.[jt]s?(on)', '**\/.{eslint,mocha,prettier}rc.{?(c|m)js,yml}']
+	* See [Including and excluding files from coverage report](https://vitest.dev/guide/coverage.html#including-and-excluding-files-from-coverage-report) for examples.
 	*/
 	exclude?: string[];
 	/**
-	* Whether to include all files, including the untested ones into report
+	* Clean coverage results before running tests
 	*
 	* @default true
 	*/
-	all?: boolean;
-	/**
-	* Clean coverage results before running tests
-	*
-	* @default true
-	*/
-	clean?: boolean;
+	clean?: boolean;
 	/**
 	* Clean coverage report on watch rerun
 	*
@@ -1325,7 +1256,7 @@ interface BaseCoverageOptions {
 	*
 	* @default ['text', 'html', 'clover', 'json']
 	*/
-	reporter?: Arrayable$1<CoverageReporter> | (CoverageReporter | [CoverageReporter] | CoverageReporterWithOptions)[];
+	reporter?: Arrayable<CoverageReporter> | (CoverageReporter | [CoverageReporter] | CoverageReporterWithOptions)[];
 	/**
 	* Do not show files with 100% statement, branch, and function coverage
 	*
@@ -1354,7 +1285,7 @@ interface BaseCoverageOptions {
 	* ```
 	*/
 	thresholds?: Thresholds | ({
-		[glob: string]: Pick<Thresholds, 100 | "statements" | "functions" | "branches" | "lines">
+		[glob: string]: Pick<Thresholds, 100 | "statements" | "functions" | "branches" | "lines">;
 	} & Thresholds);
 	/**
 	* Watermarks for statements, lines, branches and functions.
@@ -1362,10 +1293,10 @@ interface BaseCoverageOptions {
 	* Default value is `[50,80]` for each property.
 	*/
 	watermarks?: {
-		statements?: [number, number]
-		functions?: [number, number]
-		branches?: [number, number]
-		lines?: [number, number]
+		statements?: [number, number];
+		functions?: [number, number];
+		branches?: [number, number];
+		lines?: [number, number];
 	};
 	/**
 	* Generate coverage report even when tests fail.
@@ -1395,8 +1326,6 @@ interface BaseCoverageOptions {
 	* Defaults to `Math.min(20, os.availableParallelism?.() ?? os.cpus().length)`
 	*/
 	processingConcurrency?: number;
-}
-interface CoverageIstanbulOptions extends BaseCoverageOptions {
 	/**
 	* Set to array of class method names to ignore for coverage
 	*
@@ -1404,25 +1333,8 @@ interface CoverageIstanbulOptions extends BaseCoverageOptions {
 	*/
 	ignoreClassMethods?: string[];
 }
-interface CoverageV8Options extends BaseCoverageOptions {
-	/**
-	* Ignore empty lines, comments and other non-runtime code, e.g. Typescript types
-	* - Requires `experimentalAstAwareRemapping: false`
-	*/
-	ignoreEmptyLines?: boolean;
-	/**
-	* Remap coverage with experimental AST based analysis
-	* - Provides more accurate results compared to default mode
-	*/
-	experimentalAstAwareRemapping?: boolean;
-	/**
-	* Set to array of class method names to ignore for coverage.
-	* - Requires `experimentalAstAwareRemapping: true`
-	*
-	* @default []
-	*/
-	ignoreClassMethods?: string[];
-}
+interface CoverageIstanbulOptions extends BaseCoverageOptions {}
+interface CoverageV8Options extends BaseCoverageOptions {}
 interface CustomProviderOptions extends Pick<BaseCoverageOptions, FieldsWithDefaultValues> {
 	/** Name of the module or path to a file to load the custom provider from */
 	customProviderModule: string;
@@ -1434,10 +1346,11 @@ interface Thresholds {
 	perFile?: boolean;
 	/**
 	* Update threshold values automatically when current coverage is higher than earlier thresholds
+	* Also can accept a function to format the new threshold values
 	*
 	* @default false
 	*/
-	autoUpdate?: boolean;
+	autoUpdate?: boolean | ((newThreshold: number) => number);
 	/** Thresholds for statements */
 	statements?: number;
 	/** Thresholds for functions */
@@ -1448,1708 +1361,1735 @@ interface Thresholds {
 	lines?: number;
 }
 
-type BuiltinEnvironment = "node" | "jsdom" | "happy-dom" | "edge-runtime";
-// Record is used, so user can get intellisense for builtin environments, but still allow custom environments
-type VitestEnvironment = BuiltinEnvironment | (string & Record<never, never>);
+interface TestRunResult {
+	testModules: TestModule[];
+	unhandledErrors: unknown[];
+}
 
-type CSSModuleScopeStrategy = "stable" | "scoped" | "non-scoped";
-type ApiConfig = Pick<ServerOptions, "port" | "strictPort" | "host" | "middlewareMode">;
+interface SuiteResultCache {
+	failed: boolean;
+	duration: number;
+}
+declare class ResultsCache {
+	private cache;
+	private workspacesKeyMap;
+	private cachePath;
+	private version;
+	private root;
+	constructor(version: string);
+	getCachePath(): string | null;
+	setConfig(root: string, config: ResolvedConfig["cache"]): void;
+	getResults(key: string): SuiteResultCache | undefined;
+	readFromCache(): Promise<void>;
+	updateResults(files: File[]): void;
+	removeFromCache(filepath: string): void;
+	writeToCache(): Promise<void>;
+}
 
-type VitestRunMode = "test" | "benchmark";
-interface ProjectName {
-	label: string;
-	color?: LabelColor;
+type FileStatsCache = Pick<Stats, "size">;
+declare class FilesStatsCache {
+	cache: Map<string, FileStatsCache>;
+	getStats(key: string): FileStatsCache | undefined;
+	populateStats(root: string, specs: TestSpecification[]): Promise<void>;
+	updateStats(fsPath: string, key: string): Promise<void>;
+	removeStats(fsPath: string): void;
 }
-interface SequenceOptions {
+
+declare class VitestCache {
+	results: ResultsCache;
+	stats: FilesStatsCache;
+	constructor(version: string);
+	getFileTestResults(key: string): SuiteResultCache | undefined;
+	getFileStats(key: string): {
+		size: number;
+	} | undefined;
+	static resolveCacheDir(root: string, dir?: string, projectName?: string): string;
+}
+
+declare class TypeCheckError extends Error {
+	message: string;
+	stacks: ParsedStack[];
+	name: string;
+	constructor(message: string, stacks: ParsedStack[]);
+}
+
+interface ErrorOptions {
+	type?: string;
+	fullStack?: boolean;
+	project?: TestProject;
+	verbose?: boolean;
+	screenshotPaths?: string[];
+	task?: Task;
+	showCodeFrame?: boolean;
+}
+type Listener = () => void;
+declare class Logger {
+	ctx: Vitest;
+	outputStream: NodeJS.WriteStream | Writable;
+	errorStream: NodeJS.WriteStream | Writable;
+	private _clearScreenPending;
+	private _highlights;
+	private cleanupListeners;
+	console: Console;
+	constructor(ctx: Vitest, outputStream?: NodeJS.WriteStream | Writable, errorStream?: NodeJS.WriteStream | Writable);
+	log(...args: any[]): void;
+	error(...args: any[]): void;
+	warn(...args: any[]): void;
+	clearFullScreen(message?: string): void;
+	clearScreen(message: string, force?: boolean): void;
+	private _clearScreen;
+	printError(err: unknown, options?: ErrorOptions): void;
+	deprecate(message: string): void;
+	clearHighlightCache(filename?: string): void;
+	highlight(filename: string, source: string): string;
+	printNoTestFound(filters?: string[]): void;
+	printBanner(): void;
+	printBrowserBanner(project: TestProject): void;
+	printUnhandledErrors(errors: ReadonlyArray<unknown>): void;
+	printSourceTypeErrors(errors: TypeCheckError[]): void;
+	getColumns(): number;
+	onTerminalCleanup(listener: Listener): void;
+	private addCleanupListeners;
+	private registerUnhandledRejection;
+}
+
+declare class VitestPackageInstaller {
+	isPackageExists(name: string, options?: {
+		paths?: string[];
+	}): boolean;
+	ensureInstalled(dependency: string, root: string, version?: string): Promise<boolean>;
+}
+
+interface BlobOptions {
+	outputFile?: string;
+}
+declare class BlobReporter implements Reporter {
+	start: number;
+	ctx: Vitest;
+	options: BlobOptions;
+	coverage: unknown | undefined;
+	constructor(options: BlobOptions);
+	onInit(ctx: Vitest): void;
+	onCoverage(coverage: unknown): void;
+	onTestRunEnd(testModules: ReadonlyArray<TestModule>, unhandledErrors: ReadonlyArray<SerializedError>): Promise<void>;
+}
+interface MergedBlobs {
+	files: File[];
+	errors: unknown[];
+	coverages: unknown[];
+	executionTimes: number[];
+}
+
+declare class StateManager {
+	filesMap: Map<string, File[]>;
+	pathsSet: Set<string>;
+	idMap: Map<string, Task>;
+	taskFileMap: WeakMap<Task, File>;
+	errorsSet: Set<unknown>;
+	processTimeoutCauses: Set<string>;
+	reportedTasksMap: WeakMap<Task, TestModule | TestCase | TestSuite>;
+	blobs?: MergedBlobs;
+	transformTime: number;
+	onUnhandledError?: OnUnhandledErrorCallback;
+	constructor(options: {
+		onUnhandledError?: OnUnhandledErrorCallback;
+	});
+	catchError(error: unknown, type: string): void;
+	clearErrors(): void;
+	getUnhandledErrors(): unknown[];
+	addProcessTimeoutCause(cause: string): void;
+	getProcessTimeoutCauses(): string[];
+	getPaths(): string[];
 	/**
-	* Class that handles sorting and sharding algorithm.
-	* If you only need to change sorting, you can extend
-	* your custom sequencer from `BaseSequencer` from `vitest/node`.
-	* @default BaseSequencer
+	* Return files that were running or collected.
 	*/
-	sequencer?: TestSequencerConstructor;
+	getFiles(keys?: string[]): File[];
+	getTestModules(keys?: string[]): TestModule[];
+	getFilepaths(): string[];
+	getFailedFilepaths(): string[];
+	collectPaths(paths?: string[]): void;
+	collectFiles(project: TestProject, files?: File[]): void;
+	clearFiles(project: TestProject, paths?: string[]): void;
+	updateId(task: Task, project: TestProject): void;
+	getReportedEntity(task: Task): TestModule | TestCase | TestSuite | undefined;
+	updateTasks(packs: TaskResultPack[]): void;
+	updateUserLog(log: UserConsoleLog): void;
+	getCountOfFailedTests(): number;
+	cancelFiles(files: string[], project: TestProject): void;
+}
+
+declare class VitestWatcher {
+	private vitest;
 	/**
-	* Controls the order in which this project runs its tests when using multiple [projects](/guide/projects).
-	*
-	* - Projects with the same group order number will run together, and groups are run from lowest to highest.
-	* - If you don’t set this option, all projects run in parallel.
-	* - If several projects use the same group order, they will run at the same time.
-	* @default 0
+	* Modules that will be invalidated on the next run.
 	*/
-	groupOrder?: number;
+	readonly invalidates: Set<string>;
 	/**
-	* Should files and tests run in random order.
-	* @default false
+	* Test files that have changed and need to be rerun.
 	*/
-	shuffle?: boolean | {
-		/**
-		* Should files run in random order. Long running tests will not start
-		* earlier if you enable this option.
-		* @default false
-		*/
-		files?: boolean
-		/**
-		* Should tests run in random order.
-		* @default false
-		*/
-		tests?: boolean
-	};
+	readonly changedTests: Set<string>;
+	private readonly _onRerun;
+	constructor(vitest: Vitest);
+	unregisterWatcher: () => void;
+	registerWatcher(): this;
+	private scheduleRerun;
+	private getTestFilesFromWatcherTrigger;
+	onFileChange: (id: string) => void;
+	onFileDelete: (id: string) => void;
+	onFileCreate: (id: string) => void;
+	private handleSetupFile;
 	/**
-	* Should tests run in parallel.
-	* @default false
+	* @returns A value indicating whether rerun is needed (changedTests was mutated)
 	*/
-	concurrent?: boolean;
+	private handleFileChanged;
+}
+interface WatcherTriggerPattern {
+	pattern: RegExp;
+	testsToRun: (file: string, match: RegExpMatchArray) => string[] | string | null | undefined | void;
+}
+
+interface VitestOptions {
+	packageInstaller?: VitestPackageInstaller;
+	stdin?: NodeJS.ReadStream;
+	stdout?: NodeJS.WriteStream | Writable;
+	stderr?: NodeJS.WriteStream | Writable;
+}
+declare class Vitest {
+	readonly mode: VitestRunMode;
 	/**
-	* Defines how setup files should be ordered
-	* - 'parallel' will run all setup files in parallel
-	* - 'list' will run all setup files in the order they are defined in the config file
-	* @default 'parallel'
+	* Current Vitest version.
+	* @example '2.0.0'
 	*/
-	setupFiles?: SequenceSetupFiles;
+	readonly version: string;
+	static readonly version: string;
 	/**
-	* Seed for the random number generator.
-	* @default Date.now()
+	* The logger instance used to log messages. It's recommended to use this logger instead of `console`.
+	* It's possible to override stdout and stderr streams when initiating Vitest.
+	* @example
+	* new Vitest('test', {
+	*   stdout: new Writable(),
+	* })
 	*/
-	seed?: number;
+	readonly logger: Logger;
 	/**
-	* Defines how hooks should be ordered
-	* - `stack` will order "after" hooks in reverse order, "before" hooks will run sequentially
-	* - `list` will order hooks in the order they are defined
-	* - `parallel` will run hooks in a single group in parallel
-	* @default 'stack'
+	* The package installer instance used to install Vitest packages.
+	* @example
+	* await vitest.packageInstaller.ensureInstalled('@vitest/browser', process.cwd())
 	*/
-	hooks?: SequenceHooks;
-}
-type DepsOptimizationOptions = Omit<DepOptimizationConfig, "disabled" | "noDiscovery"> & {
-	enabled?: boolean
-};
-interface TransformModePatterns {
+	readonly packageInstaller: VitestPackageInstaller;
 	/**
-	* Use SSR transform pipeline for all modules inside specified tests.
-	* Vite plugins will receive `ssr: true` flag when processing those files.
-	*
-	* @default tests with node or edge environment
+	* A path to the built Vitest directory. This is usually a folder in `node_modules`.
 	*/
-	ssr?: string[];
+	readonly distPath: string;
 	/**
-	* First do a normal transform pipeline (targeting browser),
-	* then then do a SSR rewrite to run the code in Node.
-	* Vite plugins will receive `ssr: false` flag when processing those files.
-	*
-	* @default tests with jsdom or happy-dom environment
+	* A list of projects that are currently running.
+	* If projects were filtered with `--project` flag, they won't appear here.
 	*/
-	web?: string[];
-}
-interface DepsOptions {
+	projects: TestProject[];
 	/**
-	* Enable dependency optimization. This can improve the performance of your tests.
+	* A watcher handler. This is not the file system watcher. The handler only
+	* exposes methods to handle changed files.
+	*
+	* If you have your own watcher, you can use these methods to replicate
+	* Vitest behaviour.
 	*/
-	optimizer?: {
-		web?: DepsOptimizationOptions
-		ssr?: DepsOptimizationOptions
-	};
-	web?: {
-		/**
-		* Should Vitest process assets (.png, .svg, .jpg, etc) files and resolve them like Vite does in the browser.
-		*
-		* These module will have a default export equal to the path to the asset, if no query is specified.
-		*
-		* **At the moment, this option only works with `{ pool: 'vmThreads' }`.**
-		*
-		* @default true
-		*/
-		transformAssets?: boolean
-		/**
-		* Should Vitest process CSS (.css, .scss, .sass, etc) files and resolve them like Vite does in the browser.
-		*
-		* If CSS files are disabled with `css` options, this option will just silence UNKNOWN_EXTENSION errors.
-		*
-		* **At the moment, this option only works with `{ pool: 'vmThreads' }`.**
-		*
-		* @default true
-		*/
-		transformCss?: boolean
-		/**
-		* Regexp pattern to match external files that should be transformed.
-		*
-		* By default, files inside `node_modules` are externalized and not transformed.
-		*
-		* **At the moment, this option only works with `{ pool: 'vmThreads' }`.**
-		*
-		* @default []
-		*/
-		transformGlobPattern?: RegExp | RegExp[]
-	};
+	readonly watcher: VitestWatcher;
+	private isFirstRun;
+	private restartsCount;
+	private readonly specifications;
+	private pool;
+	private _config?;
+	private _vite?;
+	private _state?;
+	private _cache?;
+	private _snapshot?;
+	private _coverageProvider?;
+	constructor(mode: VitestRunMode, cliOptions: UserConfig, options?: VitestOptions);
+	private _onRestartListeners;
+	private _onClose;
+	private _onSetServer;
+	private _onCancelListeners;
+	private _onUserTestsRerun;
+	private _onFilterWatchedSpecification;
 	/**
-	* Externalize means that Vite will bypass the package to native Node.
-	*
-	* Externalized dependencies will not be applied Vite's transformers and resolvers.
-	* And does not support HMR on reload.
-	*
-	* Typically, packages under `node_modules` are externalized.
-	*
-	* @deprecated If you rely on vite-node directly, use `server.deps.external` instead. Otherwise, consider using `deps.optimizer.{web,ssr}.exclude`.
+	* The global config.
 	*/
-	external?: (string | RegExp)[];
+	get config(): ResolvedConfig;
 	/**
-	* Vite will process inlined modules.
-	*
-	* This could be helpful to handle packages that ship `.js` in ESM format (that Node can't handle).
-	*
-	* If `true`, every dependency will be inlined
-	*
-	* @deprecated If you rely on vite-node directly, use `server.deps.inline` instead. Otherwise, consider using `deps.optimizer.{web,ssr}.include`.
+	* Global Vite's dev server instance.
 	*/
-	inline?: (string | RegExp)[] | true;
+	get vite(): ViteDevServer;
 	/**
-	* Interpret CJS module's default as named exports
-	*
-	* @default true
+	* The global test state manager.
+	* @experimental The State API is experimental and not subject to semver.
 	*/
-	interopDefault?: boolean;
+	get state(): StateManager;
 	/**
-	* When a dependency is a valid ESM package, try to guess the cjs version based on the path.
-	* This will significantly improve the performance in huge repo, but might potentially
-	* cause some misalignment if a package have different logic in ESM and CJS mode.
-	*
-	* @default false
-	*
-	* @deprecated Use `server.deps.fallbackCJS` instead.
+	* The global snapshot manager. You can access the current state on `snapshot.summary`.
 	*/
-	fallbackCJS?: boolean;
+	get snapshot(): SnapshotManager;
 	/**
-	* A list of directories relative to the config file that should be treated as module directories.
-	*
-	* @default ['node_modules']
+	* Test results and test file stats cache. Primarily used by the sequencer to sort tests.
 	*/
-	moduleDirectories?: string[];
-}
-type InlineReporter = Reporter;
-type ReporterName = BuiltinReporters | "html" | (string & {});
-type ReporterWithOptions<Name extends ReporterName = ReporterName> = Name extends keyof BuiltinReporterOptions ? BuiltinReporterOptions[Name] extends never ? [Name, object] : [Name, Partial<BuiltinReporterOptions[Name]>] : [Name, Record<string, unknown>];
-interface ResolveSnapshotPathHandlerContext {
-	config: SerializedConfig;
-}
-type ResolveSnapshotPathHandler = (testPath: string, snapExtension: string, context: ResolveSnapshotPathHandlerContext) => string;
-interface InlineConfig {
+	get cache(): VitestCache;
+	enableCoverage(): Promise<void>;
+	disableCoverage(): void;
+	private _coverageOverrideCache;
 	/**
-	* Name of the project. Will be used to display in the reporter.
+	* Inject new test projects into the workspace.
+	* @param config Glob, config path or a custom config options.
+	* @returns An array of new test projects. Can be empty if the name was filtered out.
 	*/
-	name?: string | ProjectName;
+	private injectTestProject;
 	/**
-	* Benchmark options.
-	*
-	* @default {}
+	* Provide a value to the test context. This value will be available to all tests with `inject`.
 	*/
-	benchmark?: BenchmarkUserOptions;
+	provide: <T extends keyof ProvidedContext & string>(key: T, value: ProvidedContext[T]) => void;
 	/**
-	* Include globs for test files
-	*
-	* @default ['**\/*.{test,spec}.?(c|m)[jt]s?(x)']
+	* Get global provided context.
 	*/
-	include?: string[];
+	getProvidedContext(): ProvidedContext;
 	/**
-	* Exclude globs for test files
-	* @default ['**\/node_modules/**', '**\/dist/**', '**\/cypress/**', '**\/.{idea,git,cache,output,temp}/**', '**\/{karma,rollup,webpack,vite,vitest,jest,ava,babel,nyc,cypress,tsup,build,eslint,prettier}.config.*']
+	* Return project that has the root (or "global") config.
 	*/
-	exclude?: string[];
+	getRootProject(): TestProject;
+	getProjectByName(name: string): TestProject;
 	/**
-	* Include globs for in-source test files
-	*
-	* @default []
+	* Import a file using Vite module runner. The file will be transformed by Vite and executed in a separate context.
+	* @param moduleId The ID of the module in Vite module graph
 	*/
-	includeSource?: string[];
+	import<T>(moduleId: string): Promise<T>;
 	/**
-	* Handling for dependencies inlining or externalizing
-	*
+	* Creates a coverage provider if `coverage` is enabled in the config.
 	*/
-	deps?: DepsOptions;
+	createCoverageProvider(): Promise<CoverageProvider | null>;
+	private resolveProjects;
 	/**
-	* Vite-node server options
+	* Glob test files in every project and create a TestSpecification for each file and pool.
+	* @param filters String filters to match the test files.
 	*/
-	server?: Omit<ViteNodeServerOptions, "transformMode">;
+	globTestSpecifications(filters?: string[]): Promise<TestSpecification[]>;
+	private initCoverageProvider;
 	/**
-	* Base directory to scan for the test files
-	*
-	* @default `config.root`
+	* Merge reports from multiple runs located in the specified directory (value from `--merge-reports` if not specified).
 	*/
-	dir?: string;
+	mergeReports(directory?: string): Promise<TestRunResult>;
+	collect(filters?: string[]): Promise<TestRunResult>;
 	/**
-	* Register apis globally
-	*
-	* @default false
+	* Returns the list of test files that match the config and filters.
+	* @param filters String filters to match the test files
 	*/
-	globals?: boolean;
+	getRelevantTestSpecifications(filters?: string[]): Promise<TestSpecification[]>;
 	/**
-	* Running environment
-	*
-	* Supports 'node', 'jsdom', 'happy-dom', 'edge-runtime'
-	*
-	* If used unsupported string, will try to load the package `vitest-environment-${env}`
-	*
-	* @default 'node'
+	* Initialize reporters, the coverage provider, and run tests.
+	* This method can throw an error:
+	*   - `FilesNotFoundError` if no tests are found
+	*   - `GitNotFoundError` if `--related` flag is used, but git repository is not initialized
+	*   - `Error` from the user reporters
+	* @param filters String filters to match the test files
 	*/
-	environment?: VitestEnvironment;
+	start(filters?: string[]): Promise<TestRunResult>;
 	/**
-	* Environment options.
+	* Initialize reporters and the coverage provider. This method doesn't run any tests.
+	* If the `--watch` flag is provided, Vitest will still run changed tests even if this method was not called.
 	*/
-	environmentOptions?: EnvironmentOptions;
+	init(): Promise<void>;
 	/**
-	* Automatically assign environment based on globs. The first match will be used.
-	* This has effect only when running tests inside Node.js.
-	*
-	* Format: [glob, environment-name]
-	*
-	* @deprecated use [`projects`](https://vitest.dev/config/#projects) instead
-	* @default []
-	* @example [
-	*   // all tests in tests/dom will run in jsdom
-	*   ['tests/dom/**', 'jsdom'],
-	*   // all tests in tests/ with .edge.test.ts will run in edge-runtime
-	*   ['**\/*.edge.test.ts', 'edge-runtime'],
-	*   // ...
-	* ]
+	* If there is a test run happening, returns a promise that will
+	* resolve when the test run is finished.
 	*/
-	environmentMatchGlobs?: [string, VitestEnvironment][];
+	waitForTestRunEnd(): Promise<void>;
 	/**
-	* Run tests in an isolated environment. This option has no effect on vmThreads pool.
-	*
-	* Disabling this option might improve performance if your code doesn't rely on side effects.
+	* Get test specifications associated with the given module. If module is not a test file, an empty array is returned.
 	*
-	* @default true
+	* **Note:** this method relies on a cache generated by `globTestSpecifications`. If the file was not processed yet, use `project.matchesGlobPattern` instead.
+	* @param moduleId The module ID to get test specifications for.
 	*/
-	isolate?: boolean;
+	getModuleSpecifications(moduleId: string): TestSpecification[];
 	/**
-	* Pool used to run tests in.
-	*
-	* Supports 'threads', 'forks', 'vmThreads'
-	*
-	* @default 'forks'
+	* Vitest automatically caches test specifications for each file. This method clears the cache for the given file or the whole cache altogether.
 	*/
-	pool?: Exclude<Pool, "browser">;
+	clearSpecificationsCache(moduleId?: string): void;
 	/**
-	* Pool options
+	* Run tests for the given test specifications. This does not trigger `onWatcher*` events.
+	* @param specifications A list of specifications to run.
+	* @param allTestsRun Indicates whether all tests were run. This only matters for coverage.
 	*/
-	poolOptions?: PoolOptions;
+	runTestSpecifications(specifications: TestSpecification[], allTestsRun?: boolean): Promise<TestRunResult>;
 	/**
-	* Maximum number or percentage of workers to run tests in. `poolOptions.{threads,vmThreads}.maxThreads`/`poolOptions.forks.maxForks` has higher priority.
+	* Rerun files and trigger `onWatcherRerun`, `onWatcherStart` and `onTestsRerun` events.
+	* @param specifications A list of specifications to run.
+	* @param allTestsRun Indicates whether all tests were run. This only matters for coverage.
 	*/
-	maxWorkers?: number | string;
+	rerunTestSpecifications(specifications: TestSpecification[], allTestsRun?: boolean): Promise<TestRunResult>;
+	private runFiles;
+	experimental_parseSpecifications(specifications: TestSpecification[], options?: {
+		/** @default os.availableParallelism() */
+		concurrency?: number;
+	}): Promise<TestModule[]>;
+	experimental_parseSpecification(specification: TestSpecification): Promise<TestModule>;
 	/**
-	* Minimum number or percentage of workers to run tests in. `poolOptions.{threads,vmThreads}.minThreads`/`poolOptions.forks.minForks` has higher priority.
+	* Collect tests in specified modules. Vitest will run the files to collect tests.
+	* @param specifications A list of specifications to run.
 	*/
-	minWorkers?: number | string;
+	collectTests(specifications: TestSpecification[]): Promise<TestRunResult>;
 	/**
-	* Should all test files run in parallel. Doesn't affect tests running in the same file.
-	* Setting this to `false` will override `maxWorkers` and `minWorkers` options to `1`.
-	*
-	* @default true
+	* Gracefully cancel the current test run. Vitest will wait until all running tests are finished before cancelling.
 	*/
-	fileParallelism?: boolean;
+	cancelCurrentRun(reason: CancelReason): Promise<void>;
+	private initializeGlobalSetup;
 	/**
-	* Automatically assign pool based on globs. The first match will be used.
-	*
-	* Format: [glob, pool-name]
+	* Update snapshots in specified files. If no files are provided, it will update files with failed tests and obsolete snapshots.
+	* @param files The list of files on the file system
+	*/
+	updateSnapshot(files?: string[]): Promise<TestRunResult>;
+	/**
+	* Enable the mode that allows updating snapshots when running tests.
+	* This method doesn't run any tests.
 	*
-	* @deprecated use [`projects`](https://vitest.dev/config/#projects) instead
-	* @default []
-	* @example [
-	*   // all tests in "forks" directory will run using "poolOptions.forks" API
-	*   ['tests/forks/**', 'forks'],
-	*   // all other tests will run based on "poolOptions.threads" option, if you didn't specify other globs
-	*   // ...
-	* ]
+	* Every test that runs after this method is called will update snapshots.
+	* To disable the mode, call `resetSnapshotUpdate`.
 	*/
-	poolMatchGlobs?: [string, Exclude<Pool, "browser">][];
+	enableSnapshotUpdate(): void;
 	/**
-	* Options for projects
+	* Disable the mode that allows updating snapshots when running tests.
 	*/
-	projects?: TestProjectConfiguration[];
+	resetSnapshotUpdate(): void;
 	/**
-	* Path to a workspace configuration file
-	* @deprecated use `projects` instead
+	* Set the global test name pattern to a regexp.
+	* This method doesn't run any tests.
 	*/
-	workspace?: string | TestProjectConfiguration[];
+	setGlobalTestNamePattern(pattern: string | RegExp): void;
 	/**
-	* Update snapshot
-	*
-	* @default false
+	* Returns the regexp used for the global test name pattern.
 	*/
-	update?: boolean;
+	getGlobalTestNamePattern(): RegExp | undefined;
 	/**
-	* Watch mode
-	*
-	* @default !process.env.CI
+	* Resets the global test name pattern. This method doesn't run any tests.
 	*/
-	watch?: boolean;
+	resetGlobalTestNamePattern(): void;
+	private _rerunTimer;
+	private scheduleRerun;
 	/**
-	* Project root
-	*
-	* @default process.cwd()
+	* Invalidate a file in all projects.
 	*/
-	root?: string;
+	invalidateFile(filepath: string): void;
+	private reportCoverage;
 	/**
-	* Custom reporter for output. Can contain one or more built-in report names, reporter instances,
-	* and/or paths to custom reporters.
-	*
-	* @default []
+	* Closes all projects and their associated resources.
+	* This can only be called once; the closing promise is cached until the server restarts.
 	*/
-	reporters?: Arrayable$1<ReporterName | InlineReporter> | ((ReporterName | InlineReporter) | [ReporterName] | ReporterWithOptions)[];
+	close(): Promise<void>;
 	/**
-	* Write test results to a file when the --reporter=json` or `--reporter=junit` option is also specified.
-	* Also definable individually per reporter by using an object instead.
+	* Closes all projects and exit the process
+	* @param force If true, the process will exit immediately after closing the projects.
 	*/
-	outputFile?: string | (Partial<Record<BuiltinReporters, string>> & Record<string, string>);
+	exit(force?: boolean): Promise<void>;
 	/**
-	* Default timeout of a test in milliseconds
-	*
-	* @default 5000
-	*/
-	testTimeout?: number;
-	/**
-	* Default timeout of a hook in milliseconds
-	*
-	* @default 10000
-	*/
-	hookTimeout?: number;
-	/**
-	* Default timeout to wait for close when Vitest shuts down, in milliseconds
-	*
-	* @default 10000
-	*/
-	teardownTimeout?: number;
-	/**
-	* Silent mode
-	*
-	* Use `'passed-only'` to see logs from failing tests only.
-	*
-	* @default false
-	*/
-	silent?: boolean | "passed-only";
-	/**
-	* Hide logs for skipped tests
-	*
-	* @default false
-	*/
-	hideSkippedTests?: boolean;
-	/**
-	* Path to setup files
-	*/
-	setupFiles?: string | string[];
-	/**
-	* Path to global setup files
-	*/
-	globalSetup?: string | string[];
-	/**
-	* Glob patter of file paths that will trigger the whole suite rerun
-	*
-	* Useful if you are testing calling CLI commands
-	*
-	* @default ['**\/package.json/**', '**\/{vitest,vite}.config.*\/**']
-	*/
-	forceRerunTriggers?: string[];
-	/**
-	* Pattern configuration to rerun only the tests that are affected
-	* by the changes of specific files in the repository.
-	*/
-	watchTriggerPatterns?: WatcherTriggerPattern[];
-	/**
-	* Coverage options
-	*/
-	coverage?: CoverageOptions;
-	/**
-	* run test names with the specified pattern
-	*/
-	testNamePattern?: string | RegExp;
-	/**
-	* Will call `.mockClear()` on all spies before each test
-	* @default false
+	* Should the server be kept running after the tests are done.
 	*/
-	clearMocks?: boolean;
+	shouldKeepServer(): boolean;
 	/**
-	* Will call `.mockReset()` on all spies before each test
-	* @default false
+	* Register a handler that will be called when the server is restarted due to a config change.
 	*/
-	mockReset?: boolean;
+	onServerRestart(fn: OnServerRestartHandler): void;
 	/**
-	* Will call `.mockRestore()` on all spies before each test
-	* @default false
+	* Register a handler that will be called when the test run is cancelled with `vitest.cancelCurrentRun`.
 	*/
-	restoreMocks?: boolean;
+	onCancel(fn: (reason: CancelReason) => Awaitable<void>): void;
 	/**
-	* Will restore all global stubs to their original values before each test
-	* @default false
+	* Register a handler that will be called when the server is closed.
 	*/
-	unstubGlobals?: boolean;
+	onClose(fn: () => Awaitable<void>): void;
 	/**
-	* Will restore all env stubs to their original values before each test
-	* @default false
+	* Register a handler that will be called when the tests are rerunning.
 	*/
-	unstubEnvs?: boolean;
+	onTestsRerun(fn: OnTestsRerunHandler): void;
 	/**
-	* Serve API options.
-	*
-	* When set to true, the default port is 51204.
-	*
-	* @default false
+	* Register a handler that will be called when a file is changed.
+	* This callback should return `true` of `false` indicating whether the test file needs to be rerun.
+	* @example
+	* const testsToRun = [resolve('./test.spec.ts')]
+	* vitest.onFilterWatchedSpecification(specification => testsToRun.includes(specification.moduleId))
 	*/
-	api?: boolean | number | ApiConfig;
+	onFilterWatchedSpecification(fn: (specification: TestSpecification) => boolean): void;
 	/**
-	* Enable Vitest UI
-	*
-	* @default false
+	* Check if the project with a given name should be included.
 	*/
-	ui?: boolean;
+	matchesProjectFilter(name: string): boolean;
+}
+type OnServerRestartHandler = (reason?: string) => Promise<void> | void;
+type OnTestsRerunHandler = (testFiles: TestSpecification[]) => Promise<void> | void;
+
+type TestRunEndReason = "passed" | "interrupted" | "failed";
+interface Reporter {
+	onInit?: (vitest: Vitest) => void;
 	/**
-	* options for test in a browser environment
+	* Called when the project initiated the browser instance.
+	* project.browser will always be defined.
 	* @experimental
-	*
-	* @default false
 	*/
-	browser?: BrowserConfigOptions;
-	/**
-	* Open UI automatically.
-	*
-	* @default !process.env.CI
-	*/
-	open?: boolean;
+	onBrowserInit?: (project: TestProject) => Awaitable$1<void>;
+	onTestRemoved?: (trigger?: string) => Awaitable$1<void>;
+	onWatcherStart?: (files?: File[], errors?: unknown[]) => Awaitable$1<void>;
+	onWatcherRerun?: (files: string[], trigger?: string) => Awaitable$1<void>;
+	onServerRestart?: (reason?: string) => Awaitable$1<void>;
+	onUserConsoleLog?: (log: UserConsoleLog) => Awaitable$1<void>;
+	onProcessTimeout?: () => Awaitable$1<void>;
 	/**
-	* Base url for the UI
-	*
-	* @default '/__vitest__/'
-	*/
-	uiBase?: string;
-	/**
-	* Determine the transform method for all modules imported inside a test that matches the glob pattern.
+	* Called when the new test run starts.
 	*/
-	testTransformMode?: TransformModePatterns;
+	onTestRunStart?: (specifications: ReadonlyArray<TestSpecification>) => Awaitable$1<void>;
 	/**
-	* Format options for snapshot testing.
+	* Called when the test run is finished.
 	*/
-	snapshotFormat?: Omit<PrettyFormatOptions, "plugins">;
+	onTestRunEnd?: (testModules: ReadonlyArray<TestModule>, unhandledErrors: ReadonlyArray<SerializedError>, reason: TestRunEndReason) => Awaitable$1<void>;
 	/**
-	* Path to a module which has a default export of diff config.
+	* Called when the module is enqueued for testing. The file itself is not loaded yet.
 	*/
-	diff?: string | SerializedDiffOptions;
+	onTestModuleQueued?: (testModule: TestModule) => Awaitable$1<void>;
 	/**
-	* Paths to snapshot serializer modules.
+	* Called when the test file is loaded and the module is ready to run tests.
 	*/
-	snapshotSerializers?: string[];
+	onTestModuleCollected?: (testModule: TestModule) => Awaitable$1<void>;
 	/**
-	* Resolve custom snapshot path
+	* Called when starting to run tests of the test file
 	*/
-	resolveSnapshotPath?: ResolveSnapshotPathHandler;
+	onTestModuleStart?: (testModule: TestModule) => Awaitable$1<void>;
 	/**
-	* Path to a custom snapshot environment module that has a default export of `SnapshotEnvironment` object.
+	* Called when all tests of the test file have finished running.
 	*/
-	snapshotEnvironment?: string;
+	onTestModuleEnd?: (testModule: TestModule) => Awaitable$1<void>;
 	/**
-	* Pass with no tests
+	* Called when test case is ready to run.
+	* Called before the `beforeEach` hooks for the test are run.
 	*/
-	passWithNoTests?: boolean;
+	onTestCaseReady?: (testCase: TestCase) => Awaitable$1<void>;
 	/**
-	* Allow tests and suites that are marked as only
-	*
-	* @default !process.env.CI
+	* Called after the test and its hooks are finished running.
+	* The `result()` cannot be `pending`.
 	*/
-	allowOnly?: boolean;
+	onTestCaseResult?: (testCase: TestCase) => Awaitable$1<void>;
 	/**
-	* Show heap usage after each test. Useful for debugging memory leaks.
+	* Called when annotation is added via the `task.annotate` API.
 	*/
-	logHeapUsage?: boolean;
+	onTestCaseAnnotate?: (testCase: TestCase, annotation: TestAnnotation) => Awaitable$1<void>;
 	/**
-	* Custom environment variables assigned to `process.env` before running tests.
+	* Called when test suite is ready to run.
+	* Called before the `beforeAll` hooks for the test are run.
 	*/
-	env?: Partial<NodeJS.ProcessEnv>;
+	onTestSuiteReady?: (testSuite: TestSuite) => Awaitable$1<void>;
 	/**
-	* Options for @sinon/fake-timers
+	* Called after the test suite and its hooks are finished running.
+	* The `state` cannot be `pending`.
 	*/
-	fakeTimers?: FakeTimerInstallOpts;
+	onTestSuiteResult?: (testSuite: TestSuite) => Awaitable$1<void>;
 	/**
-	* Custom handler for console.log in tests.
-	*
-	* Return `false` to ignore the log.
+	* Called before the hook starts to run.
 	*/
-	onConsoleLog?: (log: string, type: "stdout" | "stderr") => boolean | void;
+	onHookStart?: (hook: ReportedHookContext) => Awaitable$1<void>;
 	/**
-	* Enable stack trace filtering. If absent, all stack trace frames
-	* will be shown.
-	*
-	* Return `false` to omit the frame.
+	* Called after the hook finished running.
 	*/
-	onStackTrace?: (error: ErrorWithDiff, frame: ParsedStack) => boolean | void;
+	onHookEnd?: (hook: ReportedHookContext) => Awaitable$1<void>;
+	onCoverage?: (coverage: unknown) => Awaitable$1<void>;
+}
+
+interface BaseOptions {
+	isTTY?: boolean;
+}
+declare abstract class BaseReporter implements Reporter {
+	start: number;
+	end: number;
+	watchFilters?: string[];
+	failedUnwatchedFiles: TestModule[];
+	isTTY: boolean;
+	ctx: Vitest;
+	renderSucceed: boolean;
+	protected verbose: boolean;
+	private _filesInWatchMode;
+	private _timeStart;
+	constructor(options?: BaseOptions);
+	onInit(ctx: Vitest): void;
+	log(...messages: any): void;
+	error(...messages: any): void;
+	relative(path: string): string;
+	onTestRunEnd(testModules: ReadonlyArray<TestModule>, unhandledErrors: ReadonlyArray<SerializedError>, _reason: TestRunEndReason): void;
+	onTestCaseResult(testCase: TestCase): void;
+	onTestSuiteResult(testSuite: TestSuite): void;
+	onTestModuleEnd(testModule: TestModule): void;
+	private logFailedTask;
+	protected printTestModule(testModule: TestModule): void;
+	protected printTestCase(moduleState: TestModuleState, test: TestCase): void;
+	private getModuleLog;
+	protected printTestSuite(_suite: TestSuite): void;
+	protected getTestName(test: Task, separator?: string): string;
+	protected getFullName(test: Task, separator?: string): string;
+	protected formatShortError(error: TestError): string;
+	protected getTestIndentation(_test: Task): string;
+	protected printAnnotations(test: TestCase, console: "log" | "error", padding?: number): void;
+	protected getDurationPrefix(task: Task): string;
+	onWatcherStart(files?: File[], errors?: unknown[]): void;
+	onWatcherRerun(files: string[], trigger?: string): void;
+	onUserConsoleLog(log: UserConsoleLog, taskState?: TestResult["state"]): void;
+	onTestRemoved(trigger?: string): void;
+	shouldLog(log: UserConsoleLog, taskState?: TestResult["state"]): boolean;
+	onServerRestart(reason?: string): void;
+	reportSummary(files: File[], errors: unknown[]): void;
+	reportTestSummary(files: File[], errors: unknown[]): void;
+	private printErrorsSummary;
+	reportBenchmarkSummary(files: File[]): void;
+	private printTaskErrors;
+}
+
+interface DefaultReporterOptions extends BaseOptions {
+	summary?: boolean;
+}
+declare class DefaultReporter extends BaseReporter {
+	private options;
+	private summary?;
+	constructor(options?: DefaultReporterOptions);
+	onTestRunStart(specifications: ReadonlyArray<TestSpecification>): void;
+	onTestRunEnd(testModules: ReadonlyArray<TestModule>, unhandledErrors: ReadonlyArray<SerializedError>, reason: TestRunEndReason): void;
+	onTestModuleQueued(file: TestModule): void;
+	onTestModuleCollected(module: TestModule): void;
+	onTestModuleEnd(module: TestModule): void;
+	onTestCaseReady(test: TestCase): void;
+	onTestCaseResult(test: TestCase): void;
+	onHookStart(hook: ReportedHookContext): void;
+	onHookEnd(hook: ReportedHookContext): void;
+	onInit(ctx: Vitest): void;
+}
+
+interface HTMLOptions {
+	outputFile?: string;
+}
+
+type Status = "passed" | "failed" | "skipped" | "pending" | "todo" | "disabled";
+type Milliseconds = number;
+interface Callsite {
+	line: number;
+	column: number;
+}
+interface JsonAssertionResult {
+	ancestorTitles: Array<string>;
+	fullName: string;
+	status: Status;
+	title: string;
+	meta: TaskMeta;
+	duration?: Milliseconds | null;
+	failureMessages: Array<string> | null;
+	location?: Callsite | null;
+}
+interface JsonTestResult {
+	message: string;
+	name: string;
+	status: "failed" | "passed";
+	startTime: number;
+	endTime: number;
+	assertionResults: Array<JsonAssertionResult>;
+}
+interface JsonTestResults {
+	numFailedTests: number;
+	numFailedTestSuites: number;
+	numPassedTests: number;
+	numPassedTestSuites: number;
+	numPendingTests: number;
+	numPendingTestSuites: number;
+	numTodoTests: number;
+	numTotalTests: number;
+	numTotalTestSuites: number;
+	startTime: number;
+	success: boolean;
+	testResults: Array<JsonTestResult>;
+	snapshot: SnapshotSummary;
+	coverageMap?: CoverageMap | null | undefined;
+}
+interface JsonOptions {
+	outputFile?: string;
+}
+declare class JsonReporter implements Reporter {
+	start: number;
+	ctx: Vitest;
+	options: JsonOptions;
+	coverageMap?: CoverageMap;
+	constructor(options: JsonOptions);
+	onInit(ctx: Vitest): void;
+	onCoverage(coverageMap: unknown): void;
+	onTestRunEnd(testModules: ReadonlyArray<TestModule>): Promise<void>;
 	/**
-	* Indicates if CSS files should be processed.
-	*
-	* When excluded, the CSS files will be replaced with empty strings to bypass the subsequent processing.
-	*
-	* @default { include: [], modules: { classNameStrategy: false } }
+	* Writes the report to an output file if specified in the config,
+	* or logs it to the console otherwise.
+	* @param report
 	*/
-	css?: boolean | {
-		include?: RegExp | RegExp[]
-		exclude?: RegExp | RegExp[]
-		modules?: {
-			classNameStrategy?: CSSModuleScopeStrategy
-		}
-	};
+	writeReport(report: string): Promise<void>;
+}
+
+interface ClassnameTemplateVariables {
+	filename: string;
+	filepath: string;
+}
+interface JUnitOptions {
+	outputFile?: string;
 	/**
-	* A number of tests that are allowed to run at the same time marked with `test.concurrent`.
-	* @default 5
+	* Template for the classname attribute. Can be either a string or a function. The string can contain placeholders {filename} and {filepath}.
 	*/
-	maxConcurrency?: number;
+	classnameTemplate?: string | ((classnameVariables: ClassnameTemplateVariables) => string);
+	suiteName?: string;
 	/**
-	* Options for configuring cache policy.
-	* @default { dir: 'node_modules/.vite/vitest/{project-hash}' }
+	* Write <system-out> and <system-err> for console output
+	* @default true
 	*/
-	cache?: false | {
-		/**
-		* @deprecated Use Vite's "cacheDir" instead if you want to change the cache director. Note caches will be written to "cacheDir\/vitest".
-		*/
-		dir: string
-	};
+	includeConsoleOutput?: boolean;
 	/**
-	* Options for configuring the order of running tests.
+	* Add <testcase file="..."> attribute (validated on CIRCLE CI and GitLab CI)
+	* @default false
 	*/
-	sequence?: SequenceOptions;
+	addFileAttribute?: boolean;
+}
+declare class JUnitReporter implements Reporter {
+	private ctx;
+	private reportFile?;
+	private baseLog;
+	private logger;
+	private _timeStart;
+	private fileFd?;
+	private options;
+	constructor(options: JUnitOptions);
+	onInit(ctx: Vitest): Promise<void>;
+	writeElement(name: string, attrs: Record<string, any>, children: () => Promise<void>): Promise<void>;
+	writeLogs(task: Task, type: "err" | "out"): Promise<void>;
+	writeTasks(tasks: Task[], filename: string): Promise<void>;
+	onTestRunEnd(testModules: ReadonlyArray<TestModule>): Promise<void>;
+}
+
+declare class DotReporter extends BaseReporter {
+	private renderer?;
+	private tests;
+	private finishedTests;
+	onInit(ctx: Vitest): void;
+	printTestModule(): void;
+	onWatcherRerun(files: string[], trigger?: string): void;
+	onTestRunEnd(testModules: ReadonlyArray<TestModule>, unhandledErrors: ReadonlyArray<SerializedError>, reason: TestRunEndReason): void;
+	onTestModuleCollected(module: TestModule): void;
+	onTestCaseReady(test: TestCase): void;
+	onTestCaseResult(test: TestCase): void;
+	onTestModuleEnd(testModule: TestModule): void;
+	private createSummary;
+}
+
+interface GithubActionsReporterOptions {
+	onWritePath?: (path: string) => string;
+}
+declare class GithubActionsReporter implements Reporter {
+	ctx: Vitest;
+	options: GithubActionsReporterOptions;
+	constructor(options?: GithubActionsReporterOptions);
+	onInit(ctx: Vitest): void;
+	onTestCaseAnnotate(testCase: TestCase, annotation: TestAnnotation): void;
+	onTestRunEnd(testModules: ReadonlyArray<TestModule>, unhandledErrors: ReadonlyArray<SerializedError>): void;
+}
+
+declare class HangingProcessReporter implements Reporter {
+	whyRunning: (() => void) | undefined;
+	onInit(): void;
+	onProcessTimeout(): void;
+}
+
+declare class TapReporter implements Reporter {
+	protected ctx: Vitest;
+	private logger;
+	onInit(ctx: Vitest): void;
+	static getComment(task: Task): string;
+	private logErrorDetails;
+	protected logTasks(tasks: Task[]): void;
+	onTestRunEnd(testModules: ReadonlyArray<TestModule>): void;
+}
+
+declare class TapFlatReporter extends TapReporter {
+	onInit(ctx: Vitest): void;
+	onTestRunEnd(testModules: ReadonlyArray<TestModule>): void;
+}
+
+declare class VerboseReporter extends DefaultReporter {
+	protected verbose: boolean;
+	renderSucceed: boolean;
+	printTestModule(module: TestModule): void;
+	onTestCaseResult(test: TestCase): void;
+	protected printTestSuite(testSuite: TestSuite): void;
+	protected getTestName(test: Task): string;
+	protected getTestIndentation(test: Task): string;
+	protected formatShortError(): string;
+}
+
+type FormattedBenchmarkResult = BenchmarkResult & {
+	id: string;
+};
+
+declare function renderTable(options: {
+	tasks: Task[];
+	level: number;
+	shallow?: boolean;
+	showHeap: boolean;
+	columns: number;
+	slowTestThreshold: number;
+	compare?: Record<Task["id"], FormattedBenchmarkResult>;
+}): string;
+
+declare class BenchmarkReporter extends DefaultReporter {
+	compare?: Parameters<typeof renderTable>[0]["compare"];
+	onInit(ctx: Vitest): Promise<void>;
+	onTaskUpdate(packs: TaskResultPack[]): void;
+	onTestSuiteResult(testSuite: TestSuite): void;
+	protected printTestModule(testModule: TestModule): void;
+	private printSuiteTable;
+	onTestRunEnd(testModules: ReadonlyArray<TestModule>, unhandledErrors: ReadonlyArray<SerializedError>, reason: TestRunEndReason): Promise<void>;
+}
+
+declare class VerboseBenchmarkReporter extends BenchmarkReporter {
+	protected verbose: boolean;
+}
+
+declare const BenchmarkReportsMap: {
+	default: typeof BenchmarkReporter;
+	verbose: typeof VerboseBenchmarkReporter;
+};
+type BenchmarkBuiltinReporters = keyof typeof BenchmarkReportsMap;
+
+declare const ReportersMap: {
+	default: typeof DefaultReporter;
+	blob: typeof BlobReporter;
+	verbose: typeof VerboseReporter;
+	dot: typeof DotReporter;
+	json: typeof JsonReporter;
+	tap: typeof TapReporter;
+	"tap-flat": typeof TapFlatReporter;
+	junit: typeof JUnitReporter;
+	"hanging-process": typeof HangingProcessReporter;
+	"github-actions": typeof GithubActionsReporter;
+};
+type BuiltinReporters = keyof typeof ReportersMap;
+interface BuiltinReporterOptions {
+	"default": DefaultReporterOptions;
+	"verbose": DefaultReporterOptions;
+	"dot": BaseOptions;
+	"json": JsonOptions;
+	"blob": BlobOptions;
+	"tap": never;
+	"tap-flat": never;
+	"junit": JUnitOptions;
+	"hanging-process": never;
+	"html": HTMLOptions;
+}
+
+interface TestSequencer {
 	/**
-	* Specifies an `Object`, or an `Array` of `Object`,
-	* which defines aliases used to replace values in `import` or `require` statements.
-	* Will be merged with the default aliases inside `resolve.alias`.
+	* Slicing tests into shards. Will be run before `sort`.
+	* Only run, if `shard` is defined.
 	*/
-	alias?: AliasOptions;
+	shard: (files: TestSpecification[]) => Awaitable$1<TestSpecification[]>;
+	sort: (files: TestSpecification[]) => Awaitable$1<TestSpecification[]>;
+}
+interface TestSequencerConstructor {
+	new (ctx: Vitest): TestSequencer;
+}
+
+interface BenchmarkUserOptions {
 	/**
-	* Ignore any unhandled errors that occur
+	* Include globs for benchmark test files
 	*
-	* @default false
+	* @default ['**\/*.{bench,benchmark}.?(c|m)[jt]s?(x)']
 	*/
-	dangerouslyIgnoreUnhandledErrors?: boolean;
+	include?: string[];
 	/**
-	* Options for configuring typechecking test environment.
+	* Exclude globs for benchmark test files
+	* @default ['**\/node_modules/**', '**\/dist/**', '**\/cypress/**', '**\/.{idea,git,cache,output,temp}/**', '**\/{karma,rollup,webpack,vite,vitest,jest,ava,babel,nyc,cypress,tsup,build,eslint,prettier}.config.*']
 	*/
-	typecheck?: Partial<TypecheckConfig>;
+	exclude?: string[];
 	/**
-	* The number of milliseconds after which a test is considered slow and reported as such in the results.
+	* Include globs for in-source benchmark test files
 	*
-	* @default 300
-	*/
-	slowTestThreshold?: number;
-	/**
-	* Path to a custom test runner.
+	* @default []
 	*/
-	runner?: string;
+	includeSource?: string[];
 	/**
-	* Debug tests by opening `node:inspector` in worker / child process.
-	* Provides similar experience as `--inspect` Node CLI argument.
+	* Custom reporter for output. Can contain one or more built-in report names, reporter instances,
+	* and/or paths to custom reporters
 	*
-	* Requires `poolOptions.threads.singleThread: true` OR `poolOptions.forks.singleFork: true`.
+	* @default ['default']
 	*/
-	inspect?: boolean | string;
+	reporters?: Arrayable$1<BenchmarkBuiltinReporters | Reporter>;
 	/**
-	* Debug tests by opening `node:inspector` in worker / child process and wait for debugger to connect.
-	* Provides similar experience as `--inspect-brk` Node CLI argument.
-	*
-	* Requires `poolOptions.threads.singleThread: true` OR `poolOptions.forks.singleFork: true`.
+	* @deprecated Use `benchmark.outputJson` instead
 	*/
-	inspectBrk?: boolean | string;
+	outputFile?: string | (Partial<Record<BenchmarkBuiltinReporters, string>> & Record<string, string>);
 	/**
-	* Inspector options. If `--inspect` or `--inspect-brk` is enabled, these options will be passed to the inspector.
+	* benchmark output file to compare against
 	*/
-	inspector?: {
-		/**
-		* Enable inspector
-		*/
-		enabled?: boolean
-		/**
-		* Port to run inspector on
-		*/
-		port?: number
-		/**
-		* Host to run inspector on
-		*/
-		host?: string
-		/**
-		* Wait for debugger to connect before running tests
-		*/
-		waitForDebugger?: boolean
-	};
+	compare?: string;
 	/**
-	* Define variables that will be returned from `inject` in the test environment.
-	* @example
-	* ```ts
-	* // vitest.config.ts
-	* export default defineConfig({
-	*   test: {
-	*     provide: {
-	*       someKey: 'someValue'
-	*     }
-	*   }
-	* })
-	* ```
-	* ```ts
-	* // test file
-	* import { inject } from 'vitest'
-	* const value = inject('someKey') // 'someValue'
-	* ```
+	* benchmark output file
 	*/
-	provide?: Partial<ProvidedContext>;
+	outputJson?: string;
 	/**
-	* Configuration options for expect() matches.
+	* Include `samples` array of benchmark results for API or custom reporter usages.
+	* This is disabled by default to reduce memory usage.
+	* @default false
 	*/
-	expect?: {
-		/**
-		* Throw an error if tests don't have any expect() assertions.
-		*/
-		requireAssertions?: boolean
-		/**
-		* Default options for expect.poll()
-		*/
-		poll?: {
-			/**
-			* Timeout in milliseconds
-			* @default 1000
-			*/
-			timeout?: number
-			/**
-			* Polling interval in milliseconds
-			* @default 50
-			*/
-			interval?: number
-		}
-	};
+	includeSamples?: boolean;
+}
+
+type BuiltinEnvironment = "node" | "jsdom" | "happy-dom" | "edge-runtime";
+type VitestEnvironment = BuiltinEnvironment | (string & Record<never, never>);
+
+type CSSModuleScopeStrategy = "stable" | "scoped" | "non-scoped";
+type ApiConfig = Pick<ServerOptions, "port" | "strictPort" | "host" | "middlewareMode">;
+interface EnvironmentOptions {
 	/**
-	* Modify default Chai config. Vitest uses Chai for `expect` and `assert` matches.
-	* https://github.com/chaijs/chai/blob/4.x.x/lib/chai/config.js
+	* jsdom options.
 	*/
-	chaiConfig?: ChaiConfig;
+	jsdom?: JSDOMOptions;
+	happyDOM?: HappyDOMOptions;
+	[x: string]: unknown;
+}
+
+type VitestRunMode = "test" | "benchmark";
+interface ProjectName {
+	label: string;
+	color?: LabelColor;
+}
+interface SequenceOptions {
 	/**
-	* Stop test execution when given number of tests have failed.
+	* Class that handles sorting and sharding algorithm.
+	* If you only need to change sorting, you can extend
+	* your custom sequencer from `BaseSequencer` from `vitest/node`.
+	* @default BaseSequencer
 	*/
-	bail?: number;
+	sequencer?: TestSequencerConstructor;
 	/**
-	* Retry the test specific number of times if it fails.
+	* Controls the order in which this project runs its tests when using multiple [projects](/guide/projects).
 	*
+	* - Projects with the same group order number will run together, and groups are run from lowest to highest.
+	* - If you don’t set this option, all projects run in parallel.
+	* - If several projects use the same group order, they will run at the same time.
 	* @default 0
 	*/
-	retry?: number;
-	/**
-	* Show full diff when snapshot fails instead of a patch.
-	*/
-	expandSnapshotDiff?: boolean;
+	groupOrder?: number;
 	/**
-	* By default, Vitest automatically intercepts console logging during tests for extra formatting of test file, test title, etc...
-	* This is also required for console log preview on Vitest UI.
-	* However, disabling such interception might help when you want to debug a code with normal synchronous terminal console logging.
-	*
-	* This option has no effect on browser pool since Vitest preserves original logging on browser devtools.
-	*
+	* Should files and tests run in random order.
 	* @default false
 	*/
-	disableConsoleIntercept?: boolean;
+	shuffle?: boolean | {
+		/**
+		* Should files run in random order. Long running tests will not start
+		* earlier if you enable this option.
+		* @default false
+		*/
+		files?: boolean;
+		/**
+		* Should tests run in random order.
+		* @default false
+		*/
+		tests?: boolean;
+	};
 	/**
-	* Always print console stack traces.
-	*
+	* Should tests run in parallel.
 	* @default false
 	*/
-	printConsoleTrace?: boolean;
+	concurrent?: boolean;
 	/**
-	* Include "location" property inside the test definition
-	*
-	* @default false
+	* Defines how setup files should be ordered
+	* - 'parallel' will run all setup files in parallel
+	* - 'list' will run all setup files in the order they are defined in the config file
+	* @default 'parallel'
 	*/
-	includeTaskLocation?: boolean;
+	setupFiles?: SequenceSetupFiles;
 	/**
-	* Directory path for storing attachments created by `context.annotate`
-	*
-	* @default '.vitest-attachments'
+	* Seed for the random number generator.
+	* @default Date.now()
 	*/
-	attachmentsDir?: string;
-}
-interface TypecheckConfig {
+	seed?: number;
 	/**
-	* Run typechecking tests alongside regular tests.
+	* Defines how hooks should be ordered
+	* - `stack` will order "after" hooks in reverse order, "before" hooks will run sequentially
+	* - `list` will order hooks in the order they are defined
+	* - `parallel` will run hooks in a single group in parallel
+	* @default 'stack'
 	*/
+	hooks?: SequenceHooks;
+}
+type DepsOptimizationOptions = Omit<DepOptimizationConfig, "disabled" | "noDiscovery"> & {
 	enabled?: boolean;
+};
+interface DepsOptions {
 	/**
-	* When typechecking is enabled, only run typechecking tests.
-	*/
-	only?: boolean;
-	/**
-	* What tools to use for type checking.
-	*
-	* @default 'tsc'
+	* Enable dependency optimization. This can improve the performance of your tests.
 	*/
-	checker: "tsc" | "vue-tsc" | (string & Record<never, never>);
+	optimizer?: Partial<Record<"client" | "ssr" | ({} & string), DepsOptimizationOptions>>;
+	web?: {
+		/**
+		* Should Vitest process assets (.png, .svg, .jpg, etc) files and resolve them like Vite does in the browser.
+		*
+		* These module will have a default export equal to the path to the asset, if no query is specified.
+		*
+		* **At the moment, this option only works with `{ pool: 'vmThreads' }`.**
+		*
+		* @default true
+		*/
+		transformAssets?: boolean;
+		/**
+		* Should Vitest process CSS (.css, .scss, .sass, etc) files and resolve them like Vite does in the browser.
+		*
+		* If CSS files are disabled with `css` options, this option will just silence UNKNOWN_EXTENSION errors.
+		*
+		* **At the moment, this option only works with `{ pool: 'vmThreads' }`.**
+		*
+		* @default true
+		*/
+		transformCss?: boolean;
+		/**
+		* Regexp pattern to match external files that should be transformed.
+		*
+		* By default, files inside `node_modules` are externalized and not transformed.
+		*
+		* **At the moment, this option only works with `{ pool: 'vmThreads' }`.**
+		*
+		* @default []
+		*/
+		transformGlobPattern?: RegExp | RegExp[];
+	};
 	/**
-	* Pattern for files that should be treated as test files
+	* Interpret CJS module's default as named exports
 	*
-	* @default ['**\/*.{test,spec}-d.?(c|m)[jt]s?(x)']
+	* @default true
 	*/
-	include: string[];
+	interopDefault?: boolean;
 	/**
-	* Pattern for files that should not be treated as test files
+	* A list of directories relative to the config file that should be treated as module directories.
 	*
-	* @default ['**\/node_modules/**', '**\/dist/**', '**\/cypress/**', '**\/.{idea,git,cache,output,temp}/**', '**\/{karma,rollup,webpack,vite,vitest,jest,ava,babel,nyc,cypress,tsup,build,eslint,prettier}.config.*']
-	*/
-	exclude: string[];
-	/**
-	* Check JS files that have `@ts-check` comment.
-	* If you have it enabled in tsconfig, this will not overwrite it.
-	*/
-	allowJs?: boolean;
-	/**
-	* Do not fail, if Vitest found errors outside the test files.
-	*/
-	ignoreSourceErrors?: boolean;
-	/**
-	* Path to tsconfig, relative to the project root.
-	*/
-	tsconfig?: string;
-	/**
-	* Minimum time in milliseconds it takes to spawn the typechecker.
-	* @default 10_000
+	* @default ['node_modules']
 	*/
-	spawnTimeout?: number;
+	moduleDirectories?: string[];
+}
+type InlineReporter = Reporter;
+type ReporterName = BuiltinReporters | "html" | (string & {});
+type ReporterWithOptions<Name extends ReporterName = ReporterName> = Name extends keyof BuiltinReporterOptions ? BuiltinReporterOptions[Name] extends never ? [Name, object] : [Name, Partial<BuiltinReporterOptions[Name]>] : [Name, Record<string, unknown>];
+interface ResolveSnapshotPathHandlerContext {
+	config: SerializedConfig;
 }
-interface UserConfig extends InlineConfig {
+type ResolveSnapshotPathHandler = (testPath: string, snapExtension: string, context: ResolveSnapshotPathHandlerContext) => string;
+interface InlineConfig {
 	/**
-	* Path to the config file.
-	*
-	* Default resolving to `vitest.config.*`, `vite.config.*`
-	*
-	* Setting to `false` will disable config resolving.
+	* Name of the project. Will be used to display in the reporter.
 	*/
-	config?: string | false | undefined;
+	name?: string | ProjectName;
 	/**
-	* Do not run tests when Vitest starts.
-	*
-	* Vitest will only run tests if it's called programmatically or the test file changes.
+	* Benchmark options.
 	*
-	* CLI file filters will be ignored.
+	* @default {}
 	*/
-	standalone?: boolean;
+	benchmark?: BenchmarkUserOptions;
 	/**
-	* Use happy-dom
+	* Include globs for test files
+	*
+	* @default ['**\/*.{test,spec}.?(c|m)[jt]s?(x)']
 	*/
-	dom?: boolean;
+	include?: string[];
 	/**
-	* Run tests that cover a list of source files
+	* Exclude globs for test files
+	* @default ['**\/node_modules/**', '**\/.git/**']
 	*/
-	related?: string[] | string;
+	exclude?: string[];
 	/**
-	* Overrides Vite mode
-	* @default 'test'
+	* Include globs for in-source test files
+	*
+	* @default []
 	*/
-	mode?: string;
+	includeSource?: string[];
 	/**
-	* Runs tests that are affected by the changes in the repository, or between specified branch or commit hash
-	* Requires initialized git repository
-	* @default false
+	* Handling for dependencies inlining or externalizing
+	*
 	*/
-	changed?: boolean | string;
+	deps?: DepsOptions;
+	server?: {
+		deps?: ServerDepsOptions;
+	};
 	/**
-	* Test suite shard to execute in a format of <index>/<count>.
-	* Will divide tests into a `count` numbers, and run only the `indexed` part.
-	* Cannot be used with enabled watch.
-	* @example --shard=2/3
+	* Base directory to scan for the test files
+	*
+	* @default `config.root`
 	*/
-	shard?: string;
+	dir?: string;
 	/**
-	* Name of the project or projects to run.
+	* Register apis globally
+	*
+	* @default false
 	*/
-	project?: string | string[];
+	globals?: boolean;
 	/**
-	* Additional exclude patterns
+	* Running environment
+	*
+	* Supports 'node', 'jsdom', 'happy-dom', 'edge-runtime'
+	*
+	* If used unsupported string, will try to load the package `vitest-environment-${env}`
+	*
+	* @default 'node'
 	*/
-	cliExclude?: string[];
+	environment?: VitestEnvironment;
 	/**
-	* Override vite config's clearScreen from cli
+	* Environment options.
 	*/
-	clearScreen?: boolean;
+	environmentOptions?: EnvironmentOptions;
 	/**
-	* benchmark.compare option exposed at the top level for cli
+	* Run tests in an isolated environment. This option has no effect on vmThreads pool.
+	*
+	* Disabling this option might improve performance if your code doesn't rely on side effects.
+	*
+	* @default true
 	*/
-	compare?: string;
+	isolate?: boolean;
 	/**
-	* benchmark.outputJson option exposed at the top level for cli
+	* Pool used to run tests in.
+	*
+	* Supports 'threads', 'forks', 'vmThreads'
+	*
+	* @default 'forks'
 	*/
-	outputJson?: string;
+	pool?: Exclude<Pool, "browser">;
 	/**
-	* Directory of blob reports to merge
-	* @default '.vitest-reports'
+	* Pool options
 	*/
-	mergeReports?: string;
-}
-interface ResolvedConfig extends Omit<Required<UserConfig>, "project" | "config" | "filters" | "browser" | "coverage" | "testNamePattern" | "related" | "api" | "reporters" | "resolveSnapshotPath" | "benchmark" | "shard" | "cache" | "sequence" | "typecheck" | "runner" | "poolOptions" | "pool" | "cliExclude" | "diff" | "setupFiles" | "snapshotEnvironment" | "bail" | "name"> {
-	mode: VitestRunMode;
-	name: ProjectName["label"];
-	color?: ProjectName["color"];
-	base?: string;
-	diff?: string | SerializedDiffOptions;
-	bail?: number;
-	setupFiles: string[];
-	snapshotEnvironment?: string;
-	config?: string;
-	filters?: string[];
-	testNamePattern?: RegExp;
-	related?: string[];
-	coverage: ResolvedCoverageOptions;
-	snapshotOptions: SnapshotStateOptions;
-	browser: ResolvedBrowserOptions;
-	pool: Pool;
-	poolOptions?: ResolvedPoolOptions;
-	reporters: (InlineReporter | ReporterWithOptions)[];
-	defines: Record<string, any>;
-	api: ApiConfig & {
-		token: string
-	};
-	cliExclude?: string[];
-	project: string[];
-	benchmark?: Required<Omit<BenchmarkUserOptions, "outputFile" | "compare" | "outputJson">> & Pick<BenchmarkUserOptions, "outputFile" | "compare" | "outputJson">;
-	shard?: {
-		index: number
-		count: number
-	};
-	cache: {
-		/**
-		* @deprecated
-		*/
-		dir: string
-	} | false;
-	sequence: {
-		sequencer: TestSequencerConstructor
-		hooks: SequenceHooks
-		setupFiles: SequenceSetupFiles
-		shuffle?: boolean
-		concurrent?: boolean
-		seed: number
-		groupOrder: number
-	};
-	typecheck: Omit<TypecheckConfig, "enabled"> & {
-		enabled: boolean
-	};
-	runner?: string;
-	maxWorkers: number;
-	minWorkers: number;
-}
-type NonProjectOptions = "shard" | "watch" | "run" | "cache" | "update" | "reporters" | "outputFile" | "teardownTimeout" | "silent" | "forceRerunTriggers" | "testNamePattern" | "ui" | "open" | "uiBase" | "snapshotFormat" | "resolveSnapshotPath" | "passWithNoTests" | "onConsoleLog" | "onStackTrace" | "dangerouslyIgnoreUnhandledErrors" | "slowTestThreshold" | "inspect" | "inspectBrk" | "coverage" | "maxWorkers" | "minWorkers" | "fileParallelism" | "workspace" | "watchTriggerPatterns";
-type ProjectConfig = Omit<InlineConfig, NonProjectOptions | "sequencer" | "deps" | "poolOptions"> & {
-	mode?: string
-	sequencer?: Omit<SequenceOptions, "sequencer" | "seed">
-	deps?: Omit<DepsOptions, "moduleDirectories">
-	poolOptions?: {
-		threads?: Pick<NonNullable<PoolOptions["threads"]>, "singleThread" | "isolate">
-		vmThreads?: Pick<NonNullable<PoolOptions["vmThreads"]>, "singleThread">
-		forks?: Pick<NonNullable<PoolOptions["forks"]>, "singleFork" | "isolate">
-	}
-};
-type ResolvedProjectConfig = Omit<ResolvedConfig, Exclude<NonProjectOptions, "coverage" | "watch">>;
-interface UserWorkspaceConfig extends UserConfig$1 {
-	test?: ProjectConfig;
-}
-type UserProjectConfigFn = (env: ConfigEnv) => UserWorkspaceConfig | Promise<UserWorkspaceConfig>;
-type UserProjectConfigExport = UserWorkspaceConfig | Promise<UserWorkspaceConfig> | UserProjectConfigFn;
-type TestProjectInlineConfiguration = (UserWorkspaceConfig & {
+	poolOptions?: PoolOptions;
 	/**
-	* Relative path to the extendable config. All other options will be merged with this config.
-	* If `true`, the project will inherit all options from the root config.
-	* @example '../vite.config.ts'
+	* Maximum number or percentage of workers to run tests in. `poolOptions.{threads,vmThreads}.maxThreads`/`poolOptions.forks.maxForks` has higher priority.
 	*/
-	extends?: string | true
-});
-type TestProjectConfiguration = string | TestProjectInlineConfiguration | Promise<UserWorkspaceConfig> | UserProjectConfigFn;
-/** @deprecated use `TestProjectConfiguration` instead */
-type WorkspaceProjectConfiguration = TestProjectConfiguration;
-
-interface BrowserProviderInitializationOptions {
-	browser: string;
-	options?: BrowserProviderOptions;
-}
-interface CDPSession {
-	send: (method: string, params?: Record<string, unknown>) => Promise<unknown>;
-	on: (event: string, listener: (...args: unknown[]) => void) => void;
-	once: (event: string, listener: (...args: unknown[]) => void) => void;
-	off: (event: string, listener: (...args: unknown[]) => void) => void;
-}
-interface BrowserModuleMocker {
-	register: (sessionId: string, module: MockedModule) => Promise<void>;
-	delete: (sessionId: string, url: string) => Promise<void>;
-	clear: (sessionId: string) => Promise<void>;
-}
-interface BrowserProvider {
-	name: string;
-	mocker?: BrowserModuleMocker;
+	maxWorkers?: number | string;
 	/**
-	* @experimental opt-in into file parallelisation
+	* Should all test files run in parallel. Doesn't affect tests running in the same file.
+	* Setting this to `false` will override `maxWorkers` option to `1`.
+	*
+	* @default true
 	*/
-	supportsParallelism: boolean;
-	getSupportedBrowsers: () => readonly string[];
-	getCommandsContext: (sessionId: string) => Record<string, unknown>;
-	openPage: (sessionId: string, url: string, beforeNavigate?: () => Promise<void>) => Promise<void>;
-	getCDPSession?: (sessionId: string) => Promise<CDPSession>;
-	close: () => Awaitable$1<void>;
-	// eslint-disable-next-line ts/method-signature-style -- we want to allow extended options
-	initialize(ctx: TestProject, options: BrowserProviderInitializationOptions): Awaitable$1<void>;
-}
-interface BrowserProviderModule {
-	new (): BrowserProvider;
-}
-interface BrowserProviderOptions {}
-type BrowserBuiltinProvider = "webdriverio" | "playwright" | "preview";
-type UnsupportedProperties = "browser" | "typecheck" | "alias" | "sequence" | "root" | "pool" | "poolOptions" | "runner" | "api" | "deps" | "testTransformMode" | "poolMatchGlobs" | "environmentMatchGlobs" | "environment" | "environmentOptions" | "server" | "benchmark" | "name";
-interface BrowserInstanceOption extends BrowserProviderOptions, Omit<ProjectConfig, UnsupportedProperties>, Pick<BrowserConfigOptions, "headless" | "locators" | "viewport" | "testerHtmlPath" | "screenshotDirectory" | "screenshotFailures"> {
+	fileParallelism?: boolean;
 	/**
-	* Name of the browser
+	* Options for projects
 	*/
-	browser: string;
-	name?: string;
-}
-interface BrowserConfigOptions {
+	projects?: TestProjectConfiguration[];
 	/**
-	* if running tests in the browser should be the default
+	* Update snapshot
 	*
 	* @default false
 	*/
-	enabled?: boolean;
-	/**
-	* Name of the browser
-	* @deprecated use `instances` instead. if both are defined, this will filter `instances` by name.
-	*/
-	name?: string;
+	update?: boolean;
 	/**
-	* Configurations for different browser setups
+	* Watch mode
+	*
+	* @default !process.env.CI
 	*/
-	instances?: BrowserInstanceOption[];
+	watch?: boolean;
 	/**
-	* Browser provider
+	* Project root
 	*
-	* @default 'preview'
+	* @default process.cwd()
 	*/
-	provider?: BrowserBuiltinProvider | (string & {});
+	root?: string;
 	/**
-	* Options that are passed down to a browser provider.
-	* To support type hinting, add one of the types to your tsconfig.json "compilerOptions.types" field:
-	*
-	* - for webdriverio: `@vitest/browser/providers/webdriverio`
-	* - for playwright: `@vitest/browser/providers/playwright`
+	* Custom reporter for output. Can contain one or more built-in report names, reporter instances,
+	* and/or paths to custom reporters.
 	*
-	* @example
-	* { playwright: { launch: { devtools: true } }
-	* @deprecated use `instances` instead
+	* @default []
 	*/
-	providerOptions?: BrowserProviderOptions;
+	reporters?: Arrayable<ReporterName | InlineReporter> | ((ReporterName | InlineReporter) | [ReporterName] | ReporterWithOptions)[];
 	/**
-	* enable headless mode
-	*
-	* @default process.env.CI
+	* Write test results to a file when the --reporter=json` or `--reporter=junit` option is also specified.
+	* Also definable individually per reporter by using an object instead.
 	*/
-	headless?: boolean;
+	outputFile?: string | (Partial<Record<BuiltinReporters, string>> & Record<string, string>);
 	/**
-	* Serve API options.
+	* Default timeout of a test in milliseconds
 	*
-	* The default port is 63315.
+	* @default 5000
 	*/
-	api?: ApiConfig | number;
+	testTimeout?: number;
 	/**
-	* Isolate test environment after each test
+	* Default timeout of a hook in milliseconds
 	*
-	* @default true
+	* @default 10000
 	*/
-	isolate?: boolean;
+	hookTimeout?: number;
 	/**
-	* Run test files in parallel if provider supports this option
-	* This option only has effect in headless mode (enabled in CI by default)
+	* Default timeout to wait for close when Vitest shuts down, in milliseconds
 	*
-	* @default // Same as "test.fileParallelism"
+	* @default 10000
 	*/
-	fileParallelism?: boolean;
+	teardownTimeout?: number;
 	/**
-	* Show Vitest UI
+	* Silent mode
 	*
-	* @default !process.env.CI
+	* Use `'passed-only'` to see logs from failing tests only.
+	*
+	* @default false
 	*/
-	ui?: boolean;
+	silent?: boolean | "passed-only";
 	/**
-	* Default viewport size
-	*/
-	viewport?: {
-		/**
-		* Width of the viewport
-		* @default 414
-		*/
-		width: number
-		/**
-		* Height of the viewport
-		* @default 896
-		*/
-		height: number
-	};
+	* Hide logs for skipped tests
+	*
+	* @default false
+	*/
+	hideSkippedTests?: boolean;
 	/**
-	* Locator options
+	* Path to setup files
 	*/
-	locators?: {
-		/**
-		* Attribute used to locate elements by test id
-		* @default 'data-testid'
-		*/
-		testIdAttribute?: string
-	};
+	setupFiles?: string | string[];
 	/**
-	* Directory where screenshots will be saved when page.screenshot() is called
-	* If not set, all screenshots are saved to __screenshots__ directory in the same folder as the test file.
-	* If this is set, it will be resolved relative to the project root.
-	* @default __screenshots__
+	* Path to global setup files
 	*/
-	screenshotDirectory?: string;
+	globalSetup?: string | string[];
 	/**
-	* Should Vitest take screenshots if the test fails
-	* @default !browser.ui
+	* Glob pattern of file paths that will trigger the whole suite rerun
+	*
+	* Useful if you are testing calling CLI commands
+	*
+	* @default ['**\/package.json/**', '**\/{vitest,vite}.config.*\/**']
 	*/
-	screenshotFailures?: boolean;
+	forceRerunTriggers?: string[];
 	/**
-	* Scripts injected into the tester iframe.
-	* @deprecated Will be removed in the future, use `testerHtmlPath` instead.
+	* Pattern configuration to rerun only the tests that are affected
+	* by the changes of specific files in the repository.
 	*/
-	testerScripts?: BrowserScript[];
+	watchTriggerPatterns?: WatcherTriggerPattern[];
 	/**
-	* Path to the index.html file that will be used to run tests.
+	* Coverage options
 	*/
-	testerHtmlPath?: string;
+	coverage?: CoverageOptions;
 	/**
-	* Scripts injected into the main window.
+	* run test names with the specified pattern
 	*/
-	orchestratorScripts?: BrowserScript[];
+	testNamePattern?: string | RegExp;
 	/**
-	* Commands that will be executed on the server
-	* via the browser `import("@vitest/browser/context").commands` API.
-	* @see {@link https://vitest.dev/guide/browser/commands}
+	* Will call `.mockClear()` on all spies before each test
+	* @default false
 	*/
-	commands?: Record<string, BrowserCommand<any>>;
+	clearMocks?: boolean;
 	/**
-	* Timeout for connecting to the browser
-	* @default 30000
+	* Will call `.mockReset()` on all spies before each test
+	* @default false
 	*/
-	connectTimeout?: number;
-}
-interface BrowserCommandContext {
-	testPath: string | undefined;
-	provider: BrowserProvider;
-	project: TestProject;
-	/** @deprecated use `sessionId` instead */
-	contextId: string;
-	sessionId: string;
-}
-interface BrowserServerStateSession {
-	project: TestProject;
-	connected: () => void;
-	fail: (v: Error) => void;
-}
-interface BrowserOrchestrator {
-	cleanupTesters: () => Promise<void>;
-	createTesters: (options: BrowserTesterOptions) => Promise<void>;
-	onCancel: (reason: CancelReason) => Promise<void>;
-	$close: () => void;
-}
-interface BrowserServerState {
-	orchestrators: Map<string, BrowserOrchestrator>;
-}
-interface ParentProjectBrowser {
-	spawn: (project: TestProject) => ProjectBrowser;
-}
-interface ProjectBrowser {
-	vite: ViteDevServer;
-	state: BrowserServerState;
-	provider: BrowserProvider;
-	close: () => Promise<void>;
-	initBrowserProvider: (project: TestProject) => Promise<void>;
-	parseStacktrace: (stack: string) => ParsedStack[];
-	parseErrorStacktrace: (error: ErrorWithDiff, options?: StackTraceParserOptions) => ParsedStack[];
-}
-interface BrowserCommand<Payload extends unknown[]> {
-	(context: BrowserCommandContext, ...payload: Payload): Awaitable$1<any>;
-}
-interface BrowserScript {
+	mockReset?: boolean;
 	/**
-	* If "content" is provided and type is "module", this will be its identifier.
-	*
-	* If you are using TypeScript, you can add `.ts` extension here for example.
-	* @default `injected-${index}.js`
+	* Will call `.mockRestore()` on all spies before each test
+	* @default false
 	*/
-	id?: string;
+	restoreMocks?: boolean;
 	/**
-	* JavaScript content to be injected. This string is processed by Vite plugins if type is "module".
-	*
-	* You can use `id` to give Vite a hint about the file extension.
+	* Will restore all global stubs to their original values before each test
+	* @default false
 	*/
-	content?: string;
+	unstubGlobals?: boolean;
 	/**
-	* Path to the script. This value is resolved by Vite so it can be a node module or a file path.
+	* Will restore all env stubs to their original values before each test
+	* @default false
 	*/
-	src?: string;
+	unstubEnvs?: boolean;
 	/**
-	* If the script should be loaded asynchronously.
+	* Serve API options.
+	*
+	* When set to true, the default port is 51204.
+	*
+	* @default false
 	*/
-	async?: boolean;
+	api?: boolean | number | ApiConfig;
 	/**
-	* Script type.
-	* @default 'module'
+	* Enable Vitest UI
+	*
+	* @default false
 	*/
-	type?: string;
-}
-interface ResolvedBrowserOptions extends BrowserConfigOptions {
-	name: string;
-	providerOptions?: BrowserProviderOptions;
-	enabled: boolean;
-	headless: boolean;
-	isolate: boolean;
-	fileParallelism: boolean;
-	api: ApiConfig;
-	ui: boolean;
-	viewport: {
-		width: number
-		height: number
-	};
-	screenshotFailures: boolean;
-	locators: {
-		testIdAttribute: string
-	};
-}
-
-declare class TestProject {
-	/** @deprecated */
-	path: string | number;
-	options?: InitializeProjectOptions | undefined;
+	ui?: boolean;
 	/**
-	* The global Vitest instance.
-	* @experimental The public Vitest API is experimental and does not follow semver.
+	* options for test in a browser environment
+	* @experimental
+	*
+	* @default false
 	*/
-	readonly vitest: Vitest;
+	browser?: BrowserConfigOptions;
 	/**
-	* Resolved global configuration. If there are no workspace projects, this will be the same as `config`.
+	* Open UI automatically.
+	*
+	* @default !process.env.CI
 	*/
-	readonly globalConfig: ResolvedConfig;
+	open?: boolean;
 	/**
-	* Browser instance if the browser is enabled. This is initialized when the tests run for the first time.
+	* Base url for the UI
+	*
+	* @default '/__vitest__/'
 	*/
-	browser?: ProjectBrowser;
-	/** @deprecated use `vitest` instead */
-	ctx: Vitest;
+	uiBase?: string;
 	/**
-	* Temporary directory for the project. This is unique for each project. Vitest stores transformed content here.
+	* Format options for snapshot testing.
 	*/
-	readonly tmpDir: string;
-	private runner;
-	private closingPromise;
-	private testFilesList;
-	private typecheckFilesList;
-	private _globalSetups?;
-	private _provided;
-	constructor(path: string | number, vitest: Vitest, options?: InitializeProjectOptions | undefined);
+	snapshotFormat?: Omit<PrettyFormatOptions, "plugins" | "compareKeys"> & {
+		compareKeys?: null | undefined;
+	};
 	/**
-	* The unique hash of this project. This value is consistent between the reruns.
-	*
-	* It is based on the root of the project (not consistent between OS) and its name.
+	* Path to a module which has a default export of diff config.
 	*/
-	get hash(): string;
-	// "provide" is a property, not a method to keep the context when destructed in the global setup,
-	// making it a method would be a breaking change, and can be done in Vitest 3 at minimum
+	diff?: string | SerializedDiffOptions;
 	/**
-	* Provide a value to the test context. This value will be available to all tests with `inject`.
+	* Paths to snapshot serializer modules.
 	*/
-	provide: <T extends keyof ProvidedContext & string>(key: T, value: ProvidedContext[T]) => void;
+	snapshotSerializers?: string[];
 	/**
-	* Get the provided context. The project context is merged with the global context.
+	* Resolve custom snapshot path
 	*/
-	getProvidedContext(): ProvidedContext;
+	resolveSnapshotPath?: ResolveSnapshotPathHandler;
 	/**
-	* Creates a new test specification. Specifications describe how to run tests.
-	* @param moduleId The file path
+	* Path to a custom snapshot environment module that has a default export of `SnapshotEnvironment` object.
 	*/
-	createSpecification(moduleId: string, locations?: number[] | undefined, pool?: string): TestSpecification;
-	toJSON(): SerializedTestProject;
+	snapshotEnvironment?: string;
 	/**
-	* Vite's dev server instance. Every workspace project has its own server.
+	* Pass with no tests
 	*/
-	get vite(): ViteDevServer;
+	passWithNoTests?: boolean;
 	/**
-	* Resolved project configuration.
+	* Allow tests and suites that are marked as only
+	*
+	* @default !process.env.CI
 	*/
-	get config(): ResolvedConfig;
+	allowOnly?: boolean;
 	/**
-	* The name of the project or an empty string if not set.
+	* Show heap usage after each test. Useful for debugging memory leaks.
 	*/
-	get name(): string;
+	logHeapUsage?: boolean;
 	/**
-	* The color used when reporting tasks of this project.
+	* Custom environment variables assigned to `process.env` before running tests.
 	*/
-	get color(): ProjectName["color"];
+	env?: Partial<NodeJS.ProcessEnv>;
 	/**
-	* Serialized project configuration. This is the config that tests receive.
+	* Options for @sinon/fake-timers
 	*/
-	get serializedConfig(): SerializedConfig;
-	/** @deprecated use `vite` instead */
-	get server(): ViteDevServer;
+	fakeTimers?: FakeTimerInstallOpts;
 	/**
-	* Check if this is the root project. The root project is the one that has the root config.
+	* Custom handler for console.log in tests.
+	*
+	* Return `false` to ignore the log.
 	*/
-	isRootProject(): boolean;
-	/** @deprecated use `isRootProject` instead */
-	isCore(): boolean;
-	/** @deprecated use `createSpecification` instead */
-	createSpec(moduleId: string, pool: string): WorkspaceSpec;
-	/** @deprecated */
-	initializeGlobalSetup(): Promise<void>;
-	onTestsRerun(cb: OnTestsRerunHandler): void;
-	/** @deprecated */
-	teardownGlobalSetup(): Promise<void>;
-	/** @deprecated use `vitest.logger` instead */
-	get logger(): Logger;
-	// it's possible that file path was imported with different queries (?raw, ?url, etc)
-	/** @deprecated use `.vite` or `.browser.vite` directly */
-	getModulesByFilepath(file: string): Set<ModuleNode>;
-	/** @deprecated use `.vite` or `.browser.vite` directly */
-	getModuleById(id: string): ModuleNode | undefined;
-	/** @deprecated use `.vite` or `.browser.vite` directly */
-	getSourceMapModuleById(id: string): TransformResult$1["map"] | undefined;
-	/** @deprecated use `vitest.reporters` instead */
-	get reporters(): Reporter[];
+	onConsoleLog?: (log: string, type: "stdout" | "stderr", entity: TestModule | TestCase | TestSuite | undefined) => boolean | void;
 	/**
-	* Get all files in the project that match the globs in the config and the filters.
-	* @param filters String filters to match the test files.
+	* Enable stack trace filtering. If absent, all stack trace frames
+	* will be shown.
+	*
+	* Return `false` to omit the frame.
 	*/
-	globTestFiles(filters?: string[]): Promise<{
-		/**
-		* Test files that match the filters.
-		*/
-		testFiles: string[]
-		/**
-		* Typecheck test files that match the filters. This will be empty unless `typecheck.enabled` is `true`.
-		*/
-		typecheckTestFiles: string[]
-	}>;
-	private globAllTestFiles;
-	isBrowserEnabled(): boolean;
-	private markTestFile;
-	/** @deprecated use `serializedConfig` instead */
-	getSerializableConfig(): SerializedConfig;
+	onStackTrace?: (error: TestError, frame: ParsedStack) => boolean | void;
 	/**
-	* Test if a file matches the test globs. This does the actual glob matching if the test is not cached, unlike `isCachedTestFile`.
+	* A callback that can return `false` to ignore an unhandled error
 	*/
-	matchesTestGlob(moduleId: string, source?: () => string): boolean;
-	/** @deprecated use `matchesTestGlob` instead */
-	isTargetFile(id: string, source?: string): Promise<boolean>;
-	private isInSourceTestCode;
-	private filterFiles;
-	private _parentBrowser?;
+	onUnhandledError?: OnUnhandledErrorCallback;
 	/**
-	* Closes the project and all associated resources. This can only be called once; the closing promise is cached until the server restarts.
-	* If the resources are needed again, create a new project.
+	* Indicates if CSS files should be processed.
+	*
+	* When excluded, the CSS files will be replaced with empty strings to bypass the subsequent processing.
+	*
+	* @default { include: [], modules: { classNameStrategy: false } }
 	*/
-	close(): Promise<void>;
+	css?: boolean | {
+		include?: RegExp | RegExp[];
+		exclude?: RegExp | RegExp[];
+		modules?: {
+			classNameStrategy?: CSSModuleScopeStrategy;
+		};
+	};
 	/**
-	* Import a file using Vite module runner.
-	* @param moduleId The ID of the module in Vite module graph
+	* A number of tests that are allowed to run at the same time marked with `test.concurrent`.
+	* @default 5
 	*/
-	import<T>(moduleId: string): Promise<T>;
-	/** @deprecated use `name` instead */
-	getName(): string;
-	/** @deprecated internal */
-	setServer(options: UserConfig, server: ViteDevServer): Promise<void>;
-	private _setHash;
-	private _serializeOverriddenConfig;
-	private clearTmpDir;
-	/** @deprecated */
-	initBrowserProvider(): Promise<void>;
-}
-
-interface SerializedTestProject {
-	name: string;
-	serializedConfig: SerializedConfig;
-	context: ProvidedContext;
-}
-interface InitializeProjectOptions extends TestProjectInlineConfiguration {
-	configFile: string | false;
-}
-
-/**
-* @deprecated use TestSpecification instead
-*/
-type WorkspaceSpec = TestSpecification & [project: TestProject, file: string, options: {
-	pool: Pool
-}];
-type RunWithFiles = (files: TestSpecification[], invalidates?: string[]) => Awaitable$1<void>;
-interface ProcessPool {
-	name: string;
-	runTests: RunWithFiles;
-	collectTests: RunWithFiles;
-	close?: () => Awaitable$1<void>;
-}
-declare function getFilePoolName(project: TestProject, file: string): Pool;
-
-interface TestRunResult {
-	testModules: TestModule[];
-	unhandledErrors: unknown[];
-}
-
-interface SuiteResultCache {
-	failed: boolean;
-	duration: number;
-}
-declare class ResultsCache {
-	private cache;
-	private workspacesKeyMap;
-	private cachePath;
-	private version;
-	private root;
-	constructor(version: string);
-	getCachePath(): string | null;
-	setConfig(root: string, config: ResolvedConfig["cache"]): void;
-	getResults(key: string): SuiteResultCache | undefined;
-	readFromCache(): Promise<void>;
-	updateResults(files: File[]): void;
-	removeFromCache(filepath: string): void;
-	writeToCache(): Promise<void>;
-}
-
-type FileStatsCache = Pick<Stats, "size">;
-declare class FilesStatsCache {
-	cache: Map<string, FileStatsCache>;
-	getStats(key: string): FileStatsCache | undefined;
-	populateStats(root: string, specs: TestSpecification[]): Promise<void>;
-	updateStats(fsPath: string, key: string): Promise<void>;
-	removeStats(fsPath: string): void;
-}
-
-declare class VitestCache {
-	results: ResultsCache;
-	stats: FilesStatsCache;
-	constructor(version: string);
-	getFileTestResults(key: string): SuiteResultCache | undefined;
-	getFileStats(key: string): {
-		size: number
-	} | undefined;
-	static resolveCacheDir(root: string, dir?: string, projectName?: string): string;
-}
-
-declare class VitestPackageInstaller {
-	isPackageExists(name: string, options?: {
-		paths?: string[]
-	}): boolean;
-	ensureInstalled(dependency: string, root: string, version?: string): Promise<boolean>;
-}
-
-declare class StateManager {
-	filesMap: Map<string, File[]>;
-	pathsSet: Set<string>;
-	idMap: Map<string, Task>;
-	taskFileMap: WeakMap<Task, File>;
-	errorsSet: Set<unknown>;
-	processTimeoutCauses: Set<string>;
-	reportedTasksMap: WeakMap<Task, TestModule | TestCase | TestSuite>;
-	blobs?: MergedBlobs;
-	catchError(err: unknown, type: string): void;
-	clearErrors(): void;
-	getUnhandledErrors(): unknown[];
-	addProcessTimeoutCause(cause: string): void;
-	getProcessTimeoutCauses(): string[];
-	getPaths(): string[];
+	maxConcurrency?: number;
 	/**
-	* Return files that were running or collected.
+	* Options for configuring cache policy.
+	* @default { dir: 'node_modules/.vite/vitest/{project-hash}' }
 	*/
-	getFiles(keys?: string[]): File[];
-	getTestModules(keys?: string[]): TestModule[];
-	getFilepaths(): string[];
-	getFailedFilepaths(): string[];
-	collectPaths(paths?: string[]): void;
-	collectFiles(project: TestProject, files?: File[]): void;
-	clearFiles(project: TestProject, paths?: string[]): void;
-	updateId(task: Task, project: TestProject): void;
-	getReportedEntity(task: Task): TestModule | TestCase | TestSuite | undefined;
-	updateTasks(packs: TaskResultPack[]): void;
-	updateUserLog(log: UserConsoleLog): void;
-	getCountOfFailedTests(): number;
-	cancelFiles(files: string[], project: TestProject): void;
-}
-
-interface VitestOptions {
-	packageInstaller?: VitestPackageInstaller;
-	stdin?: NodeJS.ReadStream;
-	stdout?: NodeJS.WriteStream | Writable;
-	stderr?: NodeJS.WriteStream | Writable;
-}
-declare class Vitest {
-	readonly mode: VitestRunMode;
+	cache?: false | {
+		/**
+		* @deprecated Use Vite's "cacheDir" instead if you want to change the cache director. Note caches will be written to "cacheDir\/vitest".
+		*/
+		dir: string;
+	};
 	/**
-	* Current Vitest version.
-	* @example '2.0.0'
+	* Options for configuring the order of running tests.
 	*/
-	readonly version: string;
-	static readonly version: string;
+	sequence?: SequenceOptions;
 	/**
-	* The logger instance used to log messages. It's recommended to use this logger instead of `console`.
-	* It's possible to override stdout and stderr streams when initiating Vitest.
-	* @example
-	* new Vitest('test', {
-	*   stdout: new Writable(),
-	* })
+	* Specifies an `Object`, or an `Array` of `Object`,
+	* which defines aliases used to replace values in `import` or `require` statements.
+	* Will be merged with the default aliases inside `resolve.alias`.
 	*/
-	readonly logger: Logger;
+	alias?: AliasOptions;
 	/**
-	* The package installer instance used to install Vitest packages.
-	* @example
-	* await vitest.packageInstaller.ensureInstalled('@vitest/browser', process.cwd())
+	* Ignore any unhandled errors that occur
+	*
+	* @default false
 	*/
-	readonly packageInstaller: VitestPackageInstaller;
+	dangerouslyIgnoreUnhandledErrors?: boolean;
 	/**
-	* A path to the built Vitest directory. This is usually a folder in `node_modules`.
+	* Options for configuring typechecking test environment.
 	*/
-	readonly distPath: string;
+	typecheck?: Partial<TypecheckConfig>;
 	/**
-	* A list of projects that are currently running.
-	* If projects were filtered with `--project` flag, they won't appear here.
+	* The number of milliseconds after which a test is considered slow and reported as such in the results.
+	*
+	* @default 300
 	*/
-	projects: TestProject[];
-	private isFirstRun;
-	private restartsCount;
-	private readonly specifications;
-	private readonly watcher;
-	private pool;
-	private _config?;
-	private _vite?;
-	private _state?;
-	private _cache?;
-	private _snapshot?;
-	private _workspaceConfigPath?;
-	constructor(mode: VitestRunMode, cliOptions: UserConfig, options?: VitestOptions);
-	private _onRestartListeners;
-	private _onClose;
-	private _onSetServer;
-	private _onCancelListeners;
-	private _onUserTestsRerun;
-	private _onFilterWatchedSpecification;
-	/** @deprecated will be removed in 4.0, use `onFilterWatchedSpecification` instead */
-	get invalidates(): Set<string>;
-	/** @deprecated will be removed in 4.0, use `onFilterWatchedSpecification` instead */
-	get changedTests(): Set<string>;
+	slowTestThreshold?: number;
 	/**
-	* The global config.
+	* Path to a custom test runner.
 	*/
-	get config(): ResolvedConfig;
-	/** @deprecated use `vitest.vite` instead */
-	get server(): ViteDevServer;
+	runner?: string;
 	/**
-	* Global Vite's dev server instance.
+	* Debug tests by opening `node:inspector` in worker / child process.
+	* Provides similar experience as `--inspect` Node CLI argument.
+	*
+	* Requires `poolOptions.threads.singleThread: true` OR `poolOptions.forks.singleFork: true`.
 	*/
-	get vite(): ViteDevServer;
+	inspect?: boolean | string;
 	/**
-	* The global test state manager.
-	* @experimental The State API is experimental and not subject to semver.
+	* Debug tests by opening `node:inspector` in worker / child process and wait for debugger to connect.
+	* Provides similar experience as `--inspect-brk` Node CLI argument.
+	*
+	* Requires `poolOptions.threads.singleThread: true` OR `poolOptions.forks.singleFork: true`.
 	*/
-	get state(): StateManager;
+	inspectBrk?: boolean | string;
 	/**
-	* The global snapshot manager. You can access the current state on `snapshot.summary`.
+	* Inspector options. If `--inspect` or `--inspect-brk` is enabled, these options will be passed to the inspector.
 	*/
-	get snapshot(): SnapshotManager;
+	inspector?: {
+		/**
+		* Enable inspector
+		*/
+		enabled?: boolean;
+		/**
+		* Port to run inspector on
+		*/
+		port?: number;
+		/**
+		* Host to run inspector on
+		*/
+		host?: string;
+		/**
+		* Wait for debugger to connect before running tests
+		*/
+		waitForDebugger?: boolean;
+	};
 	/**
-	* Test results and test file stats cache. Primarily used by the sequencer to sort tests.
+	* Define variables that will be returned from `inject` in the test environment.
+	* @example
+	* ```ts
+	* // vitest.config.ts
+	* export default defineConfig({
+	*   test: {
+	*     provide: {
+	*       someKey: 'someValue'
+	*     }
+	*   }
+	* })
+	* ```
+	* ```ts
+	* // test file
+	* import { inject } from 'vitest'
+	* const value = inject('someKey') // 'someValue'
+	* ```
 	*/
-	get cache(): VitestCache;
-	/** @deprecated internal */
-	setServer(options: UserConfig, server: ViteDevServer): Promise<void>;
+	provide?: Partial<ProvidedContext>;
 	/**
-	* Inject new test projects into the workspace.
-	* @param config Glob, config path or a custom config options.
-	* @returns An array of new test projects. Can be empty if the name was filtered out.
+	* Configuration options for expect() matches.
 	*/
-	private injectTestProject;
+	expect?: {
+		/**
+		* Throw an error if tests don't have any expect() assertions.
+		*/
+		requireAssertions?: boolean;
+		/**
+		* Default options for expect.poll()
+		*/
+		poll?: {
+			/**
+			* Timeout in milliseconds
+			* @default 1000
+			*/
+			timeout?: number;
+			/**
+			* Polling interval in milliseconds
+			* @default 50
+			*/
+			interval?: number;
+		};
+	};
 	/**
-	* Provide a value to the test context. This value will be available to all tests with `inject`.
+	* Modify default Chai config. Vitest uses Chai for `expect` and `assert` matches.
+	* https://github.com/chaijs/chai/blob/4.x.x/lib/chai/config.js
 	*/
-	provide: <T extends keyof ProvidedContext & string>(key: T, value: ProvidedContext[T]) => void;
+	chaiConfig?: ChaiConfig;
 	/**
-	* Get global provided context.
+	* Stop test execution when given number of tests have failed.
 	*/
-	getProvidedContext(): ProvidedContext;
-	/** @deprecated use `getRootProject` instead */
-	getCoreWorkspaceProject(): TestProject;
+	bail?: number;
 	/**
-	* Return project that has the root (or "global") config.
+	* Retry the test specific number of times if it fails.
+	*
+	* @default 0
 	*/
-	getRootProject(): TestProject;
+	retry?: number;
 	/**
-	* @deprecated use Reported Task API instead
+	* Show full diff when snapshot fails instead of a patch.
 	*/
-	getProjectByTaskId(taskId: string): TestProject;
-	getProjectByName(name: string): TestProject;
+	expandSnapshotDiff?: boolean;
 	/**
-	* Import a file using Vite module runner. The file will be transformed by Vite and executed in a separate context.
-	* @param moduleId The ID of the module in Vite module graph
+	* By default, Vitest automatically intercepts console logging during tests for extra formatting of test file, test title, etc...
+	* This is also required for console log preview on Vitest UI.
+	* However, disabling such interception might help when you want to debug a code with normal synchronous terminal console logging.
+	*
+	* This option has no effect on browser pool since Vitest preserves original logging on browser devtools.
+	*
+	* @default false
 	*/
-	import<T>(moduleId: string): Promise<T>;
-	private resolveWorkspaceConfigPath;
-	private resolveProjects;
+	disableConsoleIntercept?: boolean;
 	/**
-	* Glob test files in every project and create a TestSpecification for each file and pool.
-	* @param filters String filters to match the test files.
+	* Always print console stack traces.
+	*
+	* @default false
 	*/
-	globTestSpecifications(filters?: string[]): Promise<TestSpecification[]>;
-	private initCoverageProvider;
+	printConsoleTrace?: boolean;
 	/**
-	* Merge reports from multiple runs located in the specified directory (value from `--merge-reports` if not specified).
+	* Include "location" property inside the test definition
+	*
+	* @default false
 	*/
-	mergeReports(directory?: string): Promise<TestRunResult>;
-	collect(filters?: string[]): Promise<TestRunResult>;
-	/** @deprecated use `getRelevantTestSpecifications` instead */
-	listFiles(filters?: string[]): Promise<TestSpecification[]>;
+	includeTaskLocation?: boolean;
 	/**
-	* Returns the list of test files that match the config and filters.
-	* @param filters String filters to match the test files
+	* Directory path for storing attachments created by `context.annotate`
+	*
+	* @default '.vitest-attachments'
 	*/
-	getRelevantTestSpecifications(filters?: string[]): Promise<TestSpecification[]>;
+	attachmentsDir?: string;
+}
+interface TypecheckConfig {
 	/**
-	* Initialize reporters, the coverage provider, and run tests.
-	* This method can throw an error:
-	*   - `FilesNotFoundError` if no tests are found
-	*   - `GitNotFoundError` if `--related` flag is used, but git repository is not initialized
-	*   - `Error` from the user reporters
-	* @param filters String filters to match the test files
+	* Run typechecking tests alongside regular tests.
 	*/
-	start(filters?: string[]): Promise<TestRunResult>;
+	enabled?: boolean;
 	/**
-	* Initialize reporters and the coverage provider. This method doesn't run any tests.
-	* If the `--watch` flag is provided, Vitest will still run changed tests even if this method was not called.
+	* When typechecking is enabled, only run typechecking tests.
 	*/
-	init(): Promise<void>;
+	only?: boolean;
 	/**
-	* @deprecated remove when vscode extension supports "getModuleSpecifications"
+	* What tools to use for type checking.
+	*
+	* @default 'tsc'
 	*/
-	getProjectsByTestFile(file: string): WorkspaceSpec[];
-	/** @deprecated */
-	getFileWorkspaceSpecs(file: string): WorkspaceSpec[];
+	checker: "tsc" | "vue-tsc" | (string & Record<never, never>);
 	/**
-	* Get test specifications associated with the given module. If module is not a test file, an empty array is returned.
+	* Pattern for files that should be treated as test files
 	*
-	* **Note:** this method relies on a cache generated by `globTestSpecifications`. If the file was not processed yet, use `project.matchesGlobPattern` instead.
-	* @param moduleId The module ID to get test specifications for.
+	* @default ['**\/*.{test,spec}-d.?(c|m)[jt]s?(x)']
 	*/
-	getModuleSpecifications(moduleId: string): TestSpecification[];
+	include: string[];
 	/**
-	* Vitest automatically caches test specifications for each file. This method clears the cache for the given file or the whole cache altogether.
+	* Pattern for files that should not be treated as test files
+	*
+	* @default ['**\/node_modules/**', '**\/dist/**', '**\/cypress/**', '**\/.{idea,git,cache,output,temp}/**', '**\/{karma,rollup,webpack,vite,vitest,jest,ava,babel,nyc,cypress,tsup,build,eslint,prettier}.config.*']
 	*/
-	clearSpecificationsCache(moduleId?: string): void;
+	exclude: string[];
 	/**
-	* Run tests for the given test specifications. This does not trigger `onWatcher*` events.
-	* @param specifications A list of specifications to run.
-	* @param allTestsRun Indicates whether all tests were run. This only matters for coverage.
+	* Check JS files that have `@ts-check` comment.
+	* If you have it enabled in tsconfig, this will not overwrite it.
 	*/
-	runTestSpecifications(specifications: TestSpecification[], allTestsRun?: boolean): Promise<TestRunResult>;
+	allowJs?: boolean;
 	/**
-	* Rerun files and trigger `onWatcherRerun`, `onWatcherStart` and `onTestsRerun` events.
-	* @param specifications A list of specifications to run.
-	* @param allTestsRun Indicates whether all tests were run. This only matters for coverage.
+	* Do not fail, if Vitest found errors outside the test files.
 	*/
-	rerunTestSpecifications(specifications: TestSpecification[], allTestsRun?: boolean): Promise<TestRunResult>;
-	private runFiles;
+	ignoreSourceErrors?: boolean;
 	/**
-	* Collect tests in specified modules. Vitest will run the files to collect tests.
-	* @param specifications A list of specifications to run.
+	* Path to tsconfig, relative to the project root.
 	*/
-	collectTests(specifications: TestSpecification[]): Promise<TestRunResult>;
+	tsconfig?: string;
 	/**
-	* Gracefully cancel the current test run. Vitest will wait until all running tests are finished before cancelling.
+	* Minimum time in milliseconds it takes to spawn the typechecker.
+	* @default 10_000
 	*/
-	cancelCurrentRun(reason: CancelReason): Promise<void>;
-	private initializeGlobalSetup;
+	spawnTimeout?: number;
+}
+interface UserConfig extends InlineConfig {
 	/**
-	* Update snapshots in specified files. If no files are provided, it will update files with failed tests and obsolete snapshots.
-	* @param files The list of files on the file system
+	* Path to the config file.
+	*
+	* Default resolving to `vitest.config.*`, `vite.config.*`
+	*
+	* Setting to `false` will disable config resolving.
 	*/
-	updateSnapshot(files?: string[]): Promise<TestRunResult>;
+	config?: string | false | undefined;
 	/**
-	* Enable the mode that allows updating snapshots when running tests.
-	* This method doesn't run any tests.
+	* Do not run tests when Vitest starts.
 	*
-	* Every test that runs after this method is called will update snapshots.
-	* To disable the mode, call `resetSnapshotUpdate`.
+	* Vitest will only run tests if it's called programmatically or the test file changes.
+	*
+	* If CLI file filters are passed, standalone mode is ignored.
 	*/
-	enableSnapshotUpdate(): void;
+	standalone?: boolean;
 	/**
-	* Disable the mode that allows updating snapshots when running tests.
+	* Use happy-dom
 	*/
-	resetSnapshotUpdate(): void;
+	dom?: boolean;
 	/**
-	* Set the global test name pattern to a regexp.
-	* This method doesn't run any tests.
+	* Run tests that cover a list of source files
 	*/
-	setGlobalTestNamePattern(pattern: string | RegExp): void;
+	related?: string[] | string;
 	/**
-	* Resets the global test name pattern. This method doesn't run any tests.
+	* Overrides Vite mode
+	* @default 'test'
 	*/
-	resetGlobalTestNamePattern(): void;
-	private _rerunTimer;
-	// we can't use a single `triggerId` yet because vscode extension relies on this
-	private scheduleRerun;
+	mode?: string;
 	/**
-	* Invalidate a file in all projects.
+	* Runs tests that are affected by the changes in the repository, or between specified branch or commit hash
+	* Requires initialized git repository
+	* @default false
 	*/
-	invalidateFile(filepath: string): void;
-	/** @deprecated use `invalidateFile` */
-	updateLastChanged(filepath: string): void;
-	private reportCoverage;
+	changed?: boolean | string;
 	/**
-	* Closes all projects and their associated resources.
-	* This can only be called once; the closing promise is cached until the server restarts.
+	* Test suite shard to execute in a format of <index>/<count>.
+	* Will divide tests into a `count` numbers, and run only the `indexed` part.
+	* Cannot be used with enabled watch.
+	* @example --shard=2/3
 	*/
-	close(): Promise<void>;
+	shard?: string;
 	/**
-	* Closes all projects and exit the process
-	* @param force If true, the process will exit immediately after closing the projects.
+	* Name of the project or projects to run.
 	*/
-	exit(force?: boolean): Promise<void>;
+	project?: string | string[];
 	/**
-	* @deprecated use `globTestSpecifications` instead
+	* Additional exclude patterns
 	*/
-	globTestSpecs(filters?: string[]): Promise<TestSpecification[]>;
+	cliExclude?: string[];
 	/**
-	* @deprecated use `globTestSpecifications` instead
+	* Override vite config's clearScreen from cli
 	*/
-	globTestFiles(filters?: string[]): Promise<TestSpecification[]>;
-	/** @deprecated filter by `this.projects` yourself */
-	getModuleProjects(filepath: string): TestProject[];
+	clearScreen?: boolean;
 	/**
-	* Should the server be kept running after the tests are done.
+	* benchmark.compare option exposed at the top level for cli
 	*/
-	shouldKeepServer(): boolean;
+	compare?: string;
 	/**
-	* Register a handler that will be called when the server is restarted due to a config change.
+	* benchmark.outputJson option exposed at the top level for cli
 	*/
-	onServerRestart(fn: OnServerRestartHandler): void;
+	outputJson?: string;
 	/**
-	* Register a handler that will be called when the test run is cancelled with `vitest.cancelCurrentRun`.
+	* Directory of blob reports to merge
+	* @default '.vitest-reports'
 	*/
-	onCancel(fn: (reason: CancelReason) => Awaitable$1<void>): void;
+	mergeReports?: string;
+}
+type OnUnhandledErrorCallback = (error: (TestError | Error) & {
+	type: string;
+}) => boolean | void;
+interface ResolvedConfig extends Omit<Required<UserConfig>, "project" | "config" | "filters" | "browser" | "coverage" | "testNamePattern" | "related" | "api" | "reporters" | "resolveSnapshotPath" | "benchmark" | "shard" | "cache" | "sequence" | "typecheck" | "runner" | "poolOptions" | "pool" | "cliExclude" | "diff" | "setupFiles" | "snapshotEnvironment" | "bail" | "name"> {
+	mode: VitestRunMode;
+	name: ProjectName["label"];
+	color?: ProjectName["color"];
+	base?: string;
+	diff?: string | SerializedDiffOptions;
+	bail?: number;
+	setupFiles: string[];
+	snapshotEnvironment?: string;
+	config?: string;
+	filters?: string[];
+	testNamePattern?: RegExp;
+	related?: string[];
+	coverage: ResolvedCoverageOptions;
+	snapshotOptions: SnapshotStateOptions;
+	browser: ResolvedBrowserOptions;
+	pool: Pool;
+	poolOptions?: ResolvedPoolOptions;
+	reporters: (InlineReporter | ReporterWithOptions)[];
+	defines: Record<string, any>;
+	api: ApiConfig & {
+		token: string;
+	};
+	cliExclude?: string[];
+	project: string[];
+	benchmark?: Required<Omit<BenchmarkUserOptions, "outputFile" | "compare" | "outputJson">> & Pick<BenchmarkUserOptions, "outputFile" | "compare" | "outputJson">;
+	shard?: {
+		index: number;
+		count: number;
+	};
+	cache: {
+		/**
+		* @deprecated
+		*/
+		dir: string;
+	} | false;
+	sequence: {
+		sequencer: TestSequencerConstructor;
+		hooks: SequenceHooks;
+		setupFiles: SequenceSetupFiles;
+		shuffle?: boolean;
+		concurrent?: boolean;
+		seed: number;
+		groupOrder: number;
+	};
+	typecheck: Omit<TypecheckConfig, "enabled"> & {
+		enabled: boolean;
+	};
+	runner?: string;
+	maxWorkers: number;
+}
+type NonProjectOptions = "shard" | "watch" | "run" | "cache" | "update" | "reporters" | "outputFile" | "teardownTimeout" | "silent" | "forceRerunTriggers" | "testNamePattern" | "ui" | "open" | "uiBase" | "snapshotFormat" | "resolveSnapshotPath" | "passWithNoTests" | "onConsoleLog" | "onStackTrace" | "dangerouslyIgnoreUnhandledErrors" | "slowTestThreshold" | "inspect" | "inspectBrk" | "coverage" | "maxWorkers" | "fileParallelism" | "watchTriggerPatterns";
+interface ServerDepsOptions {
 	/**
-	* Register a handler that will be called when the server is closed.
+	* Externalize means that Vite will bpass the package to native Node.
+	*
+	* Externalized dependencies will not be applied Vite's transformers and resolvers.
+	* And does not support HMR on reload.
+	*
+	* Typically, packages under `node_modules` are externalized.
 	*/
-	onClose(fn: () => Awaitable$1<void>): void;
+	external?: (string | RegExp)[];
 	/**
-	* Register a handler that will be called when the tests are rerunning.
+	* Vite will process inlined modules.
+	*
+	* This could be helpful to handle packages that ship `.js` in ESM format (that Node can't handle).
+	*
+	* If `true`, every dependency will be inlined
 	*/
-	onTestsRerun(fn: OnTestsRerunHandler): void;
+	inline?: (string | RegExp)[] | true;
 	/**
-	* Register a handler that will be called when a file is changed.
-	* This callback should return `true` of `false` indicating whether the test file needs to be rerun.
-	* @example
-	* const testsToRun = [resolve('./test.spec.ts')]
-	* vitest.onFilterWatchedSpecification(specification => testsToRun.includes(specification.moduleId))
+	* Try to guess the CJS version of a package when it's invalid ESM
+	* @default false
 	*/
-	onFilterWatchedSpecification(fn: (specification: TestSpecification) => boolean): void;
+	fallbackCJS?: boolean;
+}
+type ProjectConfig = Omit<InlineConfig, NonProjectOptions | "sequencer" | "deps" | "poolOptions"> & {
+	mode?: string;
+	sequencer?: Omit<SequenceOptions, "sequencer" | "seed">;
+	deps?: Omit<DepsOptions, "moduleDirectories">;
+	poolOptions?: {
+		threads?: Pick<NonNullable<PoolOptions["threads"]>, "singleThread" | "isolate">;
+		vmThreads?: Pick<NonNullable<PoolOptions["vmThreads"]>, "singleThread">;
+		forks?: Pick<NonNullable<PoolOptions["forks"]>, "singleFork" | "isolate">;
+	};
+};
+type ResolvedProjectConfig = Omit<ResolvedConfig, Exclude<NonProjectOptions, "coverage" | "watch">>;
+interface UserWorkspaceConfig extends UserConfig$1 {
+	test?: ProjectConfig;
+}
+type UserProjectConfigFn = (env: ConfigEnv) => UserWorkspaceConfig | Promise<UserWorkspaceConfig>;
+type UserProjectConfigExport = UserWorkspaceConfig | Promise<UserWorkspaceConfig> | UserProjectConfigFn;
+type TestProjectInlineConfiguration = (UserWorkspaceConfig & {
 	/**
-	* Check if the project with a given name should be included.
+	* Relative path to the extendable config. All other options will be merged with this config.
+	* If `true`, the project will inherit all options from the root config.
+	* @example '../vite.config.ts'
 	*/
-	matchesProjectFilter(name: string): boolean;
-}
-type OnServerRestartHandler = (reason?: string) => Promise<void> | void;
-type OnTestsRerunHandler = (testFiles: TestSpecification[]) => Promise<void> | void;
+	extends?: string | true;
+});
+type TestProjectConfiguration = string | TestProjectInlineConfiguration | Promise<UserWorkspaceConfig> | UserProjectConfigFn;
 
-export { CoverageMap as C, TestSpecification as K, Logger as L, TestModule as M, TestProject as T, Vitest as V, VitestPackageInstaller as X, getFilePoolName as _, TestCase as a4, TestCollection as a5, BasicReporter as aC, BenchmarkReporter as aD, BenchmarkReportsMap as aE, DefaultReporter as aF, DotReporter as aG, GithubActionsReporter as aH, HangingProcessReporter as aI, JsonReporter as aJ, JUnitReporter as aK, ReportersMap as aL, TapFlatReporter as aM, TapReporter as aN, VerboseBenchmarkReporter as aO, VerboseReporter as aP, BaseReporter as aQ, TestSuite as ad };
-export type { SerializedTestProject as $, ApiConfig as A, BaseCoverageOptions as B, DepsOptimizationOptions as D, ProjectConfig as E, BenchmarkUserOptions as F, BrowserTesterOptions as G, VitestOptions as H, InlineConfig as I, TestSequencer as J, ModuleDiagnostic as N, OnServerRestartHandler as O, Pool as P, OnTestsRerunHandler as Q, ResolvedCoverageOptions as R, SerializedTestSpecification as S, UserWorkspaceConfig as U, WorkspaceProjectConfiguration as W, ProcessPool as Y, WorkspaceSpec as Z, ReportContext as a, HTMLOptions as a0, JsonOptions$1 as a1, JUnitOptions as a2, TaskOptions as a3, TestDiagnostic as a6, TestModuleState as a7, TestResult as a8, TestResultFailed as a9, ReportedHookContext as aA, TestRunEndReason as aB, BenchmarkBuiltinReporters as aR, BuiltinReporterOptions as aS, BuiltinReporters as aT, JsonAssertionResult as aU, JsonTestResult as aV, JsonTestResults as aW, TestResultPassed as aa, TestResultSkipped as ab, TestState as ac, TestSuiteState as ae, TestSequencerConstructor as af, BrowserBuiltinProvider as ag, BrowserCommand as ah, BrowserCommandContext as ai, BrowserInstanceOption as aj, BrowserModuleMocker as ak, BrowserOrchestrator as al, BrowserProvider as am, BrowserProviderInitializationOptions as an, BrowserProviderModule as ao, BrowserProviderOptions as ap, BrowserServerState as aq, BrowserServerStateSession as ar, CDPSession as as, ParentProjectBrowser as at, ProjectBrowser as au, ResolvedBrowserOptions as av, ResolvedProjectConfig as aw, ResolveSnapshotPathHandler as ax, ResolveSnapshotPathHandlerContext as ay, TestRunResult as az, TestProjectConfiguration as b, CoverageV8Options as c, UserProjectConfigFn as d, UserProjectConfigExport as e, TestProjectInlineConfiguration as f, WatcherTriggerPattern as g, CoverageProvider as h, CoverageProviderModule as i, CoverageReporter as j, CoverageProviderName as k, CoverageOptions as l, CoverageIstanbulOptions as m, CustomProviderOptions as n, Reporter as o, BrowserScript as p, BrowserConfigOptions as q, BuiltinEnvironment as r, VitestEnvironment as s, PoolOptions as t, CSSModuleScopeStrategy as u, VitestRunMode as v, TransformModePatterns as w, TypecheckConfig as x, UserConfig as y, ResolvedConfig as z };
+export { TestSuite as B, CoverageMap as C, experimental_getRunnerTask as E, Logger as L, TestProject as T, Vitest as V, GithubActionsReporter as aA, HangingProcessReporter as aB, JsonReporter as aC, JUnitReporter as aD, ReportersMap as aE, TapFlatReporter as aF, TapReporter as aG, VerboseBenchmarkReporter as aH, VerboseReporter as aI, BaseReporter as aJ, BenchmarkReporter as aw, BenchmarkReportsMap as ax, DefaultReporter as ay, DotReporter as az, TestSpecification as k, VitestPackageInstaller as n, TestCase as q, TestCollection as r, TestModule as t };
+export type { BrowserProvider as $, ApiConfig as A, TestSuiteState as D, TestSequencerConstructor as F, BenchmarkUserOptions as G, HTMLOptions as H, InlineConfig as I, JsonOptions as J, BrowserBuiltinProvider as K, ModuleDiagnostic as M, BrowserCommand as N, OnServerRestartHandler as O, Pool as P, BrowserCommandContext as Q, ResolvedCoverageOptions as R, SerializedTestProject as S, UserWorkspaceConfig as U, WatcherTriggerPattern as W, BrowserConfigOptions as X, BrowserInstanceOption as Y, BrowserModuleMocker as Z, BrowserOrchestrator as _, TestProjectConfiguration as a, BrowserProviderOption as a0, BrowserScript as a1, BrowserServerState as a2, BrowserServerStateSession as a3, CDPSession as a4, ParentProjectBrowser as a5, ProjectBrowser as a6, ResolvedBrowserOptions as a7, ToMatchScreenshotComparators as a8, ToMatchScreenshotOptions as a9, BenchmarkBuiltinReporters as aK, BuiltinReporterOptions as aL, BuiltinReporters as aM, JsonAssertionResult as aN, JsonTestResult as aO, JsonTestResults as aP, BuiltinEnvironment as aa, CSSModuleScopeStrategy as ab, DepsOptimizationOptions as ac, EnvironmentOptions as ad, PoolOptions as ae, ProjectConfig as af, ResolvedProjectConfig as ag, ResolveSnapshotPathHandler as ah, ResolveSnapshotPathHandlerContext as ai, TypecheckConfig as aj, VitestEnvironment as ak, BaseCoverageOptions as al, CoverageIstanbulOptions as am, CoverageOptions as an, CoverageProvider as ao, CoverageProviderModule as ap, CoverageReporter as aq, CustomProviderOptions as ar, TestRunResult as as, ReportedHookContext as at, Reporter as au, TestRunEndReason as av, ReportContext as b, CoverageV8Options as c, UserProjectConfigFn as d, UserProjectConfigExport as e, UserConfig as f, TestProjectInlineConfiguration as g, ResolvedConfig as h, VitestRunMode as i, VitestOptions as j, TestSequencer as l, OnTestsRerunHandler as m, JUnitOptions as o, TaskOptions as p, TestDiagnostic as s, TestModuleState as u, TestResult as v, TestResultFailed as w, TestResultPassed as x, TestResultSkipped as y, TestState as z };