@rstest/core 0.0.1

package/dist-types/public.d.ts

@@ -0,0 +1,850 @@
+import type { addSerializer } from '@vitest/snapshot';
+import type { assert as assert_2 } from 'chai';
+import type { Assertion as Assertion_2 } from '@vitest/expect';
+import type { ExpectStatic as ExpectStatic_2 } from '@vitest/expect';
+import type { MatcherState as MatcherState_2 } from '@vitest/expect';
+import type { RsbuildConfig } from '@rsbuild/core';
+import type { SnapshotResult } from '@vitest/snapshot';
+import type { SnapshotState } from '@vitest/snapshot';
+import type { SnapshotSummary } from '@vitest/snapshot';
+import type { Tester } from '@vitest/expect';
+
+export declare const afterAll: Rstest['afterAll'];
+
+declare type AfterAllListener = (ctx: SuiteContext) => MaybePromise<void>;
+
+export declare const afterEach: Rstest['afterEach'];
+
+declare type AfterEachListener = () => MaybePromise<void>;
+
+export declare const assert: Rstest['assert'];
+
+export declare interface Assertion<T = any> extends Assertion_2<T> {
+    matchSnapshot: SnapshotMatcher<T>;
+    toMatchSnapshot: SnapshotMatcher<T>;
+    toMatchInlineSnapshot: InlineSnapshotMatcher<T>;
+    /**
+     * Checks that an error thrown by a function matches a previously recorded snapshot.
+     *
+     * @param message - Optional custom error message.
+     *
+     * @example
+     * expect(functionWithError).toThrowErrorMatchingSnapshot();
+     */
+    toThrowErrorMatchingSnapshot: (message?: string) => void;
+    /**
+     * Checks that an error thrown by a function matches an inline snapshot within the test file.
+     * Useful for keeping snapshots close to the test code.
+     *
+     * @param snapshot - Optional inline snapshot string to match.
+     * @param message - Optional custom error message.
+     *
+     * @example
+     * const throwError = () => { throw new Error('Error occurred') };
+     * expect(throwError).toThrowErrorMatchingInlineSnapshot(`"Error occurred"`);
+     */
+    toThrowErrorMatchingInlineSnapshot: (snapshot?: string, message?: string) => void;
+    /**
+     * Compares the received value to a snapshot saved in a specified file.
+     * Useful for cases where snapshot content is large or needs to be shared across tests.
+     *
+     * @param filepath - Path to the snapshot file.
+     * @param message - Optional custom error message.
+     *
+     * @example
+     * await expect(largeData).toMatchFileSnapshot('path/to/snapshot.json');
+     */
+    toMatchFileSnapshot: (filepath: string, message?: string) => Promise<void>;
+    /**
+     * Verifies that a promise resolves.
+     *
+     * @example
+     * await expect(someAsyncFunc).resolves.toBe(42);
+     */
+    resolves: PromisifyAssertion<T>;
+    /**
+     * Verifies that a promise rejects.
+     *
+     * @example
+     * await expect(someAsyncFunc).rejects.toThrow('error');
+     */
+    rejects: PromisifyAssertion<T>;
+}
+
+export declare const beforeAll: Rstest['beforeAll'];
+
+declare type BeforeAllListener = (ctx: SuiteContext) => MaybePromise<void | AfterAllListener>;
+
+export declare const beforeEach: Rstest['beforeEach'];
+
+declare type BeforeEachListener = () => MaybePromise<void | AfterEachListener>;
+
+declare type BuiltInReporterNames = keyof typeof reportersMap;
+
+declare type BuiltinReporterOptions = {
+    default: DefaultReporterOptions;
+};
+
+declare interface DecodedSourceMap extends SourceMapV3 {
+    mappings: SourceMapSegment[][];
+}
+
+declare type DecodedSourceMapXInput = DecodedSourceMap & XInput;
+
+declare class DefaultReporter implements Reporter {
+    private rootPath;
+    private config;
+    private options;
+    private statusRenderer;
+    constructor({ rootPath, options, config, }: {
+        rootPath: string;
+        config: NormalizedConfig;
+        options: DefaultReporterOptions;
+    });
+    onTestFileStart(test: TestFileInfo): void;
+    onTestFileResult(test: TestFileResult): void;
+    onTestCaseResult(_result: TestResult): void;
+    onUserConsoleLog(log: UserConsoleLog): void;
+    onExit(): Promise<void>;
+    onTestRunEnd({ results, testResults, duration, getSourcemap, snapshotSummary, }: {
+        results: TestFileResult[];
+        testResults: TestResult[];
+        duration: Duration;
+        snapshotSummary: SnapshotSummary;
+        getSourcemap: GetSourcemap;
+    }): Promise<void>;
+}
+
+declare type DefaultReporterOptions = {
+    /**
+     * prints out summary of all tests
+     * @default true
+     */
+    summary?: boolean;
+};
+
+/**
+ * This function helps you to autocomplete configuration types.
+ * It accepts a Rsbuild config object, or a function that returns a config.
+ */
+export declare function defineConfig(config: RstestConfig): RstestConfig;
+
+export declare function defineConfig(config: RstestConfigSyncFn): RstestConfigSyncFn;
+
+export declare function defineConfig(config: RstestConfigAsyncFn): RstestConfigAsyncFn;
+
+export declare function defineConfig(config: RstestConfigExport): RstestConfigExport;
+
+export declare const describe: Rstest['describe'];
+
+declare type DescribeAPI = DescribeFn & {
+    each: DescribeEachFn;
+    for: DescribeForFn;
+    only: DescribeAPI;
+    skip: DescribeAPI;
+    runIf: (condition: boolean) => DescribeAPI;
+    skipIf: (condition: boolean) => DescribeAPI;
+    todo: DescribeAPI;
+    concurrent: DescribeAPI;
+    sequential: DescribeAPI;
+};
+
+declare interface DescribeEachFn {
+    <T extends Record<string, unknown>>(cases: ReadonlyArray<T>): (description: string, fn?: (param: T) => MaybePromise<void>) => void;
+    <T extends readonly [unknown, ...Array<unknown>]>(cases: ReadonlyArray<T>): (description: string, fn: (...args: [...T]) => MaybePromise<void>) => void;
+}
+
+declare type DescribeFn = (description: string, fn?: () => void) => void;
+
+declare type DescribeForFn = <T>(cases: ReadonlyArray<T>) => (description: string, fn?: (param: T) => MaybePromise<void>) => void;
+
+declare type Duration = {
+    totalTime: number;
+    buildTime: number;
+    testTime: number;
+};
+
+declare interface EncodedSourceMap extends SourceMapV3 {
+    mappings: string;
+}
+
+declare type EncodedSourceMapXInput = EncodedSourceMap & XInput;
+
+export declare const expect: Rstest['expect'];
+
+declare interface ExpectPollOptions {
+    /**
+     * @default 50
+     */
+    interval?: number;
+    /**
+     * @default 1000
+     */
+    timeout?: number;
+    message?: string;
+}
+
+declare interface ExpectStatic extends ExpectStatic_2 {
+    <T>(actual: T, message?: string): Assertion<T>;
+    unreachable: (message?: string) => never;
+    soft: <T>(actual: T, message?: string) => Assertion<T>;
+    poll: <T>(actual: () => T, options?: ExpectPollOptions) => Omit<PromisifyAssertion<Awaited<T>>, 'rejects' | 'resolves' | 'toThrow' | 'toThrowError' | 'throw' | 'throws' | 'matchSnapshot' | 'toMatchSnapshot' | 'toMatchInlineSnapshot' | 'toThrowErrorMatchingSnapshot' | 'toThrowErrorMatchingInlineSnapshot'>;
+    addEqualityTesters: (testers: Array<Tester>) => void;
+    assertions: (expected: number) => void;
+    hasAssertions: () => void;
+    addSnapshotSerializer: typeof addSerializer;
+    getState: () => MatcherState;
+    setState: (state: Partial<MatcherState>) => void;
+}
+
+declare type Fixture<T, K extends keyof T, ExtraContext = object> = ((...args: any) => any) extends T[K] ? T[K] extends any ? FixtureFn<T, K, Omit<ExtraContext, Exclude<keyof T, K>>> : never : T[K] | (T[K] extends any ? FixtureFn<T, K, Omit<ExtraContext, Exclude<keyof T, K>>> : never);
+
+declare type FixtureFn<T, K extends keyof T, ExtraContext> = (context: Omit<T, K> & ExtraContext, use: Use<T[K]>) => Promise<void>;
+
+declare interface FixtureOptions {
+    /**
+     * Whether to automatically set up current fixture, even though it's not being used in tests.
+     */
+    auto?: boolean;
+}
+
+declare type Fixtures<T extends Record<string, any> = object, ExtraContext = object> = {
+    [K in keyof T]: Fixture<T, K, ExtraContext & TestContext> | [Fixture<T, K, ExtraContext & TestContext>, FixtureOptions?];
+};
+
+declare type FormattedError = {
+    message: string;
+    name?: string;
+    stack?: string;
+    diff?: string;
+};
+
+declare type FunctionLike = (...args: any) => any;
+
+declare type GeneratedColumn = number;
+
+declare type GetSourcemap = (sourcePath: string) => SourceMapInput | null;
+
+declare interface InlineSnapshotMatcher<T> {
+    <U extends {
+        [P in keyof T]: any;
+    }>(properties: Partial<U>, snapshot?: string, message?: string): void;
+    (message?: string): void;
+}
+
+export declare const it: Rstest['it'];
+
+declare interface MatcherState extends MatcherState_2 {
+    environment: string;
+    snapshotState: SnapshotState;
+}
+
+declare type MaybePromise<T> = T | Promise<T>;
+
+declare interface Mock<T extends FunctionLike = FunctionLike> extends MockInstance<T> {
+    new (...args: Parameters<T>): ReturnType<T>;
+    (...args: Parameters<T>): ReturnType<T>;
+}
+
+declare type MockContext<T extends FunctionLike = FunctionLike> = {
+    /**
+     * List of the call arguments of all calls that have been made to the mock.
+     */
+    calls: Array<Parameters<T>>;
+    /**
+     * List of all the object instances that have been instantiated from the mock.
+     */
+    instances: Array<ReturnType<T>>;
+    /**
+     * List of all the function contexts that have been applied to calls to the mock.
+     */
+    contexts: Array<ThisParameterType<T>>;
+    /**
+     * The order of mock's execution.
+     * This returns an array of numbers which are shared between all defined mocks.
+     * The index is starting with `1`.
+     */
+    invocationCallOrder: Array<number>;
+    /**
+     * List of the call arguments of the last call that was made to the mock.
+     * If the function was not called, it will return `undefined`.
+     */
+    lastCall: Parameters<T> | undefined;
+    /**
+     * List of the results of all calls that have been made to the mock.
+     */
+    results: Array<MockResult<ReturnType<T>>>;
+    /**
+     * List of the results of all values that were `resolved` or `rejected` from the function.
+     */
+    settledResults: MockSettledResult<Awaited<ReturnType<T>>>[];
+};
+
+declare type MockFn = <T extends FunctionLike = FunctionLike>(fn?: T) => Mock<T>;
+
+declare interface MockInstance<T extends FunctionLike = FunctionLike> {
+    _isMockFunction: true;
+    /**
+     * Returns the mock name string set by calling `.mockName()`
+     */
+    getMockName(): string;
+    /**
+     * Sets the mock name for this mock.
+     */
+    mockName(name: string): this;
+    mock: MockContext<T>;
+    /**
+     * Clears all information about every call.
+     */
+    mockClear(): this;
+    /**
+     * Does what `mockClear` does and resets inner implementation to the original function.
+     */
+    mockReset(): this;
+    /**
+     * Does what `mockReset` does and restores original descriptors of spied-on objects.
+     */
+    mockRestore(): void;
+    /**
+     * Returns current mock implementation if there is one.
+     */
+    getMockImplementation(): T | undefined;
+    /**
+     * Accepts a function that should be used as the implementation of the mock.
+     */
+    mockImplementation(fn: T): this;
+    /**
+     * Accepts a function that will be used as an implementation of the mock for one call to the mocked function.
+     */
+    mockImplementationOnce(fn: T): this;
+    /**
+     * Accepts a function which should be temporarily used as the implementation of the mock while the callback is being executed.
+     */
+    withImplementation<T2>(fn: T, callback: () => T2): T2 extends Promise<unknown> ? Promise<void> : void;
+    /**
+     * Return the `this` context from the method without invoking the actual implementation.
+     */
+    mockReturnThis(): this;
+    /**
+     * Accepts a value that will be returned whenever the mock function is called.
+     */
+    mockReturnValue(value: ReturnType<T>): this;
+    /**
+     * Accepts a value that will be returned for one call to the mock function.
+     */
+    mockReturnValueOnce(value: ReturnType<T>): this;
+    /**
+     * Accepts a value that will be resolved when the async function is called.
+     */
+    mockResolvedValue(value: Awaited<ReturnType<T>>): this;
+    /**
+     * Accepts a value that will be resolved during the next function call.
+     */
+    mockResolvedValueOnce(value: Awaited<ReturnType<T>>): this;
+    /**
+     * Accepts an error that will be rejected when async function is called.
+     */
+    mockRejectedValue(error: unknown): this;
+    /**
+     * Accepts a value that will be rejected during the next function call.
+     */
+    mockRejectedValueOnce(error: unknown): this;
+}
+
+declare type MockResult<T> = MockResultReturn<T> | MockResultThrow | MockResultIncomplete;
+
+declare interface MockResultIncomplete {
+    type: 'incomplete';
+    value: undefined;
+}
+
+declare interface MockResultReturn<T> {
+    type: 'return';
+    /**
+     * The value that was returned from the function. If function returned a Promise, then this will be a resolved value.
+     */
+    value: T;
+}
+
+declare interface MockResultThrow {
+    type: 'throw';
+    /**
+     * An error that was thrown during function execution.
+     */
+    value: any;
+}
+
+declare type MockSettledResult<T> = MockSettledResultFulfilled<T> | MockSettledResultRejected;
+
+declare interface MockSettledResultFulfilled<T> {
+    type: 'fulfilled';
+    value: T;
+}
+
+declare interface MockSettledResultFulfilled<T> {
+    type: 'fulfilled';
+    value: T;
+}
+
+declare interface MockSettledResultRejected {
+    type: 'rejected';
+    value: any;
+}
+
+declare interface MockSettledResultRejected {
+    type: 'rejected';
+    value: any;
+}
+
+declare type NamesIndex = number;
+
+declare type NormalizedConfig = Required<Omit<RstestConfig, OptionalKeys | 'pool'>> & {
+    [key in OptionalKeys]?: RstestConfig[key];
+} & {
+    pool: RstestPoolOptions;
+};
+
+declare type OptionalKeys = 'setupFiles' | 'testNamePattern' | 'plugins' | 'source' | 'resolve' | 'output' | 'tools' | 'onConsoleLog';
+
+declare type Promisify<O> = {
+    [K in keyof O]: O[K] extends (...args: infer A) => infer R ? Promisify<O[K]> & ((...args: A) => Promise<R>) : O[K];
+};
+
+declare type PromisifyAssertion<T> = Promisify<Assertion<T>>;
+
+declare interface Reporter {
+    /**
+     * Called before test file run.
+     */
+    onTestFileStart?: (test: TestFileInfo) => void;
+    /**
+     * Called when the test file has finished running.
+     */
+    onTestFileResult?: (test: TestFileResult) => void;
+    /**
+     * Called when the test has finished running or was just skipped.
+     */
+    onTestCaseResult?: (result: TestResult) => void;
+    /**
+     * Called after all tests have finished running.
+     */
+    onTestRunEnd?: ({ results, testResults, duration, getSourcemap, snapshotSummary, }: {
+        results: TestFileResult[];
+        testResults: TestResult[];
+        duration: Duration;
+        getSourcemap: GetSourcemap;
+        snapshotSummary: SnapshotSummary;
+    }) => MaybePromise<void>;
+    /**
+     * Called when console log is calling.
+     */
+    onUserConsoleLog?: (log: UserConsoleLog) => void;
+    /**
+     * Called when rstest exit abnormally
+     */
+    onExit?: () => void;
+}
+
+declare const reportersMap: {
+    default: typeof DefaultReporter;
+};
+
+declare type ReporterWithOptions<Name extends BuiltInReporterNames = BuiltInReporterNames> = Name extends keyof BuiltinReporterOptions ? [Name, Partial<BuiltinReporterOptions[Name]>] : [Name, Record<string, unknown>];
+
+declare type Rstest = RunnerAPI & {
+    expect: RstestExpect;
+    assert: typeof assert_2;
+    rstest: RstestUtilities;
+};
+
+export declare const rstest: RstestUtilities;
+
+export declare interface RstestConfig {
+    /**
+     * Project root
+     *
+     * @default process.cwd()
+     */
+    root?: string;
+    /**
+     * Project name
+     *
+     * @default rstest
+     */
+    name?: string;
+    /**
+     * A list of glob patterns that match your test files.
+     *
+     * @default ['**\/*.{test,spec}.?(c|m)[jt]s?(x)']
+     */
+    include?: string[];
+    /**
+     * A list of glob patterns that should be excluded from your test files.
+     *
+     * @default ['**\/node_modules/**', '**\/dist/**']
+     */
+    exclude?: string[];
+    /**
+     * A list of glob patterns that match your in-source test files
+     *
+     * @default []
+     */
+    includeSource?: string[];
+    /**
+     * Path to setup files. They will be run before each test file.
+     */
+    setupFiles?: string[] | string;
+    /**
+     * Retry the test specific number of times if it fails.
+     * @default 0
+     */
+    retry?: number;
+    /**
+     * Allows the test suite to pass when no files are found.
+     *
+     * @default false
+     */
+    passWithNoTests?: boolean;
+    /**
+     * Pool used to run tests in.
+     */
+    pool?: RstestPoolType | RstestPoolOptions;
+    /**
+     * Run tests in an isolated environment
+     *
+     * @default true
+     */
+    isolate?: boolean;
+    /**
+     * Provide global APIs
+     *
+     * @default false
+     */
+    globals?: boolean;
+    /**
+     * The environment that will be used for testing
+     *
+     * TODO: support more test environments
+     * @default 'node'
+     */
+    testEnvironment?: 'node';
+    /**
+     * print console traces when calling any console method.
+     *
+     * @default false
+     */
+    printConsoleTrace?: boolean;
+    /**
+     * Disable console intercept. `onConsoleLog` & `printConsoleTrace` configuration will not take effect.
+     *
+     * @default false
+     */
+    disableConsoleIntercept?: boolean;
+    /**
+     * Update snapshot files. Will update all changed snapshots and delete obsolete ones.
+     *
+     * @default false
+     */
+    update?: boolean;
+    /**
+     * Custom reporter for output.
+     * @default ['default']
+     */
+    reporters?: Reporter | BuiltInReporterNames | (Reporter | BuiltInReporterNames | [BuiltInReporterNames] | ReporterWithOptions)[];
+    /**
+     * Run only tests with a name that matches the regex.
+     */
+    testNamePattern?: string | RegExp;
+    /**
+     * Timeout of a test in milliseconds.
+     * @default 5000
+     */
+    testTimeout?: number;
+    /**
+     * Automatically clear mock calls, instances, contexts and results before every test.
+     * @default false
+     */
+    clearMocks?: boolean;
+    /**
+     * Automatically reset mock state before every test.
+     * @default false
+     */
+    resetMocks?: boolean;
+    /**
+     * Automatically restore mock state and implementation before every test.
+     * @default false
+     */
+    restoreMocks?: boolean;
+    /**
+     * The number of milliseconds after which a test or suite is considered slow and reported as such in the results.
+     * @default 300
+     */
+    slowTestThreshold?: number;
+    /**
+     * Restores all global variables that were changed with `rstest.stubGlobal` before every test.
+     * @default false
+     */
+    unstubGlobals?: boolean;
+    /**
+     * Restores all `process.env` values that were changed with `rstest.stubEnv` before every test.
+     * @default false
+     */
+    unstubEnvs?: boolean;
+    /**
+     * Maximum number of concurrent tests
+     * @default 5
+     */
+    maxConcurrency?: number;
+    /**
+     * Custom handler for console log in tests
+     */
+    onConsoleLog?: (content: string) => boolean | void;
+    plugins?: RsbuildConfig['plugins'];
+    source?: Pick<NonNullable<RsbuildConfig['source']>, 'define' | 'tsconfigPath' | 'decorators' | 'include' | 'exclude'>;
+    output?: Pick<NonNullable<RsbuildConfig['output']>, 'cssModules'>;
+    resolve?: RsbuildConfig['resolve'];
+    tools?: Pick<NonNullable<RsbuildConfig['tools']>, 'rspack' | 'swc' | 'bundlerChain'>;
+}
+
+export declare type RstestConfigAsyncFn = () => Promise<RstestConfig>;
+
+export declare type RstestConfigExport = RstestConfig | RstestConfigSyncFn | RstestConfigAsyncFn;
+
+export declare type RstestConfigSyncFn = () => RstestConfig;
+
+declare type RstestExpect = ExpectStatic;
+
+declare type RstestPoolOptions = {
+    /** Pool used to run tests in. */
+    type: RstestPoolType;
+    /** Maximum number or percentage of workers to run tests in. */
+    maxWorkers?: number | string;
+    /** Minimum number or percentage of workers to run tests in. */
+    minWorkers?: number | string;
+    /** Pass additional arguments to node process in the child processes. */
+    execArgv?: string[];
+};
+
+declare type RstestPoolType = 'forks';
+
+declare type RstestUtilities = {
+    /**
+     * Creates a spy on a function.
+     */
+    fn: MockFn;
+    /**
+     * Creates a spy on a method of an object
+     */
+    spyOn: <T extends Record<string, any>, K extends keyof T>(obj: T, methodName: K, accessType?: 'get' | 'set') => MockInstance<T[K]>;
+    /**
+     * Determines if the given function is a mocked function.
+     */
+    isMockFunction: (fn: any) => fn is MockInstance;
+    /**
+     * Calls `.mockClear()` on all spies.
+     */
+    clearAllMocks: () => RstestUtilities;
+    /**
+     * Calls `.mockReset()` on all spies.
+     */
+    resetAllMocks: () => RstestUtilities;
+    /**
+     * Calls `.mockRestore()` on all spies.
+     */
+    restoreAllMocks: () => RstestUtilities;
+    /**
+     * @todo
+     * Mock a module
+     */
+    mock: <T = unknown>(moduleName: string, moduleFactory?: () => T) => void;
+    /**
+     * @todo
+     * Mock a module, not hoisted.
+     */
+    doMock: <T = unknown>(moduleName: string, moduleFactory?: () => T) => void;
+    /**
+     * @todo
+     * Removes module from the mocked registry.
+     */
+    unMock: (path: string) => void;
+    /**
+     * @todo
+     * Removes module from the mocked registry, not hoisted.
+     */
+    doUnMock: (path: string) => void;
+    /**
+     * @todo
+     * Imports a module with all of its properties (including nested properties) mocked.
+     */
+    importMock: <T = Record<string, unknown>>(path: string) => Promise<T>;
+    /**
+     * @todo
+     * Returns the actual module instead of a mock, bypassing all checks on whether the module should receive a mock implementation or not.
+     */
+    importActual: <T = Record<string, unknown>>(path: string) => Promise<T>;
+    /**
+     * @todo
+     * Resets modules registry by clearing the cache of all modules.
+     */
+    resetModules: () => RstestUtilities;
+    /**
+     * Changes the value of environmental variable on `process.env`.
+     */
+    stubEnv: (name: string, value: string | undefined) => RstestUtilities;
+    /**
+     * Restores all `process.env` values that were changed with `rstest.stubEnv`.
+     */
+    unstubAllEnvs: () => RstestUtilities;
+    /**
+     * Changes the value of global variable.
+     */
+    stubGlobal: (name: string | number | symbol, value: unknown) => RstestUtilities;
+    /**
+     * Restores all global variables that were changed with `rstest.stubGlobal`.
+     */
+    unstubAllGlobals: () => RstestUtilities;
+};
+
+declare type RunnerAPI = {
+    describe: DescribeAPI;
+    it: TestAPIs;
+    test: TestAPIs;
+    beforeAll: (fn: BeforeAllListener, timeout?: number) => MaybePromise<void>;
+    afterAll: (fn: AfterAllListener, timeout?: number) => MaybePromise<void>;
+    beforeEach: (fn: BeforeEachListener, timeout?: number) => MaybePromise<void>;
+    afterEach: (fn: AfterEachListener, timeout?: number) => MaybePromise<void>;
+};
+
+declare interface SnapshotMatcher<T> {
+    <U extends {
+        [P in keyof T]: any;
+    }>(snapshot: Partial<U>, message?: string): void;
+    (message?: string): void;
+}
+
+declare type SourceColumn = number;
+
+declare type SourceLine = number;
+
+declare abstract class SourceMap {
+    version: SourceMapV3['version'];
+    file: SourceMapV3['file'];
+    names: SourceMapV3['names'];
+    sourceRoot: SourceMapV3['sourceRoot'];
+    sources: SourceMapV3['sources'];
+    sourcesContent: SourceMapV3['sourcesContent'];
+    resolvedSources: SourceMapV3['sources'];
+    ignoreList: SourceMapV3['ignoreList'];
+}
+
+declare type SourceMapInput = string | EncodedSourceMapXInput | DecodedSourceMapXInput | TraceMap;
+
+declare type SourceMapSegment = [GeneratedColumn] | [GeneratedColumn, SourcesIndex, SourceLine, SourceColumn] | [GeneratedColumn, SourcesIndex, SourceLine, SourceColumn, NamesIndex];
+
+declare interface SourceMapV3 {
+    file?: string | null;
+    names: string[];
+    sourceRoot?: string;
+    sources: (string | null)[];
+    sourcesContent?: (string | null)[];
+    version: 3;
+    ignoreList?: number[];
+}
+
+declare type SourcesIndex = number;
+
+declare type SuiteContext = {
+    filepath: TestPath;
+};
+
+export declare const test: Rstest['test'];
+
+declare type TestAPI<ExtraContext = object> = TestFn<ExtraContext> & {
+    each: TestEachFn;
+    for: TestForFn<ExtraContext>;
+    fails: TestAPI<ExtraContext>;
+    concurrent: TestAPI<ExtraContext>;
+    sequential: TestAPI<ExtraContext>;
+    only: TestAPI<ExtraContext>;
+    skip: TestAPI<ExtraContext>;
+    todo: TestAPI<ExtraContext>;
+    runIf: (condition: boolean) => TestAPI<ExtraContext>;
+    skipIf: (condition: boolean) => TestAPI<ExtraContext>;
+};
+
+declare type TestAPIs<ExtraContext = object> = TestAPI<ExtraContext> & {
+    extend: <T extends Record<string, any> = object>(fixtures: Fixtures<T, ExtraContext>) => TestAPIs<{
+        [K in keyof T | keyof ExtraContext]: K extends keyof T ? T[K] : K extends keyof ExtraContext ? ExtraContext[K] : never;
+    }>;
+};
+
+declare type TestCallbackFn<ExtraContext = object> = (context: TestContext & ExtraContext) => MaybePromise<void>;
+
+declare type TestContext = {
+    expect: RstestExpect;
+};
+
+declare interface TestEachFn {
+    <T extends Record<string, unknown>>(cases: ReadonlyArray<T>): (description: string, fn?: (param: T) => MaybePromise<void>, timeout?: number) => void;
+    <T extends readonly [unknown, ...Array<unknown>]>(cases: ReadonlyArray<T>): (description: string, fn: (...args: [...T]) => MaybePromise<void>, timeout?: number) => void;
+}
+
+declare type TestFileInfo = {
+    testPath: TestPath;
+};
+
+declare type TestFileResult = TestResult & {
+    results: TestResult[];
+    snapshotResult?: SnapshotResult;
+};
+
+declare type TestFn<ExtraContext = object> = (description: string, fn?: TestCallbackFn<ExtraContext>, timeout?: number) => void;
+
+declare type TestForFn<ExtraContext = object> = <T>(cases: ReadonlyArray<T>) => (description: string, fn?: (param: T, context: TestContext & ExtraContext) => MaybePromise<void>, timeout?: number) => void;
+
+/** The test file original path */
+declare type TestPath = string;
+
+declare type TestResult = {
+    status: TestResultStatus;
+    name: string;
+    testPath: TestPath;
+    parentNames?: string[];
+    duration?: number;
+    errors?: FormattedError[];
+};
+
+declare type TestResultStatus = 'skip' | 'pass' | 'fail' | 'todo';
+
+declare class TraceMap implements SourceMap {
+    version: SourceMapV3['version'];
+    file: SourceMapV3['file'];
+    names: SourceMapV3['names'];
+    sourceRoot: SourceMapV3['sourceRoot'];
+    sources: SourceMapV3['sources'];
+    sourcesContent: SourceMapV3['sourcesContent'];
+    ignoreList: SourceMapV3['ignoreList'];
+    resolvedSources: string[];
+    private _encoded;
+    private _decoded;
+    private _decodedMemo;
+    private _bySources;
+    private _bySourceMemos;
+    constructor(map: SourceMapInput, mapUrl?: string | null);
+}
+
+declare type Use<T> = (value: T) => Promise<void>;
+
+declare interface UserConsoleLog {
+    content: string;
+    name: string;
+    trace?: string;
+    testPath: TestPath;
+    type: 'stdout' | 'stderr';
+}
+
+declare type XInput = {
+    x_google_ignoreList?: SourceMapV3['ignoreList'];
+};
+
+export { }