ts-mockito

const _default: {
    spy: typeof spy;
    mock: typeof mock;
    verify: typeof verify;
    when: typeof when;
    instance: typeof instance;
    capture: typeof capture;
    reset: typeof reset;
    resetCalls: typeof resetCalls;
    anyOfClass: typeof anyOfClass;
    anyFunction: typeof anyFunction;
    anyNumber: typeof anyNumber;
    anyString: typeof anyString;
    anything: typeof anything;
    between: typeof between;
    deepEqual: typeof deepEqual;
    notNull: typeof notNull;
    strictEqual: typeof strictEqual;
    match: typeof match;
    objectContaining: typeof objectContaining;
};

anyFunction: () => any;

anyNumber: () => any;

anyOfClass: <T>(expectedClass: new (...args: any[]) => T) => any;

anyString: () => any;

anything: () => any;

between: (min: number, max: number) => any;

capture: {
    <T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>(
        method: (
            a: T0,
            b: T1,
            c: T2,
            d: T3,
            e: T4,
            f: T5,
            g: T6,
            h: T7,
            i: T8,
            j: T9
        ) => any
    ): ArgCaptor10<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>;
    <T0, T1, T2, T3, T4, T5, T6, T7, T8>(
        method: (
            a: T0,
            b: T1,
            c: T2,
            d: T3,
            e: T4,
            f: T5,
            g: T6,
            h: T7,
            i: T8
        ) => any
    ): ArgCaptor9<T0, T1, T2, T3, T4, T5, T6, T7, T8>;
    <T0, T1, T2, T3, T4, T5, T6, T7>(
        method: (a: T0, b: T1, c: T2, d: T3, e: T4, f: T5, g: T6, h: T7) => any
    ): ArgCaptor8<T0, T1, T2, T3, T4, T5, T6, T7>;
    <T0, T1, T2, T3, T4, T5, T6>(
        method: (a: T0, b: T1, c: T2, d: T3, e: T4, f: T5, g: T6) => any
    ): ArgCaptor7<T0, T1, T2, T3, T4, T5, T6>;
    <T0, T1, T2, T3, T4, T5>(
        method: (a: T0, b: T1, c: T2, d: T3, e: T4, f: T5) => any
    ): ArgCaptor6<T0, T1, T2, T3, T4, T5>;
    <T0, T1, T2, T3, T4>(
        method: (a: T0, b: T1, c: T2, d: T3, e: T4) => any
    ): ArgCaptor5<T0, T1, T2, T3, T4>;
    <T0, T1, T2, T3>(method: (a: T0, b: T1, c: T2, d: T3) => any): ArgCaptor4<
        T0,
        T1,
        T2,
        T3
    >;
    <T0, T1, T2>(method: (a: T0, b: T1, c: T2) => any): ArgCaptor3<T0, T1, T2>;
    <T0, T1>(method: (a: T0, b: T1) => any): ArgCaptor2<T0, T1>;
    <T0>(method: (a: T0) => any): ArgCaptor1<T0>;
};

deepEqual: <T>(expectedValue: T) => T;

instance: <T>(mockedValue: T) => T;

match: (expectedValue: RegExp | string) => any;

mock: {
    <T>(clazz: (new (...args: any[]) => T) | (Function & { prototype: T })): T;
    <T>(clazz?: any): T;
};

notNull: () => any;

objectContaining: (expectedValue: Object) => any;

reset: <T>(...mockedValues: T[]) => void;

resetCalls: <T>(...mockedValues: T[]) => void;

spy: <T>(instanceToSpy: T) => T;

strictEqual: (expectedValue: any) => any;

verify: <T>(method: T) => MethodStubVerificator<T>;

when: {
    <T>(method: Promise<T>): MethodStubSetter<Promise<T>, T, Error>;
    <T>(method: T): MethodStubSetter<T, void, Error>;
};