bun-types 1.2.11-canary.20250418T140557 → 1.2.11-canary.20250420T140512

package/test.d.ts

@@ -29,11 +29,14 @@ declare module "bun:test" {
      *
      * This is useful for mocking modules.
      *
+     * If the module is already loaded, exports are overwritten with the return
+     * value of `factory`. If the export didn't exist before, it will not be
+     * added to existing import statements. This is due to how ESM works.
+     *
      * @param id module ID to mock
      * @param factory a function returning an object that will be used as the exports of the mocked module
      *
      * @example
-     * ## Example
      * ```ts
      * import { mock } from "bun:test";
      *
@@ -47,12 +50,6 @@ declare module "bun:test" {
      *
      * console.log(await readFile("hello.txt", "utf8")); // hello world
      * ```
-     *
-     * ## More notes
-     *
-     * If the module is already loaded, exports are overwritten with the return
-     * value of `factory`. If the export didn't exist before, it will not be
-     * added to existing import statements. This is due to how ESM works.
      */
     module(id: string, factory: () => any): void | Promise<void>;
     /**
@@ -155,6 +152,8 @@ declare module "bun:test" {
     readonly name: string;
   }
 
+  type DescribeLabel = number | string | Function | FunctionLike;
+
   /**
    * Describes a group of related tests.
    *
@@ -176,28 +175,28 @@ declare module "bun:test" {
   export interface Describe {
     (fn: () => void): void;
 
-    (label: number | string | Function | FunctionLike, fn: () => void): void;
+    (label: DescribeLabel, fn: () => void): void;
     /**
      * Skips all other tests, except this group of tests.
      *
      * @param label the label for the tests
      * @param fn the function that defines the tests
      */
-    only(label: string, fn: () => void): void;
+    only(label: DescribeLabel, fn: () => void): void;
     /**
      * Skips this group of tests.
      *
      * @param label the label for the tests
      * @param fn the function that defines the tests
      */
-    skip(label: string, fn: () => void): void;
+    skip(label: DescribeLabel, fn: () => void): void;
     /**
      * Marks this group of tests as to be written or to be fixed.
      *
      * @param label the label for the tests
      * @param fn the function that defines the tests
      */
-    todo(label: string, fn?: () => void): void;
+    todo(label: DescribeLabel, fn?: () => void): void;
     /**
      * Runs this group of tests, only if `condition` is true.
      *
@@ -205,19 +204,19 @@ declare module "bun:test" {
      *
      * @param condition if these tests should run
      */
-    if(condition: boolean): (label: string, fn: () => void) => void;
+    if(condition: boolean): (label: DescribeLabel, fn: () => void) => void;
     /**
      * Skips this group of tests, if `condition` is true.
      *
      * @param condition if these tests should be skipped
      */
-    skipIf(condition: boolean): (label: string, fn: () => void) => void;
+    skipIf(condition: boolean): (label: DescribeLabel, fn: () => void) => void;
     /**
      * Marks this group of tests as to be written or to be fixed, if `condition` is true.
      *
      * @param condition if these tests should be skipped
      */
-    todoIf(condition: boolean): (label: string, fn: () => void) => void;
+    todoIf(condition: boolean): (label: DescribeLabel, fn: () => void) => void;
     /**
      * Returns a function that runs for each item in `table`.
      *
@@ -225,13 +224,17 @@ declare module "bun:test" {
      */
     each<T extends Readonly<[any, ...any[]]>>(
       table: readonly T[],
-    ): (label: string, fn: (...args: [...T]) => void | Promise<unknown>, options?: number | TestOptions) => void;
+    ): (label: DescribeLabel, fn: (...args: [...T]) => void | Promise<unknown>, options?: number | TestOptions) => void;
     each<T extends any[]>(
       table: readonly T[],
-    ): (label: string, fn: (...args: Readonly<T>) => void | Promise<unknown>, options?: number | TestOptions) => void;
+    ): (
+      label: DescribeLabel,
+      fn: (...args: Readonly<T>) => void | Promise<unknown>,
+      options?: number | TestOptions,
+    ) => void;
     each<T>(
       table: T[],
-    ): (label: string, fn: (...args: T[]) => void | Promise<unknown>, options?: number | TestOptions) => void;
+    ): (label: DescribeLabel, fn: (...args: T[]) => void | Promise<unknown>, options?: number | TestOptions) => void;
   }
   /**
    * Describes a group of related tests.
@@ -593,8 +596,6 @@ declare module "bun:test" {
      * @returns never
      *
      * @example
-     * ## Example
-     *
      * ```ts
      * import { expect, test } from "bun:test";
      *
@@ -1786,367 +1787,329 @@ declare module "bun:test" {
   }
 
   type MatcherContext = MatcherUtils & MatcherState;
-}
-
-declare namespace JestMock {
-  /**
-   * Copyright (c) Meta Platforms, Inc. and affiliates.
-   *
-   * This source code is licensed under the MIT license found in the
-   * LICENSE file in the root directory of this source tree.
-   */
-  export interface ClassLike {
-    new (...args: any): any;
-  }
-
-  export type ConstructorLikeKeys<T> = keyof {
-    [K in keyof T as Required<T>[K] extends ClassLike ? K : never]: T[K];
-  };
 
-  // export const fn: <T extends FunctionLike = UnknownFunction>(
-  //   implementation?: T | undefined,
-  // ) => Mock<T>;
-
-  export type FunctionLike = (...args: any) => any;
-
-  export type MethodLikeKeys<T> = keyof {
-    [K in keyof T as Required<T>[K] extends FunctionLike ? K : never]: T[K];
-  };
-
-  export interface Mock<T extends (...args: any[]) => any> extends MockInstance<T> {
-    (...args: Parameters<T>): ReturnType<T>;
-  }
-
-  /**
-   * All what the internal typings need is to be sure that we have any-function.
-   * `FunctionLike` type ensures that and helps to constrain the type as well.
-   * The default of `UnknownFunction` makes sure that `any`s do not leak to the
-   * user side. For instance, calling `fn()` without implementation will return
-   * a mock of `(...args: Array<unknown>) => unknown` type. If implementation
-   * is provided, its typings are inferred correctly.
-   */
-  // export interface Mock<T extends FunctionLike = UnknownFunction>
-  //   extends Function,
-  //     MockInstance<T> {
-  //   new (...args: Parameters<T>): ReturnType<T>;
-  //   (...args: Parameters<T>): ReturnType<T>;
-  // }
-
-  // export type Mocked<T> = T extends ClassLike
-  //   ? MockedClass<T>
-  //   : T extends FunctionLike
-  //   ? MockedFunction<T>
-  //   : T extends object
-  //   ? MockedObject<T>
-  //   : T;
-
-  // export const mocked: {
-  //   <T extends object>(
-  //     source: T,
-  //     options?: {
-  //       shallow: false;
-  //     },
-  //   ): Mocked<T>;
-  //   <T_1 extends object>(
-  //     source: T_1,
-  //     options: {
-  //       shallow: true;
-  //     },
-  //   ): MockedShallow<T_1>;
-  // };
-
-  // 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 MockedFunctionShallow<T extends FunctionLike> = MockInstance<T> & T;
-
-  // export 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;
-
-  // export type MockedShallow<T> = T extends ClassLike
-  //   ? MockedClass<T>
-  //   : T extends FunctionLike
-  //   ? MockedFunctionShallow<T>
-  //   : T extends object
-  //   ? MockedObjectShallow<T>
-  //   : T;
-
-  // export type MockFunctionMetadata<
-  //   T = unknown,
-  //   MetadataType = MockMetadataType,
-  // > = MockMetadata<T, MetadataType>;
-
-  // export type MockFunctionMetadataType = MockMetadataType;
-
-  type MockFunctionResult<T extends FunctionLike = UnknownFunction> =
-    | MockFunctionResultIncomplete
-    | MockFunctionResultReturn<T>
-    | MockFunctionResultThrow;
-
-  interface 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;
-  }
-
-  interface MockFunctionResultReturn<T extends FunctionLike = UnknownFunction> {
-    type: "return";
-    /**
-     * Result of a single call to a mock function that returned.
-     */
-    value: ReturnType<T>;
-  }
-
-  interface MockFunctionResultThrow {
-    type: "throw";
-    /**
-     * Result of a single call to a mock function that threw.
-     */
-    value: unknown;
-  }
-
-  interface MockFunctionState<T extends FunctionLike = FunctionLike> {
-    /**
-     * 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: 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>>;
-  }
-
-  export interface MockInstance<T extends FunctionLike = UnknownFunction> {
-    _isMockFunction: true;
-    _protoImpl: Function;
-    getMockImplementation(): T | undefined;
-    getMockName(): string;
-    mock: MockFunctionState<T>;
-    mockClear(): this;
-    mockReset(): this;
-    mockRestore(): void;
-    mockImplementation(fn: T): this;
-    mockImplementationOnce(fn: T): this;
-    withImplementation(fn: T, callback: () => Promise<unknown>): Promise<void>;
-    withImplementation(fn: T, callback: () => void): void;
-    mockName(name: string): this;
-    mockReturnThis(): this;
-    mockReturnValue(value: ReturnType<T>): this;
-    mockReturnValueOnce(value: ReturnType<T>): this;
-    mockResolvedValue(value: ResolveType<T>): this;
-    mockResolvedValueOnce(value: ResolveType<T>): this;
-    mockRejectedValue(value: RejectType<T>): this;
-    mockRejectedValueOnce(value: RejectType<T>): this;
-  }
-
-  // export type MockMetadata<T, MetadataType = MockMetadataType> = {
-  //   ref?: number;
-  //   members?: Record<string, MockMetadata<T>>;
-  //   mockImpl?: T;
-  //   name?: string;
-  //   refID?: number;
-  //   type?: MetadataType;
-  //   value?: T;
-  //   length?: number;
-  // };
-
-  // export type MockMetadataType =
-  //   | "object"
-  //   | "array"
-  //   | "regexp"
-  //   | "function"
-  //   | "constant"
-  //   | "collection"
-  //   | "null"
-  //   | "undefined";
-
-  // export class ModuleMocker {
-  //   private readonly _environmentGlobal;
-  //   private _mockState;
-  //   private _mockConfigRegistry;
-  //   private _spyState;
-  //   private _invocationCallCounter;
-  //   /**
-  //    * @see README.md
-  //    * @param global Global object of the test environment, used to create
-  //    * mocks
-  //    */
-  //   constructor(global: typeof globalThis);
-  //   private _getSlots;
-  //   private _ensureMockConfig;
-  //   private _ensureMockState;
-  //   private _defaultMockConfig;
-  //   private _defaultMockState;
-  //   private _makeComponent;
-  //   private _createMockFunction;
-  //   private _generateMock;
-  //   /**
-  //    * Check whether the given property of an object has been already replaced.
-  //    */
-  //   private _findReplacedProperty;
-  //   /**
-  //    * @see README.md
-  //    * @param metadata Metadata for the mock in the schema returned by the
-  //    * getMetadata method of this module.
-  //    */
-  //   generateFromMetadata<T>(metadata: MockMetadata<T>): Mocked<T>;
-  //   /**
-  //    * @see README.md
-  //    * @param component The component for which to retrieve metadata.
-  //    */
-  //   getMetadata<T = unknown>(
-  //     component: T,
-  //     _refs?: Map<T, number>,
-  //   ): MockMetadata<T> | null;
-  //   isMockFunction<T extends FunctionLike = UnknownFunction>(
-  //     fn: MockInstance<T>,
-  //   ): fn is MockInstance<T>;
-  //   isMockFunction<P extends Array<unknown>, R>(
-  //     fn: (...args: P) => R,
-  //   ): fn is Mock<(...args: P) => R>;
-  //   isMockFunction(fn: unknown): fn is Mock<UnknownFunction>;
-  //   fn<T extends FunctionLike = UnknownFunction>(implementation?: T): Mock<T>;
-  //   private _attachMockImplementation;
-  //   spyOn<
-  //     T extends object,
-  //     K extends PropertyLikeKeys<T>,
-  //     A extends "get" | "set",
-  //   >(
-  //     object: T,
-  //     methodKey: K,
-  //     accessType: A,
-  //   ): A extends "get"
-  //     ? SpiedGetter<T[K]>
-  //     : A extends "set"
-  //     ? SpiedSetter<T[K]>
-  //     : never;
-  //   spyOn<
-  //     T extends object,
-  //     K extends ConstructorLikeKeys<T> | MethodLikeKeys<T>,
-  //     V extends Required<T>[K],
-  //   >(
-  //     object: T,
-  //     methodKey: K,
-  //   ): V extends ClassLike | FunctionLike ? Spied<V> : never;
-  //   private _spyOnProperty;
-  //   replaceProperty<
-  //     T extends object,
-  //     K extends PropertyLikeKeys<T>,
-  //     V extends T[K],
-  //   >(object: T, propertyKey: K, value: V): Replaced<T[K]>;
-  //   clearAllMocks(): void;
-  //   resetAllMocks(): void;
-  //   restoreAllMocks(): void;
-  //   private _typeOf;
-  //   mocked<T extends object>(
-  //     source: T,
-  //     options?: {
-  //       shallow: false;
-  //     },
-  //   ): Mocked<T>;
-  //   mocked<T extends object>(
-  //     source: T,
-  //     options: {
-  //       shallow: true;
-  //     },
-  //   ): MockedShallow<T>;
-  // }
-
-  export type PropertyLikeKeys<T> = Exclude<keyof T, ConstructorLikeKeys<T> | MethodLikeKeys<T>>;
-
-  export type RejectType<T extends FunctionLike> = ReturnType<T> extends PromiseLike<any> ? unknown : never;
-
-  export interface Replaced<T = unknown> {
-    /**
-     * Restore property to its original value known at the time of mocking.
-     */
-    restore(): void;
-    /**
-     * Change the value of the property.
-     */
-    replaceValue(value: T): this;
-  }
-
-  export function replaceProperty<
-    T extends object,
-    K_2 extends Exclude<
-      keyof T,
-      | keyof {
-          [K in keyof T as Required<T>[K] extends ClassLike ? K : never]: T[K];
-        }
-      | keyof {
-          [K_1 in keyof T as Required<T>[K_1] extends FunctionLike ? K_1 : never]: T[K_1];
-        }
-    >,
-    V extends T[K_2],
-  >(object: T, propertyKey: K_2, value: V): Replaced<T[K_2]>;
-
-  export type ResolveType<T extends FunctionLike> = ReturnType<T> extends PromiseLike<infer U> ? U : never;
-
-  export type Spied<T extends ClassLike | FunctionLike> = T extends ClassLike
-    ? SpiedClass<T>
-    : T extends FunctionLike
-      ? SpiedFunction<T>
-      : never;
-
-  export type SpiedClass<T extends ClassLike = UnknownClass> = MockInstance<
-    (...args: ConstructorParameters<T>) => InstanceType<T>
-  >;
-
-  export type SpiedFunction<T extends FunctionLike = UnknownFunction> = MockInstance<
-    (...args: Parameters<T>) => ReturnType<T>
-  >;
+  namespace JestMock {
+    /**
+     * Copyright (c) Meta Platforms, Inc. and affiliates.
+     *
+     * This source code is licensed under the MIT license found in the
+     * LICENSE file in the root directory of this source tree.
+     */
+    export interface ClassLike {
+      new (...args: any): any;
+    }
+
+    export type ConstructorLikeKeys<T> = keyof {
+      [K in keyof T as Required<T>[K] extends ClassLike ? K : never]: T[K];
+    };
+
+    // export const fn: <T extends FunctionLike = UnknownFunction>(
+    //   implementation?: T | undefined,
+    // ) => Mock<T>;
+
+    export type FunctionLike = (...args: any) => any;
+
+    export type MethodLikeKeys<T> = keyof {
+      [K in keyof T as Required<T>[K] extends FunctionLike ? K : never]: T[K];
+    };
+
+    export interface Mock<T extends (...args: any[]) => any> extends MockInstance<T> {
+      (...args: Parameters<T>): ReturnType<T>;
+    }
+
+    /**
+     * All what the internal typings need is to be sure that we have any-function.
+     * `FunctionLike` type ensures that and helps to constrain the type as well.
+     * The default of `UnknownFunction` makes sure that `any`s do not leak to the
+     * user side. For instance, calling `fn()` without implementation will return
+     * a mock of `(...args: Array<unknown>) => unknown` type. If implementation
+     * is provided, its typings are inferred correctly.
+     */
+    // export interface Mock<T extends FunctionLike = UnknownFunction>
+    //   extends Function,
+    //     MockInstance<T> {
+    //   new (...args: Parameters<T>): ReturnType<T>;
+    //   (...args: Parameters<T>): ReturnType<T>;
+    // }
+
+    // export type Mocked<T> = T extends ClassLike
+    //   ? MockedClass<T>
+    //   : T extends FunctionLike
+    //   ? MockedFunction<T>
+    //   : T extends object
+    //   ? MockedObject<T>
+    //   : T;
+
+    // export const mocked: {
+    //   <T extends object>(
+    //     source: T,
+    //     options?: {
+    //       shallow: false;
+    //     },
+    //   ): Mocked<T>;
+    //   <T_1 extends object>(
+    //     source: T_1,
+    //     options: {
+    //       shallow: true;
+    //     },
+    //   ): MockedShallow<T_1>;
+    // };
+
+    // 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 MockedFunctionShallow<T extends FunctionLike> = MockInstance<T> & T;
+
+    // export 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;
+
+    // export type MockedShallow<T> = T extends ClassLike
+    //   ? MockedClass<T>
+    //   : T extends FunctionLike
+    //   ? MockedFunctionShallow<T>
+    //   : T extends object
+    //   ? MockedObjectShallow<T>
+    //   : T;
+
+    // export type MockFunctionMetadata<
+    //   T = unknown,
+    //   MetadataType = MockMetadataType,
+    // > = MockMetadata<T, MetadataType>;
+
+    // export type MockFunctionMetadataType = MockMetadataType;
+
+    type MockFunctionResult<T extends FunctionLike = UnknownFunction> =
+      | MockFunctionResultIncomplete
+      | MockFunctionResultReturn<T>
+      | MockFunctionResultThrow;
+
+    interface 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;
+    }
 
-  export type SpiedGetter<T> = MockInstance<() => T>;
+    interface MockFunctionResultReturn<T extends FunctionLike = UnknownFunction> {
+      type: "return";
+      /**
+       * Result of a single call to a mock function that returned.
+       */
+      value: ReturnType<T>;
+    }
 
-  export type SpiedSetter<T> = MockInstance<(arg: T) => void>;
+    interface MockFunctionResultThrow {
+      type: "throw";
+      /**
+       * Result of a single call to a mock function that threw.
+       */
+      value: unknown;
+    }
 
-  export interface SpyInstance<T extends FunctionLike = UnknownFunction> extends MockInstance<T> {}
+    interface MockFunctionState<T extends FunctionLike = FunctionLike> {
+      /**
+       * 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: 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>>;
+    }
+
+    export interface MockInstance<T extends FunctionLike = UnknownFunction> {
+      _isMockFunction: true;
+      _protoImpl: Function;
+      getMockImplementation(): T | undefined;
+      getMockName(): string;
+      mock: MockFunctionState<T>;
+      mockClear(): this;
+      mockReset(): this;
+      mockRestore(): void;
+      mockImplementation(fn: T): this;
+      mockImplementationOnce(fn: T): this;
+      withImplementation(fn: T, callback: () => Promise<unknown>): Promise<void>;
+      withImplementation(fn: T, callback: () => void): void;
+      mockName(name: string): this;
+      mockReturnThis(): this;
+      mockReturnValue(value: ReturnType<T>): this;
+      mockReturnValueOnce(value: ReturnType<T>): this;
+      mockResolvedValue(value: ResolveType<T>): this;
+      mockResolvedValueOnce(value: ResolveType<T>): this;
+      mockRejectedValue(value: RejectType<T>): this;
+      mockRejectedValueOnce(value: RejectType<T>): this;
+    }
+
+    // export type MockMetadata<T, MetadataType = MockMetadataType> = {
+    //   ref?: number;
+    //   members?: Record<string, MockMetadata<T>>;
+    //   mockImpl?: T;
+    //   name?: string;
+    //   refID?: number;
+    //   type?: MetadataType;
+    //   value?: T;
+    //   length?: number;
+    // };
+
+    // export type MockMetadataType =
+    //   | "object"
+    //   | "array"
+    //   | "regexp"
+    //   | "function"
+    //   | "constant"
+    //   | "collection"
+    //   | "null"
+    //   | "undefined";
+
+    // export class ModuleMocker {
+    //   private readonly _environmentGlobal;
+    //   private _mockState;
+    //   private _mockConfigRegistry;
+    //   private _spyState;
+    //   private _invocationCallCounter;
+    //   /**
+    //    * @see README.md
+    //    * @param global Global object of the test environment, used to create
+    //    * mocks
+    //    */
+    //   constructor(global: typeof globalThis);
+    //   private _getSlots;
+    //   private _ensureMockConfig;
+    //   private _ensureMockState;
+    //   private _defaultMockConfig;
+    //   private _defaultMockState;
+    //   private _makeComponent;
+    //   private _createMockFunction;
+    //   private _generateMock;
+    //   /**
+    //    * Check whether the given property of an object has been already replaced.
+    //    */
+    //   private _findReplacedProperty;
+    //   /**
+    //    * @see README.md
+    //    * @param metadata Metadata for the mock in the schema returned by the
+    //    * getMetadata method of this module.
+    //    */
+    //   generateFromMetadata<T>(metadata: MockMetadata<T>): Mocked<T>;
+    //   /**
+    //    * @see README.md
+    //    * @param component The component for which to retrieve metadata.
+    //    */
+    //   getMetadata<T = unknown>(
+    //     component: T,
+    //     _refs?: Map<T, number>,
+    //   ): MockMetadata<T> | null;
+    //   isMockFunction<T extends FunctionLike = UnknownFunction>(
+    //     fn: MockInstance<T>,
+    //   ): fn is MockInstance<T>;
+    //   isMockFunction<P extends Array<unknown>, R>(
+    //     fn: (...args: P) => R,
+    //   ): fn is Mock<(...args: P) => R>;
+    //   isMockFunction(fn: unknown): fn is Mock<UnknownFunction>;
+    //   fn<T extends FunctionLike = UnknownFunction>(implementation?: T): Mock<T>;
+    //   private _attachMockImplementation;
+    //   spyOn<
+    //     T extends object,
+    //     K extends PropertyLikeKeys<T>,
+    //     A extends "get" | "set",
+    //   >(
+    //     object: T,
+    //     methodKey: K,
+    //     accessType: A,
+    //   ): A extends "get"
+    //     ? SpiedGetter<T[K]>
+    //     : A extends "set"
+    //     ? SpiedSetter<T[K]>
+    //     : never;
+    //   spyOn<
+    //     T extends object,
+    //     K extends ConstructorLikeKeys<T> | MethodLikeKeys<T>,
+    //     V extends Required<T>[K],
+    //   >(
+    //     object: T,
+    //     methodKey: K,
+    //   ): V extends ClassLike | FunctionLike ? Spied<V> : never;
+    //   private _spyOnProperty;
+    //   replaceProperty<
+    //     T extends object,
+    //     K extends PropertyLikeKeys<T>,
+    //     V extends T[K],
+    //   >(object: T, propertyKey: K, value: V): Replaced<T[K]>;
+    //   clearAllMocks(): void;
+    //   resetAllMocks(): void;
+    //   restoreAllMocks(): void;
+    //   private _typeOf;
+    //   mocked<T extends object>(
+    //     source: T,
+    //     options?: {
+    //       shallow: false;
+    //     },
+    //   ): Mocked<T>;
+    //   mocked<T extends object>(
+    //     source: T,
+    //     options: {
+    //       shallow: true;
+    //     },
+    //   ): MockedShallow<T>;
+    // }
+
+    export type PropertyLikeKeys<T> = Exclude<keyof T, ConstructorLikeKeys<T> | MethodLikeKeys<T>>;
+
+    export type RejectType<T extends FunctionLike> = ReturnType<T> extends PromiseLike<any> ? unknown : never;
+
+    export interface Replaced<T = unknown> {
+      /**
+       * Restore property to its original value known at the time of mocking.
+       */
+      restore(): void;
+      /**
+       * Change the value of the property.
+       */
+      replaceValue(value: T): this;
+    }
 
-  export const spyOn: {
-    <
+    export function replaceProperty<
       T extends object,
       K_2 extends Exclude<
         keyof T,
@@ -2157,32 +2120,70 @@ declare namespace JestMock {
             [K_1 in keyof T as Required<T>[K_1] extends FunctionLike ? K_1 : never]: T[K_1];
           }
       >,
-      V extends Required<T>[K_2],
-      A extends "set" | "get",
-    >(
-      object: T,
-      methodKey: K_2,
-      accessType: A,
-    ): A extends "get" ? SpiedGetter<V> : A extends "set" ? SpiedSetter<V> : never;
-    <
-      T_1 extends object,
-      K_5 extends
-        | keyof {
-            [K_3 in keyof T_1 as Required<T_1>[K_3] extends ClassLike ? K_3 : never]: T_1[K_3];
-          }
-        | keyof {
-            [K_4 in keyof T_1 as Required<T_1>[K_4] extends FunctionLike ? K_4 : never]: T_1[K_4];
-          },
-      V_1 extends Required<T_1>[K_5],
-    >(
-      object: T_1,
-      methodKey: K_5,
-    ): V_1 extends ClassLike | FunctionLike ? Spied<V_1> : never;
-  };
-
-  export interface UnknownClass {
-    new (...args: unknown[]): unknown;
+      V extends T[K_2],
+    >(object: T, propertyKey: K_2, value: V): Replaced<T[K_2]>;
+
+    export type ResolveType<T extends FunctionLike> = ReturnType<T> extends PromiseLike<infer U> ? U : never;
+
+    export type Spied<T extends ClassLike | FunctionLike> = T extends ClassLike
+      ? SpiedClass<T>
+      : T extends FunctionLike
+        ? SpiedFunction<T>
+        : never;
+
+    export type SpiedClass<T extends ClassLike = UnknownClass> = MockInstance<
+      (...args: ConstructorParameters<T>) => InstanceType<T>
+    >;
+
+    export type SpiedFunction<T extends FunctionLike = UnknownFunction> = MockInstance<
+      (...args: Parameters<T>) => ReturnType<T>
+    >;
+
+    export type SpiedGetter<T> = MockInstance<() => T>;
+
+    export type SpiedSetter<T> = MockInstance<(arg: T) => void>;
+
+    export interface SpyInstance<T extends FunctionLike = UnknownFunction> extends MockInstance<T> {}
+
+    export const spyOn: {
+      <
+        T extends object,
+        K_2 extends Exclude<
+          keyof T,
+          | keyof {
+              [K in keyof T as Required<T>[K] extends ClassLike ? K : never]: T[K];
+            }
+          | keyof {
+              [K_1 in keyof T as Required<T>[K_1] extends FunctionLike ? K_1 : never]: T[K_1];
+            }
+        >,
+        V extends Required<T>[K_2],
+        A extends "set" | "get",
+      >(
+        object: T,
+        methodKey: K_2,
+        accessType: A,
+      ): A extends "get" ? SpiedGetter<V> : A extends "set" ? SpiedSetter<V> : never;
+      <
+        T_1 extends object,
+        K_5 extends
+          | keyof {
+              [K_3 in keyof T_1 as Required<T_1>[K_3] extends ClassLike ? K_3 : never]: T_1[K_3];
+            }
+          | keyof {
+              [K_4 in keyof T_1 as Required<T_1>[K_4] extends FunctionLike ? K_4 : never]: T_1[K_4];
+            },
+        V_1 extends Required<T_1>[K_5],
+      >(
+        object: T_1,
+        methodKey: K_5,
+      ): V_1 extends ClassLike | FunctionLike ? Spied<V_1> : never;
+    };
+
+    export interface UnknownClass {
+      new (...args: unknown[]): unknown;
+    }
+
+    export type UnknownFunction = (...args: unknown[]) => unknown;
   }
-
-  export type UnknownFunction = (...args: unknown[]) => unknown;
 }