jest-mock

const mocked: {
    <T extends object>(source: T, options?: { shallow: false }): Mocked<T>;
    <T extends object>(source: T, options: { shallow: true }): MockedShallow<T>;
};

const spyOn: {
    <
        T extends object,
        K extends Exclude<
            keyof T,
            | keyof {
                  [K in keyof T as Required<T>[K] extends ClassLike
                      ? K
                      : never]: T[K];
              }
            | keyof {
                  [K in keyof T as Required<T>[K] extends FunctionLike
                      ? K
                      : never]: T[K];
              }
        >,
        V extends Required<T>[K],
        A extends 'get' | 'set'
    >(
        object: T,
        methodKey: K,
        accessType: A
    ): A extends 'get' ? SpiedGetter<V> : A extends 'set' ? SpiedSetter<V> : never;
    <
        T extends object,
        K extends
            | keyof {
                  [K in keyof T as Required<T>[K] extends ClassLike
                      ? K
                      : never]: T[K];
              }
            | keyof {
                  [K in keyof T as Required<T>[K] extends FunctionLike
                      ? K
                      : never]: T[K];
              },
        V extends Required<T>[K]
    >(
        object: T,
        methodKey: K
    ): V extends FunctionLike | ClassLike ? Spied<V> : never;
};

fn: <T extends FunctionLike = UnknownFunction>(implementation?: T) => Mock<T>;

replaceProperty: <T extends object, K extends keyof T>(
    object: T,
    propertyKey: K,
    value: T[K]
) => Replaced<T[K]>;

type ClassLike = new (...args: any) => any;

type ConstructorLikeKeys<T> = keyof {
    [K in keyof T as Required<T>[K] extends ClassLike ? K : never]: T[K];
};

type FunctionLike = (...args: any) => any;

type MethodLikeKeys<T> = keyof {
    [K in keyof T as Required<T>[K] extends FunctionLike ? K : never]: T[K];
};

type Mocked<T> = T extends ClassLike
    ? MockedClass<T>
    : T extends FunctionLike
    ? MockedFunction<T>
    : T extends object
    ? MockedObject<T>
    : T;

type MockedClass<T extends ClassLike> = MockInstance<
    (...args: ConstructorParameters<T>) => Mocked<InstanceType<T>>
> &
    MockedObject<T>;

type MockedFunction<T extends FunctionLike> = MockInstance<T> & MockedObject<T>;

type MockedFunctionShallow<T extends FunctionLike> = MockInstance<T> & T;

type MockedObject<T extends object> = {
    [K in keyof T]: T[K] extends ClassLike
        ? MockedClass<T[K]>
        : T[K] extends FunctionLike
        ? MockedFunction<T[K]>
        : T[K] extends object
        ? MockedObject<T[K]>
        : T[K];
} & T;

type MockedObjectShallow<T extends object> = {
    [K in keyof T]: T[K] extends ClassLike
        ? MockedClass<T[K]>
        : T[K] extends FunctionLike
        ? MockedFunctionShallow<T[K]>
        : T[K];
} & T;

type MockedShallow<T> = T extends ClassLike
    ? MockedClass<T>
    : T extends FunctionLike
    ? MockedFunctionShallow<T>
    : T extends object
    ? MockedObjectShallow<T>
    : T;

type MockFunctionResult<T extends FunctionLike = UnknownFunction> =
    | MockFunctionResultIncomplete
    | MockFunctionResultReturn<T>
    | MockFunctionResultThrow;

type MockFunctionResultIncomplete = {
    type: 'incomplete';
    /**
     * Result of a single call to a mock function that has not yet completed.
     * This occurs if you test the result from within the mock function itself,
     * or from within a function that was called by the mock.
     */
    value: undefined;
};

type MockFunctionResultReturn<T extends FunctionLike = UnknownFunction> = {
    type: 'return';
    /**
     * Result of a single call to a mock function that returned.
     */
    value: ReturnType<T>;
};

type MockFunctionResultThrow = {
    type: 'throw';
    /**
     * Result of a single call to a mock function that threw.
     */
    value: unknown;
};

type MockFunctionState<T extends FunctionLike = UnknownFunction> = {
    /**
     * List of the call arguments of all calls that have been made to the mock.
     */
    calls: Array<Parameters<T>>;
    /**
     * List of all the object instances that have been instantiated from the mock.
     */
    instances: Array<ReturnType<T>>;
    /**
     * List of all the function contexts that have been applied to calls to the mock.
     */
    contexts: Array<ThisParameterType<T>>;
    /**
     * List of the call order indexes of the mock. Jest is indexing the order of
     * invocations of all mocks in a test file. The index is starting with `1`.
     */
    invocationCallOrder: Array<number>;
    /**
     * List of the call arguments of the last call that was made to the mock.
     * If the function was not called, it will return `undefined`.
     */
    lastCall?: Parameters<T>;
    /**
     * List of the results of all calls that have been made to the mock.
     */
    results: Array<MockFunctionResult<T>>;
};

type MockMetadata<T, MetadataType = MockMetadataType> = {
    ref?: number;
    members?: Record<string, MockMetadata<T>>;
    mockImpl?: T;
    name?: string;
    refID?: number;
    type?: MetadataType;
    value?: T;
    length?: number;
};

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

type PropertyLikeKeys<T> = Exclude<
    keyof T,
    ConstructorLikeKeys<T> | MethodLikeKeys<T>
>;

type RejectType<T extends FunctionLike> = ReturnType<T> extends PromiseLike<any>
    ? unknown
    : never;

type ResolveType<T extends FunctionLike> = ReturnType<T> extends PromiseLike<infer U>
    ? U
    : never;

type Spied<T extends ClassLike | FunctionLike> = T extends ClassLike
    ? SpiedClass<T>
    : T extends FunctionLike
    ? SpiedFunction<T>
    : never;

type SpiedClass<T extends ClassLike = UnknownClass> = MockInstance<
    (...args: ConstructorParameters<T>) => InstanceType<T>
>;

type SpiedFunction<T extends FunctionLike = UnknownFunction> = MockInstance<
    (...args: Parameters<T>) => ReturnType<T>
>;

type SpiedGetter<T> = MockInstance<() => T>;

type SpiedSetter<T> = MockInstance<(arg: T) => void>;

type UnknownClass = new (...args: Array<unknown>) => unknown;

type UnknownFunction = (...args: Array<unknown>) => unknown;