@jest/types

  • Version 28.1.3
  • Published
  • 31.9 kB
  • 6 dependencies
  • MIT license

Install

npm i @jest/types
yarn add @jest/types
pnpm add @jest/types

Overview

This package contains shared types of Jest's packages.

Index

Namespaces

namespace Circus

namespace Circus {}

    interface EventHandler

    interface EventHandler {}

      call signature

      (event: AsyncEvent, state: State): void | Promise<void>;

        call signature

        (event: SyncEvent, state: State): void;

          type AsyncEvent

          type AsyncEvent =
          | {
          name: 'setup';
          testNamePattern?: string;
          runtimeGlobals: JestGlobals;
          parentProcess: Process;
          }
          | {
          name: 'include_test_location_in_result';
          }
          | {
          name: 'hook_start';
          hook: Hook;
          }
          | {
          name: 'hook_success';
          describeBlock?: DescribeBlock;
          test?: TestEntry;
          hook: Hook;
          }
          | {
          name: 'hook_failure';
          error: string | Exception;
          describeBlock?: DescribeBlock;
          test?: TestEntry;
          hook: Hook;
          }
          | {
          name: 'test_fn_start';
          test: TestEntry;
          }
          | {
          name: 'test_fn_success';
          test: TestEntry;
          }
          | {
          name: 'test_fn_failure';
          error: Exception;
          test: TestEntry;
          }
          | {
          name: 'test_retry';
          test: TestEntry;
          }
          | {
          name: 'test_start';
          test: TestEntry;
          }
          | {
          name: 'test_skip';
          test: TestEntry;
          }
          | {
          name: 'test_todo';
          test: TestEntry;
          }
          | {
          name: 'test_done';
          test: TestEntry;
          }
          | {
          name: 'run_describe_start';
          describeBlock: DescribeBlock;
          }
          | {
          name: 'run_describe_finish';
          describeBlock: DescribeBlock;
          }
          | {
          name: 'run_start';
          }
          | {
          name: 'run_finish';
          }
          | {
          name: 'teardown';
          };

            type AsyncFn

            type AsyncFn = TestFn_2 | HookFn_2;

              type BlockFn

              type BlockFn_2 = Global.BlockFn;

                type BlockMode

                type BlockMode = void | 'skip' | 'only' | 'todo';

                  type BlockName

                  type BlockName_2 = Global.BlockName;

                    type BlockNameLike

                    type BlockNameLike_2 = Global.BlockNameLike;

                      type ConcurrentTestFn

                      type ConcurrentTestFn_2 = Global.ConcurrentTestFn;

                        type DescribeBlock

                        type DescribeBlock = {
                        type: 'describeBlock';
                        children: Array<DescribeBlock | TestEntry>;
                        hooks: Array<Hook>;
                        mode: BlockMode;
                        name: BlockName_2;
                        parent?: DescribeBlock;
                        /** @deprecated Please get from `children` array instead */
                        tests: Array<TestEntry>;
                        };

                          type DoneFn

                          type DoneFn = Global.DoneFn;

                            type Event

                            type Event_2 = SyncEvent | AsyncEvent;

                              type Exception

                              type Exception = any;

                                type FormattedError

                                type FormattedError = string;

                                  type GlobalErrorHandlers

                                  type GlobalErrorHandlers = {
                                  uncaughtException: Array<(exception: Exception) => void>;
                                  unhandledRejection: Array<
                                  (exception: Exception, promise: Promise<unknown>) => void
                                  >;
                                  };

                                    type Hook

                                    type Hook = {
                                    asyncError: Error;
                                    fn: HookFn_2;
                                    type: HookType;
                                    parent: DescribeBlock;
                                    seenDone: boolean;
                                    timeout: number | undefined | null;
                                    };

                                      type HookFn

                                      type HookFn_2 = Global.HookFn;

                                        type HookType

                                        type HookType = SharedHookType | 'afterEach' | 'beforeEach';

                                          type MatcherResults

                                          type MatcherResults = {
                                          actual: unknown;
                                          expected: unknown;
                                          name: string;
                                          pass: boolean;
                                          };

                                            type RunResult

                                            type RunResult = {
                                            unhandledErrors: Array<FormattedError>;
                                            testResults: TestResults;
                                            };

                                              type SharedHookType

                                              type SharedHookType = 'afterAll' | 'beforeAll';

                                                type State

                                                type State = {
                                                currentDescribeBlock: DescribeBlock;
                                                currentlyRunningTest?: TestEntry | null;
                                                expand?: boolean;
                                                hasFocusedTests: boolean;
                                                hasStarted: boolean;
                                                originalGlobalErrorHandlers?: GlobalErrorHandlers;
                                                parentProcess: Process | null;
                                                rootDescribeBlock: DescribeBlock;
                                                testNamePattern?: RegExp | null;
                                                testTimeout: number;
                                                unhandledErrors: Array<Exception>;
                                                includeTestLocationInResult: boolean;
                                                maxConcurrency: number;
                                                };

                                                  type SyncEvent

                                                  type SyncEvent =
                                                  | {
                                                  asyncError: Error;
                                                  mode: BlockMode;
                                                  name: 'start_describe_definition';
                                                  blockName: BlockName_2;
                                                  }
                                                  | {
                                                  mode: BlockMode;
                                                  name: 'finish_describe_definition';
                                                  blockName: BlockName_2;
                                                  }
                                                  | {
                                                  asyncError: Error;
                                                  name: 'add_hook';
                                                  hookType: HookType;
                                                  fn: HookFn_2;
                                                  timeout: number | undefined;
                                                  }
                                                  | {
                                                  asyncError: Error;
                                                  name: 'add_test';
                                                  testName: TestName_2;
                                                  fn: TestFn_2;
                                                  mode?: TestMode;
                                                  concurrent: boolean;
                                                  timeout: number | undefined;
                                                  failing: boolean;
                                                  }
                                                  | {
                                                  name: 'error';
                                                  error: Exception;
                                                  };

                                                    type TestContext

                                                    type TestContext_2 = Global.TestContext;

                                                      type TestEntry

                                                      type TestEntry = {
                                                      type: 'test';
                                                      asyncError: Exception;
                                                      errors: Array<TestError>;
                                                      retryReasons: Array<TestError>;
                                                      fn: TestFn_2;
                                                      invocations: number;
                                                      mode: TestMode;
                                                      concurrent: boolean;
                                                      name: TestName_2;
                                                      parent: DescribeBlock;
                                                      startedAt?: number | null;
                                                      duration?: number | null;
                                                      seenDone: boolean;
                                                      status?: TestStatus | null;
                                                      timeout?: number;
                                                      failing: boolean;
                                                      };

                                                        type TestError

                                                        type TestError = Exception | [Exception | undefined, Exception];

                                                          type TestFn

                                                          type TestFn_2 = Global.TestFn;

                                                            type TestMode

                                                            type TestMode = BlockMode;

                                                              type TestName

                                                              type TestName_2 = Global.TestName;

                                                                type TestNameLike

                                                                type TestNameLike_2 = Global.TestNameLike;

                                                                  type TestResult

                                                                  type TestResult_2 = {
                                                                  duration?: number | null;
                                                                  errors: Array<FormattedError>;
                                                                  errorsDetailed: Array<MatcherResults | unknown>;
                                                                  invocations: number;
                                                                  status: TestStatus;
                                                                  location?: {
                                                                  column: number;
                                                                  line: number;
                                                                  } | null;
                                                                  retryReasons: Array<FormattedError>;
                                                                  testPath: Array<TestName_2 | BlockName_2>;
                                                                  };

                                                                    type TestResults

                                                                    type TestResults = Array<TestResult_2>;

                                                                      type TestStatus

                                                                      type TestStatus = 'skip' | 'done' | 'todo';

                                                                        namespace Config

                                                                        namespace Config {}

                                                                          interface ConfigGlobals

                                                                          interface ConfigGlobals {}

                                                                            index signature

                                                                            [K: string]: unknown;

                                                                              type Argv

                                                                              type Argv = Arguments<
                                                                              Partial<{
                                                                              all: boolean;
                                                                              automock: boolean;
                                                                              bail: boolean | number;
                                                                              cache: boolean;
                                                                              cacheDirectory: string;
                                                                              changedFilesWithAncestor: boolean;
                                                                              changedSince: string;
                                                                              ci: boolean;
                                                                              clearCache: boolean;
                                                                              clearMocks: boolean;
                                                                              collectCoverage: boolean;
                                                                              collectCoverageFrom: string;
                                                                              collectCoverageOnlyFrom: Array<string>;
                                                                              color: boolean;
                                                                              colors: boolean;
                                                                              config: string;
                                                                              coverage: boolean;
                                                                              coverageDirectory: string;
                                                                              coveragePathIgnorePatterns: Array<string>;
                                                                              coverageReporters: Array<string>;
                                                                              coverageThreshold: string;
                                                                              debug: boolean;
                                                                              env: string;
                                                                              expand: boolean;
                                                                              findRelatedTests: boolean;
                                                                              forceExit: boolean;
                                                                              globals: string;
                                                                              globalSetup: string | null | undefined;
                                                                              globalTeardown: string | null | undefined;
                                                                              haste: string;
                                                                              ignoreProjects: Array<string>;
                                                                              init: boolean;
                                                                              injectGlobals: boolean;
                                                                              json: boolean;
                                                                              lastCommit: boolean;
                                                                              logHeapUsage: boolean;
                                                                              maxWorkers: number | string;
                                                                              moduleDirectories: Array<string>;
                                                                              moduleFileExtensions: Array<string>;
                                                                              moduleNameMapper: string;
                                                                              modulePathIgnorePatterns: Array<string>;
                                                                              modulePaths: Array<string>;
                                                                              noStackTrace: boolean;
                                                                              notify: boolean;
                                                                              notifyMode: string;
                                                                              onlyChanged: boolean;
                                                                              onlyFailures: boolean;
                                                                              outputFile: string;
                                                                              preset: string | null | undefined;
                                                                              prettierPath: string | null | undefined;
                                                                              projects: Array<string>;
                                                                              reporters: Array<string>;
                                                                              resetMocks: boolean;
                                                                              resetModules: boolean;
                                                                              resolver: string | null | undefined;
                                                                              restoreMocks: boolean;
                                                                              rootDir: string;
                                                                              roots: Array<string>;
                                                                              runInBand: boolean;
                                                                              selectProjects: Array<string>;
                                                                              setupFiles: Array<string>;
                                                                              setupFilesAfterEnv: Array<string>;
                                                                              shard: string;
                                                                              showConfig: boolean;
                                                                              silent: boolean;
                                                                              snapshotSerializers: Array<string>;
                                                                              testEnvironment: string;
                                                                              testEnvironmentOptions: string;
                                                                              testFailureExitCode: string | null | undefined;
                                                                              testMatch: Array<string>;
                                                                              testNamePattern: string;
                                                                              testPathIgnorePatterns: Array<string>;
                                                                              testPathPattern: Array<string>;
                                                                              testRegex: string | Array<string>;
                                                                              testResultsProcessor: string;
                                                                              testRunner: string;
                                                                              testSequencer: string;
                                                                              testTimeout: number | null | undefined;
                                                                              transform: string;
                                                                              transformIgnorePatterns: Array<string>;
                                                                              unmockedModulePathPatterns: Array<string> | null | undefined;
                                                                              updateSnapshot: boolean;
                                                                              useStderr: boolean;
                                                                              verbose: boolean;
                                                                              version: boolean;
                                                                              watch: boolean;
                                                                              watchAll: boolean;
                                                                              watchman: boolean;
                                                                              watchPathIgnorePatterns: Array<string>;
                                                                              }>
                                                                              >;

                                                                                type CoverageReporterName

                                                                                type CoverageReporterName = keyof ReportOptions;

                                                                                  type CoverageReporters

                                                                                  type CoverageReporters = Array<CoverageReporterName | CoverageReporterWithOptions>;

                                                                                    type CoverageReporterWithOptions

                                                                                    type CoverageReporterWithOptions<K = CoverageReporterName> =
                                                                                    K extends CoverageReporterName
                                                                                    ? ReportOptions[K] extends never
                                                                                    ? never
                                                                                    : [K, Partial<ReportOptions[K]>]
                                                                                    : never;

                                                                                      type CoverageThresholdValue

                                                                                      type CoverageThresholdValue = {
                                                                                      branches?: number;
                                                                                      functions?: number;
                                                                                      lines?: number;
                                                                                      statements?: number;
                                                                                      };

                                                                                        type DefaultOptions

                                                                                        type DefaultOptions = {
                                                                                        automock: boolean;
                                                                                        bail: number;
                                                                                        cache: boolean;
                                                                                        cacheDirectory: string;
                                                                                        changedFilesWithAncestor: boolean;
                                                                                        ci: boolean;
                                                                                        clearMocks: boolean;
                                                                                        collectCoverage: boolean;
                                                                                        coveragePathIgnorePatterns: Array<string>;
                                                                                        coverageReporters: Array<CoverageReporterName>;
                                                                                        coverageProvider: CoverageProvider;
                                                                                        detectLeaks: boolean;
                                                                                        detectOpenHandles: boolean;
                                                                                        errorOnDeprecated: boolean;
                                                                                        expand: boolean;
                                                                                        extensionsToTreatAsEsm: Array<string>;
                                                                                        fakeTimers: FakeTimers;
                                                                                        forceCoverageMatch: Array<string>;
                                                                                        globals: ConfigGlobals;
                                                                                        haste: HasteConfig;
                                                                                        injectGlobals: boolean;
                                                                                        listTests: boolean;
                                                                                        maxConcurrency: number;
                                                                                        maxWorkers: number | string;
                                                                                        moduleDirectories: Array<string>;
                                                                                        moduleFileExtensions: Array<string>;
                                                                                        moduleNameMapper: Record<string, string | Array<string>>;
                                                                                        modulePathIgnorePatterns: Array<string>;
                                                                                        noStackTrace: boolean;
                                                                                        notify: boolean;
                                                                                        notifyMode: NotifyMode;
                                                                                        passWithNoTests: boolean;
                                                                                        prettierPath: string;
                                                                                        resetMocks: boolean;
                                                                                        resetModules: boolean;
                                                                                        restoreMocks: boolean;
                                                                                        roots: Array<string>;
                                                                                        runTestsByPath: boolean;
                                                                                        runner: string;
                                                                                        setupFiles: Array<string>;
                                                                                        setupFilesAfterEnv: Array<string>;
                                                                                        skipFilter: boolean;
                                                                                        slowTestThreshold: number;
                                                                                        snapshotSerializers: Array<string>;
                                                                                        testEnvironment: string;
                                                                                        testEnvironmentOptions: Record<string, unknown>;
                                                                                        testFailureExitCode: string | number;
                                                                                        testLocationInResults: boolean;
                                                                                        testMatch: Array<string>;
                                                                                        testPathIgnorePatterns: Array<string>;
                                                                                        testRegex: Array<string>;
                                                                                        testRunner: string;
                                                                                        testSequencer: string;
                                                                                        transformIgnorePatterns: Array<string>;
                                                                                        useStderr: boolean;
                                                                                        watch: boolean;
                                                                                        watchPathIgnorePatterns: Array<string>;
                                                                                        watchman: boolean;
                                                                                        };

                                                                                          type DisplayName

                                                                                          type DisplayName = {
                                                                                          name: string;
                                                                                          color: typeof ForegroundColor;
                                                                                          };

                                                                                            type FakeableAPI

                                                                                            type FakeableAPI =
                                                                                            | 'Date'
                                                                                            | 'hrtime'
                                                                                            | 'nextTick'
                                                                                            | 'performance'
                                                                                            | 'queueMicrotask'
                                                                                            | 'requestAnimationFrame'
                                                                                            | 'cancelAnimationFrame'
                                                                                            | 'requestIdleCallback'
                                                                                            | 'cancelIdleCallback'
                                                                                            | 'setImmediate'
                                                                                            | 'clearImmediate'
                                                                                            | 'setInterval'
                                                                                            | 'clearInterval'
                                                                                            | 'setTimeout'
                                                                                            | 'clearTimeout';

                                                                                              type FakeTimersConfig

                                                                                              type FakeTimersConfig = {
                                                                                              /**
                                                                                              * If set to `true` all timers will be advanced automatically
                                                                                              * by 20 milliseconds every 20 milliseconds. A custom time delta
                                                                                              * may be provided by passing a number.
                                                                                              *
                                                                                              * @defaultValue
                                                                                              * The default is `false`.
                                                                                              */
                                                                                              advanceTimers?: boolean | number;
                                                                                              /**
                                                                                              * List of names of APIs (e.g. `Date`, `nextTick()`, `setImmediate()`,
                                                                                              * `setTimeout()`) that should not be faked.
                                                                                              *
                                                                                              * @defaultValue
                                                                                              * The default is `[]`, meaning all APIs are faked.
                                                                                              * */
                                                                                              doNotFake?: Array<FakeableAPI>;
                                                                                              /**
                                                                                              * Sets current system time to be used by fake timers.
                                                                                              *
                                                                                              * @defaultValue
                                                                                              * The default is `Date.now()`.
                                                                                              */
                                                                                              now?: number | Date;
                                                                                              /**
                                                                                              * The maximum number of recursive timers that will be run when calling
                                                                                              * `jest.runAllTimers()`.
                                                                                              *
                                                                                              * @defaultValue
                                                                                              * The default is `100_000` timers.
                                                                                              */
                                                                                              timerLimit?: number;
                                                                                              /**
                                                                                              * Use the old fake timers implementation instead of one backed by
                                                                                              * [`@sinonjs/fake-timers`](https://github.com/sinonjs/fake-timers).
                                                                                              *
                                                                                              * @defaultValue
                                                                                              * The default is `false`.
                                                                                              */
                                                                                              legacyFakeTimers?: false;
                                                                                              };

                                                                                                type GlobalConfig

                                                                                                type GlobalConfig = {
                                                                                                bail: number;
                                                                                                changedSince?: string;
                                                                                                changedFilesWithAncestor: boolean;
                                                                                                ci: boolean;
                                                                                                collectCoverage: boolean;
                                                                                                collectCoverageFrom: Array<string>;
                                                                                                collectCoverageOnlyFrom?: {
                                                                                                [key: string]: boolean;
                                                                                                };
                                                                                                coverageDirectory: string;
                                                                                                coveragePathIgnorePatterns?: Array<string>;
                                                                                                coverageProvider: CoverageProvider;
                                                                                                coverageReporters: CoverageReporters;
                                                                                                coverageThreshold?: CoverageThreshold;
                                                                                                detectLeaks: boolean;
                                                                                                detectOpenHandles: boolean;
                                                                                                expand: boolean;
                                                                                                filter?: string;
                                                                                                findRelatedTests: boolean;
                                                                                                forceExit: boolean;
                                                                                                json: boolean;
                                                                                                globalSetup?: string;
                                                                                                globalTeardown?: string;
                                                                                                lastCommit: boolean;
                                                                                                logHeapUsage: boolean;
                                                                                                listTests: boolean;
                                                                                                maxConcurrency: number;
                                                                                                maxWorkers: number;
                                                                                                noStackTrace: boolean;
                                                                                                nonFlagArgs: Array<string>;
                                                                                                noSCM?: boolean;
                                                                                                notify: boolean;
                                                                                                notifyMode: NotifyMode;
                                                                                                outputFile?: string;
                                                                                                onlyChanged: boolean;
                                                                                                onlyFailures: boolean;
                                                                                                passWithNoTests: boolean;
                                                                                                projects: Array<string>;
                                                                                                replname?: string;
                                                                                                reporters?: Array<ReporterConfig>;
                                                                                                runTestsByPath: boolean;
                                                                                                rootDir: string;
                                                                                                shard?: ShardConfig;
                                                                                                silent?: boolean;
                                                                                                skipFilter: boolean;
                                                                                                snapshotFormat: SnapshotFormat;
                                                                                                errorOnDeprecated: boolean;
                                                                                                testFailureExitCode: number;
                                                                                                testNamePattern?: string;
                                                                                                testPathPattern: string;
                                                                                                testResultsProcessor?: string;
                                                                                                testSequencer: string;
                                                                                                testTimeout?: number;
                                                                                                updateSnapshot: SnapshotUpdateState;
                                                                                                useStderr: boolean;
                                                                                                verbose?: boolean;
                                                                                                watch: boolean;
                                                                                                watchAll: boolean;
                                                                                                watchman: boolean;
                                                                                                watchPlugins?: Array<{
                                                                                                path: string;
                                                                                                config: Record<string, unknown>;
                                                                                                }> | null;
                                                                                                };

                                                                                                  type GlobalFakeTimersConfig

                                                                                                  type GlobalFakeTimersConfig = {
                                                                                                  /**
                                                                                                  * Whether fake timers should be enabled globally for all test files.
                                                                                                  *
                                                                                                  * @defaultValue
                                                                                                  * The default is `false`.
                                                                                                  * */
                                                                                                  enableGlobally?: boolean;
                                                                                                  };

                                                                                                    type HasteConfig

                                                                                                    type HasteConfig = {
                                                                                                    /** Whether to hash files using SHA-1. */
                                                                                                    computeSha1?: boolean;
                                                                                                    /** The platform to use as the default, e.g. 'ios'. */
                                                                                                    defaultPlatform?: string | null;
                                                                                                    /** Force use of Node's `fs` APIs rather than shelling out to `find` */
                                                                                                    forceNodeFilesystemAPI?: boolean;
                                                                                                    /**
                                                                                                    * Whether to follow symlinks when crawling for files.
                                                                                                    * This options cannot be used in projects which use watchman.
                                                                                                    * Projects with `watchman` set to true will error if this option is set to true.
                                                                                                    */
                                                                                                    enableSymlinks?: boolean;
                                                                                                    /** string to a custom implementation of Haste. */
                                                                                                    hasteImplModulePath?: string;
                                                                                                    /** All platforms to target, e.g ['ios', 'android']. */
                                                                                                    platforms?: Array<string>;
                                                                                                    /** Whether to throw on error on module collision. */
                                                                                                    throwOnModuleCollision?: boolean;
                                                                                                    /** Custom HasteMap module */
                                                                                                    hasteMapModulePath?: string;
                                                                                                    /** Whether to retain all files, allowing e.g. search for tests in `node_modules`. */
                                                                                                    retainAllFiles?: boolean;
                                                                                                    };

                                                                                                      type InitialOptions

                                                                                                      type InitialOptions = Partial<{
                                                                                                      automock: boolean;
                                                                                                      bail: boolean | number;
                                                                                                      cache: boolean;
                                                                                                      cacheDirectory: string;
                                                                                                      ci: boolean;
                                                                                                      clearMocks: boolean;
                                                                                                      changedFilesWithAncestor: boolean;
                                                                                                      changedSince: string;
                                                                                                      collectCoverage: boolean;
                                                                                                      collectCoverageFrom: Array<string>;
                                                                                                      collectCoverageOnlyFrom: {
                                                                                                      [key: string]: boolean;
                                                                                                      };
                                                                                                      coverageDirectory: string;
                                                                                                      coveragePathIgnorePatterns: Array<string>;
                                                                                                      coverageProvider: CoverageProvider;
                                                                                                      coverageReporters: CoverageReporters;
                                                                                                      coverageThreshold: CoverageThreshold;
                                                                                                      dependencyExtractor: string;
                                                                                                      detectLeaks: boolean;
                                                                                                      detectOpenHandles: boolean;
                                                                                                      displayName: string | DisplayName;
                                                                                                      expand: boolean;
                                                                                                      extensionsToTreatAsEsm: Array<string>;
                                                                                                      fakeTimers: FakeTimers;
                                                                                                      filter: string;
                                                                                                      findRelatedTests: boolean;
                                                                                                      forceCoverageMatch: Array<string>;
                                                                                                      forceExit: boolean;
                                                                                                      json: boolean;
                                                                                                      globals: ConfigGlobals;
                                                                                                      globalSetup: string | null | undefined;
                                                                                                      globalTeardown: string | null | undefined;
                                                                                                      haste: HasteConfig;
                                                                                                      id: string;
                                                                                                      injectGlobals: boolean;
                                                                                                      reporters: Array<string | ReporterConfig>;
                                                                                                      logHeapUsage: boolean;
                                                                                                      lastCommit: boolean;
                                                                                                      listTests: boolean;
                                                                                                      maxConcurrency: number;
                                                                                                      maxWorkers: number | string;
                                                                                                      moduleDirectories: Array<string>;
                                                                                                      moduleFileExtensions: Array<string>;
                                                                                                      moduleNameMapper: {
                                                                                                      [key: string]: string | Array<string>;
                                                                                                      };
                                                                                                      modulePathIgnorePatterns: Array<string>;
                                                                                                      modulePaths: Array<string>;
                                                                                                      noStackTrace: boolean;
                                                                                                      notify: boolean;
                                                                                                      notifyMode: string;
                                                                                                      onlyChanged: boolean;
                                                                                                      onlyFailures: boolean;
                                                                                                      outputFile: string;
                                                                                                      passWithNoTests: boolean;
                                                                                                      preset: string | null | undefined;
                                                                                                      prettierPath: string | null | undefined;
                                                                                                      projects: Array<string | InitialProjectOptions>;
                                                                                                      replname: string | null | undefined;
                                                                                                      resetMocks: boolean;
                                                                                                      resetModules: boolean;
                                                                                                      resolver: string | null | undefined;
                                                                                                      restoreMocks: boolean;
                                                                                                      rootDir: string;
                                                                                                      roots: Array<string>;
                                                                                                      runner: string;
                                                                                                      runTestsByPath: boolean;
                                                                                                      runtime: string;
                                                                                                      sandboxInjectedGlobals: Array<string>;
                                                                                                      setupFiles: Array<string>;
                                                                                                      setupFilesAfterEnv: Array<string>;
                                                                                                      silent: boolean;
                                                                                                      skipFilter: boolean;
                                                                                                      skipNodeResolution: boolean;
                                                                                                      slowTestThreshold: number;
                                                                                                      snapshotResolver: string;
                                                                                                      snapshotSerializers: Array<string>;
                                                                                                      snapshotFormat: SnapshotFormat;
                                                                                                      errorOnDeprecated: boolean;
                                                                                                      testEnvironment: string;
                                                                                                      testEnvironmentOptions: Record<string, unknown>;
                                                                                                      testFailureExitCode: string | number;
                                                                                                      testLocationInResults: boolean;
                                                                                                      testMatch: Array<string>;
                                                                                                      testNamePattern: string;
                                                                                                      testPathIgnorePatterns: Array<string>;
                                                                                                      testRegex: string | Array<string>;
                                                                                                      testResultsProcessor: string;
                                                                                                      testRunner: string;
                                                                                                      testSequencer: string;
                                                                                                      testTimeout: number;
                                                                                                      transform: {
                                                                                                      [regex: string]: string | TransformerConfig;
                                                                                                      };
                                                                                                      transformIgnorePatterns: Array<string>;
                                                                                                      watchPathIgnorePatterns: Array<string>;
                                                                                                      unmockedModulePathPatterns: Array<string>;
                                                                                                      updateSnapshot: boolean;
                                                                                                      useStderr: boolean;
                                                                                                      verbose?: boolean;
                                                                                                      watch: boolean;
                                                                                                      watchAll: boolean;
                                                                                                      watchman: boolean;
                                                                                                      watchPlugins: Array<string | [string, Record<string, unknown>]>;
                                                                                                      }>;

                                                                                                        type InitialOptionsWithRootDir

                                                                                                        type InitialOptionsWithRootDir = InitialOptions &
                                                                                                        Required<Pick<InitialOptions, 'rootDir'>>;

                                                                                                          type InitialProjectOptions

                                                                                                          type InitialProjectOptions = Pick<
                                                                                                          InitialOptions & {
                                                                                                          cwd?: string;
                                                                                                          },
                                                                                                          keyof ProjectConfig
                                                                                                          >;

                                                                                                            type LegacyFakeTimersConfig

                                                                                                            type LegacyFakeTimersConfig = {
                                                                                                            /**
                                                                                                            * Use the old fake timers implementation instead of one backed by
                                                                                                            * [`@sinonjs/fake-timers`](https://github.com/sinonjs/fake-timers).
                                                                                                            *
                                                                                                            * @defaultValue
                                                                                                            * The default is `false`.
                                                                                                            */
                                                                                                            legacyFakeTimers?: true;
                                                                                                            };

                                                                                                              type ProjectConfig

                                                                                                              type ProjectConfig = {
                                                                                                              automock: boolean;
                                                                                                              cache: boolean;
                                                                                                              cacheDirectory: string;
                                                                                                              clearMocks: boolean;
                                                                                                              coveragePathIgnorePatterns: Array<string>;
                                                                                                              cwd: string;
                                                                                                              dependencyExtractor?: string;
                                                                                                              detectLeaks: boolean;
                                                                                                              detectOpenHandles: boolean;
                                                                                                              displayName?: DisplayName;
                                                                                                              errorOnDeprecated: boolean;
                                                                                                              extensionsToTreatAsEsm: Array<string>;
                                                                                                              fakeTimers: FakeTimers;
                                                                                                              filter?: string;
                                                                                                              forceCoverageMatch: Array<string>;
                                                                                                              globalSetup?: string;
                                                                                                              globalTeardown?: string;
                                                                                                              globals: ConfigGlobals;
                                                                                                              haste: HasteConfig;
                                                                                                              id: string;
                                                                                                              injectGlobals: boolean;
                                                                                                              moduleDirectories: Array<string>;
                                                                                                              moduleFileExtensions: Array<string>;
                                                                                                              moduleNameMapper: Array<[string, string]>;
                                                                                                              modulePathIgnorePatterns: Array<string>;
                                                                                                              modulePaths?: Array<string>;
                                                                                                              prettierPath: string;
                                                                                                              resetMocks: boolean;
                                                                                                              resetModules: boolean;
                                                                                                              resolver?: string;
                                                                                                              restoreMocks: boolean;
                                                                                                              rootDir: string;
                                                                                                              roots: Array<string>;
                                                                                                              runner: string;
                                                                                                              runtime?: string;
                                                                                                              sandboxInjectedGlobals: Array<keyof typeof globalThis>;
                                                                                                              setupFiles: Array<string>;
                                                                                                              setupFilesAfterEnv: Array<string>;
                                                                                                              skipFilter: boolean;
                                                                                                              skipNodeResolution?: boolean;
                                                                                                              slowTestThreshold: number;
                                                                                                              snapshotResolver?: string;
                                                                                                              snapshotSerializers: Array<string>;
                                                                                                              snapshotFormat: SnapshotFormat;
                                                                                                              testEnvironment: string;
                                                                                                              testEnvironmentOptions: Record<string, unknown>;
                                                                                                              testMatch: Array<string>;
                                                                                                              testLocationInResults: boolean;
                                                                                                              testPathIgnorePatterns: Array<string>;
                                                                                                              testRegex: Array<string | RegExp>;
                                                                                                              testRunner: string;
                                                                                                              transform: Array<[string, string, Record<string, unknown>]>;
                                                                                                              transformIgnorePatterns: Array<string>;
                                                                                                              watchPathIgnorePatterns: Array<string>;
                                                                                                              unmockedModulePathPatterns?: Array<string>;
                                                                                                              };

                                                                                                                type ReporterConfig

                                                                                                                type ReporterConfig = [string, Record<string, unknown>];

                                                                                                                  type SnapshotUpdateState

                                                                                                                  type SnapshotUpdateState = 'all' | 'new' | 'none';

                                                                                                                    type TransformerConfig

                                                                                                                    type TransformerConfig = [string, Record<string, unknown>];

                                                                                                                      namespace Global

                                                                                                                      namespace Global {}

                                                                                                                        interface Describe

                                                                                                                        interface Describe extends DescribeBase {}

                                                                                                                          property only

                                                                                                                          only: DescribeBase;

                                                                                                                            property skip

                                                                                                                            skip: DescribeBase;

                                                                                                                              interface DescribeBase

                                                                                                                              interface DescribeBase {}

                                                                                                                                property each

                                                                                                                                each: Each<BlockFn>;

                                                                                                                                  call signature

                                                                                                                                  (blockName: BlockNameLike, blockFn: BlockFn): void;

                                                                                                                                    interface Global

                                                                                                                                    interface Global_2
                                                                                                                                    extends GlobalAdditions,
                                                                                                                                    Omit<typeof globalThis, keyof GlobalAdditions> {}

                                                                                                                                      index signature

                                                                                                                                      [extras: PropertyKey]: unknown;

                                                                                                                                        interface GlobalAdditions

                                                                                                                                        interface GlobalAdditions extends TestFrameworkGlobals {}

                                                                                                                                          interface HookBase

                                                                                                                                          interface HookBase {}

                                                                                                                                            call signature

                                                                                                                                            (fn: HookFn, timeout?: number): void;

                                                                                                                                              interface It

                                                                                                                                              interface It extends ItBase {}

                                                                                                                                                property only

                                                                                                                                                only: ItBase;

                                                                                                                                                  property skip

                                                                                                                                                  skip: ItBase;

                                                                                                                                                    property todo

                                                                                                                                                    todo: (testName: TestNameLike) => void;

                                                                                                                                                      interface ItBase

                                                                                                                                                      interface ItBase {}

                                                                                                                                                        property each

                                                                                                                                                        each: Each<TestFn>;

                                                                                                                                                          method failing

                                                                                                                                                          failing: (testName: TestNameLike, fn: TestFn, timeout?: number) => void;

                                                                                                                                                            call signature

                                                                                                                                                            (testName: TestNameLike, fn: TestFn, timeout?: number): void;

                                                                                                                                                              interface ItConcurrent

                                                                                                                                                              interface ItConcurrent extends It {}

                                                                                                                                                                property concurrent

                                                                                                                                                                concurrent: ItConcurrentExtended;

                                                                                                                                                                  interface ItConcurrentBase

                                                                                                                                                                  interface ItConcurrentBase {}

                                                                                                                                                                    property each

                                                                                                                                                                    each: Each<ConcurrentTestFn>;

                                                                                                                                                                      method failing

                                                                                                                                                                      failing: (
                                                                                                                                                                      testName: TestNameLike,
                                                                                                                                                                      fn: ConcurrentTestFn,
                                                                                                                                                                      timeout?: number
                                                                                                                                                                      ) => void;

                                                                                                                                                                        call signature

                                                                                                                                                                        (testName: TestNameLike, testFn: ConcurrentTestFn, timeout?: number): void;

                                                                                                                                                                          interface ItConcurrentExtended

                                                                                                                                                                          interface ItConcurrentExtended extends ItConcurrentBase {}

                                                                                                                                                                            property only

                                                                                                                                                                            only: ItConcurrentBase;

                                                                                                                                                                              property skip

                                                                                                                                                                              skip: ItConcurrentBase;

                                                                                                                                                                                interface TestFrameworkGlobals

                                                                                                                                                                                interface TestFrameworkGlobals {}

                                                                                                                                                                                  property afterAll

                                                                                                                                                                                  afterAll: HookBase;

                                                                                                                                                                                    property afterEach

                                                                                                                                                                                    afterEach: HookBase;

                                                                                                                                                                                      property beforeAll

                                                                                                                                                                                      beforeAll: HookBase;

                                                                                                                                                                                        property beforeEach

                                                                                                                                                                                        beforeEach: HookBase;

                                                                                                                                                                                          property describe

                                                                                                                                                                                          describe: Describe;

                                                                                                                                                                                            property fdescribe

                                                                                                                                                                                            fdescribe: DescribeBase;

                                                                                                                                                                                              property fit

                                                                                                                                                                                              fit: ItBase & {
                                                                                                                                                                                              concurrent?: ItConcurrentBase;
                                                                                                                                                                                              };

                                                                                                                                                                                                property it

                                                                                                                                                                                                it: ItConcurrent;

                                                                                                                                                                                                  property test

                                                                                                                                                                                                  test: ItConcurrent;

                                                                                                                                                                                                    property xdescribe

                                                                                                                                                                                                    xdescribe: DescribeBase;

                                                                                                                                                                                                      property xit

                                                                                                                                                                                                      xit: ItBase;

                                                                                                                                                                                                        property xtest

                                                                                                                                                                                                        xtest: ItBase;

                                                                                                                                                                                                          type ArrayTable

                                                                                                                                                                                                          type ArrayTable = Table | Row;

                                                                                                                                                                                                            type BlockFn

                                                                                                                                                                                                            type BlockFn = () => void;

                                                                                                                                                                                                              type BlockName

                                                                                                                                                                                                              type BlockName = string;

                                                                                                                                                                                                                type BlockNameLike

                                                                                                                                                                                                                type BlockNameLike = BlockName | NameLike;

                                                                                                                                                                                                                  type Col

                                                                                                                                                                                                                  type Col = unknown;

                                                                                                                                                                                                                    type ConcurrentTestFn

                                                                                                                                                                                                                    type ConcurrentTestFn = () => TestReturnValuePromise;

                                                                                                                                                                                                                      type DoneFn

                                                                                                                                                                                                                      type DoneFn_2 = (reason?: string | Error) => void;

                                                                                                                                                                                                                        type DoneTakingTestFn

                                                                                                                                                                                                                        type DoneTakingTestFn = (this: TestContext, done: DoneFn_2) => ValidTestReturnValues;

                                                                                                                                                                                                                          type EachTable

                                                                                                                                                                                                                          type EachTable = ArrayTable | TemplateTable;

                                                                                                                                                                                                                            type EachTestFn

                                                                                                                                                                                                                            type EachTestFn<EachCallback extends TestCallback> = (
                                                                                                                                                                                                                            ...args: ReadonlyArray<any>
                                                                                                                                                                                                                            ) => ReturnType<EachCallback>;

                                                                                                                                                                                                                              type GeneratorReturningTestFn

                                                                                                                                                                                                                              type GeneratorReturningTestFn = (this: TestContext) => TestReturnValueGenerator;

                                                                                                                                                                                                                                type HookFn

                                                                                                                                                                                                                                type HookFn = TestFn;

                                                                                                                                                                                                                                  type NameLike

                                                                                                                                                                                                                                  type NameLike = number | Function;

                                                                                                                                                                                                                                    type PromiseReturningTestFn

                                                                                                                                                                                                                                    type PromiseReturningTestFn = (this: TestContext) => TestReturnValue;

                                                                                                                                                                                                                                      type Row

                                                                                                                                                                                                                                      type Row = ReadonlyArray<Col>;

                                                                                                                                                                                                                                        type Table

                                                                                                                                                                                                                                        type Table = ReadonlyArray<Row>;

                                                                                                                                                                                                                                          type TemplateData

                                                                                                                                                                                                                                          type TemplateData = ReadonlyArray<unknown>;

                                                                                                                                                                                                                                            type TemplateTable

                                                                                                                                                                                                                                            type TemplateTable = TemplateStringsArray;

                                                                                                                                                                                                                                              type TestCallback

                                                                                                                                                                                                                                              type TestCallback = BlockFn | TestFn | ConcurrentTestFn;

                                                                                                                                                                                                                                                type TestContext

                                                                                                                                                                                                                                                type TestContext = Record<string, unknown>;

                                                                                                                                                                                                                                                  type TestFn

                                                                                                                                                                                                                                                  type TestFn = PromiseReturningTestFn | GeneratorReturningTestFn | DoneTakingTestFn;

                                                                                                                                                                                                                                                    type TestName

                                                                                                                                                                                                                                                    type TestName = string;

                                                                                                                                                                                                                                                      type TestNameLike

                                                                                                                                                                                                                                                      type TestNameLike = TestName | NameLike;

                                                                                                                                                                                                                                                        type TestReturnValue

                                                                                                                                                                                                                                                        type TestReturnValue = ValidTestReturnValues | TestReturnValuePromise;

                                                                                                                                                                                                                                                          type ValidTestReturnValues

                                                                                                                                                                                                                                                          type ValidTestReturnValues = void | undefined;

                                                                                                                                                                                                                                                            namespace TestResult

                                                                                                                                                                                                                                                            namespace TestResult {}

                                                                                                                                                                                                                                                              type AssertionResult

                                                                                                                                                                                                                                                              type AssertionResult = {
                                                                                                                                                                                                                                                              ancestorTitles: Array<string>;
                                                                                                                                                                                                                                                              duration?: Milliseconds | null;
                                                                                                                                                                                                                                                              failureDetails: Array<unknown>;
                                                                                                                                                                                                                                                              failureMessages: Array<string>;
                                                                                                                                                                                                                                                              fullName: string;
                                                                                                                                                                                                                                                              invocations?: number;
                                                                                                                                                                                                                                                              location?: Callsite | null;
                                                                                                                                                                                                                                                              numPassingAsserts: number;
                                                                                                                                                                                                                                                              retryReasons?: Array<string>;
                                                                                                                                                                                                                                                              status: Status;
                                                                                                                                                                                                                                                              title: string;
                                                                                                                                                                                                                                                              };

                                                                                                                                                                                                                                                                type Milliseconds

                                                                                                                                                                                                                                                                type Milliseconds = number;

                                                                                                                                                                                                                                                                  type SerializableError

                                                                                                                                                                                                                                                                  type SerializableError = {
                                                                                                                                                                                                                                                                  code?: unknown;
                                                                                                                                                                                                                                                                  message: string;
                                                                                                                                                                                                                                                                  stack: string | null | undefined;
                                                                                                                                                                                                                                                                  type?: string;
                                                                                                                                                                                                                                                                  };

                                                                                                                                                                                                                                                                    namespace TransformTypes

                                                                                                                                                                                                                                                                    namespace TransformTypes {}

                                                                                                                                                                                                                                                                      type TransformResult

                                                                                                                                                                                                                                                                      type TransformResult = {
                                                                                                                                                                                                                                                                      code: string;
                                                                                                                                                                                                                                                                      originalCode: string;
                                                                                                                                                                                                                                                                      sourceMapPath: string | null;
                                                                                                                                                                                                                                                                      };

                                                                                                                                                                                                                                                                        Package Files (1)

                                                                                                                                                                                                                                                                        Dependencies (6)

                                                                                                                                                                                                                                                                        Dev Dependencies (2)

                                                                                                                                                                                                                                                                        Peer Dependencies (0)

                                                                                                                                                                                                                                                                        No peer dependencies.

                                                                                                                                                                                                                                                                        Badge

                                                                                                                                                                                                                                                                        To add a badge like this onejsDocs.io badgeto your package's README, use the codes available below.

                                                                                                                                                                                                                                                                        You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/@jest/types.

                                                                                                                                                                                                                                                                        • Markdown
                                                                                                                                                                                                                                                                          [![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/@jest/types)
                                                                                                                                                                                                                                                                        • HTML
                                                                                                                                                                                                                                                                          <a href="https://www.jsdocs.io/package/@jest/types"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>