@types/mocha

  • Version 8.2.2
  • Published
  • 93.1 kB
  • No dependencies
  • MIT license

Install

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

Overview

TypeScript definitions for mocha

Index

Variables

Functions

Namespaces

Variables

variable after

var after: Mocha.HookFunction;
  • Execute after running tests.

    - _Only available when invoked via the mocha CLI._

    See Also

    • https://mochajs.org/api/global.html#after

variable afterEach

var afterEach: Mocha.HookFunction;
  • Execute after each test case.

    - _Only available when invoked via the mocha CLI._

    See Also

    • https://mochajs.org/api/global.html#afterEach

variable before

var before: Mocha.HookFunction;
  • Execute before running tests.

    - _Only available when invoked via the mocha CLI._

    See Also

    • https://mochajs.org/api/global.html#before

variable beforeEach

var beforeEach: Mocha.HookFunction;
  • Execute before each test case.

    - _Only available when invoked via the mocha CLI._

    See Also

    • https://mochajs.org/api/global.html#beforeEach

variable context

var context: Mocha.SuiteFunction;
  • Describe a "suite" containing nested suites and tests.

    - _Only available when invoked via the mocha CLI._

variable describe

var describe: Mocha.SuiteFunction;
  • Describe a "suite" containing nested suites and tests.

    - _Only available when invoked via the mocha CLI._

variable it

var it: Mocha.TestFunction;
  • Describes a test case.

    - _Only available when invoked via the mocha CLI._

variable mocha

const mocha: BrowserMocha;
  • Mocha global.

    - _Only supported in the browser._

variable setup

var setup: Mocha.HookFunction;
  • Execute before each test case.

    - _Only available when invoked via the mocha CLI._

    See Also

    • https://mochajs.org/api/global.html#beforeEach

variable specify

var specify: Mocha.TestFunction;
  • Describes a test case.

    - _Only available when invoked via the mocha CLI._

variable suite

var suite: Mocha.SuiteFunction;
  • Describe a "suite" containing nested suites and tests.

    - _Only available when invoked via the mocha CLI._

variable suiteSetup

var suiteSetup: Mocha.HookFunction;
  • Execute before running tests.

    - _Only available when invoked via the mocha CLI._

    See Also

    • https://mochajs.org/api/global.html#before

variable suiteTeardown

var suiteTeardown: Mocha.HookFunction;
  • Execute after running tests.

    - _Only available when invoked via the mocha CLI._

    See Also

    • https://mochajs.org/api/global.html#after

variable teardown

var teardown: Mocha.HookFunction;
  • Execute after each test case.

    - _Only available when invoked via the mocha CLI._

    See Also

    • https://mochajs.org/api/global.html#afterEach

variable test

var test: Mocha.TestFunction;
  • Describes a test case.

    - _Only available when invoked via the mocha CLI._

variable xcontext

var xcontext: Mocha.PendingSuiteFunction;
  • Pending suite.

    - _Only available when invoked via the mocha CLI._

variable xdescribe

var xdescribe: Mocha.PendingSuiteFunction;
  • Pending suite.

    - _Only available when invoked via the mocha CLI._

variable xit

var xit: Mocha.PendingTestFunction;
  • Describes a pending test case.

    - _Only available when invoked via the mocha CLI._

variable xspecify

var xspecify: Mocha.PendingTestFunction;
  • Describes a pending test case.

    - _Only available when invoked via the mocha CLI._

Functions

function run

run: () => void;
  • Triggers root suite execution.

    - _Only available if flag --delay is passed into Mocha._ - _Only available when invoked via the mocha CLI._

    See Also

    • https://mochajs.org/api/global.html#runWithSuite

Namespaces

namespace mocha

module 'mocha' {}

    variable after

    let after: HookFunction;
    • Execute after running tests.

      - _Only available when invoked via the mocha CLI._

      See Also

      • https://mochajs.org/api/global.html#after

    variable afterEach

    let afterEach: HookFunction;
    • Execute after each test case.

      - _Only available when invoked via the mocha CLI._

      See Also

      • https://mochajs.org/api/global.html#afterEach

    variable before

    let before: HookFunction;
    • Execute before running tests.

      - _Only available when invoked via the mocha CLI._

      See Also

      • https://mochajs.org/api/global.html#before

    variable beforeEach

    let beforeEach: HookFunction;
    • Execute before each test case.

      - _Only available when invoked via the mocha CLI._

      See Also

      • https://mochajs.org/api/global.html#beforeEach

    variable describe

    let describe: SuiteFunction;
    • Describe a "suite" containing nested suites and tests.

      - _Only available when invoked via the mocha CLI._

    variable it

    let it: TestFunction;
    • Describes a test case.

      - _Only available when invoked via the mocha CLI._

    variable setup

    let setup: HookFunction;
    • Execute before each test case.

      - _Only available when invoked via the mocha CLI._

      See Also

      • https://mochajs.org/api/global.html#beforeEach

    variable suite

    let suite: SuiteFunction;
    • Describe a "suite" containing nested suites and tests.

      - _Only available when invoked via the mocha CLI._

    variable suiteSetup

    let suiteSetup: HookFunction;
    • Execute before running tests.

      - _Only available when invoked via the mocha CLI._

      See Also

      • https://mochajs.org/api/global.html#before

    variable suiteTeardown

    let suiteTeardown: HookFunction;
    • Execute after running tests.

      - _Only available when invoked via the mocha CLI._

      See Also

      • https://mochajs.org/api/global.html#after

    variable teardown

    let teardown: HookFunction;
    • Execute after each test case.

      - _Only available when invoked via the mocha CLI._

      See Also

      • https://mochajs.org/api/global.html#afterEach

    variable test

    let test: TestFunction;
    • Describes a test case.

      - _Only available when invoked via the mocha CLI._

    variable xit

    let xit: PendingTestFunction;
    • Describes a pending test case.

      - _Only available when invoked via the mocha CLI._

    function run

    run: () => void;
    • Triggers root suite execution.

      - _Only available if flag --delay is passed into Mocha._ - _Only available when invoked via the mocha CLI._

      See Also

      • https://mochajs.org/api/global.html#runWithSuite

    class Context

    class Context {}
    • Test context

      See Also

      • https://mochajs.org/api/module-Context.html#~Context

    property currentTest

    currentTest?: Test;

      property test

      test?: Runnable;

        method retries

        retries: { (): number; (n: number): this };
        • Get the number of allowed retries on failed tests.

        • Set the number of allowed retries on failed tests.

        method runnable

        runnable: { (): Runnable; (runnable: Runnable): this };
        • Get the context Runnable.

        • Set the context Runnable.

        method skip

        skip: () => never;
        • Mark a test as skipped.

        method slow

        slow: { (): number; (ms: string | number): this };
        • Get test slowness threshold.

        • Set test slowness threshold.

        method timeout

        timeout: { (): number; (ms: string | number): this };
        • Get test timeout.

        • Set test timeout.

        class Hook

        class Hook extends Runnable {}
        • Initialize a new Hook with the given title and callback fn

          See Also

          • https://mochajs.org/api/Hook.html

        property originalTitle

        originalTitle?: string;

          property type

          type: string;

            method error

            error: { (): any; (err: any): void };
            • Get the test err.

              See Also

              • https://mochajs.org/api/Hook.html#error

            • Set the test err.

              See Also

              • https://mochajs.org/api/Hook.html#error

            class Mocha

            class Mocha {}
            • Mocha API

              See Also

              • https://mochajs.org/api/mocha

            constructor

            constructor(options?: Mocha.MochaOptions);

              property files

              files: string[];

                property globalSetup

                globalSetup: Mocha.HookFunction;
                • Configures one or more global setup fixtures. If given no parameters, unsets any previously-set fixtures.

                  See Also

                  • https://mochajs.org/api/mocha#globalSetup

                property globalTeardown

                globalTeardown: Mocha.HookFunction;
                • Configures one or more global teardown fixtures. If given no parameters, unsets any previously-set fixtures.

                  See Also

                  • https://mochajs.org/api/mocha#globalTeardown

                property options

                options: Mocha.MochaInstanceOptions;

                  property suite

                  suite: Mocha.Suite;

                    method addFile

                    addFile: (file: string) => this;
                    • Add test file.

                      See Also

                      • https://mochajs.org/api/mocha#addFile

                    method allowUncaught

                    allowUncaught: () => boolean;
                    • Enable uncaught errors to propagate (in browser).

                      See Also

                      • https://mochajs.org/api/mocha#allowUncaught

                    method asyncOnly

                    asyncOnly: () => this;
                    • Makes all tests async (accepting a callback)

                      See Also

                      • https://mochajs.org/api/mocha#asyncOnly.

                    method bail

                    bail: (bail?: boolean) => this;
                    • Enable or disable bailing on the first failure.

                      See Also

                      • https://mochajs.org/api/mocha#bail

                    method checkLeaks

                    checkLeaks: () => this;
                    • Enable global leak checking.

                      See Also

                      • https://mochajs.org/api/mocha#checkLeaks

                    method delay

                    delay: () => boolean;
                    • Delay root suite execution.

                      See Also

                      • https://mochajs.org/api/mocha#delay

                    method dispose

                    dispose: () => void;
                    • Manually dispose this mocha instance. Mark this instance as disposed and unable to run more tests. It also removes function references to tests functions and hooks, so variables trapped in closures can be cleaned by the garbage collector.

                      See Also

                      • https://mochajs.org/api/mocha#dispose

                    method enableGlobalSetup

                    enableGlobalSetup: (enabled: boolean) => this;
                    • Toggle execution of any global setup fixture(s)

                      See Also

                      • https://mochajs.org/api/mocha#enableGlobalSetup

                    method enableGlobalTeardown

                    enableGlobalTeardown: (enabled: boolean) => this;
                    • Toggle execution of any global teardown fixture(s)

                      See Also

                      • https://mochajs.org/api/mocha#enableGlobalTeardown

                    method fgrep

                    fgrep: (str: string) => this;
                    • Escape string and add it to grep as a RegExp.

                      See Also

                      • https://mochajs.org/api/mocha#fgrep

                    method forbidOnly

                    forbidOnly: () => boolean;
                    • Tests marked only fail the suite

                      See Also

                      • https://mochajs.org/api/mocha#forbidOnly

                    method forbidPending

                    forbidPending: () => boolean;
                    • Pending tests and tests marked skip fail the suite

                      See Also

                      • https://mochajs.org/api/mocha#forbidPending

                    method fullTrace

                    fullTrace: () => this;
                    • Display long stack-trace on failing

                      See Also

                      • https://mochajs.org/api/mocha#fullTrace

                    method globals

                    globals: (globals: string | ReadonlyArray<string>) => this;
                    • Ignore globals array or string.

                      See Also

                      • https://mochajs.org/api/mocha#globals

                    method grep

                    grep: (re: string | RegExp) => this;
                    • Add regexp to grep, if re is a string it is escaped.

                      See Also

                      • https://mochajs.org/api/mocha#grep

                    method growl

                    growl: () => this;
                    • Enable growl support.

                      See Also

                      • https://mochajs.org/api/mocha#growl

                    method hasGlobalSetupFixtures

                    hasGlobalSetupFixtures: () => boolean;
                    • Returns true if one or more global setup fixtures have been supplied

                      See Also

                      • https://mochajs.org/api/mocha#hasGlobalSetupFixtures

                    method hasGlobalTeardownFixtures

                    hasGlobalTeardownFixtures: () => boolean;
                    • Returns true if one or more global teardown fixtures have been supplied

                      See Also

                      • https://mochajs.org/api/mocha#hasGlobalTeardownFixtures

                    method invert

                    invert: () => this;
                    • Invert .grep() matches.

                      See Also

                      • https://mochajs.org/api/mocha#invert

                    method loadFiles

                    protected loadFiles: (fn?: () => void) => void;
                    • Load registered files.

                      See Also

                      • https://mochajs.org/api/mocha#loadFiles

                    method loadFilesAsync

                    loadFilesAsync: () => Promise<void>;
                    • Loads ESM (and CJS) test files asynchronously.

                      See Also

                      • https://mochajs.org/api/mocha#loadFilesAsync

                    method noHighlighting

                    noHighlighting: () => this;
                    • Disable syntax highlighting (in browser).

                      See Also

                      • https://mochajs.org/api/mocha#noHighlighting

                    method parallelMode

                    parallelMode: (enabled?: boolean) => this;
                    • Toggles parallel mode.

                      Must be run before calling run. Changes the Runner class to use; also enables lazy file loading if not already done so.

                      See Also

                      • https://mochajs.org/api/mocha#parallelMode

                    method reporter

                    reporter: {
                    (reporter: Mocha.Reporter, reporterOptions?: any): this;
                    (reporter?: string | Mocha.ReporterConstructor, reporterOptions?: any): this;
                    };
                    • Set reporter to one of the built-in reporters.

                      See Also

                      • https://mochajs.org/api/mocha#reporter

                    • Set reporter to the provided constructor, one of the built-in reporters, or loads a reporter from a module path. Defaults to "spec".

                      See Also

                      • https://mochajs.org/api/mocha#reporter

                    method retries

                    retries: (n: number) => this;
                    • Set the number of times to retry failed tests.

                      See Also

                      • https://mochajs.org/api/mocha#retries

                    method rootHooks

                    rootHooks: (hooks: Mocha.RootHookObject) => this;
                    • Assigns hooks to the root suite.

                      See Also

                      • https://mochajs.org/api/mocha#rootHooks

                    method run

                    run: (fn?: (failures: number) => void) => Mocha.Runner;
                    • Run tests and invoke fn() when complete.

                      Note that run relies on Node's require to execute the test interface functions and will be subject to the cache - if the files are already in the require cache, they will effectively be skipped. Therefore, to run tests multiple times or to run tests in files that are already in the require cache, make sure to clear them from the cache first in whichever manner best suits your needs.

                      See Also

                      • https://mochajs.org/api/mocha#run

                    method slow

                    slow: (slow: string | number) => this;
                    • Set slowness threshold in milliseconds.

                      See Also

                      • https://mochajs.org/api/mocha#slow

                    method timeout

                    timeout: (timeout: string | number) => this;
                    • Set the timeout in milliseconds.

                      See Also

                      • https://mochajs.org/api/mocha#timeout

                    method ui

                    ui: { (name: Mocha.Interface): this; (name?: string): this };
                    • Set test UI to one of the built-in test interfaces.

                      See Also

                      • https://mochajs.org/api/mocha#ui

                    • Set test UI to one of the built-in test interfaces or loads a test interface from a module path. Defaults to "bdd".

                      See Also

                      • https://mochajs.org/api/mocha#ui

                    method unloadFiles

                    unloadFiles: () => this;
                    • Unloads files from Node's require cache.

                      This allows required files to be "freshly" reloaded, providing the ability to reuse a Mocha instance programmatically. Note: does not clear ESM module files from the cache

                    class Runnable

                    class Runnable {}
                    • Initialize a new Runnable with the given title and callback fn.

                      See Also

                      • https://mochajs.org/api/Runnable.html

                    constructor

                    constructor(title: string, fn?: Func | AsyncFunc);

                      property allowUncaught

                      allowUncaught?: boolean;

                        property async

                        async: boolean;

                          property body

                          body: string;

                            property callback

                            callback?: Done;

                              property ctx

                              ctx?: Context;

                                property duration

                                duration?: number;

                                  property file

                                  file?: string;

                                    property fn

                                    fn: Func | AsyncFunc;

                                      property parent

                                      parent?: Suite;

                                        property pending

                                        pending: boolean;

                                          property state

                                          state?: 'failed' | 'passed';

                                            property sync

                                            sync: boolean;

                                              property timedOut

                                              timedOut: boolean;

                                                property timer

                                                timer?: any;

                                                  property title

                                                  title: string;

                                                    method clearTimeout

                                                    clearTimeout: () => void;
                                                    • Clear the timeout.

                                                      See Also

                                                      • https://mochajs.org/api/Runnable.html#clearTimeout

                                                    method currentRetry

                                                    protected currentRetry: { (): number; (n: number): void };
                                                    • Set or get current retry

                                                      See Also

                                                      • https://mochajs.org/api/Runnable.html#currentRetry

                                                    method fullTitle

                                                    fullTitle: () => string;
                                                    • Return the full title generated by recursively concatenating the parent's full title.

                                                    method globals

                                                    globals: { (): string[]; (globals: readonly string[]): void };
                                                    • Get a list of whitelisted globals for this test run.

                                                      See Also

                                                      • https://mochajs.org/api/Runnable.html#globals

                                                    • Set a list of whitelisted globals for this test run.

                                                      See Also

                                                      • https://mochajs.org/api/Runnable.html#globals

                                                    method inspect

                                                    inspect: () => string;
                                                    • Inspect the runnable void of private properties.

                                                      See Also

                                                      • https://mochajs.org/api/Runnable.html#inspect

                                                    method isFailed

                                                    isFailed: () => boolean;
                                                    • Return true if this Runnable has failed.

                                                    method isPassed

                                                    isPassed: () => boolean;
                                                    • Return true if this Runnable has passed.

                                                    method isPending

                                                    isPending: () => boolean;
                                                    • Check if this runnable or its parent suite is marked as pending.

                                                      See Also

                                                      • https://mochajs.org/api/Runnable.html#isPending

                                                    method resetTimeout

                                                    resetTimeout: () => void;
                                                    • Reset the timeout.

                                                      See Also

                                                      • https://mochajs.org/api/Runnable.html#resetTimeout

                                                    method retries

                                                    retries: { (): number; (n: number): void };
                                                    • Set or get number of retries.

                                                      See Also

                                                      • https://mochajs.org/api/Runnable.html#retries

                                                    method run

                                                    run: (fn: Done) => void;
                                                    • Run the test and invoke fn(err).

                                                      See Also

                                                      • https://mochajs.org/api/Runnable.html#run

                                                    method skip

                                                    skip: () => never;
                                                    • Halt and mark as pending.

                                                    method slow

                                                    slow: { (): number; (ms: string | number): this };
                                                    • Get test slowness threshold.

                                                      See Also

                                                      • https://mochajs.org/api/Runnable.html#slow

                                                    • Set test slowness threshold.

                                                      See Also

                                                      • https://mochajs.org/api/Runnable.html#slow

                                                    method timeout

                                                    timeout: { (): number; (ms: string | number): this };
                                                    • Get test timeout.

                                                      See Also

                                                      • https://mochajs.org/api/Runnable.html#timeout

                                                    • Set test timeout.

                                                      See Also

                                                      • https://mochajs.org/api/Runnable.html#timeout

                                                    method titlePath

                                                    titlePath: () => string[];
                                                    • Return the title path generated by concatenating the parent's title path with the title.

                                                    class Runner

                                                    class Runner {}
                                                    • Initialize a Runner for the given suite.

                                                      See Also

                                                      • https://mochajs.org/api/Mocha.Runner.html

                                                    constructor

                                                    constructor(suite: Suite, delay: boolean);

                                                      property allowUncaught

                                                      allowUncaught?: boolean;

                                                        property asyncOnly

                                                        asyncOnly?: boolean;

                                                          property checkLeaks

                                                          checkLeaks?: boolean;

                                                            property constants

                                                            static readonly constants: RunnerConstants;

                                                              property currentRunnable

                                                              currentRunnable?: Runnable;

                                                                property failures

                                                                failures: number;

                                                                  property forbidOnly

                                                                  forbidOnly?: boolean;

                                                                    property forbidPending

                                                                    forbidPending?: boolean;

                                                                      property fullStackTrace

                                                                      fullStackTrace?: boolean;

                                                                        property started

                                                                        started: boolean;

                                                                          property stats

                                                                          stats?: Stats;

                                                                            property suite

                                                                            suite: Suite;

                                                                              property test

                                                                              test?: Test;

                                                                                property total

                                                                                total: number;

                                                                                  method abort

                                                                                  abort: () => this;
                                                                                  • Cleanly abort execution.

                                                                                    See Also

                                                                                    • https://mochajs.org/api/Mocha.Runner.html#.Runner#abort

                                                                                  method checkGlobals

                                                                                  protected checkGlobals: (test: Test) => void;
                                                                                  • Check for global variable leaks.

                                                                                    See Also

                                                                                    • https://mochajs.org/api/Mocha.Runner.html#checkGlobals

                                                                                  method dispose

                                                                                  dispose: () => void;
                                                                                  • Removes all event handlers set during a run on this instance. Remark: this does *not* clean/dispose the tests or suites themselves.

                                                                                    See Also

                                                                                    • https://mochajs.org/api/runner#dispose

                                                                                  method fail

                                                                                  protected fail: (test: Test, err: any) => void;
                                                                                  • Fail the given test.

                                                                                    See Also

                                                                                    • https://mochajs.org/api/Mocha.Runner.html#fail

                                                                                  method failHook

                                                                                  protected failHook: (hook: Hook, err: any) => void;
                                                                                  • Fail the given hook with err.

                                                                                    Hook failures work in the following pattern: - If bail, then exit - Failed before hook skips all tests in a suite and subsuites, but jumps to corresponding after hook - Failed before each hook skips remaining tests in a suite and jumps to corresponding after each hook, which is run only once - Failed after hook does not alter execution order - Failed after each hook skips remaining tests in a suite and subsuites, but executes other after each hooks

                                                                                    See Also

                                                                                    • https://mochajs.org/api/Mocha.Runner.html#failHook

                                                                                  method globalProps

                                                                                  protected globalProps: () => string[];
                                                                                  • Return a list of global properties.

                                                                                    See Also

                                                                                    • https://mochajs.org/api/Mocha.Runner.html#globalProps

                                                                                  method globals

                                                                                  globals: { (): string[]; (arr: readonly string[]): this };
                                                                                  • Gets the allowed globals.

                                                                                    See Also

                                                                                    • https://mochajs.org/api/Mocha.Runner.html#.Runner#globals

                                                                                  • Allow the given arr of globals.

                                                                                    See Also

                                                                                    • https://mochajs.org/api/Mocha.Runner.html#.Runner#globals

                                                                                  method grep

                                                                                  grep: (re: RegExp, invert: boolean) => this;
                                                                                  • Run tests with full titles matching re. Updates runner.total with number of tests matched.

                                                                                    See Also

                                                                                    • https://mochajs.org/api/Mocha.Runner.html#.Runner#grep

                                                                                  method grepTotal

                                                                                  grepTotal: (suite: Suite) => number;
                                                                                  • Returns the number of tests matching the grep search for the given suite.

                                                                                    See Also

                                                                                    • https://mochajs.org/api/Mocha.Runner.html#.Runner#grepTotal

                                                                                  method hook

                                                                                  protected hook: (name: string, fn: () => void) => void;
                                                                                  • Run hook name callbacks and then invoke fn().

                                                                                    See Also

                                                                                    • https://mochajs.org/api/Mocha.Runner.html#hook

                                                                                  method hookDown

                                                                                  protected hookDown: (
                                                                                  name: string,
                                                                                  fn: (err?: any, errSuite?: Suite) => void
                                                                                  ) => void;
                                                                                  • Run hooks from the bottom up.

                                                                                    See Also

                                                                                    • https://mochajs.org/api/Mocha.Runner.html#hookDown

                                                                                  method hooks

                                                                                  protected hooks: (
                                                                                  name: string,
                                                                                  suites: Suite[],
                                                                                  fn: (err?: any, errSuite?: Suite) => void
                                                                                  ) => void;
                                                                                  • Run hook name for the given array of suites in order, and callback fn(err, errSuite).

                                                                                    See Also

                                                                                    • https://mochajs.org/api/Mocha.Runner.html#hooks

                                                                                  method hookUp

                                                                                  protected hookUp: (
                                                                                  name: string,
                                                                                  fn: (err?: any, errSuite?: Suite) => void
                                                                                  ) => void;
                                                                                  • Run hooks from the top level down.

                                                                                    See Also

                                                                                    • https://mochajs.org/api/Mocha.Runner.html#hookUp

                                                                                  method immediately

                                                                                  protected static immediately: (callback: Function) => void;
                                                                                  • Wrapper for setImmediate, process.nextTick, or browser polyfill.

                                                                                  method parents

                                                                                  protected parents: () => Suite[];
                                                                                  • Return an array of parent Suites from closest to furthest.

                                                                                    See Also

                                                                                    • https://mochajs.org/api/Mocha.Runner.html#parents

                                                                                  method run

                                                                                  run: (fn?: (failures: number) => void) => this;
                                                                                  • Run the root suite and invoke fn(failures) on completion.

                                                                                    See Also

                                                                                    • https://mochajs.org/api/Mocha.Runner.html#.Runner#run

                                                                                  method runSuite

                                                                                  protected runSuite: (suite: Suite, fn: (errSuite?: Suite) => void) => void;
                                                                                  • Run the given suite and invoke the callback fn() when complete.

                                                                                    See Also

                                                                                    • https://mochajs.org/api/Mocha.Runner.html#runSuite

                                                                                  method runTest

                                                                                  protected runTest: (fn: Done) => any;
                                                                                  • Run the current test and callback fn(err).

                                                                                    See Also

                                                                                    • https://mochajs.org/api/Mocha.Runner.html#runTest

                                                                                  method runTests

                                                                                  protected runTests: (suite: Suite, fn: (errSuite?: Suite) => void) => void;
                                                                                  • Run tests in the given suite and invoke the callback fn() when complete.

                                                                                    See Also

                                                                                    • https://mochajs.org/api/Mocha.Runner.html#runTests

                                                                                  method uncaught

                                                                                  uncaught: (err: any) => void;
                                                                                  • Handle uncaught exceptions.

                                                                                    See Also

                                                                                    • https://mochajs.org/api/Mocha.Runner.html#uncaught

                                                                                  class Suite

                                                                                  class Suite {}
                                                                                  • Initialize a new Suite with the given title and ctx.

                                                                                    See Also

                                                                                    • https://mochajs.org/api/Mocha.Suite.html

                                                                                  constructor

                                                                                  constructor(title: string, parentContext?: Context);

                                                                                    property constants

                                                                                    static readonly constants: SuiteConstants;

                                                                                      property ctx

                                                                                      ctx: Context;

                                                                                        property delayed

                                                                                        delayed: boolean;

                                                                                          property file

                                                                                          file?: string;

                                                                                            property parent

                                                                                            parent: Suite;

                                                                                              property pending

                                                                                              pending: boolean;

                                                                                                property root

                                                                                                root: boolean;

                                                                                                  property suites

                                                                                                  suites: Suite[];

                                                                                                    property tests

                                                                                                    tests: Test[];

                                                                                                      property title

                                                                                                      title: string;

                                                                                                        method addSuite

                                                                                                        addSuite: (suite: Suite) => this;
                                                                                                        • Add a test suite.

                                                                                                          See Also

                                                                                                          • https://mochajs.org/api/Mocha.Suite.html#addSuite

                                                                                                        method addTest

                                                                                                        addTest: (test: Test) => this;
                                                                                                        • Add a test to this suite.

                                                                                                          See Also

                                                                                                          • https://mochajs.org/api/Mocha.Suite.html#addTest

                                                                                                        method afterAll

                                                                                                        afterAll: {
                                                                                                        (fn?: Func): this;
                                                                                                        (fn?: AsyncFunc): this;
                                                                                                        (title: string, fn?: Func): this;
                                                                                                        (title: string, fn?: AsyncFunc): this;
                                                                                                        };
                                                                                                        • Run fn(test[, done]) after running tests.

                                                                                                          See Also

                                                                                                          • https://mochajs.org/api/Mocha.Suite.html#afterAll

                                                                                                        method afterEach

                                                                                                        afterEach: {
                                                                                                        (fn?: Func): this;
                                                                                                        (fn?: AsyncFunc): this;
                                                                                                        (title: string, fn?: Func): this;
                                                                                                        (title: string, fn?: AsyncFunc): this;
                                                                                                        };
                                                                                                        • Run fn(test[, done]) after each test case.

                                                                                                          See Also

                                                                                                          • https://mochajs.org/api/Mocha.Suite.html#afterEach

                                                                                                        method bail

                                                                                                        bail: { (): boolean; (bail: boolean): this };
                                                                                                        • Get whether to bail after first error.

                                                                                                          See Also

                                                                                                          • https://mochajs.org/api/Mocha.Suite.html#bail

                                                                                                        • Set whether to bail after first error.

                                                                                                          See Also

                                                                                                          • https://mochajs.org/api/Mocha.Suite.html#bail

                                                                                                        method beforeAll

                                                                                                        beforeAll: {
                                                                                                        (fn?: Func): this;
                                                                                                        (fn?: AsyncFunc): this;
                                                                                                        (title: string, fn?: Func): this;
                                                                                                        (title: string, fn?: AsyncFunc): this;
                                                                                                        };
                                                                                                        • Run fn(test[, done]) before running tests.

                                                                                                          See Also

                                                                                                          • https://mochajs.org/api/Mocha.Suite.html#beforeAll

                                                                                                        method beforeEach

                                                                                                        beforeEach: {
                                                                                                        (fn?: Func): this;
                                                                                                        (fn?: AsyncFunc): this;
                                                                                                        (title: string, fn?: Func): this;
                                                                                                        (title: string, fn?: AsyncFunc): this;
                                                                                                        };
                                                                                                        • Run fn(test[, done]) before each test case.

                                                                                                          See Also

                                                                                                          • https://mochajs.org/api/Mocha.Suite.html#beforeEach

                                                                                                        method clone

                                                                                                        clone: () => Suite;
                                                                                                        • Return a clone of this Suite.

                                                                                                          See Also

                                                                                                          • https://mochajs.org/api/Mocha.Suite.html#clone

                                                                                                        method create

                                                                                                        static create: (parent: Suite, title: string) => Suite;
                                                                                                        • Create a new Suite with the given title and parent Suite. When a suite with the same title is already present, that suite is returned to provide nicer reporter and more flexible meta-testing.

                                                                                                          See Also

                                                                                                          • https://mochajs.org/api/mocha#.exports.create

                                                                                                        method dispose

                                                                                                        dispose: () => void;
                                                                                                        • Cleans all references from this suite and all child suites.

                                                                                                          https://mochajs.org/api/suite#dispose

                                                                                                        method eachTest

                                                                                                        eachTest: (fn: (test: Test) => void) => this;
                                                                                                        • Iterates through each suite recursively to find all tests. Applies a function in the format fn(test).

                                                                                                          See Also

                                                                                                          • https://mochajs.org/api/Mocha.Suite.html#eachTest

                                                                                                        method fullTitle

                                                                                                        fullTitle: () => string;
                                                                                                        • Return the full title generated by recursively concatenating the parent's full title.

                                                                                                          See Also

                                                                                                          • https://mochajs.org/api/Mocha.Suite.html#.Suite#fullTitle

                                                                                                        method isPending

                                                                                                        isPending: () => boolean;
                                                                                                        • Check if this suite or its parent suite is marked as pending.

                                                                                                          See Also

                                                                                                          • https://mochajs.org/api/Mocha.Suite.html#isPending

                                                                                                        method retries

                                                                                                        retries: { (): number; (n: string | number): this };
                                                                                                        • Get number of times to retry a failed test.

                                                                                                          See Also

                                                                                                          • https://mochajs.org/api/Mocha.Suite.html#retries

                                                                                                        • Set number of times to retry a failed test.

                                                                                                          See Also

                                                                                                          • https://mochajs.org/api/Mocha.Suite.html#retries

                                                                                                        method run

                                                                                                        run: () => void;
                                                                                                        • This will run the root suite if we happen to be running in delayed mode.

                                                                                                          See Also

                                                                                                          • https://mochajs.org/api/Mocha.Suite.html#run

                                                                                                        method slow

                                                                                                        slow: { (): number; (ms: string | number): this };
                                                                                                        • Get slow ms.

                                                                                                          See Also

                                                                                                          • https://mochajs.org/api/Mocha.Suite.html#slow

                                                                                                        • Set slow ms or short-hand such as "2s".

                                                                                                          See Also

                                                                                                          • https://mochajs.org/api/Mocha.Suite.html#slow

                                                                                                        method timeout

                                                                                                        timeout: { (): number; (ms: string | number): this };
                                                                                                        • Get timeout ms.

                                                                                                          See Also

                                                                                                          • https://mochajs.org/api/Mocha.Suite.html#timeout

                                                                                                        • Set timeout ms or short-hand such as "2s".

                                                                                                          See Also

                                                                                                          • https://mochajs.org/api/Mocha.Suite.html#timeout

                                                                                                        method titlePath

                                                                                                        titlePath: () => string[];
                                                                                                        • Return the title path generated by recursively concatenating the parent's title path.

                                                                                                          See Also

                                                                                                          • https://mochajs.org/api/Mocha.Suite.html#.Suite#titlePath

                                                                                                        method total

                                                                                                        total: () => number;
                                                                                                        • Return the total number of tests.

                                                                                                          See Also

                                                                                                          • https://mochajs.org/api/Mocha.Suite.html#.Suite#total

                                                                                                        class Test

                                                                                                        class Test extends Runnable {}
                                                                                                        • Initialize a new Test with the given title and callback fn.

                                                                                                          See Also

                                                                                                          • https://mochajs.org/api/Test.html

                                                                                                        property err

                                                                                                        err?: Error;

                                                                                                          property speed

                                                                                                          speed?: 'slow' | 'medium' | 'fast';

                                                                                                            property type

                                                                                                            type: string;

                                                                                                              method clone

                                                                                                              clone: () => Test;

                                                                                                                interface ExclusiveSuiteFunction

                                                                                                                interface ExclusiveSuiteFunction {}

                                                                                                                  call signature

                                                                                                                  (title: string, fn: (this: Suite) => void): Suite;
                                                                                                                  • [bdd, tdd] Describe a "suite" with the given title and callback fn containing nested suites. Indicates this suite should be executed exclusively.

                                                                                                                    - _Only available when invoked via the mocha CLI._

                                                                                                                  call signature

                                                                                                                  (title: string): Suite;
                                                                                                                  • [qunit] Describe a "suite" with the given title. Indicates this suite should be executed exclusively.

                                                                                                                    - _Only available when invoked via the mocha CLI._

                                                                                                                  interface ExclusiveTestFunction

                                                                                                                  interface ExclusiveTestFunction {}

                                                                                                                    call signature

                                                                                                                    (fn: Func): Test;
                                                                                                                    • [bdd, tdd, qunit] Describe a specification or test-case with the given callback fn acting as a thunk. The name of the function is used as the name of the test. Indicates this test should be executed exclusively.

                                                                                                                      - _Only available when invoked via the mocha CLI._

                                                                                                                    call signature

                                                                                                                    (fn: AsyncFunc): Test;
                                                                                                                    • [bdd, tdd, qunit] Describe a specification or test-case with the given callback fn acting as a thunk. The name of the function is used as the name of the test. Indicates this test should be executed exclusively.

                                                                                                                      - _Only available when invoked via the mocha CLI._

                                                                                                                    call signature

                                                                                                                    (title: string, fn?: Func): Test;
                                                                                                                    • [bdd, tdd, qunit] Describe a specification or test-case with the given title and callback fn acting as a thunk. Indicates this test should be executed exclusively.

                                                                                                                      - _Only available when invoked via the mocha CLI._

                                                                                                                    call signature

                                                                                                                    (title: string, fn?: AsyncFunc): Test;
                                                                                                                    • [bdd, tdd, qunit] Describe a specification or test-case with the given title and callback fn acting as a thunk. Indicates this test should be executed exclusively.

                                                                                                                      - _Only available when invoked via the mocha CLI._

                                                                                                                    interface HookFunction

                                                                                                                    interface HookFunction {}

                                                                                                                      call signature

                                                                                                                      (fn: Func): void;
                                                                                                                      • [bdd, qunit, tdd] Describe a "hook" to execute the given callback fn. The name of the function is used as the name of the hook.

                                                                                                                        - _Only available when invoked via the mocha CLI._

                                                                                                                      call signature

                                                                                                                      (fn: AsyncFunc): void;
                                                                                                                      • [bdd, qunit, tdd] Describe a "hook" to execute the given callback fn. The name of the function is used as the name of the hook.

                                                                                                                        - _Only available when invoked via the mocha CLI._

                                                                                                                      call signature

                                                                                                                      (name: string, fn?: Func): void;
                                                                                                                      • [bdd, qunit, tdd] Describe a "hook" to execute the given title and callback fn.

                                                                                                                        - _Only available when invoked via the mocha CLI._

                                                                                                                      call signature

                                                                                                                      (name: string, fn?: AsyncFunc): void;
                                                                                                                      • [bdd, qunit, tdd] Describe a "hook" to execute the given title and callback fn.

                                                                                                                        - _Only available when invoked via the mocha CLI._

                                                                                                                      interface InterfaceContributions

                                                                                                                      interface InterfaceContributions {}
                                                                                                                      • Third-party declarations that want to add new entries to the Interface union can contribute names here.

                                                                                                                      property bdd

                                                                                                                      bdd: never;

                                                                                                                        property exports

                                                                                                                        exports: never;

                                                                                                                          property qunit

                                                                                                                          qunit: never;

                                                                                                                            property tdd

                                                                                                                            tdd: never;

                                                                                                                              interface MochaGlobals

                                                                                                                              interface MochaGlobals {}
                                                                                                                              • Variables added to the global scope by Mocha when run in the CLI.

                                                                                                                              property after

                                                                                                                              after: HookFunction;
                                                                                                                              • Execute after running tests.

                                                                                                                                - _Only available when invoked via the mocha CLI._

                                                                                                                                See Also

                                                                                                                                • https://mochajs.org/api/global.html#after

                                                                                                                              property afterEach

                                                                                                                              afterEach: HookFunction;
                                                                                                                              • Execute after each test case.

                                                                                                                                - _Only available when invoked via the mocha CLI._

                                                                                                                                See Also

                                                                                                                                • https://mochajs.org/api/global.html#afterEach

                                                                                                                              property before

                                                                                                                              before: HookFunction;
                                                                                                                              • Execute before running tests.

                                                                                                                                - _Only available when invoked via the mocha CLI._

                                                                                                                                See Also

                                                                                                                                • https://mochajs.org/api/global.html#before

                                                                                                                              property beforeEach

                                                                                                                              beforeEach: HookFunction;
                                                                                                                              • Execute before each test case.

                                                                                                                                - _Only available when invoked via the mocha CLI._

                                                                                                                                See Also

                                                                                                                                • https://mochajs.org/api/global.html#beforeEach

                                                                                                                              property context

                                                                                                                              context: SuiteFunction;
                                                                                                                              • Describe a "suite" containing nested suites and tests.

                                                                                                                                - _Only available when invoked via the mocha CLI._

                                                                                                                              property describe

                                                                                                                              describe: SuiteFunction;
                                                                                                                              • Describe a "suite" containing nested suites and tests.

                                                                                                                                - _Only available when invoked via the mocha CLI._

                                                                                                                              property it

                                                                                                                              it: TestFunction;
                                                                                                                              • Describes a test case.

                                                                                                                                - _Only available when invoked via the mocha CLI._

                                                                                                                              property run

                                                                                                                              run: typeof run;

                                                                                                                                property setup

                                                                                                                                setup: HookFunction;
                                                                                                                                • Execute before each test case.

                                                                                                                                  - _Only available when invoked via the mocha CLI._

                                                                                                                                  See Also

                                                                                                                                  • https://mochajs.org/api/global.html#beforeEach

                                                                                                                                property specify

                                                                                                                                specify: TestFunction;
                                                                                                                                • Describes a test case.

                                                                                                                                  - _Only available when invoked via the mocha CLI._

                                                                                                                                property suite

                                                                                                                                suite: SuiteFunction;
                                                                                                                                • Describe a "suite" containing nested suites and tests.

                                                                                                                                  - _Only available when invoked via the mocha CLI._

                                                                                                                                property suiteSetup

                                                                                                                                suiteSetup: HookFunction;
                                                                                                                                • Execute before running tests.

                                                                                                                                  - _Only available when invoked via the mocha CLI._

                                                                                                                                  See Also

                                                                                                                                  • https://mochajs.org/api/global.html#before

                                                                                                                                property suiteTeardown

                                                                                                                                suiteTeardown: HookFunction;
                                                                                                                                • Execute after running tests.

                                                                                                                                  - _Only available when invoked via the mocha CLI._

                                                                                                                                  See Also

                                                                                                                                  • https://mochajs.org/api/global.html#after

                                                                                                                                property teardown

                                                                                                                                teardown: HookFunction;
                                                                                                                                • Execute after each test case.

                                                                                                                                  - _Only available when invoked via the mocha CLI._

                                                                                                                                  See Also

                                                                                                                                  • https://mochajs.org/api/global.html#afterEach

                                                                                                                                property test

                                                                                                                                test: TestFunction;
                                                                                                                                • Describes a test case.

                                                                                                                                  - _Only available when invoked via the mocha CLI._

                                                                                                                                property xcontext

                                                                                                                                xcontext: PendingSuiteFunction;
                                                                                                                                • Pending suite.

                                                                                                                                  - _Only available when invoked via the mocha CLI._

                                                                                                                                property xdescribe

                                                                                                                                xdescribe: PendingSuiteFunction;
                                                                                                                                • Pending suite.

                                                                                                                                  - _Only available when invoked via the mocha CLI._

                                                                                                                                property xit

                                                                                                                                xit: PendingTestFunction;
                                                                                                                                • Describes a pending test case.

                                                                                                                                  - _Only available when invoked via the mocha CLI._

                                                                                                                                property xspecify

                                                                                                                                xspecify: PendingTestFunction;
                                                                                                                                • Describes a pending test case.

                                                                                                                                  - _Only available when invoked via the mocha CLI._

                                                                                                                                interface MochaInstanceOptions

                                                                                                                                interface MochaInstanceOptions extends MochaOptions {}

                                                                                                                                  property files

                                                                                                                                  files?: string[];

                                                                                                                                    interface MochaOptions

                                                                                                                                    interface MochaOptions {}
                                                                                                                                    • Options to pass to Mocha.

                                                                                                                                    property allowUncaught

                                                                                                                                    allowUncaught?: boolean;

                                                                                                                                      property asyncOnly

                                                                                                                                      asyncOnly?: boolean;

                                                                                                                                        property bail

                                                                                                                                        bail?: boolean;
                                                                                                                                        • bail on the first test failure.

                                                                                                                                        property checkLeaks

                                                                                                                                        checkLeaks?: boolean;
                                                                                                                                        • check for global variable leaks.

                                                                                                                                        property color

                                                                                                                                        color?: boolean;
                                                                                                                                        • Color TTY output from reporter

                                                                                                                                        property delay

                                                                                                                                        delay?: boolean;

                                                                                                                                          property forbidOnly

                                                                                                                                          forbidOnly?: boolean;

                                                                                                                                            property forbidPending

                                                                                                                                            forbidPending?: boolean;

                                                                                                                                              property fullStackTrace

                                                                                                                                              fullStackTrace?: boolean;
                                                                                                                                              • display the full stack trace on failure.

                                                                                                                                              property fullTrace

                                                                                                                                              fullTrace?: boolean;

                                                                                                                                                property globals

                                                                                                                                                globals?: string[];
                                                                                                                                                • Array of accepted globals.

                                                                                                                                                property grep

                                                                                                                                                grep?: string | RegExp;
                                                                                                                                                • string or regexp to filter tests with.

                                                                                                                                                property growl

                                                                                                                                                growl?: boolean;
                                                                                                                                                • Enable growl support.

                                                                                                                                                property hideDiff

                                                                                                                                                hideDiff?: boolean;
                                                                                                                                                • Do not show diffs at all.

                                                                                                                                                property inlineDiffs

                                                                                                                                                inlineDiffs?: boolean;
                                                                                                                                                • Use inline diffs rather than +/-.

                                                                                                                                                property jobs

                                                                                                                                                jobs?: number;
                                                                                                                                                • Max number of worker processes for parallel runs

                                                                                                                                                property noHighlighting

                                                                                                                                                noHighlighting?: boolean;

                                                                                                                                                  property parallel

                                                                                                                                                  parallel?: boolean;
                                                                                                                                                  • Run job in parallel

                                                                                                                                                  property reporter

                                                                                                                                                  reporter?: string | ReporterConstructor;
                                                                                                                                                  • Reporter constructor, built-in reporter name, or reporter module path. Defaults to "spec".

                                                                                                                                                  property reporterOptions

                                                                                                                                                  reporterOptions?: any;
                                                                                                                                                  • Options to pass to the reporter.

                                                                                                                                                  property retries

                                                                                                                                                  retries?: number;
                                                                                                                                                  • number of times to retry failed tests.

                                                                                                                                                  property rootHooks

                                                                                                                                                  rootHooks?: RootHookObject;
                                                                                                                                                  • Assigns hooks to the root suite

                                                                                                                                                  property slow

                                                                                                                                                  slow?: number;
                                                                                                                                                  • milliseconds to wait before considering a test slow.

                                                                                                                                                  property timeout

                                                                                                                                                  timeout?: number | string;
                                                                                                                                                  • timeout in milliseconds or time string like '1s'.

                                                                                                                                                  property ui

                                                                                                                                                  ui?: Interface;
                                                                                                                                                  • Test interfaces ("bdd", "tdd", "exports", etc.).

                                                                                                                                                  interface PendingSuiteFunction

                                                                                                                                                  interface PendingSuiteFunction {}
                                                                                                                                                  • [bdd, tdd] Describe a "suite" with the given title and callback fn containing nested suites. Indicates this suite should not be executed.

                                                                                                                                                    - _Only available when invoked via the mocha CLI._

                                                                                                                                                    Returns

                                                                                                                                                    [tdd] void

                                                                                                                                                  call signature

                                                                                                                                                  (title: string, fn: (this: Suite) => void): Suite | void;

                                                                                                                                                    interface PendingTestFunction

                                                                                                                                                    interface PendingTestFunction {}

                                                                                                                                                      call signature

                                                                                                                                                      (fn: Func): Test;
                                                                                                                                                      • [bdd, tdd, qunit] Describe a specification or test-case with the given callback fn acting as a thunk. The name of the function is used as the name of the test. Indicates this test should not be executed.

                                                                                                                                                        - _Only available when invoked via the mocha CLI._

                                                                                                                                                      call signature

                                                                                                                                                      (fn: AsyncFunc): Test;
                                                                                                                                                      • [bdd, tdd, qunit] Describe a specification or test-case with the given callback fn acting as a thunk. The name of the function is used as the name of the test. Indicates this test should not be executed.

                                                                                                                                                        - _Only available when invoked via the mocha CLI._

                                                                                                                                                      call signature

                                                                                                                                                      (title: string, fn?: Func): Test;
                                                                                                                                                      • [bdd, tdd, qunit] Describe a specification or test-case with the given title and callback fn acting as a thunk. Indicates this test should not be executed.

                                                                                                                                                        - _Only available when invoked via the mocha CLI._

                                                                                                                                                      call signature

                                                                                                                                                      (title: string, fn?: AsyncFunc): Test;
                                                                                                                                                      • [bdd, tdd, qunit] Describe a specification or test-case with the given title and callback fn acting as a thunk. Indicates this test should not be executed.

                                                                                                                                                        - _Only available when invoked via the mocha CLI._

                                                                                                                                                      interface ReporterConstructor

                                                                                                                                                      interface ReporterConstructor {}

                                                                                                                                                        construct signature

                                                                                                                                                        new (runner: Runner, options: MochaOptions): reporters.Base;

                                                                                                                                                          interface ReporterContributions

                                                                                                                                                          interface ReporterContributions {}
                                                                                                                                                          • Third-party declarations that want to add new entries to the Reporter union can contribute names here.

                                                                                                                                                          property "json-stream"

                                                                                                                                                          'json-stream': never;

                                                                                                                                                            property base

                                                                                                                                                            base: never;

                                                                                                                                                              property Base

                                                                                                                                                              Base: never;

                                                                                                                                                                property dot

                                                                                                                                                                dot: never;

                                                                                                                                                                  property Dot

                                                                                                                                                                  Dot: never;

                                                                                                                                                                    property html

                                                                                                                                                                    html: never;

                                                                                                                                                                      property HTML

                                                                                                                                                                      HTML: never;

                                                                                                                                                                        property json

                                                                                                                                                                        json: never;

                                                                                                                                                                          property JSON

                                                                                                                                                                          JSON: never;

                                                                                                                                                                            property JSONStream

                                                                                                                                                                            JSONStream: never;

                                                                                                                                                                              property landing

                                                                                                                                                                              landing: never;

                                                                                                                                                                                property Landing

                                                                                                                                                                                Landing: never;

                                                                                                                                                                                  property list

                                                                                                                                                                                  list: never;

                                                                                                                                                                                    property List

                                                                                                                                                                                    List: never;

                                                                                                                                                                                      property markdown

                                                                                                                                                                                      markdown: never;

                                                                                                                                                                                        property Markdown

                                                                                                                                                                                        Markdown: never;

                                                                                                                                                                                          property min

                                                                                                                                                                                          min: never;

                                                                                                                                                                                            property Min

                                                                                                                                                                                            Min: never;

                                                                                                                                                                                              property nyan

                                                                                                                                                                                              nyan: never;

                                                                                                                                                                                                property Nyan

                                                                                                                                                                                                Nyan: never;

                                                                                                                                                                                                  property progress

                                                                                                                                                                                                  progress: never;

                                                                                                                                                                                                    property Progress

                                                                                                                                                                                                    Progress: never;

                                                                                                                                                                                                      property spec

                                                                                                                                                                                                      spec: never;

                                                                                                                                                                                                        property Spec

                                                                                                                                                                                                        Spec: never;

                                                                                                                                                                                                          property tap

                                                                                                                                                                                                          tap: never;

                                                                                                                                                                                                            property TAP

                                                                                                                                                                                                            TAP: never;

                                                                                                                                                                                                              property xunit

                                                                                                                                                                                                              xunit: never;

                                                                                                                                                                                                                property XUnit

                                                                                                                                                                                                                XUnit: never;

                                                                                                                                                                                                                  interface RootHookObject

                                                                                                                                                                                                                  interface RootHookObject {}
                                                                                                                                                                                                                  • An alternative way to define root hooks that works with parallel runs.

                                                                                                                                                                                                                    Root hooks work with any interface, but the property names do not change. In other words, if you are using the tdd interface, suiteSetup maps to beforeAll, and setup maps to beforeEach.

                                                                                                                                                                                                                    As with other hooks, this refers to to the current context object.

                                                                                                                                                                                                                    See Also

                                                                                                                                                                                                                    • https://mochajs.org/#root-hook-plugins

                                                                                                                                                                                                                  property afterAll

                                                                                                                                                                                                                  afterAll?: Func | AsyncFunc | Func[] | AsyncFunc[];
                                                                                                                                                                                                                  • In serial mode, run after all tests end, once only. In parallel mode, run after all tests end, for each file.

                                                                                                                                                                                                                  property afterEach

                                                                                                                                                                                                                  afterEach?: Func | AsyncFunc | Func[] | AsyncFunc[];
                                                                                                                                                                                                                  • In both modes, run after every test.

                                                                                                                                                                                                                  property beforeAll

                                                                                                                                                                                                                  beforeAll?: Func | AsyncFunc | Func[] | AsyncFunc[];
                                                                                                                                                                                                                  • In serial mode (Mocha's default), before all tests begin, once only. In parallel mode, run before all tests begin, for each file.

                                                                                                                                                                                                                  property beforeEach

                                                                                                                                                                                                                  beforeEach?: Func | AsyncFunc | Func[] | AsyncFunc[];
                                                                                                                                                                                                                  • In both modes, run before each test.

                                                                                                                                                                                                                  interface Runnable

                                                                                                                                                                                                                  interface Runnable extends NodeJS.EventEmitter {}

                                                                                                                                                                                                                    method addListener

                                                                                                                                                                                                                    addListener: {
                                                                                                                                                                                                                    (event: 'error', listener: (error: any) => void): this;
                                                                                                                                                                                                                    (event: string, listener: (...args: any[]) => void): this;
                                                                                                                                                                                                                    };

                                                                                                                                                                                                                      method emit

                                                                                                                                                                                                                      emit: {
                                                                                                                                                                                                                      (name: 'error', error: any): boolean;
                                                                                                                                                                                                                      (name: string, ...args: any[]): boolean;
                                                                                                                                                                                                                      };

                                                                                                                                                                                                                        method on

                                                                                                                                                                                                                        on: {
                                                                                                                                                                                                                        (event: 'error', listener: (error: any) => void): this;
                                                                                                                                                                                                                        (event: string, listener: (...args: any[]) => void): this;
                                                                                                                                                                                                                        };

                                                                                                                                                                                                                          method once

                                                                                                                                                                                                                          once: {
                                                                                                                                                                                                                          (event: 'error', listener: (error: any) => void): this;
                                                                                                                                                                                                                          (event: string, listener: (...args: any[]) => void): this;
                                                                                                                                                                                                                          };

                                                                                                                                                                                                                            method prependListener

                                                                                                                                                                                                                            prependListener: {
                                                                                                                                                                                                                            (event: 'error', listener: (error: any) => void): this;
                                                                                                                                                                                                                            (event: string, listener: (...args: any[]) => void): this;
                                                                                                                                                                                                                            };

                                                                                                                                                                                                                              method prependOnceListener

                                                                                                                                                                                                                              prependOnceListener: {
                                                                                                                                                                                                                              (event: 'error', listener: (error: any) => void): this;
                                                                                                                                                                                                                              (event: string, listener: (...args: any[]) => void): this;
                                                                                                                                                                                                                              };

                                                                                                                                                                                                                                method removeListener

                                                                                                                                                                                                                                removeListener: {
                                                                                                                                                                                                                                (event: 'error', listener: (error: any) => void): this;
                                                                                                                                                                                                                                (event: string, listener: (...args: any[]) => void): this;
                                                                                                                                                                                                                                };

                                                                                                                                                                                                                                  interface Runnable

                                                                                                                                                                                                                                  interface Runnable extends NodeJS.EventEmitter {}

                                                                                                                                                                                                                                    method addListener

                                                                                                                                                                                                                                    addListener: {
                                                                                                                                                                                                                                    (event: 'error', listener: (error: any) => void): this;
                                                                                                                                                                                                                                    (event: string, listener: (...args: any[]) => void): this;
                                                                                                                                                                                                                                    };

                                                                                                                                                                                                                                      method emit

                                                                                                                                                                                                                                      emit: {
                                                                                                                                                                                                                                      (name: 'error', error: any): boolean;
                                                                                                                                                                                                                                      (name: string, ...args: any[]): boolean;
                                                                                                                                                                                                                                      };

                                                                                                                                                                                                                                        method on

                                                                                                                                                                                                                                        on: {
                                                                                                                                                                                                                                        (event: 'error', listener: (error: any) => void): this;
                                                                                                                                                                                                                                        (event: string, listener: (...args: any[]) => void): this;
                                                                                                                                                                                                                                        };

                                                                                                                                                                                                                                          method once

                                                                                                                                                                                                                                          once: {
                                                                                                                                                                                                                                          (event: 'error', listener: (error: any) => void): this;
                                                                                                                                                                                                                                          (event: string, listener: (...args: any[]) => void): this;
                                                                                                                                                                                                                                          };

                                                                                                                                                                                                                                            method prependListener

                                                                                                                                                                                                                                            prependListener: {
                                                                                                                                                                                                                                            (event: 'error', listener: (error: any) => void): this;
                                                                                                                                                                                                                                            (event: string, listener: (...args: any[]) => void): this;
                                                                                                                                                                                                                                            };

                                                                                                                                                                                                                                              method prependOnceListener

                                                                                                                                                                                                                                              prependOnceListener: {
                                                                                                                                                                                                                                              (event: 'error', listener: (error: any) => void): this;
                                                                                                                                                                                                                                              (event: string, listener: (...args: any[]) => void): this;
                                                                                                                                                                                                                                              };

                                                                                                                                                                                                                                                method removeListener

                                                                                                                                                                                                                                                removeListener: {
                                                                                                                                                                                                                                                (event: 'error', listener: (error: any) => void): this;
                                                                                                                                                                                                                                                (event: string, listener: (...args: any[]) => void): this;
                                                                                                                                                                                                                                                };

                                                                                                                                                                                                                                                  interface Runner

                                                                                                                                                                                                                                                  interface Runner {}

                                                                                                                                                                                                                                                    method addListener

                                                                                                                                                                                                                                                    addListener: {
                                                                                                                                                                                                                                                    (event: 'waiting', listener: (rootSuite: Suite) => void): this;
                                                                                                                                                                                                                                                    (event: 'start', listener: () => void): this;
                                                                                                                                                                                                                                                    (event: 'end', listener: () => void): this;
                                                                                                                                                                                                                                                    (event: 'suite', listener: (suite: Suite) => void): this;
                                                                                                                                                                                                                                                    (event: 'suite end', listener: (suite: Suite) => void): this;
                                                                                                                                                                                                                                                    (event: 'test', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                    (event: 'test end', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                    (event: 'hook', listener: (hook: Hook) => void): this;
                                                                                                                                                                                                                                                    (event: 'hook end', listener: (hook: Hook) => void): this;
                                                                                                                                                                                                                                                    (event: 'pass', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                    (event: 'fail', listener: (test: Test, err: any) => void): this;
                                                                                                                                                                                                                                                    (event: 'pending', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                    (event: string, listener: (...args: any[]) => void): this;
                                                                                                                                                                                                                                                    };

                                                                                                                                                                                                                                                      method emit

                                                                                                                                                                                                                                                      emit: {
                                                                                                                                                                                                                                                      (name: 'waiting', rootSuite: Suite): boolean;
                                                                                                                                                                                                                                                      (name: 'start'): boolean;
                                                                                                                                                                                                                                                      (name: 'end'): boolean;
                                                                                                                                                                                                                                                      (name: 'suite', suite: Suite): boolean;
                                                                                                                                                                                                                                                      (name: 'suite end', suite: Suite): boolean;
                                                                                                                                                                                                                                                      (name: 'test', test: Test): boolean;
                                                                                                                                                                                                                                                      (name: 'test end', test: Test): boolean;
                                                                                                                                                                                                                                                      (name: 'hook', hook: Hook): boolean;
                                                                                                                                                                                                                                                      (name: 'hook end', hook: Hook): boolean;
                                                                                                                                                                                                                                                      (name: 'pass', test: Test): boolean;
                                                                                                                                                                                                                                                      (name: 'fail', test: Test, err: any): boolean;
                                                                                                                                                                                                                                                      (name: 'pending', test: Test): boolean;
                                                                                                                                                                                                                                                      (name: string, ...args: any[]): boolean;
                                                                                                                                                                                                                                                      };

                                                                                                                                                                                                                                                        method on

                                                                                                                                                                                                                                                        on: {
                                                                                                                                                                                                                                                        (event: 'waiting', listener: (rootSuite: Suite) => void): this;
                                                                                                                                                                                                                                                        (event: 'start', listener: () => void): this;
                                                                                                                                                                                                                                                        (event: 'end', listener: () => void): this;
                                                                                                                                                                                                                                                        (event: 'suite', listener: (suite: Suite) => void): this;
                                                                                                                                                                                                                                                        (event: 'suite end', listener: (suite: Suite) => void): this;
                                                                                                                                                                                                                                                        (event: 'test', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                        (event: 'test end', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                        (event: 'hook', listener: (hook: Hook) => void): this;
                                                                                                                                                                                                                                                        (event: 'hook end', listener: (hook: Hook) => void): this;
                                                                                                                                                                                                                                                        (event: 'pass', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                        (event: 'fail', listener: (test: Test, err: any) => void): this;
                                                                                                                                                                                                                                                        (event: 'pending', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                        (event: string, listener: (...args: any[]) => void): this;
                                                                                                                                                                                                                                                        };

                                                                                                                                                                                                                                                          method once

                                                                                                                                                                                                                                                          once: {
                                                                                                                                                                                                                                                          (event: 'waiting', listener: (rootSuite: Suite) => void): this;
                                                                                                                                                                                                                                                          (event: 'start', listener: () => void): this;
                                                                                                                                                                                                                                                          (event: 'end', listener: () => void): this;
                                                                                                                                                                                                                                                          (event: 'suite', listener: (suite: Suite) => void): this;
                                                                                                                                                                                                                                                          (event: 'suite end', listener: (suite: Suite) => void): this;
                                                                                                                                                                                                                                                          (event: 'test', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                          (event: 'test end', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                          (event: 'hook', listener: (hook: Hook) => void): this;
                                                                                                                                                                                                                                                          (event: 'hook end', listener: (hook: Hook) => void): this;
                                                                                                                                                                                                                                                          (event: 'pass', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                          (event: 'fail', listener: (test: Test, err: any) => void): this;
                                                                                                                                                                                                                                                          (event: 'pending', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                          (event: string, listener: (...args: any[]) => void): this;
                                                                                                                                                                                                                                                          };

                                                                                                                                                                                                                                                            method prependListener

                                                                                                                                                                                                                                                            prependListener: {
                                                                                                                                                                                                                                                            (event: 'waiting', listener: (rootSuite: Suite) => void): this;
                                                                                                                                                                                                                                                            (event: 'start', listener: () => void): this;
                                                                                                                                                                                                                                                            (event: 'end', listener: () => void): this;
                                                                                                                                                                                                                                                            (event: 'suite', listener: (suite: Suite) => void): this;
                                                                                                                                                                                                                                                            (event: 'suite end', listener: (suite: Suite) => void): this;
                                                                                                                                                                                                                                                            (event: 'test', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                            (event: 'test end', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                            (event: 'hook', listener: (hook: Hook) => void): this;
                                                                                                                                                                                                                                                            (event: 'hook end', listener: (hook: Hook) => void): this;
                                                                                                                                                                                                                                                            (event: 'pass', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                            (event: 'fail', listener: (test: Test, err: any) => void): this;
                                                                                                                                                                                                                                                            (event: 'pending', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                            (event: string, listener: (...args: any[]) => void): this;
                                                                                                                                                                                                                                                            };

                                                                                                                                                                                                                                                              method prependOnceListener

                                                                                                                                                                                                                                                              prependOnceListener: {
                                                                                                                                                                                                                                                              (event: 'waiting', listener: (rootSuite: Suite) => void): this;
                                                                                                                                                                                                                                                              (event: 'start', listener: () => void): this;
                                                                                                                                                                                                                                                              (event: 'end', listener: () => void): this;
                                                                                                                                                                                                                                                              (event: 'suite', listener: (suite: Suite) => void): this;
                                                                                                                                                                                                                                                              (event: 'suite end', listener: (suite: Suite) => void): this;
                                                                                                                                                                                                                                                              (event: 'test', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                              (event: 'test end', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                              (event: 'hook', listener: (hook: Hook) => void): this;
                                                                                                                                                                                                                                                              (event: 'hook end', listener: (hook: Hook) => void): this;
                                                                                                                                                                                                                                                              (event: 'pass', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                              (event: 'fail', listener: (test: Test, err: any) => void): this;
                                                                                                                                                                                                                                                              (event: 'pending', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                              (event: string, listener: (...args: any[]) => void): this;
                                                                                                                                                                                                                                                              };

                                                                                                                                                                                                                                                                method removeListener

                                                                                                                                                                                                                                                                removeListener: {
                                                                                                                                                                                                                                                                (event: 'waiting', listener: (rootSuite: Suite) => void): this;
                                                                                                                                                                                                                                                                (event: 'start', listener: () => void): this;
                                                                                                                                                                                                                                                                (event: 'end', listener: () => void): this;
                                                                                                                                                                                                                                                                (event: 'suite', listener: (suite: Suite) => void): this;
                                                                                                                                                                                                                                                                (event: 'suite end', listener: (suite: Suite) => void): this;
                                                                                                                                                                                                                                                                (event: 'test', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                                (event: 'test end', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                                (event: 'hook', listener: (hook: Hook) => void): this;
                                                                                                                                                                                                                                                                (event: 'hook end', listener: (hook: Hook) => void): this;
                                                                                                                                                                                                                                                                (event: 'pass', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                                (event: 'fail', listener: (test: Test, err: any) => void): this;
                                                                                                                                                                                                                                                                (event: 'pending', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                                (event: string, listener: (...args: any[]) => void): this;
                                                                                                                                                                                                                                                                };

                                                                                                                                                                                                                                                                  interface Runner

                                                                                                                                                                                                                                                                  interface Runner extends NodeJS.EventEmitter {}

                                                                                                                                                                                                                                                                    method addListener

                                                                                                                                                                                                                                                                    addListener: {
                                                                                                                                                                                                                                                                    (event: 'waiting', listener: (rootSuite: Suite) => void): this;
                                                                                                                                                                                                                                                                    (event: 'start', listener: () => void): this;
                                                                                                                                                                                                                                                                    (event: 'end', listener: () => void): this;
                                                                                                                                                                                                                                                                    (event: 'suite', listener: (suite: Suite) => void): this;
                                                                                                                                                                                                                                                                    (event: 'suite end', listener: (suite: Suite) => void): this;
                                                                                                                                                                                                                                                                    (event: 'test', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                                    (event: 'test end', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                                    (event: 'hook', listener: (hook: Hook) => void): this;
                                                                                                                                                                                                                                                                    (event: 'hook end', listener: (hook: Hook) => void): this;
                                                                                                                                                                                                                                                                    (event: 'pass', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                                    (event: 'fail', listener: (test: Test, err: any) => void): this;
                                                                                                                                                                                                                                                                    (event: 'pending', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                                    (event: string, listener: (...args: any[]) => void): this;
                                                                                                                                                                                                                                                                    };

                                                                                                                                                                                                                                                                      method emit

                                                                                                                                                                                                                                                                      emit: {
                                                                                                                                                                                                                                                                      (name: 'waiting', rootSuite: Suite): boolean;
                                                                                                                                                                                                                                                                      (name: 'start'): boolean;
                                                                                                                                                                                                                                                                      (name: 'end'): boolean;
                                                                                                                                                                                                                                                                      (name: 'suite', suite: Suite): boolean;
                                                                                                                                                                                                                                                                      (name: 'suite end', suite: Suite): boolean;
                                                                                                                                                                                                                                                                      (name: 'test', test: Test): boolean;
                                                                                                                                                                                                                                                                      (name: 'test end', test: Test): boolean;
                                                                                                                                                                                                                                                                      (name: 'hook', hook: Hook): boolean;
                                                                                                                                                                                                                                                                      (name: 'hook end', hook: Hook): boolean;
                                                                                                                                                                                                                                                                      (name: 'pass', test: Test): boolean;
                                                                                                                                                                                                                                                                      (name: 'fail', test: Test, err: any): boolean;
                                                                                                                                                                                                                                                                      (name: 'pending', test: Test): boolean;
                                                                                                                                                                                                                                                                      (name: string, ...args: any[]): boolean;
                                                                                                                                                                                                                                                                      };

                                                                                                                                                                                                                                                                        method on

                                                                                                                                                                                                                                                                        on: {
                                                                                                                                                                                                                                                                        (event: 'waiting', listener: (rootSuite: Suite) => void): this;
                                                                                                                                                                                                                                                                        (event: 'start', listener: () => void): this;
                                                                                                                                                                                                                                                                        (event: 'end', listener: () => void): this;
                                                                                                                                                                                                                                                                        (event: 'suite', listener: (suite: Suite) => void): this;
                                                                                                                                                                                                                                                                        (event: 'suite end', listener: (suite: Suite) => void): this;
                                                                                                                                                                                                                                                                        (event: 'test', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                                        (event: 'test end', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                                        (event: 'hook', listener: (hook: Hook) => void): this;
                                                                                                                                                                                                                                                                        (event: 'hook end', listener: (hook: Hook) => void): this;
                                                                                                                                                                                                                                                                        (event: 'pass', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                                        (event: 'fail', listener: (test: Test, err: any) => void): this;
                                                                                                                                                                                                                                                                        (event: 'pending', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                                        (event: string, listener: (...args: any[]) => void): this;
                                                                                                                                                                                                                                                                        };

                                                                                                                                                                                                                                                                          method once

                                                                                                                                                                                                                                                                          once: {
                                                                                                                                                                                                                                                                          (event: 'waiting', listener: (rootSuite: Suite) => void): this;
                                                                                                                                                                                                                                                                          (event: 'start', listener: () => void): this;
                                                                                                                                                                                                                                                                          (event: 'end', listener: () => void): this;
                                                                                                                                                                                                                                                                          (event: 'suite', listener: (suite: Suite) => void): this;
                                                                                                                                                                                                                                                                          (event: 'suite end', listener: (suite: Suite) => void): this;
                                                                                                                                                                                                                                                                          (event: 'test', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                                          (event: 'test end', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                                          (event: 'hook', listener: (hook: Hook) => void): this;
                                                                                                                                                                                                                                                                          (event: 'hook end', listener: (hook: Hook) => void): this;
                                                                                                                                                                                                                                                                          (event: 'pass', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                                          (event: 'fail', listener: (test: Test, err: any) => void): this;
                                                                                                                                                                                                                                                                          (event: 'pending', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                                          (event: string, listener: (...args: any[]) => void): this;
                                                                                                                                                                                                                                                                          };

                                                                                                                                                                                                                                                                            method prependListener

                                                                                                                                                                                                                                                                            prependListener: {
                                                                                                                                                                                                                                                                            (event: 'waiting', listener: (rootSuite: Suite) => void): this;
                                                                                                                                                                                                                                                                            (event: 'start', listener: () => void): this;
                                                                                                                                                                                                                                                                            (event: 'end', listener: () => void): this;
                                                                                                                                                                                                                                                                            (event: 'suite', listener: (suite: Suite) => void): this;
                                                                                                                                                                                                                                                                            (event: 'suite end', listener: (suite: Suite) => void): this;
                                                                                                                                                                                                                                                                            (event: 'test', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                                            (event: 'test end', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                                            (event: 'hook', listener: (hook: Hook) => void): this;
                                                                                                                                                                                                                                                                            (event: 'hook end', listener: (hook: Hook) => void): this;
                                                                                                                                                                                                                                                                            (event: 'pass', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                                            (event: 'fail', listener: (test: Test, err: any) => void): this;
                                                                                                                                                                                                                                                                            (event: 'pending', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                                            (event: string, listener: (...args: any[]) => void): this;
                                                                                                                                                                                                                                                                            };

                                                                                                                                                                                                                                                                              method prependOnceListener

                                                                                                                                                                                                                                                                              prependOnceListener: {
                                                                                                                                                                                                                                                                              (event: 'waiting', listener: (rootSuite: Suite) => void): this;
                                                                                                                                                                                                                                                                              (event: 'start', listener: () => void): this;
                                                                                                                                                                                                                                                                              (event: 'end', listener: () => void): this;
                                                                                                                                                                                                                                                                              (event: 'suite', listener: (suite: Suite) => void): this;
                                                                                                                                                                                                                                                                              (event: 'suite end', listener: (suite: Suite) => void): this;
                                                                                                                                                                                                                                                                              (event: 'test', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                                              (event: 'test end', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                                              (event: 'hook', listener: (hook: Hook) => void): this;
                                                                                                                                                                                                                                                                              (event: 'hook end', listener: (hook: Hook) => void): this;
                                                                                                                                                                                                                                                                              (event: 'pass', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                                              (event: 'fail', listener: (test: Test, err: any) => void): this;
                                                                                                                                                                                                                                                                              (event: 'pending', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                                              (event: string, listener: (...args: any[]) => void): this;
                                                                                                                                                                                                                                                                              };

                                                                                                                                                                                                                                                                                method removeListener

                                                                                                                                                                                                                                                                                removeListener: {
                                                                                                                                                                                                                                                                                (event: 'waiting', listener: (rootSuite: Suite) => void): this;
                                                                                                                                                                                                                                                                                (event: 'start', listener: () => void): this;
                                                                                                                                                                                                                                                                                (event: 'end', listener: () => void): this;
                                                                                                                                                                                                                                                                                (event: 'suite', listener: (suite: Suite) => void): this;
                                                                                                                                                                                                                                                                                (event: 'suite end', listener: (suite: Suite) => void): this;
                                                                                                                                                                                                                                                                                (event: 'test', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                                                (event: 'test end', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                                                (event: 'hook', listener: (hook: Hook) => void): this;
                                                                                                                                                                                                                                                                                (event: 'hook end', listener: (hook: Hook) => void): this;
                                                                                                                                                                                                                                                                                (event: 'pass', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                                                (event: 'fail', listener: (test: Test, err: any) => void): this;
                                                                                                                                                                                                                                                                                (event: 'pending', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                                                (event: string, listener: (...args: any[]) => void): this;
                                                                                                                                                                                                                                                                                };

                                                                                                                                                                                                                                                                                  interface Runner

                                                                                                                                                                                                                                                                                  interface Runner extends NodeJS.EventEmitter {}

                                                                                                                                                                                                                                                                                    method addListener

                                                                                                                                                                                                                                                                                    addListener: {
                                                                                                                                                                                                                                                                                    (event: 'waiting', listener: (rootSuite: Suite) => void): this;
                                                                                                                                                                                                                                                                                    (event: 'start', listener: () => void): this;
                                                                                                                                                                                                                                                                                    (event: 'end', listener: () => void): this;
                                                                                                                                                                                                                                                                                    (event: 'suite', listener: (suite: Suite) => void): this;
                                                                                                                                                                                                                                                                                    (event: 'suite end', listener: (suite: Suite) => void): this;
                                                                                                                                                                                                                                                                                    (event: 'test', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                                                    (event: 'test end', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                                                    (event: 'hook', listener: (hook: Hook) => void): this;
                                                                                                                                                                                                                                                                                    (event: 'hook end', listener: (hook: Hook) => void): this;
                                                                                                                                                                                                                                                                                    (event: 'pass', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                                                    (event: 'fail', listener: (test: Test, err: any) => void): this;
                                                                                                                                                                                                                                                                                    (event: 'pending', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                                                    (event: string, listener: (...args: any[]) => void): this;
                                                                                                                                                                                                                                                                                    };

                                                                                                                                                                                                                                                                                      method emit

                                                                                                                                                                                                                                                                                      emit: {
                                                                                                                                                                                                                                                                                      (name: 'waiting', rootSuite: Suite): boolean;
                                                                                                                                                                                                                                                                                      (name: 'start'): boolean;
                                                                                                                                                                                                                                                                                      (name: 'end'): boolean;
                                                                                                                                                                                                                                                                                      (name: 'suite', suite: Suite): boolean;
                                                                                                                                                                                                                                                                                      (name: 'suite end', suite: Suite): boolean;
                                                                                                                                                                                                                                                                                      (name: 'test', test: Test): boolean;
                                                                                                                                                                                                                                                                                      (name: 'test end', test: Test): boolean;
                                                                                                                                                                                                                                                                                      (name: 'hook', hook: Hook): boolean;
                                                                                                                                                                                                                                                                                      (name: 'hook end', hook: Hook): boolean;
                                                                                                                                                                                                                                                                                      (name: 'pass', test: Test): boolean;
                                                                                                                                                                                                                                                                                      (name: 'fail', test: Test, err: any): boolean;
                                                                                                                                                                                                                                                                                      (name: 'pending', test: Test): boolean;
                                                                                                                                                                                                                                                                                      (name: string, ...args: any[]): boolean;
                                                                                                                                                                                                                                                                                      };

                                                                                                                                                                                                                                                                                        method on

                                                                                                                                                                                                                                                                                        on: {
                                                                                                                                                                                                                                                                                        (event: 'waiting', listener: (rootSuite: Suite) => void): this;
                                                                                                                                                                                                                                                                                        (event: 'start', listener: () => void): this;
                                                                                                                                                                                                                                                                                        (event: 'end', listener: () => void): this;
                                                                                                                                                                                                                                                                                        (event: 'suite', listener: (suite: Suite) => void): this;
                                                                                                                                                                                                                                                                                        (event: 'suite end', listener: (suite: Suite) => void): this;
                                                                                                                                                                                                                                                                                        (event: 'test', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                                                        (event: 'test end', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                                                        (event: 'hook', listener: (hook: Hook) => void): this;
                                                                                                                                                                                                                                                                                        (event: 'hook end', listener: (hook: Hook) => void): this;
                                                                                                                                                                                                                                                                                        (event: 'pass', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                                                        (event: 'fail', listener: (test: Test, err: any) => void): this;
                                                                                                                                                                                                                                                                                        (event: 'pending', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                                                        (event: string, listener: (...args: any[]) => void): this;
                                                                                                                                                                                                                                                                                        };

                                                                                                                                                                                                                                                                                          method once

                                                                                                                                                                                                                                                                                          once: {
                                                                                                                                                                                                                                                                                          (event: 'waiting', listener: (rootSuite: Suite) => void): this;
                                                                                                                                                                                                                                                                                          (event: 'start', listener: () => void): this;
                                                                                                                                                                                                                                                                                          (event: 'end', listener: () => void): this;
                                                                                                                                                                                                                                                                                          (event: 'suite', listener: (suite: Suite) => void): this;
                                                                                                                                                                                                                                                                                          (event: 'suite end', listener: (suite: Suite) => void): this;
                                                                                                                                                                                                                                                                                          (event: 'test', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                                                          (event: 'test end', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                                                          (event: 'hook', listener: (hook: Hook) => void): this;
                                                                                                                                                                                                                                                                                          (event: 'hook end', listener: (hook: Hook) => void): this;
                                                                                                                                                                                                                                                                                          (event: 'pass', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                                                          (event: 'fail', listener: (test: Test, err: any) => void): this;
                                                                                                                                                                                                                                                                                          (event: 'pending', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                                                          (event: string, listener: (...args: any[]) => void): this;
                                                                                                                                                                                                                                                                                          };

                                                                                                                                                                                                                                                                                            method prependListener

                                                                                                                                                                                                                                                                                            prependListener: {
                                                                                                                                                                                                                                                                                            (event: 'waiting', listener: (rootSuite: Suite) => void): this;
                                                                                                                                                                                                                                                                                            (event: 'start', listener: () => void): this;
                                                                                                                                                                                                                                                                                            (event: 'end', listener: () => void): this;
                                                                                                                                                                                                                                                                                            (event: 'suite', listener: (suite: Suite) => void): this;
                                                                                                                                                                                                                                                                                            (event: 'suite end', listener: (suite: Suite) => void): this;
                                                                                                                                                                                                                                                                                            (event: 'test', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                                                            (event: 'test end', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                                                            (event: 'hook', listener: (hook: Hook) => void): this;
                                                                                                                                                                                                                                                                                            (event: 'hook end', listener: (hook: Hook) => void): this;
                                                                                                                                                                                                                                                                                            (event: 'pass', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                                                            (event: 'fail', listener: (test: Test, err: any) => void): this;
                                                                                                                                                                                                                                                                                            (event: 'pending', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                                                            (event: string, listener: (...args: any[]) => void): this;
                                                                                                                                                                                                                                                                                            };

                                                                                                                                                                                                                                                                                              method prependOnceListener

                                                                                                                                                                                                                                                                                              prependOnceListener: {
                                                                                                                                                                                                                                                                                              (event: 'waiting', listener: (rootSuite: Suite) => void): this;
                                                                                                                                                                                                                                                                                              (event: 'start', listener: () => void): this;
                                                                                                                                                                                                                                                                                              (event: 'end', listener: () => void): this;
                                                                                                                                                                                                                                                                                              (event: 'suite', listener: (suite: Suite) => void): this;
                                                                                                                                                                                                                                                                                              (event: 'suite end', listener: (suite: Suite) => void): this;
                                                                                                                                                                                                                                                                                              (event: 'test', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                                                              (event: 'test end', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                                                              (event: 'hook', listener: (hook: Hook) => void): this;
                                                                                                                                                                                                                                                                                              (event: 'hook end', listener: (hook: Hook) => void): this;
                                                                                                                                                                                                                                                                                              (event: 'pass', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                                                              (event: 'fail', listener: (test: Test, err: any) => void): this;
                                                                                                                                                                                                                                                                                              (event: 'pending', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                                                              (event: string, listener: (...args: any[]) => void): this;
                                                                                                                                                                                                                                                                                              };

                                                                                                                                                                                                                                                                                                method removeListener

                                                                                                                                                                                                                                                                                                removeListener: {
                                                                                                                                                                                                                                                                                                (event: 'waiting', listener: (rootSuite: Suite) => void): this;
                                                                                                                                                                                                                                                                                                (event: 'start', listener: () => void): this;
                                                                                                                                                                                                                                                                                                (event: 'end', listener: () => void): this;
                                                                                                                                                                                                                                                                                                (event: 'suite', listener: (suite: Suite) => void): this;
                                                                                                                                                                                                                                                                                                (event: 'suite end', listener: (suite: Suite) => void): this;
                                                                                                                                                                                                                                                                                                (event: 'test', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                                                                (event: 'test end', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                                                                (event: 'hook', listener: (hook: Hook) => void): this;
                                                                                                                                                                                                                                                                                                (event: 'hook end', listener: (hook: Hook) => void): this;
                                                                                                                                                                                                                                                                                                (event: 'pass', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                                                                (event: 'fail', listener: (test: Test, err: any) => void): this;
                                                                                                                                                                                                                                                                                                (event: 'pending', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                                                                (event: string, listener: (...args: any[]) => void): this;
                                                                                                                                                                                                                                                                                                };

                                                                                                                                                                                                                                                                                                  interface Runner

                                                                                                                                                                                                                                                                                                  interface Runner extends NodeJS.EventEmitter {}

                                                                                                                                                                                                                                                                                                    method addListener

                                                                                                                                                                                                                                                                                                    addListener: {
                                                                                                                                                                                                                                                                                                    (event: 'waiting', listener: (rootSuite: Suite) => void): this;
                                                                                                                                                                                                                                                                                                    (event: 'start', listener: () => void): this;
                                                                                                                                                                                                                                                                                                    (event: 'end', listener: () => void): this;
                                                                                                                                                                                                                                                                                                    (event: 'suite', listener: (suite: Suite) => void): this;
                                                                                                                                                                                                                                                                                                    (event: 'suite end', listener: (suite: Suite) => void): this;
                                                                                                                                                                                                                                                                                                    (event: 'test', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                                                                    (event: 'test end', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                                                                    (event: 'hook', listener: (hook: Hook) => void): this;
                                                                                                                                                                                                                                                                                                    (event: 'hook end', listener: (hook: Hook) => void): this;
                                                                                                                                                                                                                                                                                                    (event: 'pass', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                                                                    (event: 'fail', listener: (test: Test, err: any) => void): this;
                                                                                                                                                                                                                                                                                                    (event: 'pending', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                                                                    (event: string, listener: (...args: any[]) => void): this;
                                                                                                                                                                                                                                                                                                    };

                                                                                                                                                                                                                                                                                                      method emit

                                                                                                                                                                                                                                                                                                      emit: {
                                                                                                                                                                                                                                                                                                      (name: 'waiting', rootSuite: Suite): boolean;
                                                                                                                                                                                                                                                                                                      (name: 'start'): boolean;
                                                                                                                                                                                                                                                                                                      (name: 'end'): boolean;
                                                                                                                                                                                                                                                                                                      (name: 'suite', suite: Suite): boolean;
                                                                                                                                                                                                                                                                                                      (name: 'suite end', suite: Suite): boolean;
                                                                                                                                                                                                                                                                                                      (name: 'test', test: Test): boolean;
                                                                                                                                                                                                                                                                                                      (name: 'test end', test: Test): boolean;
                                                                                                                                                                                                                                                                                                      (name: 'hook', hook: Hook): boolean;
                                                                                                                                                                                                                                                                                                      (name: 'hook end', hook: Hook): boolean;
                                                                                                                                                                                                                                                                                                      (name: 'pass', test: Test): boolean;
                                                                                                                                                                                                                                                                                                      (name: 'fail', test: Test, err: any): boolean;
                                                                                                                                                                                                                                                                                                      (name: 'pending', test: Test): boolean;
                                                                                                                                                                                                                                                                                                      (name: string, ...args: any[]): boolean;
                                                                                                                                                                                                                                                                                                      };

                                                                                                                                                                                                                                                                                                        method on

                                                                                                                                                                                                                                                                                                        on: {
                                                                                                                                                                                                                                                                                                        (event: 'waiting', listener: (rootSuite: Suite) => void): this;
                                                                                                                                                                                                                                                                                                        (event: 'start', listener: () => void): this;
                                                                                                                                                                                                                                                                                                        (event: 'end', listener: () => void): this;
                                                                                                                                                                                                                                                                                                        (event: 'suite', listener: (suite: Suite) => void): this;
                                                                                                                                                                                                                                                                                                        (event: 'suite end', listener: (suite: Suite) => void): this;
                                                                                                                                                                                                                                                                                                        (event: 'test', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                                                                        (event: 'test end', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                                                                        (event: 'hook', listener: (hook: Hook) => void): this;
                                                                                                                                                                                                                                                                                                        (event: 'hook end', listener: (hook: Hook) => void): this;
                                                                                                                                                                                                                                                                                                        (event: 'pass', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                                                                        (event: 'fail', listener: (test: Test, err: any) => void): this;
                                                                                                                                                                                                                                                                                                        (event: 'pending', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                                                                        (event: string, listener: (...args: any[]) => void): this;
                                                                                                                                                                                                                                                                                                        };

                                                                                                                                                                                                                                                                                                          method once

                                                                                                                                                                                                                                                                                                          once: {
                                                                                                                                                                                                                                                                                                          (event: 'waiting', listener: (rootSuite: Suite) => void): this;
                                                                                                                                                                                                                                                                                                          (event: 'start', listener: () => void): this;
                                                                                                                                                                                                                                                                                                          (event: 'end', listener: () => void): this;
                                                                                                                                                                                                                                                                                                          (event: 'suite', listener: (suite: Suite) => void): this;
                                                                                                                                                                                                                                                                                                          (event: 'suite end', listener: (suite: Suite) => void): this;
                                                                                                                                                                                                                                                                                                          (event: 'test', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                                                                          (event: 'test end', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                                                                          (event: 'hook', listener: (hook: Hook) => void): this;
                                                                                                                                                                                                                                                                                                          (event: 'hook end', listener: (hook: Hook) => void): this;
                                                                                                                                                                                                                                                                                                          (event: 'pass', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                                                                          (event: 'fail', listener: (test: Test, err: any) => void): this;
                                                                                                                                                                                                                                                                                                          (event: 'pending', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                                                                          (event: string, listener: (...args: any[]) => void): this;
                                                                                                                                                                                                                                                                                                          };

                                                                                                                                                                                                                                                                                                            method prependListener

                                                                                                                                                                                                                                                                                                            prependListener: {
                                                                                                                                                                                                                                                                                                            (event: 'waiting', listener: (rootSuite: Suite) => void): this;
                                                                                                                                                                                                                                                                                                            (event: 'start', listener: () => void): this;
                                                                                                                                                                                                                                                                                                            (event: 'end', listener: () => void): this;
                                                                                                                                                                                                                                                                                                            (event: 'suite', listener: (suite: Suite) => void): this;
                                                                                                                                                                                                                                                                                                            (event: 'suite end', listener: (suite: Suite) => void): this;
                                                                                                                                                                                                                                                                                                            (event: 'test', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                                                                            (event: 'test end', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                                                                            (event: 'hook', listener: (hook: Hook) => void): this;
                                                                                                                                                                                                                                                                                                            (event: 'hook end', listener: (hook: Hook) => void): this;
                                                                                                                                                                                                                                                                                                            (event: 'pass', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                                                                            (event: 'fail', listener: (test: Test, err: any) => void): this;
                                                                                                                                                                                                                                                                                                            (event: 'pending', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                                                                            (event: string, listener: (...args: any[]) => void): this;
                                                                                                                                                                                                                                                                                                            };

                                                                                                                                                                                                                                                                                                              method prependOnceListener

                                                                                                                                                                                                                                                                                                              prependOnceListener: {
                                                                                                                                                                                                                                                                                                              (event: 'waiting', listener: (rootSuite: Suite) => void): this;
                                                                                                                                                                                                                                                                                                              (event: 'start', listener: () => void): this;
                                                                                                                                                                                                                                                                                                              (event: 'end', listener: () => void): this;
                                                                                                                                                                                                                                                                                                              (event: 'suite', listener: (suite: Suite) => void): this;
                                                                                                                                                                                                                                                                                                              (event: 'suite end', listener: (suite: Suite) => void): this;
                                                                                                                                                                                                                                                                                                              (event: 'test', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                                                                              (event: 'test end', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                                                                              (event: 'hook', listener: (hook: Hook) => void): this;
                                                                                                                                                                                                                                                                                                              (event: 'hook end', listener: (hook: Hook) => void): this;
                                                                                                                                                                                                                                                                                                              (event: 'pass', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                                                                              (event: 'fail', listener: (test: Test, err: any) => void): this;
                                                                                                                                                                                                                                                                                                              (event: 'pending', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                                                                              (event: string, listener: (...args: any[]) => void): this;
                                                                                                                                                                                                                                                                                                              };

                                                                                                                                                                                                                                                                                                                method removeListener

                                                                                                                                                                                                                                                                                                                removeListener: {
                                                                                                                                                                                                                                                                                                                (event: 'waiting', listener: (rootSuite: Suite) => void): this;
                                                                                                                                                                                                                                                                                                                (event: 'start', listener: () => void): this;
                                                                                                                                                                                                                                                                                                                (event: 'end', listener: () => void): this;
                                                                                                                                                                                                                                                                                                                (event: 'suite', listener: (suite: Suite) => void): this;
                                                                                                                                                                                                                                                                                                                (event: 'suite end', listener: (suite: Suite) => void): this;
                                                                                                                                                                                                                                                                                                                (event: 'test', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                                                                                (event: 'test end', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                                                                                (event: 'hook', listener: (hook: Hook) => void): this;
                                                                                                                                                                                                                                                                                                                (event: 'hook end', listener: (hook: Hook) => void): this;
                                                                                                                                                                                                                                                                                                                (event: 'pass', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                                                                                (event: 'fail', listener: (test: Test, err: any) => void): this;
                                                                                                                                                                                                                                                                                                                (event: 'pending', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                                                                                (event: string, listener: (...args: any[]) => void): this;
                                                                                                                                                                                                                                                                                                                };

                                                                                                                                                                                                                                                                                                                  interface Runner

                                                                                                                                                                                                                                                                                                                  interface Runner extends NodeJS.EventEmitter {}

                                                                                                                                                                                                                                                                                                                    method addListener

                                                                                                                                                                                                                                                                                                                    addListener: {
                                                                                                                                                                                                                                                                                                                    (event: 'waiting', listener: (rootSuite: Suite) => void): this;
                                                                                                                                                                                                                                                                                                                    (event: 'start', listener: () => void): this;
                                                                                                                                                                                                                                                                                                                    (event: 'end', listener: () => void): this;
                                                                                                                                                                                                                                                                                                                    (event: 'suite', listener: (suite: Suite) => void): this;
                                                                                                                                                                                                                                                                                                                    (event: 'suite end', listener: (suite: Suite) => void): this;
                                                                                                                                                                                                                                                                                                                    (event: 'test', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                                                                                    (event: 'test end', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                                                                                    (event: 'hook', listener: (hook: Hook) => void): this;
                                                                                                                                                                                                                                                                                                                    (event: 'hook end', listener: (hook: Hook) => void): this;
                                                                                                                                                                                                                                                                                                                    (event: 'pass', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                                                                                    (event: 'fail', listener: (test: Test, err: any) => void): this;
                                                                                                                                                                                                                                                                                                                    (event: 'pending', listener: (test: Test) => void): this;
                                                                                                                                                                                                                                                                                                                    (event: string, listener: (...args: any[]) => void): this;
                                                                                                                                                                                                                                                                                                                    };

                                                                                                                                                                                                                                                                                                                      method emit

                                                                                                                                                                                                                                                                                                                      emit: {
                                                                                                                                                                                                                                                                                                                      (name: 'waiting', rootSuite: Suite): boolean;
                                                                                                                                                                                                                                                                                                                      (name: 'start'): boolean;
                                                                                                                                                                                                                                                                                                                      (name: 'end'): boolean;
                                                                                                                                                                                                                                                                                                                      (name: 'suite', suite: Suite): boolean;
                                                                                                                                                                                                                                                                                                                      (name: 'suite end', suite: Suite): boolean;
                                                                                                                                                                                                                                                                                                                      (name: 'test', test: Test): boolean;
                                                                                                                                                                                                                                                                                                                      (name: 'test end', test: Test): boolean;
                                                                                                                                                                                                                                                                                                                      (name: 'hook', hook: Hook): boolean;
                                                                                                                                                                                                                                                                                                                      (name: 'hook end', hook: Hook): boolean;
                                                                                                                                                                                                                                                                                                                      (name: 'pass', test: Test): boolean;
                                                                                                                                                                                                                                                                                                                      (name: 'fail', test: Test, err: any): boolean;
                                                                                                                                                                                                                                                                                                                      (name: 'pending', test: Test): boolean;
                                                                                                                                                                                                                                                                                                                      (name: string, ...args: any[]): boolean;
                                                                                                                                                                                                                                                                                                                      };

                                                                                                                                                                                                                                                                                                                        method on

                                                                                                                                                                                                                                                                                                                        on: {
                                                                                                                                                                                                                                                                                                                        (event: 'waiting', listener: (rootSuite: Suite) => void): this;
                                                                                                                                                                                                                                                                                                                        (event: 'start', listener: () => void): this;
                                                                                                                                                                                                                                                                                                                        (event: 'end', listener