jest-mock

const mocked: {
    <T>(item: T, deep?: false | undefined): MaybeMocked<T>;
    <T_2>(item: T_2, deep: true): MaybeMockedDeep<T_2>;
};

const spyOn: {
    <T extends {}, M extends NonFunctionPropertyNames<T>>(
        object: T,
        methodName: M,
        accessType: 'get'
    ): SpyInstance<T[M], []>;
    <T_2 extends {}, M_2 extends NonFunctionPropertyNames<T_2>>(
        object: T_2,
        methodName: M_2,
        accessType: 'set'
    ): SpyInstance<void, [T_2[M_2]]>;
    <T_4 extends {}, M_4 extends FunctionPropertyNames<T_4>>(
        object: T_4,
        methodName: M_4
    ): T_4[M_4] extends (...args: Array<any>) => any
        ? SpyInstance<ReturnType<T_4[M_4]>, Parameters<T_4[M_4]>>
        : never;
};

fn: <T, Y extends unknown[]>(implementation?: (...args: Y) => T) => Mock<T, Y>;

type ArgsType<T> = T extends (...args: infer A) => any ? A : never;

type ArgumentsOf<T> = T extends (...args: infer A) => any ? A : never;

type ConstructorArgumentsOf<T> = T extends new (...args: infer A) => any ? A : never;

type MaybeMocked<T> = T extends MockableFunction
    ? MockedFunction<T>
    : T extends object
    ? MockedObject<T>
    : T;

type MaybeMockedConstructor<T> = T extends new (...args: Array<any>) => infer R
    ? MockInstance<R, ConstructorArgumentsOf<T>>
    : T;

type MaybeMockedDeep<T> = T extends MockableFunction
    ? MockedFunctionDeep<T>
    : T extends object
    ? MockedObjectDeep<T>
    : T;

type MethodKeysOf<T> = {
    [K in keyof T]: T[K] extends MockableFunction ? K : never;
}[keyof T];

type MockableFunction = (...args: Array<any>) => any;

type Mocked<T> = {
    [P in keyof T]: T[P] extends (...args: Array<any>) => any
        ? MockInstance<ReturnType<T[P]>, ArgsType<T[P]>>
        : T[P] extends Constructable
        ? MockedClass<T[P]>
        : T[P];
} & T;

type MockedClass<T extends Constructable> = MockInstance<
    InstanceType<T>,
    T extends new (...args: infer P) => any ? P : never
> & {
    prototype: T extends {
        prototype: any;
    }
        ? Mocked<T['prototype']>
        : never;
} & T;

type MockedFunction<T extends MockableFunction> = MockWithArgs<T> & {
    [K in keyof T]: T[K];
};

type MockedFunctionDeep<T extends MockableFunction> = MockWithArgs<T> &
    MockedObjectDeep<T>;

type MockedObject<T> = MaybeMockedConstructor<T> & {
    [K in MethodKeysOf<T>]: T[K] extends MockableFunction
        ? MockedFunction<T[K]>
        : T[K];
} & {
    [K in PropertyKeysOf<T>]: T[K];
};

type MockedObjectDeep<T> = MaybeMockedConstructor<T> & {
    [K in MethodKeysOf<T>]: T[K] extends MockableFunction
        ? MockedFunctionDeep<T[K]>
        : T[K];
} & {
    [K in PropertyKeysOf<T>]: MaybeMockedDeep<T[K]>;
};

type MockFunctionMetadata<
    T,
    Y extends Array<unknown>,
    Type = MockFunctionMetadataType
> = {
    ref?: number;
    members?: Record<string, MockFunctionMetadata<T, Y>>;
    mockImpl?: (...args: Y) => T;
    name?: string;
    refID?: number;
    type?: Type;
    value?: T;
    length?: number;
};

type MockFunctionMetadataType =
    | 'object'
    | 'array'
    | 'regexp'
    | 'function'
    | 'constant'
    | 'collection'
    | 'null'
    | 'undefined';

type PropertyKeysOf<T> = {
    [K in keyof T]: T[K] extends MockableFunction ? never : K;
}[keyof T];