fca-shadow 0.0.1-security → 9.0.0

package/.cache/typescript/5.0/node_modules/@types/mocha/index.d.ts

@@ -0,0 +1,2916 @@
+/**
+ * Mocha API
+ *
+ * @see https://mochajs.org/api/mocha
+ */
+declare class Mocha {
+    private _growl;
+    private _reporter;
+    private _ui;
+
+    constructor(options?: Mocha.MochaOptions);
+
+    suite: Mocha.Suite;
+    files: string[];
+    options: Mocha.MochaInstanceOptions;
+
+    /**
+     * Add test `file`.
+     *
+     * @see https://mochajs.org/api/mocha#addFile
+     */
+    addFile(file: string): this;
+
+    /**
+     * Enable or disable bailing on the first failure.
+     *
+     * @see https://mochajs.org/api/mocha#bail
+     */
+    bail(bail?: boolean): this;
+
+    /**
+     * Enables or disables whether or not to dispose after each test run.
+     * Disable this to ensure you can run the test suite multiple times.
+     * If disabled, be sure to dispose mocha when you're done to prevent memory leaks.
+     *
+     * @see https://mochajs.org/api/mocha#cleanReferencesAfterRun
+     */
+    cleanReferencesAfterRun(clean?: boolean): this;
+
+    /**
+     * 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 https://mochajs.org/api/mocha#dispose
+     */
+    dispose(): void;
+
+    /**
+     * Set reporter to one of the built-in reporters.
+     *
+     * @see https://mochajs.org/api/mocha#reporter
+     */
+    reporter(reporter: Mocha.Reporter, reporterOptions?: any): this;
+
+    /**
+     * Set reporter to the provided constructor, one of the built-in reporters, or loads a reporter
+     * from a module path. Defaults to `"spec"`.
+     *
+     * @see https://mochajs.org/api/mocha#reporter
+     */
+    reporter(reporter?: string | Mocha.ReporterConstructor, reporterOptions?: any): this;
+
+    /**
+     * Set test UI to one of the built-in test interfaces.
+     *
+     * @see https://mochajs.org/api/mocha#ui
+     */
+    ui(name: Mocha.Interface): this;
+
+    /**
+     * Set test UI to one of the built-in test interfaces or loads a test interface from a module
+     * path. Defaults to `"bdd"`.
+     *
+     * @see https://mochajs.org/api/mocha#ui
+     */
+    ui(name?: string): this;
+
+    /**
+     * Escape string and add it to grep as a RegExp.
+     *
+     * @see https://mochajs.org/api/mocha#fgrep
+     */
+    fgrep(str: string): this;
+
+    /**
+     * Add regexp to grep, if `re` is a string it is escaped.
+     *
+     * @see https://mochajs.org/api/mocha#grep
+     */
+    grep(re: string | RegExp): this;
+
+    /**
+     * Whether to activate dry-run mode.
+     *
+     * @param dryRun Whether to activate dry-run mode. Defaults to `true`.
+     */
+    dryRun(dryRun?: boolean): this;
+
+    /**
+     * Invert `.grep()` matches.
+     *
+     * @see https://mochajs.org/api/mocha#invert
+     */
+    invert(): this;
+
+    /**
+     * Enable global leak checking.
+     *
+     * @see https://mochajs.org/api/mocha#checkLeaks
+     */
+    checkLeaks(): this;
+
+    /**
+     * Display long stack-trace on failing
+     *
+     * @see https://mochajs.org/api/mocha#fullTrace
+     */
+    fullTrace(): this;
+
+    /**
+     * Enable growl support.
+     *
+     * @see https://mochajs.org/api/mocha#growl
+     */
+    growl(): this;
+
+    /**
+     * Ignore `globals` array or string.
+     *
+     * @see https://mochajs.org/api/mocha#globals
+     */
+    globals(globals: string | readonly string[]): this;
+
+    /**
+     * Set the timeout in milliseconds.
+     *
+     * @see https://mochajs.org/api/mocha#timeout
+     */
+    timeout(timeout: string | number): this;
+
+    /**
+     * Set the number of times to retry failed tests.
+     *
+     * @see https://mochajs.org/api/mocha#retries
+     */
+    retries(n: number): this;
+
+    /**
+     * Set slowness threshold in milliseconds.
+     *
+     * @see https://mochajs.org/api/mocha#slow
+     */
+    slow(slow: string | number): this;
+
+    /**
+     * Makes all tests async (accepting a callback)
+     *
+     * @see https://mochajs.org/api/mocha#asyncOnly.
+     */
+    asyncOnly(): this;
+
+    /**
+     * Disable syntax highlighting (in browser).
+     *
+     * @see https://mochajs.org/api/mocha#noHighlighting
+     */
+    noHighlighting(): this;
+
+    /**
+     * Enable uncaught errors to propagate (in browser).
+     *
+     * @see https://mochajs.org/api/mocha#allowUncaught
+     */
+    allowUncaught(): boolean;
+
+    /**
+     * Delay root suite execution.
+     *
+     * @see https://mochajs.org/api/mocha#delay
+     */
+    delay(): boolean;
+
+    /**
+     * Tests marked only fail the suite
+     *
+     * @see https://mochajs.org/api/mocha#forbidOnly
+     */
+    forbidOnly(): boolean;
+
+    /**
+     * Pending tests and tests marked skip fail the suite
+     *
+     * @see https://mochajs.org/api/mocha#forbidPending
+     */
+    forbidPending(): boolean;
+
+    /**
+     * 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 https://mochajs.org/api/mocha#run
+     */
+    run(fn?: (failures: number) => void): Mocha.Runner;
+
+    /**
+     * Loads ESM (and CJS) test files asynchronously.
+     *
+     * @see https://mochajs.org/api/mocha#loadFilesAsync
+     */
+    loadFilesAsync(): Promise<void>;
+
+    /**
+     * Load registered files.
+     *
+     * @see https://mochajs.org/api/mocha#loadFiles
+     */
+    protected loadFiles(fn?: () => void): void;
+
+    /**
+     * 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
+     */
+    unloadFiles(): 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 https://mochajs.org/api/mocha#parallelMode
+     */
+    parallelMode(enabled?: boolean): this;
+
+    /**
+     * Assigns hooks to the root suite.
+     *
+     * @see https://mochajs.org/api/mocha#rootHooks
+     */
+    rootHooks(hooks: Mocha.RootHookObject): this;
+
+    /**
+     * Configures one or more global setup fixtures.
+     * If given no parameters, unsets any previously-set fixtures.
+     *
+     * @see https://mochajs.org/api/mocha#globalSetup
+     */
+    globalSetup: Mocha.HookFunction;
+
+    /**
+     * Configures one or more global teardown fixtures.
+     * If given no parameters, unsets any previously-set fixtures.
+     *
+     * @see https://mochajs.org/api/mocha#globalTeardown
+     */
+    globalTeardown: Mocha.HookFunction;
+
+    /**
+     * Returns `true` if one or more global setup fixtures have been supplied
+     *
+     * @see https://mochajs.org/api/mocha#hasGlobalSetupFixtures
+     */
+    hasGlobalSetupFixtures(): boolean;
+
+    /**
+     * Returns `true` if one or more global teardown fixtures have been supplied
+     *
+     * @see https://mochajs.org/api/mocha#hasGlobalTeardownFixtures
+     */
+    hasGlobalTeardownFixtures(): boolean;
+
+    /**
+     * Toggle execution of any global setup fixture(s)
+     *
+     * @see https://mochajs.org/api/mocha#enableGlobalSetup
+     */
+    enableGlobalSetup(enabled: boolean): this;
+
+    /**
+     * Toggle execution of any global teardown fixture(s)
+     *
+     * @see https://mochajs.org/api/mocha#enableGlobalTeardown
+     */
+    enableGlobalTeardown(enabled: boolean): this;
+}
+
+declare namespace Mocha {
+    namespace utils {
+        /**
+         * Compute a slug from the given `str`.
+         *
+         * @see https://mochajs.org/api/module-utils.html#.slug
+         */
+        function slug(str: string): string;
+
+        /**
+         * Strip the function definition from `str`, and re-indent for pre whitespace.
+         *
+         * @see https://mochajs.org/api/module-utils.html#.clean
+         */
+        function clean(str: string): string;
+
+        /**
+         * Highlight the given string of `js`.
+         */
+        function highlight(js: string): string;
+
+        /**
+         * Takes some variable and asks `Object.prototype.toString()` what it thinks it is.
+         */
+        function type(value: any): string;
+
+        /**
+         * Stringify `value`. Different behavior depending on type of value:
+         *
+         * - If `value` is undefined or null, return `'[undefined]'` or `'[null]'`, respectively.
+         * - If `value` is not an object, function or array, return result of `value.toString()` wrapped in double-quotes.
+         * - If `value` is an *empty* object, function, or array, returns `'{}'`, `'[Function]'`, or `'[]'` respectively.
+         * - If `value` has properties, call canonicalize} on it, then return result of `JSON.stringify()`
+         *
+         * @see https://mochajs.org/api/module-utils.html#.stringify
+         */
+        function stringify(value: any): string;
+
+        /**
+         * Return a new Thing that has the keys in sorted order. Recursive.
+         *
+         * If the Thing...
+         * - has already been seen, return string `'[Circular]'`
+         * - is `undefined`, return string `'[undefined]'`
+         * - is `null`, return value `null`
+         * - is some other primitive, return the value
+         * - is not a primitive or an `Array`, `Object`, or `Function`, return the value of the Thing's `toString()` method
+         * - is a non-empty `Array`, `Object`, or `Function`, return the result of calling this function again.
+         * - is an empty `Array`, `Object`, or `Function`, returns `'[]'`, `'{}'`, or `'[Function]'` respectively.
+         *
+         * @see https://mochajs.org/api/module-utils.html#.canonicalize
+         */
+        function canonicalize(value: any, stack: any[], typeHint: string): any;
+
+        /**
+         * Generate an undefined error with a message warning the user.
+         *
+         * @see https://mochajs.org/api/module-utils.html#.undefinedError
+         */
+        function undefinedError(): Error;
+
+        /**
+         * Generate an undefined error if `err` is not defined.
+         *
+         * @see https://mochajs.org/api/module-utils.html#.getError
+         */
+        function getError(err: Error | undefined): Error;
+
+        /**
+         * When invoking this function you get a filter function that get the Error.stack as an
+         * input, and return a prettify output. (i.e: strip Mocha and internal node functions from
+         * stack trace).
+         *
+         * @see https://mochajs.org/api/module-utils.html#.stackTraceFilter
+         */
+        function stackTraceFilter(): (stack: string) => string;
+    }
+
+    namespace interfaces {
+        function bdd(suite: Suite): void;
+        function tdd(suite: Suite): void;
+        function qunit(suite: Suite): void;
+        function exports(suite: Suite): void;
+    }
+
+    // #region Test interface augmentations
+
+    interface HookFunction {
+        /**
+         * [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._
+         */
+        (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._
+         */
+        (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._
+         */
+        (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._
+         */
+        (name: string, fn?: AsyncFunc): void;
+    }
+
+    interface SuiteFunction {
+        /**
+         * [bdd, tdd] Describe a "suite" with the given `title` and callback `fn` containing
+         * nested suites.
+         *
+         * - _Only available when invoked via the mocha CLI._
+         */
+        (title: string, fn: (this: Suite) => void): Suite;
+
+        /**
+         * [qunit] Describe a "suite" with the given `title`.
+         *
+         * - _Only available when invoked via the mocha CLI._
+         */
+        (title: string): Suite;
+
+        /**
+         * [bdd, tdd, qunit] Indicates this suite should be executed exclusively.
+         *
+         * - _Only available when invoked via the mocha CLI._
+         */
+        only: ExclusiveSuiteFunction;
+
+        /**
+         * [bdd, tdd] Indicates this suite should not be executed.
+         *
+         * - _Only available when invoked via the mocha CLI._
+         */
+        skip: PendingSuiteFunction;
+    }
+
+    interface ExclusiveSuiteFunction {
+        /**
+         * [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._
+         */
+        (title: string, fn: (this: Suite) => void): Suite;
+
+        /**
+         * [qunit] Describe a "suite" with the given `title`. Indicates this suite should be executed
+         * exclusively.
+         *
+         * - _Only available when invoked via the mocha CLI._
+         */
+        (title: string): Suite;
+    }
+
+    /**
+     * [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 [bdd] `Suite`
+     * @returns [tdd] `void`
+     */
+    interface PendingSuiteFunction {
+        // eslint-disable-next-line @typescript-eslint/no-invalid-void-type
+        (title: string, fn: (this: Suite) => void): Suite | void;
+    }
+
+    interface TestFunction {
+        /**
+         * 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.
+         *
+         * - _Only available when invoked via the mocha CLI._
+         */
+        (fn: Func): Test;
+
+        /**
+         * 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.
+         *
+         * - _Only available when invoked via the mocha CLI._
+         */
+        (fn: AsyncFunc): Test;
+
+        /**
+         * Describe a specification or test-case with the given `title` and callback `fn` acting
+         * as a thunk.
+         *
+         * - _Only available when invoked via the mocha CLI._
+         */
+        (title: string, fn?: Func): Test;
+
+        /**
+         * Describe a specification or test-case with the given `title` and callback `fn` acting
+         * as a thunk.
+         *
+         * - _Only available when invoked via the mocha CLI._
+         */
+        (title: string, fn?: AsyncFunc): Test;
+
+        /**
+         * Indicates this test should be executed exclusively.
+         *
+         * - _Only available when invoked via the mocha CLI._
+         */
+        only: ExclusiveTestFunction;
+
+        /**
+         * Indicates this test should not be executed.
+         *
+         * - _Only available when invoked via the mocha CLI._
+         */
+        skip: PendingTestFunction;
+
+        /**
+         * Number of attempts to retry.
+         *
+         * - _Only available when invoked via the mocha CLI._
+         */
+        retries(n: number): void;
+    }
+
+    interface ExclusiveTestFunction {
+        /**
+         * [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._
+         */
+        (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._
+         */
+        (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._
+         */
+        (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._
+         */
+        (title: string, fn?: AsyncFunc): Test;
+    }
+
+    interface PendingTestFunction {
+        /**
+         * [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._
+         */
+        (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._
+         */
+        (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._
+         */
+        (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._
+         */
+        (title: string, fn?: AsyncFunc): Test;
+    }
+
+    /**
+     * Execute after each test case.
+     *
+     * - _Only available when invoked via the mocha CLI._
+     *
+     * @see https://mochajs.org/api/global.html#afterEach
+     */
+    let afterEach: HookFunction;
+
+    /**
+     * Execute after running tests.
+     *
+     * - _Only available when invoked via the mocha CLI._
+     *
+     * @see https://mochajs.org/api/global.html#after
+     */
+    let after: HookFunction;
+
+    /**
+     * Execute before each test case.
+     *
+     * - _Only available when invoked via the mocha CLI._
+     *
+     * @see https://mochajs.org/api/global.html#beforeEach
+     */
+    let beforeEach: HookFunction;
+
+    /**
+     * Execute before running tests.
+     *
+     * - _Only available when invoked via the mocha CLI._
+     *
+     * @see https://mochajs.org/api/global.html#before
+     */
+    let before: HookFunction;
+
+    /**
+     * Describe a "suite" containing nested suites and tests.
+     *
+     * - _Only available when invoked via the mocha CLI._
+     */
+    let describe: SuiteFunction;
+
+    /**
+     * Describe a pending suite.
+     *
+     * - _Only available when invoked via the mocha CLI._
+     */
+    let xdescribe: PendingSuiteFunction;
+
+    /**
+     * Describes a test case.
+     *
+     * - _Only available when invoked via the mocha CLI._
+     */
+    let it: TestFunction;
+
+    /**
+     * Describes a pending test case.
+     *
+     * - _Only available when invoked via the mocha CLI._
+     */
+    let xit: PendingTestFunction;
+
+    /**
+     * Execute before each test case.
+     *
+     * - _Only available when invoked via the mocha CLI._
+     *
+     * @see https://mochajs.org/api/global.html#beforeEach
+     */
+    let setup: HookFunction;
+
+    /**
+     * Execute before running tests.
+     *
+     * - _Only available when invoked via the mocha CLI._
+     *
+     * @see https://mochajs.org/api/global.html#before
+     */
+    let suiteSetup: HookFunction;
+
+    /**
+     * Execute after running tests.
+     *
+     * - _Only available when invoked via the mocha CLI._
+     *
+     * @see https://mochajs.org/api/global.html#after
+     */
+    let suiteTeardown: HookFunction;
+
+    /**
+     * Describe a "suite" containing nested suites and tests.
+     *
+     * - _Only available when invoked via the mocha CLI._
+     */
+    let suite: SuiteFunction;
+
+    /**
+     * Execute after each test case.
+     *
+     * - _Only available when invoked via the mocha CLI._
+     *
+     * @see https://mochajs.org/api/global.html#afterEach
+     */
+    let teardown: HookFunction;
+
+    /**
+     * Describes a test case.
+     *
+     * - _Only available when invoked via the mocha CLI._
+     */
+    let test: TestFunction;
+
+    /**
+     * Triggers root suite execution.
+     *
+     * - _Only available if flag --delay is passed into Mocha._
+     * - _Only available when invoked via the mocha CLI._
+     *
+     * @see https://mochajs.org/api/global.html#runWithSuite
+     */
+    function run(): void;
+
+    // #endregion Test interface augmentations
+
+    namespace reporters {
+        /**
+         * Initialize a new `Base` reporter.
+         *
+         * All other reporters generally inherit from this reporter, providing stats such as test duration,
+         * number of tests passed / failed, etc.
+         *
+         * @see https://mochajs.org/api/Mocha.reporters.Base.html
+         */
+        class Base {
+            constructor(runner: Runner, options?: MochaOptions);
+
+            /**
+             * Test run statistics
+             */
+            stats: Stats;
+
+            /**
+             * Test failures
+             */
+            failures: Test[];
+
+            /**
+             * The configured runner
+             */
+            runner: Runner;
+
+            /**
+             * Output common epilogue used by many of the bundled reporters.
+             *
+             * @see https://mochajs.org/api/Mocha.reporters.Base.html#.Base#epilogue
+             */
+            epilogue(): void;
+
+            done?(failures: number, fn?: (failures: number) => void): void;
+        }
+
+        namespace Base {
+            /**
+             * Enables coloring by default
+             *
+             * @see https://mochajs.org/api/module-base#.useColors
+             */
+            let useColors: boolean;
+
+            /**
+             * Inline diffs instead of +/-
+             *
+             * @see https://mochajs.org/api/module-base#.inlineDiffs
+             */
+            let inlineDiffs: boolean;
+
+            /**
+             * Default color map
+             *
+             * @see https://mochajs.org/api/module-base#.colors
+             */
+            const colors: ColorMap;
+
+            /**
+             * Default color map
+             *
+             * @see https://mochajs.org/api/module-base#.colors
+             */
+            interface ColorMap {
+                // added by Base
+                pass: number;
+                fail: number;
+                "bright pass": number;
+                "bright fail": number;
+                "bright yellow": number;
+                pending: number;
+                suite: number;
+                "error title": number;
+                "error message": number;
+                "error stack": number;
+                checkmark: number;
+                fast: number;
+                medium: number;
+                slow: number;
+                green: number;
+                light: number;
+                "diff gutter": number;
+                "diff added": number;
+                "diff removed": number;
+
+                // added by Progress
+                progress: number;
+
+                // added by Landing
+                plane: number;
+                "plane crash": number;
+                runway: number;
+
+                [key: string]: number;
+            }
+
+            /**
+             * Default symbol map
+             *
+             * @see https://mochajs.org/api/module-base#.symbols
+             */
+            const symbols: SymbolMap;
+
+            /**
+             * Default symbol map
+             *
+             * @see https://mochajs.org/api/module-base#.symbols
+             */
+            interface SymbolMap {
+                ok: string;
+                err: string;
+                dot: string;
+                comma: string;
+                bang: string;
+                [key: string]: string;
+            }
+
+            /**
+             * Color `str` with the given `type` (from `colors`)
+             *
+             * @see https://mochajs.org/api/module-base#.color
+             */
+            function color(type: string, str: string): string;
+
+            /**
+             * Expose terminal window size
+             *
+             * @see https://mochajs.org/api/module-base#.window
+             */
+            const window: {
+                width: number;
+            };
+
+            /**
+             * ANSI TTY control sequences common among reporters.
+             *
+             * @see https://mochajs.org/api/module-base#.cursor
+             */
+            namespace cursor {
+                /**
+                 * Hides the cursor
+                 */
+                function hide(): void;
+
+                /**
+                 * Shows the cursor
+                 */
+                function show(): void;
+
+                /**
+                 * Deletes the current line
+                 */
+                function deleteLine(): void;
+
+                /**
+                 * Moves to the beginning of the line
+                 */
+                function beginningOfLine(): void;
+
+                /**
+                 * Clears the line and moves to the beginning of the line.
+                 */
+                function CR(): void;
+            }
+
+            /**
+             * Returns a diff between two strings with colored ANSI output.
+             *
+             * @see https://mochajs.org/api/module-base#.generateDiff
+             */
+            function generateDiff(actual: string, expected: string): string;
+
+            /**
+             * Output the given `failures` as a list.
+             *
+             * @see https://mochajs.org/api/Mocha.reporters.Base.html#.exports.list1
+             */
+            function list(failures: Test[]): void;
+        }
+
+        /**
+         * Initialize a new `Dot` matrix test reporter.
+         *
+         * @see https://mochajs.org/api/Mocha.reporters.Dot.html
+         */
+        class Dot extends Base {}
+
+        /**
+         * Initialize a new `Doc` reporter.
+         *
+         * @see https://mochajs.org/api/Mocha.reporters.Doc.html
+         */
+        class Doc extends Base {}
+
+        /**
+         * Initialize a new `TAP` test reporter.
+         *
+         * @see https://mochajs.org/api/Mocha.reporters.TAP.html
+         */
+        class TAP extends Base {}
+
+        /**
+         * Initialize a new `JSON` reporter
+         *
+         * @see https://mochajs.org/api/Mocha.reporters.JSON.html
+         */
+        class JSON extends Base {}
+
+        /**
+         * Initialize a new `HTML` reporter.
+         *
+         * - _This reporter cannot be used on the console._
+         *
+         * @see https://mochajs.org/api/Mocha.reporters.HTML.html
+         */
+        class HTML extends Base {
+            /**
+             * Provide suite URL.
+             *
+             * @see https://mochajs.org/api/Mocha.reporters.HTML.html#suiteURL
+             */
+            suiteURL(suite: Suite): string;
+
+            /**
+             * Provide test URL.
+             *
+             * @see https://mochajs.org/api/Mocha.reporters.HTML.html#testURL
+             */
+            testURL(test: Test): string;
+
+            /**
+             * Adds code toggle functionality for the provided test's list element.
+             *
+             * @see https://mochajs.org/api/Mocha.reporters.HTML.html#addCodeToggle
+             */
+            addCodeToggle(el: HTMLLIElement, contents: string): void;
+        }
+
+        /**
+         * Initialize a new `List` test reporter.
+         *
+         * @see https://mochajs.org/api/Mocha.reporters.List.html
+         */
+        class List extends Base {}
+
+        /**
+         * Initialize a new `Min` minimal test reporter (best used with --watch).
+         *
+         * @see https://mochajs.org/api/Mocha.reporters.Min.html
+         */
+        class Min extends Base {}
+
+        /**
+         * Initialize a new `Spec` test reporter.
+         *
+         * @see https://mochajs.org/api/Mocha.reporters.Spec.html
+         */
+        class Spec extends Base {}
+
+        /**
+         * Initialize a new `NyanCat` test reporter.
+         *
+         * @see https://mochajs.org/api/Mocha.reporters.Nyan.html
+         */
+        class Nyan extends Base {
+            private colorIndex;
+            private numberOfLines;
+            private rainbowColors;
+            private scoreboardWidth;
+            private tick;
+            private trajectories;
+            private trajectoryWidthMax;
+            private draw;
+            private drawScoreboard;
+            private appendRainbow;
+            private drawRainbow;
+            private drawNyanCat;
+            private face;
+            private cursorUp;
+            private cursorDown;
+            private generateColors;
+            private rainbowify;
+        }
+
+        /**
+         * Initialize a new `XUnit` test reporter.
+         *
+         * @see https://mochajs.org/api/Mocha.reporters.XUnit.html
+         */
+        class XUnit extends Base {
+            constructor(runner: Runner, options?: XUnit.MochaOptions);
+
+            /**
+             * Override done to close the stream (if it's a file).
+             *
+             * @see https://mochajs.org/api/Mocha.reporters.XUnit.html#done
+             */
+            done(failures: number, fn: (failures: number) => void): void;
+
+            /**
+             * Write out the given line.
+             *
+             * @see https://mochajs.org/api/Mocha.reporters.XUnit.html#write
+             */
+            write(line: string): void;
+
+            /**
+             * Output tag for the given `test.`
+             *
+             * @see https://mochajs.org/api/Mocha.reporters.XUnit.html#test
+             */
+            test(test: Test): void;
+        }
+
+        namespace XUnit {
+            interface MochaOptions extends Mocha.MochaOptions {
+                reporterOptions?: ReporterOptions | undefined;
+            }
+
+            interface ReporterOptions {
+                output?: string | undefined;
+                suiteName?: string | undefined;
+            }
+        }
+
+        /**
+         * Initialize a new `Markdown` test reporter.
+         *
+         * @see https://mochajs.org/api/Mocha.reporters.Markdown.html
+         */
+        class Markdown extends Base {}
+
+        /**
+         * Initialize a new `Progress` bar test reporter.
+         *
+         * @see https://mochajs.org/api/Mocha.reporters.Progress.html
+         */
+        class Progress extends Base {
+            constructor(runner: Runner, options?: Progress.MochaOptions);
+        }
+
+        namespace Progress {
+            interface MochaOptions extends Mocha.MochaOptions {
+                reporterOptions?: ReporterOptions | undefined;
+            }
+
+            interface ReporterOptions {
+                open?: string | undefined;
+                complete?: string | undefined;
+                incomplete?: string | undefined;
+                close?: string | undefined;
+                verbose?: boolean | undefined;
+            }
+        }
+
+        /**
+         * Initialize a new `Landing` reporter.
+         *
+         * @see https://mochajs.org/api/Mocha.reporters.Landing.html
+         */
+        class Landing extends Base {}
+
+        /**
+         * Initialize a new `JSONStream` test reporter.
+         *
+         * @see https://mochajs.org/api/Mocha.reporters.JSONStream.html
+         */
+        class JSONStream extends Base {}
+
+        // value-only aliases
+        const base: typeof Base;
+        const dot: typeof Dot;
+        const doc: typeof Doc;
+        const tap: typeof TAP;
+        const json: typeof JSON;
+        const html: typeof HTML;
+        const list: typeof List;
+        const spec: typeof Spec;
+        const nyan: typeof Nyan;
+        const xunit: typeof XUnit;
+        const markdown: typeof Markdown;
+        const progress: typeof Progress;
+        const landing: typeof Landing;
+        // NOTE: not possible to type this correctly:
+        // const "json-stream": typeof JSONStream;
+    }
+
+    /**
+     * Initialize a new `Runnable` with the given `title` and callback `fn`.
+     *
+     * @see https://mochajs.org/api/Runnable.html
+     */
+    class Runnable {
+        private _slow;
+        private _retries;
+        private _currentRetry;
+        private _timeout;
+        private _timeoutError;
+
+        constructor(title: string, fn?: Func | AsyncFunc);
+
+        id: string;
+        title: string;
+        fn: Func | AsyncFunc | undefined;
+        body: string;
+        async: boolean;
+        sync: boolean;
+        timedOut: boolean;
+        pending: boolean;
+        duration?: number | undefined;
+        parent?: Suite | undefined;
+        state?: "failed" | "passed" | "pending" | undefined;
+        timer?: any;
+        ctx?: Context | undefined;
+        callback?: Done | undefined;
+        allowUncaught?: boolean | undefined;
+        file?: string | undefined;
+
+        /**
+         * Get test timeout.
+         *
+         * @see https://mochajs.org/api/Runnable.html#timeout
+         */
+        timeout(): number;
+
+        /**
+         * Set test timeout.
+         *
+         * @see https://mochajs.org/api/Runnable.html#timeout
+         */
+        timeout(ms: string | number): this;
+
+        /**
+         * Get test slowness threshold.
+         *
+         * @see https://mochajs.org/api/Runnable.html#slow
+         */
+        slow(): number;
+
+        /**
+         * Set test slowness threshold.
+         *
+         * @see https://mochajs.org/api/Runnable.html#slow
+         */
+        slow(ms: string | number): this;
+
+        /**
+         * Halt and mark as pending.
+         */
+        skip(): never;
+
+        /**
+         * Check if this runnable or its parent suite is marked as pending.
+         *
+         * @see https://mochajs.org/api/Runnable.html#isPending
+         */
+        isPending(): boolean;
+
+        /**
+         * Return `true` if this Runnable has failed.
+         */
+        isFailed(): boolean;
+
+        /**
+         * Return `true` if this Runnable has passed.
+         */
+        isPassed(): boolean;
+
+        /**
+         * Set or get number of retries.
+         *
+         * @see https://mochajs.org/api/Runnable.html#retries
+         */
+        retries(): number;
+
+        /**
+         * Set or get number of retries.
+         *
+         * @see https://mochajs.org/api/Runnable.html#retries
+         */
+        retries(n: number): void;
+
+        /**
+         * Set or get current retry
+         *
+         * @see https://mochajs.org/api/Runnable.html#currentRetry
+         */
+        protected currentRetry(): number;
+
+        /**
+         * Set or get current retry
+         *
+         * @see https://mochajs.org/api/Runnable.html#currentRetry
+         */
+        protected currentRetry(n: number): void;
+
+        /**
+         * Return the full title generated by recursively concatenating the parent's full title.
+         */
+        fullTitle(): string;
+
+        /**
+         * Return the title path generated by concatenating the parent's title path with the title.
+         */
+        titlePath(): string[];
+
+        /**
+         * Clear the timeout.
+         *
+         * @see https://mochajs.org/api/Runnable.html#clearTimeout
+         */
+        clearTimeout(): void;
+
+        /**
+         * Inspect the runnable void of private properties.
+         *
+         * @see https://mochajs.org/api/Runnable.html#inspect
+         */
+        inspect(): string;
+
+        /**
+         * Reset the timeout.
+         *
+         * @see https://mochajs.org/api/Runnable.html#resetTimeout
+         */
+        resetTimeout(): void;
+
+        /**
+         * Get a list of whitelisted globals for this test run.
+         *
+         * @see https://mochajs.org/api/Runnable.html#globals
+         */
+        globals(): string[];
+
+        /**
+         * Set a list of whitelisted globals for this test run.
+         *
+         * @see https://mochajs.org/api/Runnable.html#globals
+         */
+        globals(globals: readonly string[]): void;
+
+        /**
+         * Run the test and invoke `fn(err)`.
+         *
+         * @see https://mochajs.org/api/Runnable.html#run
+         */
+        run(fn: Done): void;
+    }
+
+    // #region Runnable "error" event
+    interface Runnable extends NodeJS.EventEmitter {
+        on(event: "error", listener: (error: any) => void): this;
+        once(event: "error", listener: (error: any) => void): this;
+        addListener(event: "error", listener: (error: any) => void): this;
+        removeListener(event: "error", listener: (error: any) => void): this;
+        prependListener(event: "error", listener: (error: any) => void): this;
+        prependOnceListener(event: "error", listener: (error: any) => void): this;
+        emit(name: "error", error: any): boolean;
+    }
+    // #endregion Runnable "error" event
+    // #region Runnable untyped events
+    interface Runnable extends NodeJS.EventEmitter {
+        on(event: string, listener: (...args: any[]) => void): this;
+        once(event: string, listener: (...args: any[]) => void): this;
+        addListener(event: string, listener: (...args: any[]) => void): this;
+        removeListener(event: string, listener: (...args: any[]) => void): this;
+        prependListener(event: string, listener: (...args: any[]) => void): this;
+        prependOnceListener(event: string, listener: (...args: any[]) => void): this;
+        emit(name: string, ...args: any[]): boolean;
+    }
+    // #endregion Runnable untyped events
+
+    /**
+     * Test context
+     *
+     * @see https://mochajs.org/api/module-Context.html#~Context
+     */
+    class Context {
+        private _runnable;
+
+        test?: Runnable | undefined;
+        currentTest?: Test | undefined;
+
+        /**
+         * Get the context `Runnable`.
+         */
+        runnable(): Runnable;
+
+        /**
+         * Set the context `Runnable`.
+         */
+        runnable(runnable: Runnable): this;
+
+        /**
+         * Get test timeout.
+         */
+        timeout(): number;
+
+        /**
+         * Set test timeout.
+         */
+        timeout(ms: string | number): this;
+
+        /**
+         * Get test slowness threshold.
+         */
+        slow(): number;
+
+        /**
+         * Set test slowness threshold.
+         */
+        slow(ms: string | number): this;
+
+        /**
+         * Mark a test as skipped.
+         */
+        skip(): never;
+
+        /**
+         * Get the number of allowed retries on failed tests.
+         */
+        retries(): number;
+
+        /**
+         * Set the number of allowed retries on failed tests.
+         */
+        retries(n: number): this;
+
+        [key: string]: any;
+    }
+
+    interface RunnerConstants {
+        readonly EVENT_HOOK_BEGIN: "hook";
+        readonly EVENT_HOOK_END: "hook end";
+        readonly EVENT_RUN_BEGIN: "start";
+        readonly EVENT_DELAY_BEGIN: "waiting";
+        readonly EVENT_DELAY_END: "ready";
+        readonly EVENT_RUN_END: "end";
+        readonly EVENT_SUITE_BEGIN: "suite";
+        readonly EVENT_SUITE_END: "suite end";
+        readonly EVENT_TEST_BEGIN: "test";
+        readonly EVENT_TEST_END: "test end";
+        readonly EVENT_TEST_FAIL: "fail";
+        readonly EVENT_TEST_PASS: "pass";
+        readonly EVENT_TEST_PENDING: "pending";
+        readonly EVENT_TEST_RETRY: "retry";
+        readonly STATE_IDLE: "idle";
+        readonly STATE_RUNNING: "running";
+        readonly STATE_STOPPED: "stopped";
+    }
+
+    interface RunnerOptions {
+        /** Whether to delay execution of root suite until ready. */
+        delay?: boolean;
+
+        /** Whether to report tests without running them. */
+        dryRun?: boolean;
+
+        /** Whether to clean references to test fns and hooks when a suite is done. */
+        cleanReferencesAfterRun?: boolean;
+    }
+
+    /**
+     * Initialize a `Runner` for the given `suite`.
+     *
+     * @see https://mochajs.org/api/Mocha.Runner.html
+     */
+    class Runner {
+        private _globals;
+        private _abort;
+        private _delay;
+        private _defaultGrep;
+        private next;
+        private hookErr;
+        private prevGlobalsLength;
+        private nextSuite;
+
+        static readonly constants: RunnerConstants;
+
+        /**
+         * Initialize a `Runner` at the Root Suite, which represents a hierarchy of Suites and Tests.
+         *
+         * @param suite Root suite
+         * @param optionsOrDelay Options. If boolean (deprecated), whether or not to delay execution of root suite until ready.
+         */
+        constructor(suite: Suite, optionsOrDelay?: RunnerOptions | boolean);
+
+        suite: Suite;
+        started: boolean;
+        total: number;
+        failures: number;
+        asyncOnly?: boolean | undefined;
+        allowUncaught?: boolean | undefined;
+        fullStackTrace?: boolean | undefined;
+        forbidOnly?: boolean | undefined;
+        forbidPending?: boolean | undefined;
+        checkLeaks?: boolean | undefined;
+        test?: Test | undefined;
+        currentRunnable?: Runnable | undefined;
+        stats?: Stats | undefined; // added by reporters
+
+        /**
+         * Removes all event handlers set during a run on this instance.
+         * Remark: this does *not* clean/dispose the tests or suites themselves.
+         *
+         * @see https://mochajs.org/api/runner#dispose
+         */
+        dispose(): void;
+
+        /**
+         * Run tests with full titles matching `re`. Updates runner.total
+         * with number of tests matched.
+         *
+         * @see https://mochajs.org/api/Mocha.Runner.html#.Runner#grep
+         */
+        grep(re: RegExp, invert: boolean): this;
+
+        /**
+         * Returns the number of tests matching the grep search for the
+         * given suite.
+         *
+         * @see https://mochajs.org/api/Mocha.Runner.html#.Runner#grepTotal
+         */
+        grepTotal(suite: Suite): number;
+
+        /**
+         * Gets the allowed globals.
+         *
+         * @see https://mochajs.org/api/Mocha.Runner.html#.Runner#globals
+         */
+        globals(): string[];
+
+        /**
+         * Allow the given `arr` of globals.
+         *
+         * @see https://mochajs.org/api/Mocha.Runner.html#.Runner#globals
+         */
+        globals(arr: readonly string[]): this;
+
+        /**
+         * Run the root suite and invoke `fn(failures)` on completion.
+         *
+         * @see https://mochajs.org/api/Mocha.Runner.html#.Runner#run
+         */
+        run(fn?: (failures: number) => void): this;
+
+        /**
+         * Cleanly abort execution.
+         *
+         * @see https://mochajs.org/api/Mocha.Runner.html#.Runner#abort
+         */
+        abort(): this;
+
+        /**
+         * Handle uncaught exceptions.
+         *
+         * @see https://mochajs.org/api/Mocha.Runner.html#uncaught
+         */
+        uncaught(err: any): void;
+
+        /**
+         * Wrapper for setImmediate, process.nextTick, or browser polyfill.
+         */
+        protected static immediately(callback: Function): void;
+
+        /**
+         * Return a list of global properties.
+         *
+         * @see https://mochajs.org/api/Mocha.Runner.html#globalProps
+         */
+        protected globalProps(): string[];
+
+        /**
+         * Check for global variable leaks.
+         *
+         * @see https://mochajs.org/api/Mocha.Runner.html#checkGlobals
+         */
+        protected checkGlobals(test: Test): void;
+
+        /**
+         * Fail the given `test`.
+         *
+         * @see https://mochajs.org/api/Mocha.Runner.html#fail
+         */
+        protected fail(test: Test, 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 https://mochajs.org/api/Mocha.Runner.html#failHook
+         */
+        protected failHook(hook: Hook, err: any): void;
+
+        /**
+         * Run hook `name` callbacks and then invoke `fn()`.
+         *
+         * @see https://mochajs.org/api/Mocha.Runner.html#hook
+         */
+        protected hook(name: string, fn: () => void): void;
+
+        /**
+         * Run hook `name` for the given array of `suites`
+         * in order, and callback `fn(err, errSuite)`.
+         *
+         * @see https://mochajs.org/api/Mocha.Runner.html#hooks
+         */
+        protected hooks(name: string, suites: Suite[], fn: (err?: any, errSuite?: Suite) => void): void;
+
+        /**
+         * Run hooks from the top level down.
+         *
+         * @see https://mochajs.org/api/Mocha.Runner.html#hookUp
+         */
+        protected hookUp(name: string, fn: (err?: any, errSuite?: Suite) => void): void;
+
+        /**
+         * Run hooks from the bottom up.
+         *
+         * @see https://mochajs.org/api/Mocha.Runner.html#hookDown
+         */
+        protected hookDown(name: string, fn: (err?: any, errSuite?: Suite) => void): void;
+
+        /**
+         * Return an array of parent Suites from closest to furthest.
+         *
+         * @see https://mochajs.org/api/Mocha.Runner.html#parents
+         */
+        protected parents(): Suite[];
+
+        /**
+         * Run the current test and callback `fn(err)`.
+         *
+         * @see https://mochajs.org/api/Mocha.Runner.html#runTest
+         */
+        protected runTest(fn: Done): any;
+
+        /**
+         * Run tests in the given `suite` and invoke the callback `fn()` when complete.
+         *
+         * @see https://mochajs.org/api/Mocha.Runner.html#runTests
+         */
+        protected runTests(suite: Suite, fn: (errSuite?: Suite) => void): void;
+
+        /**
+         * Run the given `suite` and invoke the callback `fn()` when complete.
+         *
+         * @see https://mochajs.org/api/Mocha.Runner.html#runSuite
+         */
+        protected runSuite(suite: Suite, fn: (errSuite?: Suite) => void): void;
+    }
+
+    // #region Runner "waiting" event
+    interface Runner {
+        on(event: "waiting", listener: (rootSuite: Suite) => void): this;
+        once(event: "waiting", listener: (rootSuite: Suite) => void): this;
+        addListener(event: "waiting", listener: (rootSuite: Suite) => void): this;
+        removeListener(event: "waiting", listener: (rootSuite: Suite) => void): this;
+        prependListener(event: "waiting", listener: (rootSuite: Suite) => void): this;
+        prependOnceListener(event: "waiting", listener: (rootSuite: Suite) => void): this;
+        emit(name: "waiting", rootSuite: Suite): boolean;
+    }
+    // #endregion Runner "waiting" event
+    // #region Runner "start" event
+    interface Runner extends NodeJS.EventEmitter {
+        on(event: "start", listener: () => void): this;
+        once(event: "start", listener: () => void): this;
+        addListener(event: "start", listener: () => void): this;
+        removeListener(event: "start", listener: () => void): this;
+        prependListener(event: "start", listener: () => void): this;
+        prependOnceListener(event: "start", listener: () => void): this;
+        emit(name: "start"): boolean;
+    }
+    // #endregion Runner "start" event
+    // #region Runner "end" event
+    interface Runner extends NodeJS.EventEmitter {
+        on(event: "end", listener: () => void): this;
+        once(event: "end", listener: () => void): this;
+        addListener(event: "end", listener: () => void): this;
+        removeListener(event: "end", listener: () => void): this;
+        prependListener(event: "end", listener: () => void): this;
+        prependOnceListener(event: "end", listener: () => void): this;
+        emit(name: "end"): boolean;
+    }
+    // #endregion Runner "end" event
+    // #region Runner "suite" event
+    interface Runner extends NodeJS.EventEmitter {
+        on(event: "suite", listener: (suite: Suite) => void): this;
+        once(event: "suite", listener: (suite: Suite) => void): this;
+        addListener(event: "suite", listener: (suite: Suite) => void): this;
+        removeListener(event: "suite", listener: (suite: Suite) => void): this;
+        prependListener(event: "suite", listener: (suite: Suite) => void): this;
+        prependOnceListener(event: "suite", listener: (suite: Suite) => void): this;
+        emit(name: "suite", suite: Suite): boolean;
+    }
+    // #endregion Runner "suite" event
+    // #region Runner "suite end" event
+    interface Runner extends NodeJS.EventEmitter {
+        on(event: "suite end", listener: (suite: Suite) => void): this;
+        once(event: "suite end", listener: (suite: Suite) => void): this;
+        addListener(event: "suite end", listener: (suite: Suite) => void): this;
+        removeListener(event: "suite end", listener: (suite: Suite) => void): this;
+        prependListener(event: "suite end", listener: (suite: Suite) => void): this;
+        prependOnceListener(event: "suite end", listener: (suite: Suite) => void): this;
+        emit(name: "suite end", suite: Suite): boolean;
+    }
+    // #endregion Runner "suite end" event
+    // #region Runner "test" event
+    interface Runner extends NodeJS.EventEmitter {
+        on(event: "test", listener: (test: Test) => void): this;
+        once(event: "test", listener: (test: Test) => void): this;
+        addListener(event: "test", listener: (test: Test) => void): this;
+        removeListener(event: "test", listener: (test: Test) => void): this;
+        prependListener(event: "test", listener: (test: Test) => void): this;
+        prependOnceListener(event: "test", listener: (test: Test) => void): this;
+        emit(name: "test", test: Test): boolean;
+    }
+    // #endregion Runner "test" event
+    // #region Runner "test end" event
+    interface Runner extends NodeJS.EventEmitter {
+        on(event: "test end", listener: (test: Test) => void): this;
+        once(event: "test end", listener: (test: Test) => void): this;
+        addListener(event: "test end", listener: (test: Test) => void): this;
+        removeListener(event: "test end", listener: (test: Test) => void): this;
+        prependListener(event: "test end", listener: (test: Test) => void): this;
+        prependOnceListener(event: "test end", listener: (test: Test) => void): this;
+        emit(name: "test end", test: Test): boolean;
+    }
+    // #endregion Runner "test end" event
+    // #region Runner "hook" event
+    interface Runner extends NodeJS.EventEmitter {
+        on(event: "hook", listener: (hook: Hook) => void): this;
+        once(event: "hook", listener: (hook: Hook) => void): this;
+        addListener(event: "hook", listener: (hook: Hook) => void): this;
+        removeListener(event: "hook", listener: (hook: Hook) => void): this;
+        prependListener(event: "hook", listener: (hook: Hook) => void): this;
+        prependOnceListener(event: "hook", listener: (hook: Hook) => void): this;
+        emit(name: "hook", hook: Hook): boolean;
+    }
+    // #endregion Runner "hook" event
+    // #region Runner "hook end" event
+    interface Runner extends NodeJS.EventEmitter {
+        on(event: "hook end", listener: (hook: Hook) => void): this;
+        once(event: "hook end", listener: (hook: Hook) => void): this;
+        addListener(event: "hook end", listener: (hook: Hook) => void): this;
+        removeListener(event: "hook end", listener: (hook: Hook) => void): this;
+        prependListener(event: "hook end", listener: (hook: Hook) => void): this;
+        prependOnceListener(event: "hook end", listener: (hook: Hook) => void): this;
+        emit(name: "hook end", hook: Hook): boolean;
+    }
+    // #endregion Runner "hook end" event
+    // #region Runner "pass" event
+    interface Runner extends NodeJS.EventEmitter {
+        on(event: "pass", listener: (test: Test) => void): this;
+        once(event: "pass", listener: (test: Test) => void): this;
+        addListener(event: "pass", listener: (test: Test) => void): this;
+        removeListener(event: "pass", listener: (test: Test) => void): this;
+        prependListener(event: "pass", listener: (test: Test) => void): this;
+        prependOnceListener(event: "pass", listener: (test: Test) => void): this;
+        emit(name: "pass", test: Test): boolean;
+    }
+    // #endregion Runner "pass" event
+    // #region Runner "fail" event
+    interface Runner extends NodeJS.EventEmitter {
+        on(event: "fail", listener: (test: Test, err: any) => void): this;
+        once(event: "fail", listener: (test: Test, err: any) => void): this;
+        addListener(event: "fail", listener: (test: Test, err: any) => void): this;
+        removeListener(event: "fail", listener: (test: Test, err: any) => void): this;
+        prependListener(event: "fail", listener: (test: Test, err: any) => void): this;
+        prependOnceListener(event: "fail", listener: (test: Test, err: any) => void): this;
+        emit(name: "fail", test: Test, err: any): boolean;
+    }
+    // #endregion Runner "fail" event
+    // #region Runner "pending" event
+    interface Runner extends NodeJS.EventEmitter {
+        on(event: "pending", listener: (test: Test) => void): this;
+        once(event: "pending", listener: (test: Test) => void): this;
+        addListener(event: "pending", listener: (test: Test) => void): this;
+        removeListener(event: "pending", listener: (test: Test) => void): this;
+        prependListener(event: "pending", listener: (test: Test) => void): this;
+        prependOnceListener(event: "pending", listener: (test: Test) => void): this;
+        emit(name: "pending", test: Test): boolean;
+    }
+    // #endregion Runner "pending" event
+    // #region Runner untyped events
+    interface Runner extends NodeJS.EventEmitter {
+        on(event: string, listener: (...args: any[]) => void): this;
+        once(event: string, listener: (...args: any[]) => void): this;
+        addListener(event: string, listener: (...args: any[]) => void): this;
+        removeListener(event: string, listener: (...args: any[]) => void): this;
+        prependListener(event: string, listener: (...args: any[]) => void): this;
+        prependOnceListener(event: string, listener: (...args: any[]) => void): this;
+        emit(name: string, ...args: any[]): boolean;
+    }
+    // #endregion Runner untyped events
+
+    interface SuiteConstants {
+        readonly EVENT_FILE_POST_REQUIRE: "post-require";
+        readonly EVENT_FILE_PRE_REQUIRE: "pre-require";
+        readonly EVENT_FILE_REQUIRE: "require";
+        readonly EVENT_ROOT_SUITE_RUN: "run";
+
+        readonly HOOK_TYPE_AFTER_ALL: "afterAll";
+        readonly HOOK_TYPE_AFTER_EACH: "afterEach";
+        readonly HOOK_TYPE_BEFORE_ALL: "beforeAll";
+        readonly HOOK_TYPE_BEFORE_EACH: "beforeEach";
+
+        readonly EVENT_SUITE_ADD_HOOK_AFTER_ALL: "afterAll";
+        readonly EVENT_SUITE_ADD_HOOK_AFTER_EACH: "afterEach";
+        readonly EVENT_SUITE_ADD_HOOK_BEFORE_ALL: "beforeAll";
+        readonly EVENT_SUITE_ADD_HOOK_BEFORE_EACH: "beforeEach";
+        readonly EVENT_SUITE_ADD_SUITE: "suite";
+        readonly EVENT_SUITE_ADD_TEST: "test";
+    }
+
+    /**
+     * Initialize a new `Suite` with the given `title` and `ctx`.
+     *
+     * @see https://mochajs.org/api/Mocha.Suite.html
+     */
+    class Suite {
+        private _beforeEach;
+        private _beforeAll;
+        private _afterEach;
+        private _afterAll;
+        private _timeout;
+        private _slow;
+        private _bail;
+        private _retries;
+        private _onlyTests;
+        private _onlySuites;
+
+        static readonly constants: SuiteConstants;
+
+        constructor(title: string, parentContext?: Context);
+
+        ctx: Context;
+        suites: Suite[];
+        tests: Test[];
+        pending: boolean;
+        file?: string | undefined;
+        root: boolean;
+        delayed: boolean;
+        parent: Suite | undefined;
+        title: string;
+
+        /**
+         * 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 https://mochajs.org/api/mocha#.exports.create
+         */
+        static create(parent: Suite, title: string): Suite;
+
+        /**
+         * Return a clone of this `Suite`.
+         *
+         * @see https://mochajs.org/api/Mocha.Suite.html#clone
+         */
+        clone(): Suite;
+
+        /**
+         * Get timeout `ms`.
+         *
+         * @see https://mochajs.org/api/Mocha.Suite.html#timeout
+         */
+        timeout(): number;
+
+        /**
+         * Set timeout `ms` or short-hand such as "2s".
+         *
+         * @see https://mochajs.org/api/Mocha.Suite.html#timeout
+         */
+        timeout(ms: string | number): this;
+
+        /**
+         * Get number of times to retry a failed test.
+         *
+         * @see https://mochajs.org/api/Mocha.Suite.html#retries
+         */
+        retries(): number;
+
+        /**
+         * Set number of times to retry a failed test.
+         *
+         * @see https://mochajs.org/api/Mocha.Suite.html#retries
+         */
+        retries(n: string | number): this;
+
+        /**
+         * Get slow `ms`.
+         *
+         * @see https://mochajs.org/api/Mocha.Suite.html#slow
+         */
+        slow(): number;
+
+        /**
+         * Set slow `ms` or short-hand such as "2s".
+         *
+         * @see https://mochajs.org/api/Mocha.Suite.html#slow
+         */
+        slow(ms: string | number): this;
+
+        /**
+         * Get whether to bail after first error.
+         *
+         * @see https://mochajs.org/api/Mocha.Suite.html#bail
+         */
+        bail(): boolean;
+
+        /**
+         * Set whether to bail after first error.
+         *
+         * @see https://mochajs.org/api/Mocha.Suite.html#bail
+         */
+        bail(bail: boolean): this;
+
+        /**
+         * Check if this suite or its parent suite is marked as pending.
+         *
+         * @see https://mochajs.org/api/Mocha.Suite.html#isPending
+         */
+        isPending(): boolean;
+
+        /**
+         * Run `fn(test[, done])` before running tests.
+         *
+         * @see https://mochajs.org/api/Mocha.Suite.html#beforeAll
+         */
+        beforeAll(fn?: Func): this;
+
+        /**
+         * Run `fn(test[, done])` before running tests.
+         *
+         * @see https://mochajs.org/api/Mocha.Suite.html#beforeAll
+         */
+        beforeAll(fn?: AsyncFunc): this;
+
+        /**
+         * Run `fn(test[, done])` before running tests.
+         *
+         * @see https://mochajs.org/api/Mocha.Suite.html#beforeAll
+         */
+        beforeAll(title: string, fn?: Func): this;
+
+        /**
+         * Run `fn(test[, done])` before running tests.
+         *
+         * @see https://mochajs.org/api/Mocha.Suite.html#beforeAll
+         */
+        beforeAll(title: string, fn?: AsyncFunc): this;
+
+        /**
+         * Run `fn(test[, done])` after running tests.
+         *
+         * @see https://mochajs.org/api/Mocha.Suite.html#afterAll
+         */
+        afterAll(fn?: Func): this;
+
+        /**
+         * Run `fn(test[, done])` after running tests.
+         *
+         * @see https://mochajs.org/api/Mocha.Suite.html#afterAll
+         */
+        afterAll(fn?: AsyncFunc): this;
+
+        /**
+         * Run `fn(test[, done])` after running tests.
+         *
+         * @see https://mochajs.org/api/Mocha.Suite.html#afterAll
+         */
+        afterAll(title: string, fn?: Func): this;
+
+        /**
+         * Run `fn(test[, done])` after running tests.
+         *
+         * @see https://mochajs.org/api/Mocha.Suite.html#afterAll
+         */
+        afterAll(title: string, fn?: AsyncFunc): this;
+
+        /**
+         * Run `fn(test[, done])` before each test case.
+         *
+         * @see https://mochajs.org/api/Mocha.Suite.html#beforeEach
+         */
+        beforeEach(fn?: Func): this;
+
+        /**
+         * Run `fn(test[, done])` before each test case.
+         *
+         * @see https://mochajs.org/api/Mocha.Suite.html#beforeEach
+         */
+        beforeEach(fn?: AsyncFunc): this;
+
+        /**
+         * Run `fn(test[, done])` before each test case.
+         *
+         * @see https://mochajs.org/api/Mocha.Suite.html#beforeEach
+         */
+        beforeEach(title: string, fn?: Func): this;
+
+        /**
+         * Run `fn(test[, done])` before each test case.
+         *
+         * @see https://mochajs.org/api/Mocha.Suite.html#beforeEach
+         */
+        beforeEach(title: string, fn?: AsyncFunc): this;
+
+        /**
+         * Run `fn(test[, done])` after each test case.
+         *
+         * @see https://mochajs.org/api/Mocha.Suite.html#afterEach
+         */
+        afterEach(fn?: Func): this;
+
+        /**
+         * Run `fn(test[, done])` after each test case.
+         *
+         * @see https://mochajs.org/api/Mocha.Suite.html#afterEach
+         */
+        afterEach(fn?: AsyncFunc): this;
+
+        /**
+         * Run `fn(test[, done])` after each test case.
+         *
+         * @see https://mochajs.org/api/Mocha.Suite.html#afterEach
+         */
+        afterEach(title: string, fn?: Func): this;
+
+        /**
+         * Run `fn(test[, done])` after each test case.
+         *
+         * @see https://mochajs.org/api/Mocha.Suite.html#afterEach
+         */
+        afterEach(title: string, fn?: AsyncFunc): this;
+
+        /**
+         * Add a test `suite`.
+         *
+         * @see https://mochajs.org/api/Mocha.Suite.html#addSuite
+         */
+        addSuite(suite: Suite): this;
+
+        /**
+         * Add a `test` to this suite.
+         *
+         * @see https://mochajs.org/api/Mocha.Suite.html#addTest
+         */
+        addTest(test: Test): this;
+
+        /**
+         * Cleans all references from this suite and all child suites.
+         *
+         * https://mochajs.org/api/suite#dispose
+         */
+        dispose(): void;
+
+        /**
+         * Return the full title generated by recursively concatenating the parent's
+         * full title.
+         *
+         * @see https://mochajs.org/api/Mocha.Suite.html#.Suite#fullTitle
+         */
+        fullTitle(): string;
+
+        /**
+         * Return the title path generated by recursively concatenating the parent's
+         * title path.
+         *
+         * @see https://mochajs.org/api/Mocha.Suite.html#.Suite#titlePath
+         */
+        titlePath(): string[];
+
+        /**
+         * Return the total number of tests.
+         *
+         * @see https://mochajs.org/api/Mocha.Suite.html#.Suite#total
+         */
+        total(): number;
+
+        /**
+         * Iterates through each suite recursively to find all tests. Applies a
+         * function in the format `fn(test)`.
+         *
+         * @see https://mochajs.org/api/Mocha.Suite.html#eachTest
+         */
+        eachTest(fn: (test: Test) => void): this;
+
+        /**
+         * This will run the root suite if we happen to be running in delayed mode.
+         *
+         * @see https://mochajs.org/api/Mocha.Suite.html#run
+         */
+        run(): void;
+
+        /**
+         * Generic hook-creator.
+         */
+        protected _createHook(title: string, fn?: Func | AsyncFunc): Hook;
+    }
+
+    // #region Suite "beforeAll" event
+    interface Suite extends NodeJS.EventEmitter {
+        on(event: "beforeAll", listener: (hook: Hook) => void): this;
+        once(event: "beforeAll", listener: (hook: Hook) => void): this;
+        addListener(event: "beforeAll", listener: (hook: Hook) => void): this;
+        removeListener(event: "beforeAll", listener: (hook: Hook) => void): this;
+        prependListener(event: "beforeAll", listener: (hook: Hook) => void): this;
+        prependOnceListener(event: "beforeAll", listener: (hook: Hook) => void): this;
+        emit(name: "beforeAll", hook: Hook): boolean;
+    }
+    // #endregion Suite "beforeAll" event
+    // #region Suite "afterAll" event
+    interface Suite extends NodeJS.EventEmitter {
+        on(event: "afterAll", listener: (hook: Hook) => void): this;
+        once(event: "afterAll", listener: (hook: Hook) => void): this;
+        addListener(event: "afterAll", listener: (hook: Hook) => void): this;
+        removeListener(event: "afterAll", listener: (hook: Hook) => void): this;
+        prependListener(event: "afterAll", listener: (hook: Hook) => void): this;
+        prependOnceListener(event: "afterAll", listener: (hook: Hook) => void): this;
+        emit(name: "afterAll", hook: Hook): boolean;
+    }
+    // #endregion Suite "afterAll" event
+    // #region Suite "beforeEach" event
+    interface Suite extends NodeJS.EventEmitter {
+        on(event: "beforeEach", listener: (hook: Hook) => void): this;
+        once(event: "beforeEach", listener: (hook: Hook) => void): this;
+        addListener(event: "beforeEach", listener: (hook: Hook) => void): this;
+        removeListener(event: "beforeEach", listener: (hook: Hook) => void): this;
+        prependListener(event: "beforeEach", listener: (hook: Hook) => void): this;
+        prependOnceListener(event: "beforeEach", listener: (hook: Hook) => void): this;
+        emit(name: "beforeEach", hook: Hook): boolean;
+    }
+    // #endregion Suite "beforeEach" event
+    // #region Suite "afterEach" event
+    interface Suite extends NodeJS.EventEmitter {
+        on(event: "afterEach", listener: (hook: Hook) => void): this;
+        once(event: "afterEach", listener: (hook: Hook) => void): this;
+        addListener(event: "afterEach", listener: (hook: Hook) => void): this;
+        removeListener(event: "afterEach", listener: (hook: Hook) => void): this;
+        prependListener(event: "afterEach", listener: (hook: Hook) => void): this;
+        prependOnceListener(event: "afterEach", listener: (hook: Hook) => void): this;
+        emit(name: "afterEach", hook: Hook): boolean;
+    }
+    // #endregion Suite "afterEach" event
+    // #region Suite "suite" event
+    interface Suite extends NodeJS.EventEmitter {
+        on(event: "suite", listener: (suite: Suite) => void): this;
+        once(event: "suite", listener: (suite: Suite) => void): this;
+        addListener(event: "suite", listener: (suite: Suite) => void): this;
+        removeListener(event: "suite", listener: (suite: Suite) => void): this;
+        prependListener(event: "suite", listener: (suite: Suite) => void): this;
+        prependOnceListener(event: "suite", listener: (suite: Suite) => void): this;
+        emit(name: "suite", suite: Suite): boolean;
+    }
+    // #endregion Suite "suite" event
+    // #region Suite "test" event
+    interface Suite {
+        on(event: "test", listener: (test: Test) => void): this;
+        once(event: "test", listener: (test: Test) => void): this;
+        addListener(event: "test", listener: (test: Test) => void): this;
+        removeListener(event: "test", listener: (test: Test) => void): this;
+        prependListener(event: "test", listener: (test: Test) => void): this;
+        prependOnceListener(event: "test", listener: (test: Test) => void): this;
+        emit(name: "test", test: Test): boolean;
+    }
+    // #endregion Suite "test" event
+    // #region Suite "run" event
+    interface Suite extends NodeJS.EventEmitter {
+        on(event: "run", listener: () => void): this;
+        once(event: "run", listener: () => void): this;
+        addListener(event: "run", listener: () => void): this;
+        removeListener(event: "run", listener: () => void): this;
+        prependListener(event: "run", listener: () => void): this;
+        prependOnceListener(event: "run", listener: () => void): this;
+        emit(name: "run"): boolean;
+    }
+    // #endregion Suite "run" event
+    // #region Suite "pre-require" event
+    interface Suite extends NodeJS.EventEmitter {
+        on(event: "pre-require", listener: (context: MochaGlobals, file: string, mocha: Mocha) => void): this;
+        once(event: "pre-require", listener: (context: MochaGlobals, file: string, mocha: Mocha) => void): this;
+        addListener(event: "pre-require", listener: (context: MochaGlobals, file: string, mocha: Mocha) => void): this;
+        removeListener(
+            event: "pre-require",
+            listener: (context: MochaGlobals, file: string, mocha: Mocha) => void,
+        ): this;
+        prependListener(
+            event: "pre-require",
+            listener: (context: MochaGlobals, file: string, mocha: Mocha) => void,
+        ): this;
+        prependOnceListener(
+            event: "pre-require",
+            listener: (context: MochaGlobals, file: string, mocha: Mocha) => void,
+        ): this;
+        emit(name: "pre-require", context: MochaGlobals, file: string, mocha: Mocha): boolean;
+    }
+    // #endregion Suite "pre-require" event
+    // #region Suite "require" event
+    interface Suite extends NodeJS.EventEmitter {
+        on(event: "require", listener: (module: any, file: string, mocha: Mocha) => void): this;
+        once(event: "require", listener: (module: any, file: string, mocha: Mocha) => void): this;
+        addListener(event: "require", listener: (module: any, file: string, mocha: Mocha) => void): this;
+        removeListener(event: "require", listener: (module: any, file: string, mocha: Mocha) => void): this;
+        prependListener(event: "require", listener: (module: any, file: string, mocha: Mocha) => void): this;
+        prependOnceListener(event: "require", listener: (module: any, file: string, mocha: Mocha) => void): this;
+        emit(name: "require", module: any, file: string, mocha: Mocha): boolean;
+    }
+    // #endregion Suite "require" event
+    // #region Suite "post-require" event
+    interface Suite extends NodeJS.EventEmitter {
+        on(event: "post-require", listener: (context: MochaGlobals, file: string, mocha: Mocha) => void): this;
+        once(event: "post-require", listener: (context: MochaGlobals, file: string, mocha: Mocha) => void): this;
+        addListener(event: "post-require", listener: (context: MochaGlobals, file: string, mocha: Mocha) => void): this;
+        removeListener(
+            event: "post-require",
+            listener: (context: MochaGlobals, file: string, mocha: Mocha) => void,
+        ): this;
+        prependListener(
+            event: "post-require",
+            listener: (context: MochaGlobals, file: string, mocha: Mocha) => void,
+        ): this;
+        prependOnceListener(
+            event: "post-require",
+            listener: (context: MochaGlobals, file: string, mocha: Mocha) => void,
+        ): this;
+        emit(name: "post-require", context: MochaGlobals, file: string, mocha: Mocha): boolean;
+    }
+    // #endregion Suite "post-require" event
+    // #region Suite untyped events
+    interface Suite extends NodeJS.EventEmitter {
+        on(event: string, listener: (...args: any[]) => void): this;
+        once(event: string, listener: (...args: any[]) => void): this;
+        addListener(event: string, listener: (...args: any[]) => void): this;
+        removeListener(event: string, listener: (...args: any[]) => void): this;
+        prependListener(event: string, listener: (...args: any[]) => void): this;
+        prependOnceListener(event: string, listener: (...args: any[]) => void): this;
+        emit(name: string, ...args: any[]): boolean;
+    }
+    // #endregion Runner untyped events
+
+    /**
+     * Initialize a new `Hook` with the given `title` and callback `fn`
+     *
+     * @see https://mochajs.org/api/Hook.html
+     */
+    class Hook extends Runnable {
+        private _error;
+
+        type: "hook";
+        originalTitle?: string | undefined; // added by Runner
+
+        /**
+         * Get the test `err`.
+         *
+         * @see https://mochajs.org/api/Hook.html#error
+         */
+        error(): any;
+
+        /**
+         * Set the test `err`.
+         *
+         * @see https://mochajs.org/api/Hook.html#error
+         */
+        error(err: any): void;
+    }
+
+    /**
+     * 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 https://mochajs.org/#root-hook-plugins
+     */
+    interface RootHookObject {
+        /**
+         * In serial mode, run after all tests end, once only.
+         * In parallel mode, run after all tests end, for each file.
+         */
+        afterAll?: Func | AsyncFunc | Func[] | AsyncFunc[] | undefined;
+        /**
+         * In serial mode (Mocha's default), before all tests begin, once only.
+         * In parallel mode, run before all tests begin, for each file.
+         */
+        beforeAll?: Func | AsyncFunc | Func[] | AsyncFunc[] | undefined;
+        /**
+         * In both modes, run after every test.
+         */
+        afterEach?: Func | AsyncFunc | Func[] | AsyncFunc[] | undefined;
+        /**
+         * In both modes, run before each test.
+         */
+        beforeEach?: Func | AsyncFunc | Func[] | AsyncFunc[] | undefined;
+    }
+
+    /**
+     * Initialize a new `Test` with the given `title` and callback `fn`.
+     *
+     * @see https://mochajs.org/api/Test.html
+     */
+    class Test extends Runnable {
+        type: "test";
+        speed?: "slow" | "medium" | "fast" | undefined; // added by reporters
+        err?: Error | undefined; // added by reporters
+        clone(): Test;
+    }
+
+    /**
+     * Test statistics
+     */
+    interface Stats {
+        suites: number;
+        tests: number;
+        passes: number;
+        pending: number;
+        failures: number;
+        start?: Date | undefined;
+        end?: Date | undefined;
+        duration?: number | undefined;
+    }
+
+    type TestInterface = (suite: Suite) => void;
+
+    interface ReporterConstructor {
+        new(runner: Runner, options: MochaOptions): reporters.Base;
+    }
+
+    type Done = (err?: any) => void;
+
+    /**
+     * Callback function used for tests and hooks.
+     */
+    type Func = (this: Context, done: Done) => void;
+
+    /**
+     * Async callback function used for tests and hooks.
+     */
+    type AsyncFunc = (this: Context) => PromiseLike<any>;
+
+    /**
+     * Options to pass to Mocha.
+     */
+    interface MochaOptions {
+        /** Propagate uncaught errors? */
+        allowUncaught?: boolean | undefined;
+
+        /** Force `done` callback or promise? */
+        asyncOnly?: boolean | undefined;
+
+        /** bail on the first test failure. */
+        bail?: boolean | undefined;
+
+        /** Check for global variable leaks? */
+        checkLeaks?: boolean | undefined;
+
+        /** Color TTY output from reporter */
+        color?: boolean | undefined;
+
+        /** Delay root suite execution? */
+        delay?: boolean | undefined;
+
+        /** Show diff on failure? */
+        diff?: boolean | undefined;
+
+        /** Report tests without running them? */
+        dryRun?: boolean | undefined;
+
+        /** Test filter given string. */
+        fgrep?: string | undefined;
+
+        /** Tests marked `only` fail the suite? */
+        forbidOnly?: boolean | undefined;
+
+        /** Pending tests fail the suite? */
+        forbidPending?: boolean | undefined;
+
+        /** Full stacktrace upon failure? */
+        fullTrace?: boolean | undefined;
+
+        /** Variables expected in global scope. */
+        globals?: string[] | undefined;
+
+        /** Test filter given regular expression. */
+        grep?: string | RegExp | undefined;
+
+        /** Enable desktop notifications? */
+        growl?: boolean | undefined;
+
+        /** Display inline diffs? */
+        inlineDiffs?: boolean | undefined;
+
+        /** Invert test filter matches? */
+        invert?: boolean | undefined;
+
+        /** Disable syntax highlighting? */
+        noHighlighting?: boolean | undefined;
+
+        /** Reporter name or constructor. */
+        reporter?: string | ReporterConstructor | undefined;
+
+        /** Reporter settings object. */
+        reporterOptions?: any;
+
+        /** Number of times to retry failed tests. */
+        retries?: number | undefined;
+
+        /** Slow threshold value. */
+        slow?: number | undefined;
+
+        /** Timeout threshold value. */
+        timeout?: number | string | undefined;
+
+        /** Interface name. */
+        ui?: Interface | undefined;
+
+        /** Run jobs in parallel */
+        parallel?: boolean | undefined;
+
+        /** Max number of worker processes for parallel runs. */
+        jobs?: number | undefined;
+
+        /** Hooks to bootstrap the root suite with. */
+        rootHooks?: RootHookObject | undefined;
+
+        /** Pathname of `rootHooks` plugin for parallel runs. */
+        require?: string[] | undefined;
+
+        /** Should be `true` if `Mocha` process is running in a worker process. */
+        isWorker?: boolean | undefined;
+    }
+
+    interface MochaInstanceOptions extends MochaOptions {
+        files?: string[] | undefined;
+    }
+
+    /**
+     * Variables added to the global scope by Mocha when run in the CLI.
+     */
+    interface MochaGlobals {
+        /**
+         * Execute before running tests.
+         *
+         * - _Only available when invoked via the mocha CLI._
+         *
+         * @see https://mochajs.org/api/global.html#before
+         */
+        before: HookFunction;
+
+        /**
+         * Execute after running tests.
+         *
+         * - _Only available when invoked via the mocha CLI._
+         *
+         * @see https://mochajs.org/api/global.html#after
+         */
+        after: HookFunction;
+
+        /**
+         * Execute before each test case.
+         *
+         * - _Only available when invoked via the mocha CLI._
+         *
+         * @see https://mochajs.org/api/global.html#beforeEach
+         */
+        beforeEach: HookFunction;
+
+        /**
+         * Execute after each test case.
+         *
+         * - _Only available when invoked via the mocha CLI._
+         *
+         * @see https://mochajs.org/api/global.html#afterEach
+         */
+        afterEach: HookFunction;
+
+        /**
+         * Describe a "suite" containing nested suites and tests.
+         *
+         * - _Only available when invoked via the mocha CLI._
+         */
+        describe: SuiteFunction;
+
+        /**
+         * Describe a "suite" containing nested suites and tests.
+         *
+         * - _Only available when invoked via the mocha CLI._
+         */
+        context: SuiteFunction;
+
+        /**
+         * Pending suite.
+         *
+         * - _Only available when invoked via the mocha CLI._
+         */
+        xdescribe: PendingSuiteFunction;
+
+        /**
+         * Pending suite.
+         *
+         * - _Only available when invoked via the mocha CLI._
+         */
+        xcontext: PendingSuiteFunction;
+
+        /**
+         * Describes a test case.
+         *
+         * - _Only available when invoked via the mocha CLI._
+         */
+        it: TestFunction;
+
+        /**
+         * Describes a test case.
+         *
+         * - _Only available when invoked via the mocha CLI._
+         */
+        specify: TestFunction;
+
+        /**
+         * Describes a pending test case.
+         *
+         * - _Only available when invoked via the mocha CLI._
+         */
+        xit: PendingTestFunction;
+
+        /**
+         * Describes a pending test case.
+         *
+         * - _Only available when invoked via the mocha CLI._
+         */
+        xspecify: PendingTestFunction;
+
+        /**
+         * Execute before running tests.
+         *
+         * - _Only available when invoked via the mocha CLI._
+         *
+         * @see https://mochajs.org/api/global.html#before
+         */
+        suiteSetup: HookFunction;
+
+        /**
+         * Execute after running tests.
+         *
+         * - _Only available when invoked via the mocha CLI._
+         *
+         * @see https://mochajs.org/api/global.html#after
+         */
+        suiteTeardown: HookFunction;
+
+        /**
+         * Execute before each test case.
+         *
+         * - _Only available when invoked via the mocha CLI._
+         *
+         * @see https://mochajs.org/api/global.html#beforeEach
+         */
+        setup: HookFunction;
+
+        /**
+         * Execute after each test case.
+         *
+         * - _Only available when invoked via the mocha CLI._
+         *
+         * @see https://mochajs.org/api/global.html#afterEach
+         */
+        teardown: HookFunction;
+
+        /**
+         * Describe a "suite" containing nested suites and tests.
+         *
+         * - _Only available when invoked via the mocha CLI._
+         */
+        suite: SuiteFunction;
+
+        /**
+         * Describes a test case.
+         *
+         * - _Only available when invoked via the mocha CLI._
+         */
+        test: TestFunction;
+
+        run: typeof run;
+    }
+
+    /**
+     * Third-party declarations that want to add new entries to the `Reporter` union can
+     * contribute names here.
+     */
+    interface ReporterContributions {
+        Base: never;
+        base: never;
+        Dot: never;
+        dot: never;
+        TAP: never;
+        tap: never;
+        JSON: never;
+        json: never;
+        HTML: never;
+        html: never;
+        List: never;
+        list: never;
+        Min: never;
+        min: never;
+        Spec: never;
+        spec: never;
+        Nyan: never;
+        nyan: never;
+        XUnit: never;
+        xunit: never;
+        Markdown: never;
+        markdown: never;
+        Progress: never;
+        progress: never;
+        Landing: never;
+        landing: never;
+        JSONStream: never;
+        "json-stream": never;
+    }
+
+    type Reporter = keyof ReporterContributions;
+
+    /**
+     * Third-party declarations that want to add new entries to the `Interface` union can
+     * contribute names here.
+     */
+    interface InterfaceContributions {
+        bdd: never;
+        tdd: never;
+        qunit: never;
+        exports: never;
+    }
+
+    type Interface = keyof InterfaceContributions;
+}
+
+// #region Test interface augmentations
+
+/**
+ * Triggers root suite execution.
+ *
+ * - _Only available if flag --delay is passed into Mocha._
+ * - _Only available when invoked via the mocha CLI._
+ *
+ * @see https://mochajs.org/api/global.html#runWithSuite
+ */
+declare function run(): void;
+
+/**
+ * Execute before running tests.
+ *
+ * - _Only available when invoked via the mocha CLI._
+ *
+ * @see https://mochajs.org/api/global.html#before
+ */
+declare var before: Mocha.HookFunction;
+
+/**
+ * Execute before running tests.
+ *
+ * - _Only available when invoked via the mocha CLI._
+ *
+ * @see https://mochajs.org/api/global.html#before
+ */
+declare var suiteSetup: Mocha.HookFunction;
+
+/**
+ * Execute after running tests.
+ *
+ * - _Only available when invoked via the mocha CLI._
+ *
+ * @see https://mochajs.org/api/global.html#after
+ */
+declare var after: Mocha.HookFunction;
+
+/**
+ * Execute after running tests.
+ *
+ * - _Only available when invoked via the mocha CLI._
+ *
+ * @see https://mochajs.org/api/global.html#after
+ */
+declare var suiteTeardown: Mocha.HookFunction;
+
+/**
+ * Execute before each test case.
+ *
+ * - _Only available when invoked via the mocha CLI._
+ *
+ * @see https://mochajs.org/api/global.html#beforeEach
+ */
+declare var beforeEach: Mocha.HookFunction;
+
+/**
+ * Execute before each test case.
+ *
+ * - _Only available when invoked via the mocha CLI._
+ *
+ * @see https://mochajs.org/api/global.html#beforeEach
+ */
+declare var setup: Mocha.HookFunction;
+
+/**
+ * Execute after each test case.
+ *
+ * - _Only available when invoked via the mocha CLI._
+ *
+ * @see https://mochajs.org/api/global.html#afterEach
+ */
+declare var afterEach: Mocha.HookFunction;
+
+/**
+ * Execute after each test case.
+ *
+ * - _Only available when invoked via the mocha CLI._
+ *
+ * @see https://mochajs.org/api/global.html#afterEach
+ */
+declare var teardown: Mocha.HookFunction;
+
+/**
+ * Describe a "suite" containing nested suites and tests.
+ *
+ * - _Only available when invoked via the mocha CLI._
+ */
+declare var describe: Mocha.SuiteFunction;
+
+/**
+ * Describe a "suite" containing nested suites and tests.
+ *
+ * - _Only available when invoked via the mocha CLI._
+ */
+declare var context: Mocha.SuiteFunction;
+
+/**
+ * Describe a "suite" containing nested suites and tests.
+ *
+ * - _Only available when invoked via the mocha CLI._
+ */
+declare var suite: Mocha.SuiteFunction;
+
+/**
+ * Pending suite.
+ *
+ * - _Only available when invoked via the mocha CLI._
+ */
+declare var xdescribe: Mocha.PendingSuiteFunction;
+
+/**
+ * Pending suite.
+ *
+ * - _Only available when invoked via the mocha CLI._
+ */
+declare var xcontext: Mocha.PendingSuiteFunction;
+
+/**
+ * Describes a test case.
+ *
+ * - _Only available when invoked via the mocha CLI._
+ */
+declare var it: Mocha.TestFunction;
+
+/**
+ * Describes a test case.
+ *
+ * - _Only available when invoked via the mocha CLI._
+ */
+declare var specify: Mocha.TestFunction;
+
+/**
+ * Describes a test case.
+ *
+ * - _Only available when invoked via the mocha CLI._
+ */
+declare var test: Mocha.TestFunction;
+
+/**
+ * Describes a pending test case.
+ *
+ * - _Only available when invoked via the mocha CLI._
+ */
+declare var xit: Mocha.PendingTestFunction;
+
+/**
+ * Describes a pending test case.
+ *
+ * - _Only available when invoked via the mocha CLI._
+ */
+declare var xspecify: Mocha.PendingTestFunction;
+
+// #endregion Test interface augmentations
+
+// #region Reporter augmentations
+
+// Forward declaration for `HTMLLIElement` from lib.dom.d.ts.
+// Required by Mocha.reporters.HTML.
+// NOTE: Mocha *must not* have a direct dependency on DOM types.
+// eslint-disable-next-line @typescript-eslint/no-empty-interface
+interface HTMLLIElement {}
+
+// Augments the DOM `Window` object when lib.dom.d.ts is loaded.
+// eslint-disable-next-line @typescript-eslint/no-empty-interface
+interface Window extends Mocha.MochaGlobals {}
+
+declare namespace NodeJS {
+    // Forward declaration for `NodeJS.EventEmitter` from node.d.ts.
+    // Required by Mocha.Runnable, Mocha.Runner, and Mocha.Suite.
+    // NOTE: Mocha *must not* have a direct dependency on @types/node.
+    // eslint-disable-next-line @typescript-eslint/no-empty-interface
+    interface EventEmitter {}
+
+    // Augments NodeJS's `global` object when node.d.ts is loaded
+    // eslint-disable-next-line @typescript-eslint/no-empty-interface
+    interface Global extends Mocha.MochaGlobals {}
+}
+
+// #endregion Reporter augmentations
+
+// #region Browser augmentations
+
+/**
+ * Mocha global.
+ *
+ * - _Only supported in the browser._
+ */
+declare const mocha: BrowserMocha;
+
+interface BrowserMocha extends Mocha {
+    /**
+     * Function to allow assertion libraries to throw errors directly into mocha.
+     * This is useful when running tests in a browser because window.onerror will
+     * only receive the 'message' attribute of the Error.
+     *
+     * - _Only supported in the browser._
+     */
+    throwError(err: any): never;
+
+    /**
+     * Setup mocha with the given settings options.
+     *
+     * - _Only supported in the browser._
+     */
+    setup(opts?: Mocha.Interface | Mocha.MochaOptions): this;
+}
+
+// #endregion Browser augmentations
+
+declare module "mocha" {
+    export = Mocha;
+}
+
+declare module "mocha/lib/stats-collector" {
+    export = createStatsCollector;
+
+    /**
+     * Provides stats such as test duration, number of tests passed / failed etc., by listening for events emitted by `runner`.
+     */
+    function createStatsCollector(runner: Mocha.Runner): void;
+}
+
+declare module "mocha/lib/interfaces/common" {
+    export = common;
+
+    function common(suites: Mocha.Suite[], context: Mocha.MochaGlobals, mocha: Mocha): common.CommonFunctions;
+
+    namespace common {
+        interface CommonFunctions {
+            /**
+             * This is only present if flag --delay is passed into Mocha. It triggers
+             * root suite execution.
+             */
+            runWithSuite(suite: Mocha.Suite): () => void;
+
+            /**
+             * Execute before running tests.
+             */
+            before(fn?: Mocha.Func | Mocha.AsyncFunc): void;
+
+            /**
+             * Execute before running tests.
+             */
+            before(name: string, fn?: Mocha.Func | Mocha.AsyncFunc): void;
+
+            /**
+             * Execute after running tests.
+             */
+            after(fn?: Mocha.Func | Mocha.AsyncFunc): void;
+
+            /**
+             * Execute after running tests.
+             */
+            after(name: string, fn?: Mocha.Func | Mocha.AsyncFunc): void;
+
+            /**
+             * Execute before each test case.
+             */
+            beforeEach(fn?: Mocha.Func | Mocha.AsyncFunc): void;
+
+            /**
+             * Execute before each test case.
+             */
+            beforeEach(name: string, fn?: Mocha.Func | Mocha.AsyncFunc): void;
+
+            /**
+             * Execute after each test case.
+             */
+            afterEach(fn?: Mocha.Func | Mocha.AsyncFunc): void;
+
+            /**
+             * Execute after each test case.
+             */
+            afterEach(name: string, fn?: Mocha.Func | Mocha.AsyncFunc): void;
+
+            suite: SuiteFunctions;
+            test: TestFunctions;
+        }
+
+        interface CreateOptions {
+            /** Title of suite */
+            title: string;
+
+            /** Suite function */
+            fn?: ((this: Mocha.Suite) => void) | undefined;
+
+            /** Is suite pending? */
+            pending?: boolean | undefined;
+
+            /** Filepath where this Suite resides */
+            file?: string | undefined;
+
+            /** Is suite exclusive? */
+            isOnly?: boolean | undefined;
+        }
+
+        interface SuiteFunctions {
+            /**
+             * Create an exclusive Suite; convenience function
+             */
+            only(opts: CreateOptions): Mocha.Suite;
+
+            /**
+             * Create a Suite, but skip it; convenience function
+             */
+            skip(opts: CreateOptions): Mocha.Suite;
+
+            /**
+             * Creates a suite.
+             */
+            create(opts: CreateOptions): Mocha.Suite;
+        }
+
+        interface TestFunctions {
+            /**
+             * Exclusive test-case.
+             */
+            only(mocha: Mocha, test: Mocha.Test): Mocha.Test;
+
+            /**
+             * Pending test case.
+             */
+            skip(title: string): void;
+
+            /**
+             * Number of retry attempts
+             */
+            retries(n: number): void;
+        }
+    }
+}