jest-mock-extended

const any: MatcherCreator<any, any>;

const anyArray: MatcherCreator<any[], any[]>;

const anyBoolean: MatcherCreator<boolean, boolean>;

const anyFunction: MatcherCreator<Function, Function>;

const anyMap: MatcherCreator<Map<any, any>, Map<any, any>>;

const anyNumber: MatcherCreator<number, number>;

const anyObject: MatcherCreator<any, any>;

const anySet: MatcherCreator<Set<any>, Set<any>>;

const anyString: MatcherCreator<string, string>;

const anySymbol: MatcherCreator<Symbol, Symbol>;

const arrayIncludes: MatcherCreator<any[], any>;

const isA: MatcherCreator<any, any>;

const JestMockExtended: {
    DEFAULT_CONFIG: GlobalConfig;
    configure: (config: GlobalConfig) => void;
    resetConfig: () => void;
};

const mapHas: MatcherCreator<Map<any, any>, any>;

const notEmpty: MatcherCreator<any, any>;

const notNull: MatcherCreator<any, any>;

const notUndefined: MatcherCreator<any, any>;

const objectContainsKey: MatcherCreator<any, string>;

const objectContainsValue: MatcherCreator<any, any>;

const setHas: MatcherCreator<Set<any>, any>;

calledWithFn: <T extends any>({
    fallbackMockImplementation,
}?: {
    fallbackMockImplementation?: T;
}) => CalledWithMock<T>;

captor: <T extends unknown = any>() => CaptorMatcher<T>;

matches: <T extends unknown = any>(matcher: MatcherFn<T>) => Matcher<T>;

mock: <T, MockedReturn extends _MockProxy<T> & T = _MockProxy<T> & T>(
    mockImplementation?: any,
    opts?: import('./Mock').MockOpts
) => MockedReturn;

mockClear: (mock: MockProxy<any>) => any;

mockDeep: {
    <T>(
        opts: {
            funcPropSupport?: true;
            fallbackMockImplementation?: MockOpts['fallbackMockImplementation'];
        },
        mockImplementation?: DeepPartial<T>
    ): DeepMockProxyWithFuncPropSupport<T>;
    <T>(mockImplementation?: DeepPartial<T>): DeepMockProxy<T>;
};

mockFn: <T extends FunctionLike>() => CalledWithMock<T> & T;

mockReset: (mock: MockProxy<any>) => any;

stub: <T extends object>() => T;

type DeepMockProxy<T> = _DeepMockProxy<T> & T;

type MatcherFn<T> = (actualValue: T) => boolean;

type MatchersOrLiterals<Y extends any[]> = {
    [K in keyof Y]: MatcherLike<Y[K]> | Y[K];
};

type MockProxy<T> = _MockProxy<T> & T;