From 4b4b03d4756f159f01e0af3986bcd57c0b2cd3c2 Mon Sep 17 00:00:00 2001
From: Tom Mrazauskas <tom@mrazauskas.de>
Date: Sun, 24 Apr 2022 20:18:10 +0300
Subject: [PATCH 01/17] feat: add jest.Mocked

---
 packages/jest-globals/package.json            |  3 +-
 packages/jest-globals/src/index.ts            | 20 ++++-
 packages/jest-globals/tsconfig.json           |  1 +
 .../jest-mock/__typetests__/Mocked.test.ts    | 85 +++++++++++++++++++
 .../jest-mock/__typetests__/tsconfig.json     |  2 +-
 packages/jest-mock/src/index.ts               | 16 +---
 packages/jest-mock/src/types.ts               | 37 ++++++++
 .../jest-types/__typetests__/jest.test.ts     | 15 +++-
 yarn.lock                                     |  1 +
 9 files changed, 159 insertions(+), 21 deletions(-)
 create mode 100644 packages/jest-mock/__typetests__/Mocked.test.ts
 create mode 100644 packages/jest-mock/src/types.ts

diff --git a/packages/jest-globals/package.json b/packages/jest-globals/package.json
index 79f68f4c293d..f5203b624fbb 100644
--- a/packages/jest-globals/package.json
+++ b/packages/jest-globals/package.json
@@ -22,7 +22,8 @@
   "dependencies": {
     "@jest/environment": "^28.0.0-alpha.11",
     "@jest/expect": "^28.0.0-alpha.11",
-    "@jest/types": "^28.0.0-alpha.9"
+    "@jest/types": "^28.0.0-alpha.9",
+    "jest-mock": "^28.0.0-alpha.9"
   },
   "publishConfig": {
     "access": "public"
diff --git a/packages/jest-globals/src/index.ts b/packages/jest-globals/src/index.ts
index 90f50d9665ec..e6ffece38583 100644
--- a/packages/jest-globals/src/index.ts
+++ b/packages/jest-globals/src/index.ts
@@ -9,7 +9,7 @@ import type {Jest} from '@jest/environment';
 import type {JestExpect} from '@jest/expect';
 import type {Global} from '@jest/types';
 
-export declare const jest: Jest;
+declare const jest: Jest;
 
 export declare const expect: JestExpect;
 
@@ -26,6 +26,24 @@ export declare const beforeEach: Global.GlobalAdditions['beforeEach'];
 export declare const afterEach: Global.GlobalAdditions['afterEach'];
 export declare const afterAll: Global.GlobalAdditions['afterAll'];
 
+declare namespace jest {
+  /**
+   * Wraps class, function, object or module with mock definitions.
+   *
+   * @example
+   *
+   *  jest.mock('../api');
+   *  import * as api from '../api';
+   *
+   *  const mockApi = api as jest.Mocked<typeof api>;
+   *
+   *  mockApi.someMethod.mockImplementation(() => 'test');
+   */
+  type Mocked<T> = import('jest-mock').Mocked<T>;
+}
+
+export {jest};
+
 throw new Error(
   'Do not import `@jest/globals` outside of the Jest test environment',
 );
diff --git a/packages/jest-globals/tsconfig.json b/packages/jest-globals/tsconfig.json
index 16a7adbc92db..90f222531f6b 100644
--- a/packages/jest-globals/tsconfig.json
+++ b/packages/jest-globals/tsconfig.json
@@ -11,6 +11,7 @@
   "references": [
     {"path": "../jest-environment"},
     {"path": "../jest-expect"},
+    {"path": "../jest-mock"},
     {"path": "../jest-types"}
   ]
 }
diff --git a/packages/jest-mock/__typetests__/Mocked.test.ts b/packages/jest-mock/__typetests__/Mocked.test.ts
new file mode 100644
index 000000000000..8b6e83f23ada
--- /dev/null
+++ b/packages/jest-mock/__typetests__/Mocked.test.ts
@@ -0,0 +1,85 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+import {expectAssignable, expectType} from 'tsd-lite';
+import type {MockInstance, Mocked} from 'jest-mock';
+
+/// mocks class
+
+class ExampleClass {
+  constructor(c: string, d?: boolean) {}
+
+  //   _propertyB: false;
+
+  methodA() {
+    return true;
+  }
+  methodB(a: string, b: number) {
+    return;
+  }
+  methodC(e: any) {
+    throw new Error();
+  }
+
+  //   propertyA: 'abc',
+}
+
+const MockExampleClass = ExampleClass as Mocked<typeof ExampleClass>;
+
+const xx = MockExampleClass.mock.calls[0];
+const yy = MockExampleClass.prototype.methodB.mock.calls[0];
+
+const ww = MockExampleClass.mock.instances[0].methodB.mock.calls[0];
+
+const mockExample = new MockExampleClass('c') as Mocked<
+  InstanceType<typeof MockExampleClass>
+>;
+
+const zz = mockExample.methodB.mock.calls[0];
+
+/// mocks function
+
+function someFunction(a: number, b?: string): boolean {
+  return true;
+}
+
+async function someAsyncFunction(a: Array<boolean>): Promise<string> {
+  return 'true';
+}
+
+const mockFunction = someFunction as Mocked<typeof someFunction>;
+
+expectType<number>(mockFunction.mock.calls[0][0]);
+expectType<string | undefined>(mockFunction.mock.calls[0][1]);
+
+const mockFunctionResult = mockFunction.mock.results[0];
+
+if (mockFunctionResult.type === 'return') {
+  expectType<boolean>(mockFunctionResult.value);
+}
+
+const mockAsyncFunction = someAsyncFunction as Mocked<typeof someAsyncFunction>;
+
+expectType<Array<boolean>>(mockAsyncFunction.mock.calls[0][0]);
+// expectError(mockAsyncFunction.mock.calls[0][1]);
+
+const mockAsyncFunctionResult = mockAsyncFunction.mock.results[0];
+
+if (mockAsyncFunctionResult.type === 'return') {
+  expectType<Promise<string>>(mockAsyncFunctionResult.value);
+}
+
+// mocks object
+
+const mockConsole = console as Mocked<typeof console>;
+
+expectAssignable<typeof console.log>(
+  mockConsole.log.mockImplementation(() => {}),
+);
+expectAssignable<MockInstance<typeof console.log>>(
+  mockConsole.log.mockImplementation(() => {}),
+);
diff --git a/packages/jest-mock/__typetests__/tsconfig.json b/packages/jest-mock/__typetests__/tsconfig.json
index 165ba1343021..d1974ed987b7 100644
--- a/packages/jest-mock/__typetests__/tsconfig.json
+++ b/packages/jest-mock/__typetests__/tsconfig.json
@@ -6,7 +6,7 @@
     "noUnusedParameters": false,
     "skipLibCheck": true,
 
-    "types": []
+    "types": ["node"]
   },
   "include": ["./**/*"]
 }
diff --git a/packages/jest-mock/src/index.ts b/packages/jest-mock/src/index.ts
index b4164f26463c..947840c8cec8 100644
--- a/packages/jest-mock/src/index.ts
+++ b/packages/jest-mock/src/index.ts
@@ -7,6 +7,8 @@
 
 /* eslint-disable local/ban-types-eventually, local/prefer-rest-params-eventually */
 
+export type {Mocked} from './types';
+
 export type MockFunctionMetadataType =
   | 'object'
   | 'array'
@@ -98,20 +100,6 @@ export type MaybeMockedDeep<T> = T extends FunctionLike
   ? MockedObjectDeep<T>
   : T;
 
-export type Mocked<T> = {
-  [P in keyof T]: T[P] extends FunctionLike
-    ? MockInstance<T[P]>
-    : T[P] extends ClassLike
-    ? MockedClass<T[P]>
-    : T[P];
-} & T;
-
-export type MockedClass<T extends ClassLike> = MockInstance<
-  (args: T extends new (...args: infer P) => any ? P : never) => InstanceType<T>
-> & {
-  prototype: T extends {prototype: any} ? Mocked<T['prototype']> : never;
-} & T;
-
 export type UnknownFunction = (...args: Array<unknown>) => unknown;
 
 /**
diff --git a/packages/jest-mock/src/types.ts b/packages/jest-mock/src/types.ts
new file mode 100644
index 000000000000..769c7e985d6e
--- /dev/null
+++ b/packages/jest-mock/src/types.ts
@@ -0,0 +1,37 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+import type {MockInstance} from './index';
+
+type ClassLike = {new (...args: any): any};
+type FunctionLike = (...args: any) => any;
+
+type MockedClass<T extends ClassLike> = MockInstance<
+  (...args: ConstructorParameters<T>) => Mocked<InstanceType<T>>
+> & {
+  prototype: T extends {prototype: any} ? Mocked<T['prototype']> : never;
+} & MockedObject<T>;
+
+type MockedFunction<T extends FunctionLike> = MockInstance<T> & MockedObject<T>;
+
+type MockedObject<T> = {
+  [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;
+
+export type Mocked<T> = T extends ClassLike
+  ? MockedClass<T>
+  : T extends FunctionLike
+  ? MockedFunction<T>
+  : T extends object
+  ? MockedObject<T>
+  : T;
diff --git a/packages/jest-types/__typetests__/jest.test.ts b/packages/jest-types/__typetests__/jest.test.ts
index ce95ca1a828a..97977ac0a345 100644
--- a/packages/jest-types/__typetests__/jest.test.ts
+++ b/packages/jest-types/__typetests__/jest.test.ts
@@ -7,7 +7,7 @@
 
 import {expectError, expectType} from 'tsd-lite';
 import {jest} from '@jest/globals';
-import type {Mock, ModuleMocker, SpyInstance} from 'jest-mock';
+import type {Mock, Mocked, ModuleMocker, SpyInstance} from 'jest-mock';
 
 expectType<typeof jest>(
   jest
@@ -117,7 +117,6 @@ expectError(jest.unmock());
 
 // Mock Functions
 
-expectType<typeof jest>(jest.retryTimes(3, {logErrorsBeforeRetry: true}));
 expectType<typeof jest>(jest.clearAllMocks());
 expectError(jest.clearAllMocks('moduleName'));
 
@@ -301,8 +300,16 @@ expectError(jest.useRealTimers(true));
 
 // Misc
 
-expectType<typeof jest>(jest.setTimeout(6000));
-expectError(jest.setTimeout());
+type VoidFn = () => void;
+declare const voidFn: VoidFn;
+
+expectType<Mocked<VoidFn>>(voidFn as jest.Mocked<VoidFn>);
 
 expectType<typeof jest>(jest.retryTimes(3));
+expectType<typeof jest>(jest.retryTimes(3, {logErrorsBeforeRetry: true}));
+expectError(jest.retryTimes(3, {logErrorsBeforeRetry: 'all'}));
+expectError(jest.retryTimes({logErrorsBeforeRetry: true}));
 expectError(jest.retryTimes());
+
+expectType<typeof jest>(jest.setTimeout(6000));
+expectError(jest.setTimeout());
diff --git a/yarn.lock b/yarn.lock
index f6617c129033..64d01de7bf7b 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -2658,6 +2658,7 @@ __metadata:
     "@jest/environment": ^28.0.0-alpha.11
     "@jest/expect": ^28.0.0-alpha.11
     "@jest/types": ^28.0.0-alpha.9
+    jest-mock: ^28.0.0-alpha.9
   languageName: unknown
   linkType: soft
 

From b1e9b813afc82c3843f53e49b9da3fa0f1a6d4e5 Mon Sep 17 00:00:00 2001
From: Tom Mrazauskas <tom@mrazauskas.de>
Date: Sun, 24 Apr 2022 21:11:30 +0300
Subject: [PATCH 02/17] export more types

---
 packages/jest-globals/src/index.ts            | 32 +++++++++++--------
 packages/jest-mock/src/index.ts               |  2 +-
 packages/jest-mock/src/types.ts               |  7 ++--
 .../jest-types/__typetests__/jest.test.ts     | 30 ++++++++++++++---
 4 files changed, 49 insertions(+), 22 deletions(-)

diff --git a/packages/jest-globals/src/index.ts b/packages/jest-globals/src/index.ts
index e6ffece38583..69347ad68673 100644
--- a/packages/jest-globals/src/index.ts
+++ b/packages/jest-globals/src/index.ts
@@ -8,8 +8,13 @@
 import type {Jest} from '@jest/environment';
 import type {JestExpect} from '@jest/expect';
 import type {Global} from '@jest/types';
-
-declare const jest: Jest;
+import type {
+  ClassLike,
+  FunctionLike,
+  Mocked as JestMocked,
+  MockedClass as JestMockedClass,
+  MockedFunction as JestMockedFunction,
+} from 'jest-mock';
 
 export declare const expect: JestExpect;
 
@@ -26,20 +31,21 @@ export declare const beforeEach: Global.GlobalAdditions['beforeEach'];
 export declare const afterEach: Global.GlobalAdditions['afterEach'];
 export declare const afterAll: Global.GlobalAdditions['afterAll'];
 
+declare const jest: Jest;
+
 declare namespace jest {
   /**
-   * Wraps class, function, object or module with mock definitions.
-   *
-   * @example
-   *
-   *  jest.mock('../api');
-   *  import * as api from '../api';
-   *
-   *  const mockApi = api as jest.Mocked<typeof api>;
-   *
-   *  mockApi.someMethod.mockImplementation(() => 'test');
+   * Wraps any object type with definitions of Jest mock.
+   */
+  type Mocked<T> = JestMocked<T>;
+  /**
+   * Wraps a class type with definitions of Jest mock.
+   */
+  type MockedClass<T extends ClassLike> = JestMockedClass<T>;
+  /**
+   * Wraps a function type with definitions of Jest mock.
    */
-  type Mocked<T> = import('jest-mock').Mocked<T>;
+  type MockedFunction<T extends FunctionLike> = JestMockedFunction<T>;
 }
 
 export {jest};
diff --git a/packages/jest-mock/src/index.ts b/packages/jest-mock/src/index.ts
index 947840c8cec8..80f2e1d07cec 100644
--- a/packages/jest-mock/src/index.ts
+++ b/packages/jest-mock/src/index.ts
@@ -7,7 +7,7 @@
 
 /* eslint-disable local/ban-types-eventually, local/prefer-rest-params-eventually */
 
-export type {Mocked} from './types';
+export type {Mocked, MockedClass} from './types';
 
 export type MockFunctionMetadataType =
   | 'object'
diff --git a/packages/jest-mock/src/types.ts b/packages/jest-mock/src/types.ts
index 769c7e985d6e..dbb57d3ebcca 100644
--- a/packages/jest-mock/src/types.ts
+++ b/packages/jest-mock/src/types.ts
@@ -10,15 +10,16 @@ import type {MockInstance} from './index';
 type ClassLike = {new (...args: any): any};
 type FunctionLike = (...args: any) => any;
 
-type MockedClass<T extends ClassLike> = MockInstance<
+export type MockedClass<T extends ClassLike> = MockInstance<
   (...args: ConstructorParameters<T>) => Mocked<InstanceType<T>>
 > & {
   prototype: T extends {prototype: any} ? Mocked<T['prototype']> : never;
 } & MockedObject<T>;
 
-type MockedFunction<T extends FunctionLike> = MockInstance<T> & MockedObject<T>;
+export type MockedFunction<T extends FunctionLike> = MockInstance<T> &
+  MockedObject<T>;
 
-type MockedObject<T> = {
+export type MockedObject<T> = {
   [K in keyof T]: T[K] extends ClassLike
     ? MockedClass<T[K]>
     : T[K] extends FunctionLike
diff --git a/packages/jest-types/__typetests__/jest.test.ts b/packages/jest-types/__typetests__/jest.test.ts
index 97977ac0a345..5b72ba1d4bd5 100644
--- a/packages/jest-types/__typetests__/jest.test.ts
+++ b/packages/jest-types/__typetests__/jest.test.ts
@@ -7,7 +7,14 @@
 
 import {expectError, expectType} from 'tsd-lite';
 import {jest} from '@jest/globals';
-import type {Mock, Mocked, ModuleMocker, SpyInstance} from 'jest-mock';
+import type {
+  Mock,
+  Mocked,
+  MockedClass,
+  MockedFunction,
+  ModuleMocker,
+  SpyInstance,
+} from 'jest-mock';
 
 expectType<typeof jest>(
   jest
@@ -298,12 +305,25 @@ expectError(jest.useFakeTimers('modern'));
 expectType<typeof jest>(jest.useRealTimers());
 expectError(jest.useRealTimers(true));
 
-// Misc
+// Mock
+
+type SomeFn = () => void;
+declare const voidFn: SomeFn;
+
+expectType<Mocked<SomeFn>>(voidFn as jest.Mocked<SomeFn>);
+
+class SomeClass {
+  constructor() {}
+  someMethod() {}
+}
+
+expectType<MockedClass<typeof SomeClass>>(
+  SomeClass as jest.MockedClass<typeof SomeClass>,
+);
 
-type VoidFn = () => void;
-declare const voidFn: VoidFn;
+expectType<MockedFunction<SomeFn>>(voidFn as jest.MockedFunction<SomeFn>);
 
-expectType<Mocked<VoidFn>>(voidFn as jest.Mocked<VoidFn>);
+// Misc
 
 expectType<typeof jest>(jest.retryTimes(3));
 expectType<typeof jest>(jest.retryTimes(3, {logErrorsBeforeRetry: true}));

From 8d87f79b268443007b8c7b8a23141fa73b3870bc Mon Sep 17 00:00:00 2001
From: Tom Mrazauskas <tom@mrazauskas.de>
Date: Sun, 24 Apr 2022 21:20:06 +0300
Subject: [PATCH 03/17] add constrain

---
 packages/jest-globals/src/index.ts | 4 ++--
 packages/jest-mock/src/types.ts    | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/packages/jest-globals/src/index.ts b/packages/jest-globals/src/index.ts
index 69347ad68673..55660ecb7617 100644
--- a/packages/jest-globals/src/index.ts
+++ b/packages/jest-globals/src/index.ts
@@ -35,9 +35,9 @@ declare const jest: Jest;
 
 declare namespace jest {
   /**
-   * Wraps any object type with definitions of Jest mock.
+   * Wraps a class, function or object type with definitions of Jest mock.
    */
-  type Mocked<T> = JestMocked<T>;
+  type Mocked<T extends object> = JestMocked<T>;
   /**
    * Wraps a class type with definitions of Jest mock.
    */
diff --git a/packages/jest-mock/src/types.ts b/packages/jest-mock/src/types.ts
index dbb57d3ebcca..ec6d29e60355 100644
--- a/packages/jest-mock/src/types.ts
+++ b/packages/jest-mock/src/types.ts
@@ -19,7 +19,7 @@ export type MockedClass<T extends ClassLike> = MockInstance<
 export type MockedFunction<T extends FunctionLike> = MockInstance<T> &
   MockedObject<T>;
 
-export type MockedObject<T> = {
+type MockedObject<T extends object> = {
   [K in keyof T]: T[K] extends ClassLike
     ? MockedClass<T[K]>
     : T[K] extends FunctionLike
@@ -29,7 +29,7 @@ export type MockedObject<T> = {
     : T[K];
 } & T;
 
-export type Mocked<T> = T extends ClassLike
+export type Mocked<T extends object> = T extends ClassLike
   ? MockedClass<T>
   : T extends FunctionLike
   ? MockedFunction<T>

From 3503613a13c1bdf7cf8a9e1d4aadcca176774d00 Mon Sep 17 00:00:00 2001
From: Tom Mrazauskas <tom@mrazauskas.de>
Date: Sun, 24 Apr 2022 21:31:31 +0300
Subject: [PATCH 04/17] slimmer

---
 packages/jest-mock/src/types.ts | 10 +++-------
 1 file changed, 3 insertions(+), 7 deletions(-)

diff --git a/packages/jest-mock/src/types.ts b/packages/jest-mock/src/types.ts
index ec6d29e60355..534b0e86ca80 100644
--- a/packages/jest-mock/src/types.ts
+++ b/packages/jest-mock/src/types.ts
@@ -5,16 +5,12 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-import type {MockInstance} from './index';
-
-type ClassLike = {new (...args: any): any};
-type FunctionLike = (...args: any) => any;
+import type {ClassLike, FunctionLike, MockInstance} from './index';
 
 export type MockedClass<T extends ClassLike> = MockInstance<
   (...args: ConstructorParameters<T>) => Mocked<InstanceType<T>>
-> & {
-  prototype: T extends {prototype: any} ? Mocked<T['prototype']> : never;
-} & MockedObject<T>;
+> &
+  MockedObject<T>;
 
 export type MockedFunction<T extends FunctionLike> = MockInstance<T> &
   MockedObject<T>;

From f1a2585a30f8d3bca83b74ce1ab4608b32e01733 Mon Sep 17 00:00:00 2001
From: Tom Mrazauskas <tom@mrazauskas.de>
Date: Sat, 30 Apr 2022 16:41:49 +0300
Subject: [PATCH 05/17] export type

---
 packages/jest-globals/src/index.ts | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/packages/jest-globals/src/index.ts b/packages/jest-globals/src/index.ts
index 55660ecb7617..3383854e054c 100644
--- a/packages/jest-globals/src/index.ts
+++ b/packages/jest-globals/src/index.ts
@@ -37,15 +37,15 @@ declare namespace jest {
   /**
    * Wraps a class, function or object type with definitions of Jest mock.
    */
-  type Mocked<T extends object> = JestMocked<T>;
+  export type Mocked<T extends object> = JestMocked<T>;
   /**
    * Wraps a class type with definitions of Jest mock.
    */
-  type MockedClass<T extends ClassLike> = JestMockedClass<T>;
+  export type MockedClass<T extends ClassLike> = JestMockedClass<T>;
   /**
    * Wraps a function type with definitions of Jest mock.
    */
-  type MockedFunction<T extends FunctionLike> = JestMockedFunction<T>;
+  export type MockedFunction<T extends FunctionLike> = JestMockedFunction<T>;
 }
 
 export {jest};

From b51b2efde3f4b84adb38b82afd8d2ff97229e02c Mon Sep 17 00:00:00 2001
From: Tom Mrazauskas <tom@mrazauskas.de>
Date: Tue, 3 May 2022 10:31:04 +0300
Subject: [PATCH 06/17] more tests

---
 .../jest-mock/__typetests__/Mocked.test.ts    | 37 ++++++++++++++++---
 1 file changed, 31 insertions(+), 6 deletions(-)

diff --git a/packages/jest-mock/__typetests__/Mocked.test.ts b/packages/jest-mock/__typetests__/Mocked.test.ts
index 8b6e83f23ada..eb77efddd48c 100644
--- a/packages/jest-mock/__typetests__/Mocked.test.ts
+++ b/packages/jest-mock/__typetests__/Mocked.test.ts
@@ -41,16 +41,12 @@ const mockExample = new MockExampleClass('c') as Mocked<
 
 const zz = mockExample.methodB.mock.calls[0];
 
-/// mocks function
+// mocks function
 
 function someFunction(a: number, b?: string): boolean {
   return true;
 }
 
-async function someAsyncFunction(a: Array<boolean>): Promise<string> {
-  return 'true';
-}
-
 const mockFunction = someFunction as Mocked<typeof someFunction>;
 
 expectType<number>(mockFunction.mock.calls[0][0]);
@@ -62,10 +58,15 @@ if (mockFunctionResult.type === 'return') {
   expectType<boolean>(mockFunctionResult.value);
 }
 
+// mocks async function
+
+async function someAsyncFunction(a: Array<boolean>): Promise<string> {
+  return 'true';
+}
+
 const mockAsyncFunction = someAsyncFunction as Mocked<typeof someAsyncFunction>;
 
 expectType<Array<boolean>>(mockAsyncFunction.mock.calls[0][0]);
-// expectError(mockAsyncFunction.mock.calls[0][1]);
 
 const mockAsyncFunctionResult = mockAsyncFunction.mock.results[0];
 
@@ -73,6 +74,30 @@ if (mockAsyncFunctionResult.type === 'return') {
   expectType<Promise<string>>(mockAsyncFunctionResult.value);
 }
 
+// mocks function object
+
+type SomeFunctionObject = {
+  (a: number, b: string): void;
+  one: {
+    (oneA: number, oneB?: boolean): boolean;
+    more: {
+      time: {
+        (time: number): void;
+      };
+    };
+  };
+};
+
+declare const someFunctionObject: SomeFunctionObject;
+
+someFunctionObject.one.more.time(12);
+
+const mockFunctionObject = someFunctionObject as Mocked<
+  typeof someFunctionObject
+>;
+
+mockFunctionObject.one.more.time.mock;
+
 // mocks object
 
 const mockConsole = console as Mocked<typeof console>;

From b98bc917ce42e4373c80c8ad28a0869054b919e0 Mon Sep 17 00:00:00 2001
From: Tom Mrazauskas <tom@mrazauskas.de>
Date: Thu, 11 Aug 2022 12:28:48 +0300
Subject: [PATCH 07/17] fix int

---
 packages/jest-globals/src/index.ts | 1 +
 1 file changed, 1 insertion(+)

diff --git a/packages/jest-globals/src/index.ts b/packages/jest-globals/src/index.ts
index 3383854e054c..c6164dc058d7 100644
--- a/packages/jest-globals/src/index.ts
+++ b/packages/jest-globals/src/index.ts
@@ -33,6 +33,7 @@ export declare const afterAll: Global.GlobalAdditions['afterAll'];
 
 declare const jest: Jest;
 
+// eslint-disable-next-line @typescript-eslint/no-namespace
 declare namespace jest {
   /**
    * Wraps a class, function or object type with definitions of Jest mock.

From d01681065217ed6e7384ba8d77a13df6996c0187 Mon Sep 17 00:00:00 2001
From: Tom Mrazauskas <tom@mrazauskas.de>
Date: Thu, 11 Aug 2022 17:33:06 +0300
Subject: [PATCH 08/17] add mocked class and mocked function test

---
 .../jest-mock/__typetests__/Mocked.test.ts    | 102 +++++++++++-------
 1 file changed, 64 insertions(+), 38 deletions(-)

diff --git a/packages/jest-mock/__typetests__/Mocked.test.ts b/packages/jest-mock/__typetests__/Mocked.test.ts
index eb77efddd48c..0b359f6d8e12 100644
--- a/packages/jest-mock/__typetests__/Mocked.test.ts
+++ b/packages/jest-mock/__typetests__/Mocked.test.ts
@@ -5,58 +5,73 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-import {expectAssignable, expectType} from 'tsd-lite';
+import {expectAssignable, expectError, expectType} from 'tsd-lite';
 import type {MockInstance, Mocked} from 'jest-mock';
 
 /// mocks class
 
-class ExampleClass {
-  constructor(c: string, d?: boolean) {}
-
-  //   _propertyB: false;
+class SomeClass {
+  constructor(one: string, two?: boolean) {}
 
   methodA() {
     return true;
   }
-  methodB(a: string, b: number) {
+  methodB(a: string, b?: number) {
     return;
   }
-  methodC(e: any) {
-    throw new Error();
-  }
-
-  //   propertyA: 'abc',
 }
 
-const MockExampleClass = ExampleClass as Mocked<typeof ExampleClass>;
+const MockSomeClass = SomeClass as Mocked<typeof SomeClass>;
+
+expectType<[one: string, two?: boolean | undefined]>(
+  MockSomeClass.mock.calls[0],
+);
+
+expectType<[]>(MockSomeClass.prototype.methodA.mock.calls[0]);
+expectType<[a: string, b?: number]>(
+  MockSomeClass.prototype.methodB.mock.calls[0],
+);
 
-const xx = MockExampleClass.mock.calls[0];
-const yy = MockExampleClass.prototype.methodB.mock.calls[0];
+expectError(MockSomeClass.prototype.methodA.mockReturnValue('true'));
+expectError(
+  MockSomeClass.prototype.methodB.mockImplementation(
+    (a: string, b?: string) => {
+      return;
+    },
+  ),
+);
 
-const ww = MockExampleClass.mock.instances[0].methodB.mock.calls[0];
+expectType<[]>(MockSomeClass.mock.instances[0].methodA.mock.calls[0]);
+expectType<[a: string, b?: number]>(
+  MockSomeClass.prototype.methodB.mock.calls[0],
+);
 
-const mockExample = new MockExampleClass('c') as Mocked<
-  InstanceType<typeof MockExampleClass>
+const mockExample = new MockSomeClass('c') as Mocked<
+  InstanceType<typeof MockSomeClass>
 >;
 
-const zz = mockExample.methodB.mock.calls[0];
+expectType<[]>(mockExample.methodA.mock.calls[0]);
+expectType<[a: string, b?: number]>(mockExample.methodB.mock.calls[0]);
+
+expectError(mockExample.methodA.mockReturnValue('true'));
+expectError(
+  mockExample.methodB.mockImplementation((a: string, b?: string) => {
+    return;
+  }),
+);
 
 // mocks function
 
-function someFunction(a: number, b?: string): boolean {
+function someFunction(a: string, b?: number): boolean {
   return true;
 }
 
 const mockFunction = someFunction as Mocked<typeof someFunction>;
 
-expectType<number>(mockFunction.mock.calls[0][0]);
-expectType<string | undefined>(mockFunction.mock.calls[0][1]);
+expectType<[a: string, b?: number]>(mockFunction.mock.calls[0]);
 
-const mockFunctionResult = mockFunction.mock.results[0];
-
-if (mockFunctionResult.type === 'return') {
-  expectType<boolean>(mockFunctionResult.value);
-}
+expectError(mockFunction.mockReturnValue(123));
+expectError(mockFunction.mockImplementation((a: boolean, b?: number) => true));
 
 // mocks async function
 
@@ -66,18 +81,19 @@ async function someAsyncFunction(a: Array<boolean>): Promise<string> {
 
 const mockAsyncFunction = someAsyncFunction as Mocked<typeof someAsyncFunction>;
 
-expectType<Array<boolean>>(mockAsyncFunction.mock.calls[0][0]);
-
-const mockAsyncFunctionResult = mockAsyncFunction.mock.results[0];
+expectType<[Array<boolean>]>(mockAsyncFunction.mock.calls[0]);
 
-if (mockAsyncFunctionResult.type === 'return') {
-  expectType<Promise<string>>(mockAsyncFunctionResult.value);
-}
+expectError(mockAsyncFunction.mockResolvedValue(123));
+expectError(
+  mockAsyncFunction.mockImplementation((a: Array<boolean>) =>
+    Promise.resolve(true),
+  ),
+);
 
 // mocks function object
 
-type SomeFunctionObject = {
-  (a: number, b: string): void;
+interface SomeFunctionObject {
+  (a: number, b?: string): void;
   one: {
     (oneA: number, oneB?: boolean): boolean;
     more: {
@@ -86,17 +102,27 @@ type SomeFunctionObject = {
       };
     };
   };
-};
+}
 
 declare const someFunctionObject: SomeFunctionObject;
 
-someFunctionObject.one.more.time(12);
-
 const mockFunctionObject = someFunctionObject as Mocked<
   typeof someFunctionObject
 >;
 
-mockFunctionObject.one.more.time.mock;
+expectType<[a: number, b?: string]>(mockFunctionObject.mock.calls[0]);
+
+expectError(mockFunctionObject.mockReturnValue(123));
+expectError(mockFunctionObject.mockImplementation(() => true));
+
+expectType<[time: number]>(mockFunctionObject.one.more.time.mock.calls[0]);
+
+expectError(mockFunctionObject.one.more.time.mockReturnValue(123));
+expectError(
+  mockFunctionObject.one.more.time.mockImplementation((time: string) => {
+    return;
+  }),
+);
 
 // mocks object
 

From 0072a54d4a9ef8a17ecd2fee5192fe52fcf61e8f Mon Sep 17 00:00:00 2001
From: Tom Mrazauskas <tom@mrazauskas.de>
Date: Thu, 11 Aug 2022 17:57:39 +0300
Subject: [PATCH 09/17] move Mocked types into index

---
 packages/jest-mock/src/index.ts | 80 ++++++++++++++++-----------------
 packages/jest-mock/src/types.ts | 34 --------------
 2 files changed, 38 insertions(+), 76 deletions(-)
 delete mode 100644 packages/jest-mock/src/types.ts

diff --git a/packages/jest-mock/src/index.ts b/packages/jest-mock/src/index.ts
index 1c9d71b03fa1..f1a31521a6e5 100644
--- a/packages/jest-mock/src/index.ts
+++ b/packages/jest-mock/src/index.ts
@@ -7,8 +7,6 @@
 
 /* eslint-disable local/ban-types-eventually, local/prefer-rest-params-eventually */
 
-export type {Mocked, MockedClass} from './types';
-
 export type MockFunctionMetadataType =
   | 'object'
   | 'array'
@@ -49,52 +47,50 @@ export type PropertyLikeKeys<T> = Exclude<
   ConstructorLikeKeys<T> | MethodLikeKeys<T>
 >;
 
-// TODO Figure out how to replace this with TS ConstructorParameters utility type
-// https://www.typescriptlang.org/docs/handbook/utility-types.html#constructorparameterstype
-type ConstructorParameters<T> = T extends new (...args: infer P) => any
-  ? P
-  : never;
+export type MockedClass<T extends ClassLike> = MockInstance<
+  (...args: ConstructorParameters<T>) => Mocked<InstanceType<T>>
+> &
+  MockedObject<T>;
 
-export type MaybeMockedConstructor<T> = T extends new (
-  ...args: Array<any>
-) => infer R
-  ? MockInstance<(...args: ConstructorParameters<T>) => R>
-  : T;
+export type MockedFunction<T extends FunctionLike> = MockInstance<T> &
+  MockedObject<T>;
 
-export interface MockWithArgs<T extends FunctionLike> extends MockInstance<T> {
-  new (...args: ConstructorParameters<T>): T;
-  (...args: Parameters<T>): ReturnType<T>;
-}
+export type MockedFunctionShallow<T extends FunctionLike> = MockInstance<T> & T;
 
-export type MockedFunction<T extends FunctionLike> = MockWithArgs<T> & {
-  [K in keyof T]: T[K];
-};
-
-export type MockedFunctionDeep<T extends FunctionLike> = MockWithArgs<T> &
-  MockedObjectDeep<T>;
-
-export type MockedObject<T> = MaybeMockedConstructor<T> & {
-  [K in MethodLikeKeys<T>]: T[K] extends FunctionLike
+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];
-} & {[K in PropertyLikeKeys<T>]: T[K]};
-
-export type MockedObjectDeep<T> = MaybeMockedConstructor<T> & {
-  [K in MethodLikeKeys<T>]: T[K] extends FunctionLike
-    ? MockedFunctionDeep<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] extends object
+    ? MockedObjectShallow<T[K]>
     : T[K];
-} & {[K in PropertyLikeKeys<T>]: MaybeMockedDeep<T[K]>};
+} & T;
 
-export type MaybeMocked<T> = T extends FunctionLike
+export type Mocked<T extends object> = T extends ClassLike
+  ? MockedClass<T>
+  : T extends FunctionLike
   ? MockedFunction<T>
   : T extends object
   ? MockedObject<T>
   : T;
 
-export type MaybeMockedDeep<T> = T extends FunctionLike
-  ? MockedFunctionDeep<T>
+export type MockedShallow<T extends object> = T extends ClassLike
+  ? MockedClass<T>
+  : T extends FunctionLike
+  ? MockedFunctionShallow<T>
   : T extends object
-  ? MockedObjectDeep<T>
+  ? MockedObjectShallow<T>
   : T;
 
 export type UnknownFunction = (...args: Array<unknown>) => unknown;
@@ -1222,13 +1218,13 @@ export class ModuleMocker {
     return value == null ? `${value}` : typeof value;
   }
 
-  // the typings test helper
-  mocked<T>(item: T, deep?: false): MaybeMocked<T>;
-
-  mocked<T>(item: T, deep: true): MaybeMockedDeep<T>;
-
-  mocked<T>(item: T, _deep = false): MaybeMocked<T> | MaybeMockedDeep<T> {
-    return item as any;
+  mocked<T extends object>(item: T, deep?: false): MockedShallow<T>;
+  mocked<T extends object>(item: T, deep: true): Mocked<T>;
+  mocked<T extends object>(
+    item: T,
+    _deep = false,
+  ): Mocked<T> | MockedShallow<T> {
+    return item as Mocked<T> | MockedShallow<T>;
   }
 }
 
diff --git a/packages/jest-mock/src/types.ts b/packages/jest-mock/src/types.ts
deleted file mode 100644
index 534b0e86ca80..000000000000
--- a/packages/jest-mock/src/types.ts
+++ /dev/null
@@ -1,34 +0,0 @@
-/**
- * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-import type {ClassLike, FunctionLike, MockInstance} from './index';
-
-export type MockedClass<T extends ClassLike> = MockInstance<
-  (...args: ConstructorParameters<T>) => Mocked<InstanceType<T>>
-> &
-  MockedObject<T>;
-
-export type MockedFunction<T extends FunctionLike> = MockInstance<T> &
-  MockedObject<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;
-
-export type Mocked<T extends object> = T extends ClassLike
-  ? MockedClass<T>
-  : T extends FunctionLike
-  ? MockedFunction<T>
-  : T extends object
-  ? MockedObject<T>
-  : T;

From 6f0f2eea46f4abbfc3d2f5236121ed67d30be054 Mon Sep 17 00:00:00 2001
From: Tom Mrazauskas <tom@mrazauskas.de>
Date: Thu, 11 Aug 2022 18:01:35 +0300
Subject: [PATCH 10/17] clean up exports

---
 packages/jest-mock/src/index.ts | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/packages/jest-mock/src/index.ts b/packages/jest-mock/src/index.ts
index f1a31521a6e5..1006a0047fa9 100644
--- a/packages/jest-mock/src/index.ts
+++ b/packages/jest-mock/src/index.ts
@@ -55,9 +55,9 @@ export type MockedClass<T extends ClassLike> = MockInstance<
 export type MockedFunction<T extends FunctionLike> = MockInstance<T> &
   MockedObject<T>;
 
-export type MockedFunctionShallow<T extends FunctionLike> = MockInstance<T> & T;
+type MockedFunctionShallow<T extends FunctionLike> = MockInstance<T> & T;
 
-type MockedObject<T extends object> = {
+export type MockedObject<T extends object> = {
   [K in keyof T]: T[K] extends ClassLike
     ? MockedClass<T[K]>
     : T[K] extends FunctionLike
@@ -85,7 +85,7 @@ export type Mocked<T extends object> = T extends ClassLike
   ? MockedObject<T>
   : T;
 
-export type MockedShallow<T extends object> = T extends ClassLike
+type MockedShallow<T extends object> = T extends ClassLike
   ? MockedClass<T>
   : T extends FunctionLike
   ? MockedFunctionShallow<T>

From ff05715fd51b44242202a0ff1719c5734e9a55b7 Mon Sep 17 00:00:00 2001
From: Tom Mrazauskas <tom@mrazauskas.de>
Date: Fri, 12 Aug 2022 09:15:23 +0300
Subject: [PATCH 11/17] add assignability tests

---
 .../jest-mock/__typetests__/Mocked.test.ts     | 18 +++++++++++++-----
 1 file changed, 13 insertions(+), 5 deletions(-)

diff --git a/packages/jest-mock/__typetests__/Mocked.test.ts b/packages/jest-mock/__typetests__/Mocked.test.ts
index 0b359f6d8e12..945bda233e6d 100644
--- a/packages/jest-mock/__typetests__/Mocked.test.ts
+++ b/packages/jest-mock/__typetests__/Mocked.test.ts
@@ -46,20 +46,22 @@ expectType<[a: string, b?: number]>(
   MockSomeClass.prototype.methodB.mock.calls[0],
 );
 
-const mockExample = new MockSomeClass('c') as Mocked<
+const mockSomeInstance = new MockSomeClass('a') as Mocked<
   InstanceType<typeof MockSomeClass>
 >;
 
-expectType<[]>(mockExample.methodA.mock.calls[0]);
-expectType<[a: string, b?: number]>(mockExample.methodB.mock.calls[0]);
+expectType<[]>(mockSomeInstance.methodA.mock.calls[0]);
+expectType<[a: string, b?: number]>(mockSomeInstance.methodB.mock.calls[0]);
 
-expectError(mockExample.methodA.mockReturnValue('true'));
+expectError(mockSomeInstance.methodA.mockReturnValue('true'));
 expectError(
-  mockExample.methodB.mockImplementation((a: string, b?: string) => {
+  mockSomeInstance.methodB.mockImplementation((a: string, b?: string) => {
     return;
   }),
 );
 
+expectAssignable<SomeClass>(mockSomeInstance);
+
 // mocks function
 
 function someFunction(a: string, b?: number): boolean {
@@ -73,6 +75,8 @@ expectType<[a: string, b?: number]>(mockFunction.mock.calls[0]);
 expectError(mockFunction.mockReturnValue(123));
 expectError(mockFunction.mockImplementation((a: boolean, b?: number) => true));
 
+expectAssignable<typeof someFunction>(mockFunction);
+
 // mocks async function
 
 async function someAsyncFunction(a: Array<boolean>): Promise<string> {
@@ -90,6 +94,8 @@ expectError(
   ),
 );
 
+expectAssignable<typeof someAsyncFunction>(mockAsyncFunction);
+
 // mocks function object
 
 interface SomeFunctionObject {
@@ -124,6 +130,8 @@ expectError(
   }),
 );
 
+expectAssignable<SomeFunctionObject>(mockFunctionObject);
+
 // mocks object
 
 const mockConsole = console as Mocked<typeof console>;

From 715c56422059c95d343aefad5d7b2101f279c0d5 Mon Sep 17 00:00:00 2001
From: Tom Mrazauskas <tom@mrazauskas.de>
Date: Fri, 12 Aug 2022 09:29:07 +0300
Subject: [PATCH 12/17] use `jest.mocked()` in TS example

---
 examples/typescript/__tests__/calc.test.ts | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/examples/typescript/__tests__/calc.test.ts b/examples/typescript/__tests__/calc.test.ts
index cb9bd0210549..7a05eadd8757 100644
--- a/examples/typescript/__tests__/calc.test.ts
+++ b/examples/typescript/__tests__/calc.test.ts
@@ -1,3 +1,7 @@
+// Copyright (c) 2014-present, Facebook, Inc. All rights reserved.
+
+import {jest} from '@jest/globals';
+
 import Memory from '../memory';
 import sub from '../sub';
 import sum from '../sum';
@@ -9,7 +13,7 @@ jest.mock('../sum');
 
 const mockSub = jest.mocked(sub);
 const mockSum = jest.mocked(sum);
-const MockMemory = Memory as jest.MockedClass<typeof Memory>;
+const MockMemory = jest.mocked(Memory);
 
 describe('calc - mocks', () => {
   const memory = new MockMemory();

From 273b08c829ab390818d5ae305e60f3e9652979ab Mon Sep 17 00:00:00 2001
From: Tom Mrazauskas <tom@mrazauskas.de>
Date: Fri, 12 Aug 2022 10:09:41 +0300
Subject: [PATCH 13/17] add mocked object test

---
 .../jest-mock/__typetests__/Mocked.test.ts    | 82 ++++++++++++++++++-
 1 file changed, 78 insertions(+), 4 deletions(-)

diff --git a/packages/jest-mock/__typetests__/Mocked.test.ts b/packages/jest-mock/__typetests__/Mocked.test.ts
index 945bda233e6d..a3ef06684c19 100644
--- a/packages/jest-mock/__typetests__/Mocked.test.ts
+++ b/packages/jest-mock/__typetests__/Mocked.test.ts
@@ -23,9 +23,7 @@ class SomeClass {
 
 const MockSomeClass = SomeClass as Mocked<typeof SomeClass>;
 
-expectType<[one: string, two?: boolean | undefined]>(
-  MockSomeClass.mock.calls[0],
-);
+expectType<[one: string, two?: boolean]>(MockSomeClass.mock.calls[0]);
 
 expectType<[]>(MockSomeClass.prototype.methodA.mock.calls[0]);
 expectType<[a: string, b?: number]>(
@@ -130,10 +128,86 @@ expectError(
   }),
 );
 
-expectAssignable<SomeFunctionObject>(mockFunctionObject);
+expectAssignable<typeof someFunctionObject>(mockFunctionObject);
 
 // mocks object
 
+const someObject = {
+  SomeClass,
+
+  methodA() {
+    return;
+  },
+  methodB(b: string) {
+    return true;
+  },
+  methodC: (c: number) => true,
+
+  one: {
+    more: {
+      time: (t: number) => {
+        return;
+      },
+    },
+  },
+
+  propertyA: 123,
+  propertyB: 'value',
+
+  someClassInstance: new SomeClass('value'),
+};
+
+const mockObject = someObject as Mocked<typeof someObject>;
+
+expectType<[]>(mockObject.methodA.mock.calls[0]);
+expectType<[b: string]>(mockObject.methodB.mock.calls[0]);
+expectType<[c: number]>(mockObject.methodC.mock.calls[0]);
+
+expectType<[t: number]>(mockObject.one.more.time.mock.calls[0]);
+
+expectType<[one: string, two?: boolean]>(mockObject.SomeClass.mock.calls[0]);
+expectType<[]>(mockObject.SomeClass.prototype.methodA.mock.calls[0]);
+expectType<[a: string, b?: number]>(
+  mockObject.SomeClass.prototype.methodB.mock.calls[0],
+);
+
+expectType<[]>(mockObject.someClassInstance.methodA.mock.calls[0]);
+expectType<[a: string, b?: number]>(
+  mockObject.someClassInstance.methodB.mock.calls[0],
+);
+
+expectError(mockObject.methodA.mockReturnValue(123));
+expectError(mockObject.methodA.mockImplementation((a: number) => 123));
+expectError(mockObject.methodB.mockReturnValue(123));
+expectError(mockObject.methodB.mockImplementation((b: number) => 123));
+expectError(mockObject.methodC.mockReturnValue(123));
+expectError(mockObject.methodC.mockImplementation((c: number) => 123));
+
+expectError(mockObject.one.more.time.mockReturnValue(123));
+expectError(mockObject.one.more.time.mockImplementation((t: boolean) => 123));
+
+expectError(mockObject.SomeClass.prototype.methodA.mockReturnValue(123));
+expectError(
+  mockObject.SomeClass.prototype.methodA.mockImplementation((a: number) => 123),
+);
+expectError(mockObject.SomeClass.prototype.methodB.mockReturnValue(123));
+expectError(
+  mockObject.SomeClass.prototype.methodB.mockImplementation((a: number) => 123),
+);
+
+expectError(mockObject.someClassInstance.methodA.mockReturnValue(123));
+expectError(
+  mockObject.someClassInstance.methodA.mockImplementation((a: number) => 123),
+);
+expectError(mockObject.someClassInstance.methodB.mockReturnValue(123));
+expectError(
+  mockObject.someClassInstance.methodB.mockImplementation((a: number) => 123),
+);
+
+expectAssignable<typeof someObject>(mockObject);
+
+// mocks 'console' object
+
 const mockConsole = console as Mocked<typeof console>;
 
 expectAssignable<typeof console.log>(

From f777a3092b0d27f2516da54033354b940d8faca8 Mon Sep 17 00:00:00 2001
From: Tom Mrazauskas <tom@mrazauskas.de>
Date: Fri, 12 Aug 2022 17:22:39 +0300
Subject: [PATCH 14/17] add MockedObject

---
 packages/jest-globals/src/index.ts | 11 ++++++++---
 1 file changed, 8 insertions(+), 3 deletions(-)

diff --git a/packages/jest-globals/src/index.ts b/packages/jest-globals/src/index.ts
index c6164dc058d7..a06db18df650 100644
--- a/packages/jest-globals/src/index.ts
+++ b/packages/jest-globals/src/index.ts
@@ -14,6 +14,7 @@ import type {
   Mocked as JestMocked,
   MockedClass as JestMockedClass,
   MockedFunction as JestMockedFunction,
+  MockedObject as JestMockedObject,
 } from 'jest-mock';
 
 export declare const expect: JestExpect;
@@ -36,17 +37,21 @@ declare const jest: Jest;
 // eslint-disable-next-line @typescript-eslint/no-namespace
 declare namespace jest {
   /**
-   * Wraps a class, function or object type with definitions of Jest mock.
+   * Wraps a class, function or object type with Jest mock type definitions.
    */
   export type Mocked<T extends object> = JestMocked<T>;
   /**
-   * Wraps a class type with definitions of Jest mock.
+   * Wraps a class type with Jest mock type definitions.
    */
   export type MockedClass<T extends ClassLike> = JestMockedClass<T>;
   /**
-   * Wraps a function type with definitions of Jest mock.
+   * Wraps a function type with Jest mock type definitions.
    */
   export type MockedFunction<T extends FunctionLike> = JestMockedFunction<T>;
+  /**
+   * Wraps an object type with Jest mock type definitions.
+   */
+  export type MockedObject<T extends object> = JestMockedObject<T>;
 }
 
 export {jest};

From 247f12fc21799df56cae780b3f37d2eb4811ac47 Mon Sep 17 00:00:00 2001
From: Tom Mrazauskas <tom@mrazauskas.de>
Date: Fri, 12 Aug 2022 17:38:54 +0300
Subject: [PATCH 15/17] tests

---
 .../jest-types/__typetests__/jest.test.ts     | 25 ++++++++++++++++++-
 1 file changed, 24 insertions(+), 1 deletion(-)

diff --git a/packages/jest-types/__typetests__/jest.test.ts b/packages/jest-types/__typetests__/jest.test.ts
index 111e5c836bc4..f5f12ba68f05 100644
--- a/packages/jest-types/__typetests__/jest.test.ts
+++ b/packages/jest-types/__typetests__/jest.test.ts
@@ -12,6 +12,7 @@ import type {
   Mocked,
   MockedClass,
   MockedFunction,
+  MockedObject,
   ModuleMocker,
   SpyInstance,
 } from 'jest-mock';
@@ -217,7 +218,7 @@ expectType<ModuleMocker['fn']>(jest.fn);
 
 expectType<ModuleMocker['spyOn']>(jest.spyOn);
 
-// deep mocked()
+// Mocked*<T>
 
 class SomeClass {
   constructor(one: string, two?: boolean) {}
@@ -230,6 +231,10 @@ class SomeClass {
   }
 }
 
+function someFunction(a: string, b?: number): boolean {
+  return true;
+}
+
 const someObject = {
   SomeClass,
 
@@ -255,6 +260,24 @@ const someObject = {
   someClassInstance: new SomeClass('value'),
 };
 
+expectType<Mocked<typeof someObject>>(
+  someObject as jest.Mocked<typeof someObject>,
+);
+
+expectType<MockedClass<typeof SomeClass>>(
+  SomeClass as jest.MockedClass<typeof SomeClass>,
+);
+
+expectType<MockedFunction<typeof someFunction>>(
+  someFunction as jest.MockedFunction<typeof someFunction>,
+);
+
+expectType<MockedObject<typeof someObject>>(
+  someObject as jest.MockedObject<typeof someObject>,
+);
+
+// deep mocked()
+
 const mockObjectA = jest.mocked(someObject, true);
 
 expectError(jest.mocked('abc', true));

From 11fc9fe73f68ddc0a6941362f8600dc0a3dd3a51 Mon Sep 17 00:00:00 2001
From: Tom Mrazauskas <tom@mrazauskas.de>
Date: Fri, 12 Aug 2022 18:02:57 +0300
Subject: [PATCH 16/17] docs

---
 docs/MockFunctionAPI.md | 25 +++++++++++++++++++++++++
 1 file changed, 25 insertions(+)

diff --git a/docs/MockFunctionAPI.md b/docs/MockFunctionAPI.md
index db8f2d5ea4b3..0b2fea48b464 100644
--- a/docs/MockFunctionAPI.md
+++ b/docs/MockFunctionAPI.md
@@ -520,3 +520,28 @@ test('calculate calls add', () => {
   expect(mockAdd).toBeCalledWith(1, 2);
 });
 ```
+
+### `jest.Mocked<Source>`
+
+The `jest.Mocked<Source>` utility type returns the `Source` type wrapped with type definitions of Jest mock function.
+
+```ts
+import fetch from 'node-fetch';
+import {expect, jest, test} from '@jest/globals';
+
+jest.mock('node-fetch');
+
+let mockedFetch: jest.Mocked<typeof fetch>;
+
+test('makes correct call', () => {
+  mockedFetch = getMockedFetch();
+  // ...
+});
+
+test('returns correct data', () => {
+  mockedFetch = getMockedFetch();
+  // ...
+});
+```
+
+Types of classes, functions or objects can be passed as type argument to `jest.Mocked<Source>`. If you prefer to constrain the input type, use: `jest.MockedClass<Source>`, `jest.MockedFunction<Source>` or `jest.MockedObject<Source>`.

From a884b46b8eccdd0ce05320cf6a6f805c6be7d1c2 Mon Sep 17 00:00:00 2001
From: Tom Mrazauskas <tom@mrazauskas.de>
Date: Fri, 12 Aug 2022 18:03:09 +0300
Subject: [PATCH 17/17] changelog entry

---
 CHANGELOG.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 02d6f94c4885..c59948435fde 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4,6 +4,7 @@
 
 - `[jest-config]` [**BREAKING**] Make `snapshotFormat` default to `escapeString: false` and `printBasicPrototype: false` ([#13036](https://github.com/facebook/jest/pull/13036))
 - `[jest-environment-jsdom]` [**BREAKING**] Upgrade to `jsdom@20` ([#13037](https://github.com/facebook/jest/pull/13037), [#13058](https://github.com/facebook/jest/pull/13058))
+- `[@jest/globals]` Add `jest.Mocked`, `jest.MockedClass`, `jest.MockedFunction` and `jest.MockedObject` utility types ([#12727](https://github.com/facebook/jest/pull/12727))
 - `[jest-mock]` [**BREAKING**] Refactor `Mocked*` utility types. `MaybeMockedDeep` and `MaybeMocked` became `Mocked` and `MockedShallow` respectively; only deep mocked variants of `MockedClass`, `MockedFunction` and `MockedObject` are exported ([#13123](https://github.com/facebook/jest/pull/13123), [#13124](https://github.com/facebook/jest/pull/13124))
 - `[jest-worker]` Adds `workerIdleMemoryLimit` option which is used as a check for worker memory leaks >= Node 16.11.0 and recycles child workers as required. ([#13056](https://github.com/facebook/jest/pull/13056), [#13105](https://github.com/facebook/jest/pull/13105), [#13106](https://github.com/facebook/jest/pull/13106), [#13107](https://github.com/facebook/jest/pull/13107))
 - `[pretty-format]` [**BREAKING**] Remove `ConvertAnsi` plugin in favour of `jest-serializer-ansi-escapes` ([#13040](https://github.com/facebook/jest/pull/13040))