claude-autopm 3.1.2 → 3.2.1

package/packages/plugin-cloud/node_modules/jest-mock/build/index.d.ts

@@ -1,406 +0,0 @@
-/**
- * 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 declare type ClassLike = {
-  new (...args: any): any;
-};
-
-export declare type ConstructorLikeKeys<T> = keyof {
-  [K in keyof T as Required<T>[K] extends ClassLike ? K : never]: T[K];
-};
-
-export declare const fn: <T extends FunctionLike = UnknownFunction>(
-  implementation?: T | undefined,
-) => Mock<T>;
-
-export declare type FunctionLike = (...args: any) => any;
-
-export declare type MethodLikeKeys<T> = keyof {
-  [K in keyof T as Required<T>[K] extends FunctionLike ? K : never]: T[K];
-};
-
-/**
- * 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 declare interface Mock<T extends FunctionLike = UnknownFunction>
-  extends Function,
-    MockInstance<T> {
-  new (...args: Parameters<T>): ReturnType<T>;
-  (...args: Parameters<T>): ReturnType<T>;
-}
-
-export declare type Mocked<T> = T extends ClassLike
-  ? MockedClass<T>
-  : T extends FunctionLike
-  ? MockedFunction<T>
-  : T extends object
-  ? MockedObject<T>
-  : T;
-
-export declare 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 declare type MockedClass<T extends ClassLike> = MockInstance<
-  (...args: ConstructorParameters<T>) => Mocked<InstanceType<T>>
-> &
-  MockedObject<T>;
-
-export declare type MockedFunction<T extends FunctionLike> = MockInstance<T> &
-  MockedObject<T>;
-
-declare type MockedFunctionShallow<T extends FunctionLike> = MockInstance<T> &
-  T;
-
-export declare 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;
-
-declare 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 declare type MockedShallow<T> = T extends ClassLike
-  ? MockedClass<T>
-  : T extends FunctionLike
-  ? MockedFunctionShallow<T>
-  : T extends object
-  ? MockedObjectShallow<T>
-  : T;
-
-export declare type MockFunctionMetadata<
-  T = unknown,
-  MetadataType = MockMetadataType,
-> = MockMetadata<T, MetadataType>;
-
-export declare type MockFunctionMetadataType = MockMetadataType;
-
-declare type MockFunctionResult<T extends FunctionLike = UnknownFunction> =
-  | MockFunctionResultIncomplete
-  | MockFunctionResultReturn<T>
-  | MockFunctionResultThrow;
-
-declare 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;
-};
-
-declare type MockFunctionResultReturn<
-  T extends FunctionLike = UnknownFunction,
-> = {
-  type: 'return';
-  /**
-   * Result of a single call to a mock function that returned.
-   */
-  value: ReturnType<T>;
-};
-
-declare type MockFunctionResultThrow = {
-  type: 'throw';
-  /**
-   * Result of a single call to a mock function that threw.
-   */
-  value: unknown;
-};
-
-declare 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>>;
-};
-
-export declare 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 declare 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 declare type MockMetadataType =
-  | 'object'
-  | 'array'
-  | 'regexp'
-  | 'function'
-  | 'constant'
-  | 'collection'
-  | 'null'
-  | 'undefined';
-
-export declare 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>;
-  spyOn<
-    T extends object,
-    K extends PropertyLikeKeys<T>,
-    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;
-  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 keyof T>(
-    object: T,
-    propertyKey: K,
-    value: T[K],
-  ): 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 declare type PropertyLikeKeys<T> = Exclude<
-  keyof T,
-  ConstructorLikeKeys<T> | MethodLikeKeys<T>
->;
-
-declare type RejectType<T extends FunctionLike> =
-  ReturnType<T> extends PromiseLike<any> ? unknown : never;
-
-export declare 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 declare const replaceProperty: <T extends object, K extends keyof T>(
-  object: T,
-  propertyKey: K,
-  value: T[K],
-) => Replaced<T[K]>;
-
-declare type ResolveType<T extends FunctionLike> =
-  ReturnType<T> extends PromiseLike<infer U> ? U : never;
-
-export declare type Spied<T extends ClassLike | FunctionLike> =
-  T extends ClassLike
-    ? SpiedClass<T>
-    : T extends FunctionLike
-    ? SpiedFunction<T>
-    : never;
-
-export declare type SpiedClass<T extends ClassLike = UnknownClass> =
-  MockInstance<(...args: ConstructorParameters<T>) => InstanceType<T>>;
-
-export declare type SpiedFunction<T extends FunctionLike = UnknownFunction> =
-  MockInstance<(...args: Parameters<T>) => ReturnType<T>>;
-
-export declare type SpiedGetter<T> = MockInstance<() => T>;
-
-export declare type SpiedSetter<T> = MockInstance<(arg: T) => void>;
-
-export declare interface SpyInstance<T extends FunctionLike = UnknownFunction>
-  extends MockInstance<T> {}
-
-export declare 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 declare type UnknownClass = {
-  new (...args: Array<unknown>): unknown;
-};
-
-export declare type UnknownFunction = (...args: Array<unknown>) => unknown;
-
-export {};