/**
 * @param {string} name
 * @param {TestFn} [fn]
 * @returns {void}
 */
export function only(name: string, fn?: TestFn): void;
/**
 * @param {string} _name
 * @param {TestFn} [_fn]
 * @returns {void}
 */
export function skip(_name: string, _fn?: TestFn): void;
/**
 * @param {boolean} strict
 * @returns {void}
 */
export function setStrict(strict: boolean): void;
/**
 * @type {{
 *    (name: string, fn?: TestFn): void
 *    only(name: string, fn?: TestFn): void
 *    skip(name: string, fn?: TestFn): void
 * }}
 *
 * @param {string} name
 * @param {TestFn} [fn]
 * @returns {void}
 */
export function test(name: string, fn?: TestFn): void;
export namespace test {
    export { only };
    export { skip };
}
/**
 * @typedef {(t: Test) => (void | Promise<any>)} TestFn
 */
/**
 * @class
 */
export class Test {
    /**
     * @constructor
     * @param {string} name
     * @param {TestFn} fn
     * @param {TestRunner} runner
     */
    constructor(name: string, fn: TestFn, runner: TestRunner);
    /** @type {string} */
    name: string;
    /** @type {null|number} */
    _planned: null | number;
    /** @type {undefined|ReturnType<typeof setTimeout>} */
    _timeout: undefined | ReturnType<typeof setTimeout>;
    /** @type {undefined|ReturnType<typeof setTimeout>} */
    _timeouttimeout: undefined | ReturnType<typeof setTimeout>;
    /** @type {number} */
    TIMEOUT_MS: number;
    /** @type {boolean} */
    _timedOut: boolean;
    /** @type {number} */
    _actual: number;
    /** @type {TestFn} */
    fn: TestFn;
    /** @type {TestRunner} */
    runner: TestRunner;
    /** @type {Promise<void>|undefined} */
    _planPromise: Promise<void> | undefined;
    _assertionQueue: any[];
    /** @type {{ pass:number, fail:number }} */
    _result: {
        pass: number;
        fail: number;
    };
    /** @type {boolean} */
    done: boolean;
    /** @type {boolean} */
    strict: boolean;
    /**
     * @param {string} msg
     * @returns {void}
     */
    comment(msg: string): void;
    /**
     * Plan the number of assertions.
     *
     * @param {number} n
     * @param {number} [timeoutMS]
     * @return {void}
     */
    plan(n: number, timeoutMS?: number): void;
    _resolve: () => void;
    /**
     * @template T
     * @param {T} actual
     * @param {T} expected
     * @param {string} [msg]
     * @returns {void}
     */
    deepEqual<T>(actual: T, expected: T, msg?: string): void;
    /**
     * @template T
     * @param {T} actual
     * @param {T} expected
     * @param {string} [msg]
     * @returns {void}
     */
    notDeepEqual<T_1>(actual: T_1, expected: T_1, msg?: string): void;
    /**
     * @template T
     * @param {T} actual
     * @param {T} expected
     * @param {string} [msg]
     * @returns {void}
     */
    equal<T_2>(actual: T_2, expected: T_2, msg?: string): void;
    /**
     * @param {unknown} actual
     * @param {unknown} expected
     * @param {string} [msg]
     * @returns {void}
     */
    notEqual(actual: unknown, expected: unknown, msg?: string): void;
    /**
     * @param {string} [msg]
     * @returns {void}
     */
    fail(msg?: string): void;
    /**
     * @param {unknown} actual
     * @param {string} [msg]
     * @returns {void}
     */
    ok(actual: unknown, msg?: string): void;
    /**
     * @param {Error | null | undefined} err
     * @param {string} [msg]
     * @returns {void}
     */
    ifError(err: Error | null | undefined, msg?: string): void;
    /**
     * @param {Function} fn
     * @param {RegExp | any} [expected]
     * @param {string} [message]
     * @returns {Promise<void>}
     */
    throws(fn: Function, expected?: RegExp | any, message?: string): Promise<void>;
    /**
     * @param {boolean} pass
     * @param {unknown} actual
     * @param {unknown} expected
     * @param {string} description
     * @param {string} operator
     * @returns {void}
     */
    _assert(pass: boolean, actual: unknown, expected: unknown, description: string, operator: string): void;
    _waitLoop(): void;
    _clearTimeout(): void;
    /**
     * @returns {Promise<{
     *   pass:number,
     *   fail:number,
     * }>}
     */
    run(): Promise<{
        pass: number;
        fail: number;
    }>;
}
/**
 * @class
 */
export class TestRunner {
    /**
     * @constructor
     * @param {(lines: string) => void} [report]
     */
    constructor(report?: (lines: string) => void);
    /** @type {(lines: string) => void} */
    report: (lines: string) => void;
    /** @type {Test[]} */
    tests: Test[];
    /** @type {Test[]} */
    onlyTests: Test[];
    /** @type {boolean} */
    scheduled: boolean;
    /** @type {number} */
    _id: number;
    /** @type {boolean} */
    completed: boolean;
    /** @type {boolean} */
    rethrowExceptions: boolean;
    /** @type {boolean} */
    strict: boolean;
    /** @type {function | void} */
    _onFinishCallback: Function | void;
    /**
     * @returns {string}
     */
    nextId(): string;
    /**
     * @param {string} name
     * @param {TestFn} fn
     * @param {boolean} only
     * @returns {void}
     */
    add(name: string, fn: TestFn, only: boolean): void;
    /**
     * @returns {Promise<void>}
     */
    run(): Promise<void>;
    /**
     * @param {(result: { total: number, success: number, fail: number }) => void} callback
     * @returns {void}
     */
    onFinish(callback: (result: {
        total: number;
        success: number;
        fail: number;
    }) => void): void;
}
export const GLOBAL_TEST_RUNNER: TestRunner;
export type TestFn = (t: Test) => (void | Promise<any>);