@storybook/test 0.0.0-pr-24225-sha-d42b137f → 0.0.0-pr-23888-sha-39ed28da

package/dist/index.d.ts

@@ -1,10 +1,496 @@
-import { AsymmetricMatchersContaining, MatchersObject, MatcherState, JestAssertion, ExpectStatic } from '@vitest/expect';
 import { TestingLibraryMatchers } from '@testing-library/jest-dom/types/matchers';
-export * from '@vitest/spy';
 import * as _testing_library_user_event_dist_types_setup_directApi from '@testing-library/user-event/dist/types/setup/directApi';
 import * as _testing_library_user_event_dist_types_setup_setup from '@testing-library/user-event/dist/types/setup/setup';
 import * as domTestingLibrary from '@testing-library/dom';
 
+interface Constructable$1 {
+    new (...args: any[]): any;
+}
+
+declare const Modifier: unique symbol;
+declare const Hint: unique symbol;
+declare const Kind: unique symbol;
+type Evaluate<T> = T extends infer O ? {
+    [K in keyof O]: O[K];
+} : never;
+type TReadonly<T extends TSchema> = T & {
+    [Modifier]: 'Readonly';
+};
+type TOptional<T extends TSchema> = T & {
+    [Modifier]: 'Optional';
+};
+type TReadonlyOptional<T extends TSchema> = T & {
+    [Modifier]: 'ReadonlyOptional';
+};
+interface SchemaOptions {
+    $schema?: string;
+    /** Id for this schema */
+    $id?: string;
+    /** Title of this schema */
+    title?: string;
+    /** Description of this schema */
+    description?: string;
+    /** Default value for this schema */
+    default?: any;
+    /** Example values matching this schema */
+    examples?: any;
+    [prop: string]: any;
+}
+interface TKind {
+    [Kind]: string;
+}
+interface TSchema extends SchemaOptions, TKind {
+    [Modifier]?: string;
+    [Hint]?: string;
+    params: unknown[];
+    static: unknown;
+}
+interface NumericOptions<N extends number | bigint> extends SchemaOptions {
+    exclusiveMaximum?: N;
+    exclusiveMinimum?: N;
+    maximum?: N;
+    minimum?: N;
+    multipleOf?: N;
+}
+interface TBoolean extends TSchema {
+    [Kind]: 'Boolean';
+    static: boolean;
+    type: 'boolean';
+}
+interface TNull extends TSchema {
+    [Kind]: 'Null';
+    static: null;
+    type: 'null';
+}
+interface TNumber extends TSchema, NumericOptions<number> {
+    [Kind]: 'Number';
+    static: number;
+    type: 'number';
+}
+type ReadonlyOptionalPropertyKeys<T extends TProperties> = {
+    [K in keyof T]: T[K] extends TReadonlyOptional<TSchema> ? K : never;
+}[keyof T];
+type ReadonlyPropertyKeys<T extends TProperties> = {
+    [K in keyof T]: T[K] extends TReadonly<TSchema> ? K : never;
+}[keyof T];
+type OptionalPropertyKeys<T extends TProperties> = {
+    [K in keyof T]: T[K] extends TOptional<TSchema> ? K : never;
+}[keyof T];
+type RequiredPropertyKeys<T extends TProperties> = keyof Omit<T, ReadonlyOptionalPropertyKeys<T> | ReadonlyPropertyKeys<T> | OptionalPropertyKeys<T>>;
+type PropertiesReducer<T extends TProperties, R extends Record<keyof any, unknown>> = Evaluate<(Readonly<Partial<Pick<R, ReadonlyOptionalPropertyKeys<T>>>> & Readonly<Pick<R, ReadonlyPropertyKeys<T>>> & Partial<Pick<R, OptionalPropertyKeys<T>>> & Required<Pick<R, RequiredPropertyKeys<T>>>)>;
+type PropertiesReduce<T extends TProperties, P extends unknown[]> = PropertiesReducer<T, {
+    [K in keyof T]: Static<T[K], P>;
+}>;
+type TProperties = Record<keyof any, TSchema>;
+type TAdditionalProperties = undefined | TSchema | boolean;
+interface ObjectOptions extends SchemaOptions {
+    additionalProperties?: TAdditionalProperties;
+    minProperties?: number;
+    maxProperties?: number;
+}
+interface TObject<T extends TProperties = TProperties> extends TSchema, ObjectOptions {
+    [Kind]: 'Object';
+    static: PropertiesReduce<T, this['params']>;
+    additionalProperties?: TAdditionalProperties;
+    type: 'object';
+    properties: T;
+    required?: string[];
+}
+interface StringOptions<Format extends string> extends SchemaOptions {
+    minLength?: number;
+    maxLength?: number;
+    pattern?: string;
+    format?: Format;
+    contentEncoding?: '7bit' | '8bit' | 'binary' | 'quoted-printable' | 'base64';
+    contentMediaType?: string;
+}
+interface TString<Format extends string = string> extends TSchema, StringOptions<Format> {
+    [Kind]: 'String';
+    static: string;
+    type: 'string';
+}
+/** Creates a TypeScript static type from a TypeBox type */
+type Static<T extends TSchema, P extends unknown[] = []> = (T & {
+    params: P;
+})['static'];
+
+/**
+ * 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.
+ */
+
+
+declare const RawSnapshotFormat: TObject<{
+  callToJSON: TReadonlyOptional<TBoolean>;
+  compareKeys: TReadonlyOptional<TNull>;
+  escapeRegex: TReadonlyOptional<TBoolean>;
+  escapeString: TReadonlyOptional<TBoolean>;
+  highlight: TReadonlyOptional<TBoolean>;
+  indent: TReadonlyOptional<TNumber>;
+  maxDepth: TReadonlyOptional<TNumber>;
+  maxWidth: TReadonlyOptional<TNumber>;
+  min: TReadonlyOptional<TBoolean>;
+  printBasicPrototype: TReadonlyOptional<TBoolean>;
+  printFunctionName: TReadonlyOptional<TBoolean>;
+  theme: TReadonlyOptional<
+    TObject<{
+      comment: TReadonlyOptional<TString<string>>;
+      content: TReadonlyOptional<TString<string>>;
+      prop: TReadonlyOptional<TString<string>>;
+      tag: TReadonlyOptional<TString<string>>;
+      value: TReadonlyOptional<TString<string>>;
+    }>
+  >;
+}>;
+
+declare const SnapshotFormat: TObject<{
+  callToJSON: TReadonlyOptional<TBoolean>;
+  compareKeys: TReadonlyOptional<TNull>;
+  escapeRegex: TReadonlyOptional<TBoolean>;
+  escapeString: TReadonlyOptional<TBoolean>;
+  highlight: TReadonlyOptional<TBoolean>;
+  indent: TReadonlyOptional<TNumber>;
+  maxDepth: TReadonlyOptional<TNumber>;
+  maxWidth: TReadonlyOptional<TNumber>;
+  min: TReadonlyOptional<TBoolean>;
+  printBasicPrototype: TReadonlyOptional<TBoolean>;
+  printFunctionName: TReadonlyOptional<TBoolean>;
+  theme: TReadonlyOptional<
+    TObject<{
+      comment: TReadonlyOptional<TString<string>>;
+      content: TReadonlyOptional<TString<string>>;
+      prop: TReadonlyOptional<TString<string>>;
+      tag: TReadonlyOptional<TString<string>>;
+      value: TReadonlyOptional<TString<string>>;
+    }>
+  >;
+}>;
+
+declare type SnapshotFormat = Static<typeof RawSnapshotFormat>;
+
+/**
+ * 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.
+ */
+
+
+declare type Colors = {
+  comment: {
+    close: string;
+    open: string;
+  };
+  content: {
+    close: string;
+    open: string;
+  };
+  prop: {
+    close: string;
+    open: string;
+  };
+  tag: {
+    close: string;
+    open: string;
+  };
+  value: {
+    close: string;
+    open: string;
+  };
+};
+
+declare type CompareKeys =
+  | ((a: string, b: string) => number)
+  | null
+  | undefined;
+
+declare type Config = {
+  callToJSON: boolean;
+  compareKeys: CompareKeys;
+  colors: Colors;
+  escapeRegex: boolean;
+  escapeString: boolean;
+  indent: string;
+  maxDepth: number;
+  maxWidth: number;
+  min: boolean;
+  plugins: Plugins;
+  printBasicPrototype: boolean;
+  printFunctionName: boolean;
+  spacingInner: string;
+  spacingOuter: string;
+};
+
+declare type Indent = (arg0: string) => string;
+
+declare type NewPlugin = {
+  serialize: (
+    val: any,
+    config: Config,
+    indentation: string,
+    depth: number,
+    refs: Refs,
+    printer: Printer,
+  ) => string;
+  test: Test;
+};
+
+declare type OldPlugin = {
+  print: (
+    val: unknown,
+    print: Print,
+    indent: Indent,
+    options: PluginOptions,
+    colors: Colors,
+  ) => string;
+  test: Test;
+};
+
+declare type Plugin_2 = NewPlugin | OldPlugin;
+
+
+declare type PluginOptions = {
+  edgeSpacing: string;
+  min: boolean;
+  spacing: string;
+};
+
+declare type Plugins = Array<Plugin_2>;
+
+declare interface PrettyFormatOptions
+  extends Omit<SnapshotFormat, 'compareKeys'> {
+  compareKeys?: CompareKeys;
+  plugins?: Plugins;
+}
+
+declare type Print = (arg0: unknown) => string;
+
+declare type Printer = (
+  val: unknown,
+  config: Config,
+  indentation: string,
+  depth: number,
+  refs: Refs,
+  hasCalledToJSON?: boolean,
+) => string;
+
+declare type Refs = Array<unknown>;
+
+declare type Test = (arg0: any) => boolean;
+
+declare function stringify(object: unknown, maxDepth?: number, { maxLength, ...options }?: PrettyFormatOptions & {
+    maxLength?: number;
+}): string;
+
+/**
+ * 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.
+ */
+
+type DiffOptionsColor = (arg: string) => string;
+interface DiffOptions {
+    aAnnotation?: string;
+    aColor?: DiffOptionsColor;
+    aIndicator?: string;
+    bAnnotation?: string;
+    bColor?: DiffOptionsColor;
+    bIndicator?: string;
+    changeColor?: DiffOptionsColor;
+    changeLineTrailingSpaceColor?: DiffOptionsColor;
+    commonColor?: DiffOptionsColor;
+    commonIndicator?: string;
+    commonLineTrailingSpaceColor?: DiffOptionsColor;
+    contextLines?: number;
+    emptyFirstOrLastLinePlaceholder?: string;
+    expand?: boolean;
+    includeChangeCounts?: boolean;
+    omitAnnotationLines?: boolean;
+    patchColor?: DiffOptionsColor;
+    compareKeys?: CompareKeys;
+}
+
+/**
+ * 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.
+*/
+
+/**
+ * @param a Expected value
+ * @param b Received value
+ * @param options Diff options
+ * @returns
+ */
+declare function diff(a: any, b: any, options?: DiffOptions): string | null;
+
+type Formatter = (input: string | number | null | undefined) => string;
+
+declare function getMatcherUtils(): {
+    EXPECTED_COLOR: {
+        (input: unknown): string;
+        open: string;
+        close: string;
+    };
+    RECEIVED_COLOR: {
+        (input: unknown): string;
+        open: string;
+        close: string;
+    };
+    INVERTED_COLOR: {
+        (input: unknown): string;
+        open: string;
+        close: string;
+    };
+    BOLD_WEIGHT: {
+        (input: unknown): string;
+        open: string;
+        close: string;
+    };
+    DIM_COLOR: {
+        (input: unknown): string;
+        open: string;
+        close: string;
+    };
+    matcherHint: (matcherName: string, received?: string, expected?: string, options?: MatcherHintOptions) => string;
+    printReceived: (object: unknown) => string;
+    printExpected: (value: unknown) => string;
+};
+type Tester = (a: any, b: any) => boolean | undefined;
+
+interface MatcherHintOptions {
+    comment?: string;
+    expectedColor?: Formatter;
+    isDirectExpectCall?: boolean;
+    isNot?: boolean;
+    promise?: string;
+    receivedColor?: Formatter;
+    secondArgument?: string;
+    secondArgumentColor?: Formatter;
+}
+interface MatcherState {
+    assertionCalls: number;
+    currentTestName?: string;
+    dontThrow?: () => void;
+    error?: Error;
+    equals: (a: unknown, b: unknown, customTesters?: Array<Tester>, strictCheck?: boolean) => boolean;
+    expand?: boolean;
+    expectedAssertionsNumber?: number | null;
+    expectedAssertionsNumberErrorGen?: (() => Error) | null;
+    isExpectingAssertions?: boolean;
+    isExpectingAssertionsError?: Error | null;
+    isNot: boolean;
+    promise: string;
+    suppressedErrors: Array<Error>;
+    testPath?: string;
+    utils: ReturnType<typeof getMatcherUtils> & {
+        diff: typeof diff;
+        stringify: typeof stringify;
+        iterableEquality: Tester;
+        subsetEquality: Tester;
+    };
+    soft?: boolean;
+}
+interface SyncExpectationResult {
+    pass: boolean;
+    message: () => string;
+    actual?: any;
+    expected?: any;
+}
+type AsyncExpectationResult = Promise<SyncExpectationResult>;
+type ExpectationResult = SyncExpectationResult | AsyncExpectationResult;
+interface RawMatcherFn<T extends MatcherState = MatcherState> {
+    (this: T, received: any, expected: any, options?: any): ExpectationResult;
+}
+type MatchersObject<T extends MatcherState = MatcherState> = Record<string, RawMatcherFn<T>>;
+interface ExpectStatic extends Chai.ExpectStatic, AsymmetricMatchersContaining {
+    <T>(actual: T, message?: string): Assertion$1<T>;
+    unreachable(message?: string): never;
+    soft<T>(actual: T, message?: string): Assertion$1<T>;
+    extend(expects: MatchersObject): void;
+    assertions(expected: number): void;
+    hasAssertions(): void;
+    anything(): any;
+    any(constructor: unknown): any;
+    getState(): MatcherState;
+    setState(state: Partial<MatcherState>): void;
+    not: AsymmetricMatchersContaining;
+}
+interface AsymmetricMatchersContaining {
+    stringContaining(expected: string): any;
+    objectContaining<T = any>(expected: T): any;
+    arrayContaining<T = unknown>(expected: Array<T>): any;
+    stringMatching(expected: string | RegExp): any;
+}
+interface JestAssertion<T = any> extends jest.Matchers<void, T> {
+    toEqual<E>(expected: E): void;
+    toStrictEqual<E>(expected: E): void;
+    toBe<E>(expected: E): void;
+    toMatch(expected: string | RegExp): void;
+    toMatchObject<E extends {} | any[]>(expected: E): void;
+    toContain<E>(item: E): void;
+    toContainEqual<E>(item: E): void;
+    toBeTruthy(): void;
+    toBeFalsy(): void;
+    toBeGreaterThan(num: number | bigint): void;
+    toBeGreaterThanOrEqual(num: number | bigint): void;
+    toBeLessThan(num: number | bigint): void;
+    toBeLessThanOrEqual(num: number | bigint): void;
+    toBeNaN(): void;
+    toBeUndefined(): void;
+    toBeNull(): void;
+    toBeDefined(): void;
+    toBeInstanceOf<E>(expected: E): void;
+    toBeCalledTimes(times: number): void;
+    toHaveLength(length: number): void;
+    toHaveProperty<E>(property: string | (string | number)[], value?: E): void;
+    toBeCloseTo(number: number, numDigits?: number): void;
+    toHaveBeenCalledTimes(times: number): void;
+    toHaveBeenCalled(): void;
+    toBeCalled(): void;
+    toHaveBeenCalledWith<E extends any[]>(...args: E): void;
+    toBeCalledWith<E extends any[]>(...args: E): void;
+    toHaveBeenNthCalledWith<E extends any[]>(n: number, ...args: E): void;
+    nthCalledWith<E extends any[]>(nthCall: number, ...args: E): void;
+    toHaveBeenLastCalledWith<E extends any[]>(...args: E): void;
+    lastCalledWith<E extends any[]>(...args: E): void;
+    toThrow(expected?: string | Constructable$1 | RegExp | Error): void;
+    toThrowError(expected?: string | Constructable$1 | RegExp | Error): void;
+    toReturn(): void;
+    toHaveReturned(): void;
+    toReturnTimes(times: number): void;
+    toHaveReturnedTimes(times: number): void;
+    toReturnWith<E>(value: E): void;
+    toHaveReturnedWith<E>(value: E): void;
+    toHaveLastReturnedWith<E>(value: E): void;
+    lastReturnedWith<E>(value: E): void;
+    toHaveNthReturnedWith<E>(nthCall: number, value: E): void;
+    nthReturnedWith<E>(nthCall: number, value: E): void;
+}
+type VitestAssertion<A, T> = {
+    [K in keyof A]: A[K] extends Chai.Assertion ? Assertion$1<T> : A[K] extends (...args: any[]) => any ? A[K] : VitestAssertion<A[K], T>;
+} & ((type: string, message?: string) => Assertion$1);
+type Promisify$1<O> = {
+    [K in keyof O]: O[K] extends (...args: infer A) => infer R ? O extends R ? Promisify$1<O[K]> : (...args: A) => Promise<R> : O[K];
+};
+interface Assertion$1<T = any> extends VitestAssertion<Chai.Assertion, T>, JestAssertion<T> {
+    toBeTypeOf(expected: 'bigint' | 'boolean' | 'function' | 'number' | 'object' | 'string' | 'symbol' | 'undefined'): void;
+    toHaveBeenCalledOnce(): void;
+    toSatisfy<E>(matcher: (value: E) => boolean, message?: string): void;
+    resolves: Promisify$1<Assertion$1<T>>;
+    rejects: Promisify$1<Assertion$1<T>>;
+}
+declare global {
+    namespace jest {
+        interface Matchers<R, T = {}> {
+        }
+    }
+}
+
 type Promisify<Fn> = Fn extends (...args: infer A) => infer R ? (...args: A) => R extends Promise<any> ? R : Promise<R> : Fn;
 type PromisifyObject<O> = {
     [K in keyof O]: Promisify<O[K]>;
@@ -31,6 +517,136 @@ interface Expect extends AsymmetricMatchersContaining {
     not: AsymmetricMatchersContaining;
 }
 
+declare const S: unique symbol;
+declare type ReturnError = ['error', any];
+declare type ReturnOk<R> = ['ok', R];
+declare type ResultFn<R> = ReturnError | ReturnOk<R>;
+interface SpyInternal<A extends any[] = any[], R = any> {
+    (this: any, ...args: A): R;
+    [S]: SpyInternalState<A, R>;
+}
+interface SpyInternalImpl<A extends any[] = any[], R = any> extends SpyInternal<A, R> {
+    [S]: SpyInternalImplState<A, R>;
+}
+interface SpyInternalState<A extends any[] = any[], R = any> {
+    called: boolean;
+    callCount: number;
+    calls: A[];
+    results: ResultFn<R>[];
+    reset(): void;
+    impl: ((...args: A) => R) | undefined;
+    next: ResultFn<R> | null;
+}
+interface SpyInternalImplState<A extends any[] = any[], R = any> extends SpyInternalState<A, R> {
+    getOriginal(): (...args: A) => R;
+    willCall(cb: (...args: A) => R): this;
+    restore(): void;
+}
+
+interface MockResultReturn<T> {
+    type: 'return';
+    value: T;
+}
+interface MockResultIncomplete {
+    type: 'incomplete';
+    value: undefined;
+}
+interface MockResultThrow {
+    type: 'throw';
+    value: any;
+}
+type MockResult<T> = MockResultReturn<T> | MockResultThrow | MockResultIncomplete;
+interface MockContext<TArgs, TReturns> {
+    calls: TArgs[];
+    instances: TReturns[];
+    invocationCallOrder: number[];
+    results: MockResult<TReturns>[];
+    lastCall: TArgs | undefined;
+}
+type Procedure = (...args: any[]) => any;
+type Methods<T> = {
+    [K in keyof T]: T[K] extends Procedure ? K : never;
+}[keyof T] & (string | symbol);
+type Properties<T> = {
+    [K in keyof T]: T[K] extends Procedure ? never : K;
+}[keyof T] & (string | symbol);
+type Classes<T> = {
+    [K in keyof T]: T[K] extends new (...args: any[]) => any ? K : never;
+}[keyof T] & (string | symbol);
+interface SpyInstance<TArgs extends any[] = any[], TReturns = any> {
+    getMockName(): string;
+    mockName(n: string): this;
+    mock: MockContext<TArgs, TReturns>;
+    mockClear(): this;
+    mockReset(): this;
+    mockRestore(): void;
+    getMockImplementation(): ((...args: TArgs) => TReturns) | undefined;
+    mockImplementation(fn: ((...args: TArgs) => TReturns) | (() => Promise<TReturns>)): this;
+    mockImplementationOnce(fn: ((...args: TArgs) => TReturns) | (() => Promise<TReturns>)): this;
+    withImplementation<T>(fn: ((...args: TArgs) => TReturns), cb: () => T): T extends Promise<unknown> ? Promise<this> : this;
+    mockReturnThis(): this;
+    mockReturnValue(obj: TReturns): this;
+    mockReturnValueOnce(obj: TReturns): this;
+    mockResolvedValue(obj: Awaited<TReturns>): this;
+    mockResolvedValueOnce(obj: Awaited<TReturns>): this;
+    mockRejectedValue(obj: any): this;
+    mockRejectedValueOnce(obj: any): this;
+}
+interface MockInstance<A extends any[] = any[], R = any> extends SpyInstance<A, R> {
+}
+interface Mock<TArgs extends any[] = any, TReturns = any> extends SpyInstance<TArgs, TReturns> {
+    new (...args: TArgs): TReturns;
+    (...args: TArgs): TReturns;
+}
+interface PartialMock<TArgs extends any[] = any, TReturns = any> extends SpyInstance<TArgs, TReturns extends Promise<Awaited<TReturns>> ? Promise<Partial<Awaited<TReturns>>> : Partial<TReturns>> {
+    new (...args: TArgs): TReturns;
+    (...args: TArgs): TReturns;
+}
+type MaybeMockedConstructor<T> = T extends new (...args: Array<any>) => infer R ? Mock<ConstructorParameters<T>, R> : T;
+type MockedFunction<T extends Procedure> = Mock<Parameters<T>, ReturnType<T>> & {
+    [K in keyof T]: T[K];
+};
+type PartiallyMockedFunction<T extends Procedure> = PartialMock<Parameters<T>, ReturnType<T>> & {
+    [K in keyof T]: T[K];
+};
+type MockedFunctionDeep<T extends Procedure> = Mock<Parameters<T>, ReturnType<T>> & MockedObjectDeep<T>;
+type PartiallyMockedFunctionDeep<T extends Procedure> = PartialMock<Parameters<T>, ReturnType<T>> & MockedObjectDeep<T>;
+type MockedObject<T> = MaybeMockedConstructor<T> & {
+    [K in Methods<T>]: T[K] extends Procedure ? MockedFunction<T[K]> : T[K];
+} & {
+    [K in Properties<T>]: T[K];
+};
+type MockedObjectDeep<T> = MaybeMockedConstructor<T> & {
+    [K in Methods<T>]: T[K] extends Procedure ? MockedFunctionDeep<T[K]> : T[K];
+} & {
+    [K in Properties<T>]: MaybeMockedDeep<T[K]>;
+};
+type MaybeMockedDeep<T> = T extends Procedure ? MockedFunctionDeep<T> : T extends object ? MockedObjectDeep<T> : T;
+type MaybePartiallyMockedDeep<T> = T extends Procedure ? PartiallyMockedFunctionDeep<T> : T extends object ? MockedObjectDeep<T> : T;
+type MaybeMocked<T> = T extends Procedure ? MockedFunction<T> : T extends object ? MockedObject<T> : T;
+type MaybePartiallyMocked<T> = T extends Procedure ? PartiallyMockedFunction<T> : T extends object ? MockedObject<T> : T;
+interface Constructable {
+    new (...args: any[]): any;
+}
+type MockedClass<T extends Constructable> = MockInstance<T extends new (...args: infer P) => any ? P : never, InstanceType<T>> & {
+    prototype: T extends {
+        prototype: any;
+    } ? Mocked<T['prototype']> : never;
+} & T;
+type Mocked<T> = {
+    [P in keyof T]: T[P] extends (...args: infer Args) => infer Returns ? MockInstance<Args, Returns> : T[P] extends Constructable ? MockedClass<T[P]> : T[P];
+} & T;
+type EnhancedSpy<TArgs extends any[] = any[], TReturns = any> = SpyInstance<TArgs, TReturns> & SpyInternalImpl<TArgs, TReturns>;
+declare const spies: Set<SpyInstance<any[], any>>;
+declare function isMockFunction(fn: any): fn is EnhancedSpy;
+declare function spyOn<T, S extends Properties<Required<T>>>(obj: T, methodName: S, accessType: 'get'): SpyInstance<[], T[S]>;
+declare function spyOn<T, G extends Properties<Required<T>>>(obj: T, methodName: G, accessType: 'set'): SpyInstance<[T[G]], void>;
+declare function spyOn<T, M extends (Classes<Required<T>> | Methods<Required<T>>)>(obj: T, methodName: M): Required<T>[M] extends ({
+    new (...args: infer A): infer R;
+}) | ((...args: infer A) => infer R) ? SpyInstance<A, R> : never;
+declare function fn<TArgs extends any[] = any, R = any>(): Mock<TArgs, R>;
+declare function fn<TArgs extends any[] = any[], R = any>(implementation: (...args: TArgs) => R): Mock<TArgs, R>;
+
 declare const buildQueries: typeof domTestingLibrary.buildQueries;
 declare const configure: typeof domTestingLibrary.configure;
 declare const createEvent: domTestingLibrary.CreateObject & domTestingLibrary.CreateFunction;
@@ -125,4 +741,4 @@ declare const userEvent: {
 
 declare const expect: Expect;
 
-export { buildQueries, configure, createEvent, expect, findAllByAltText, findAllByDisplayValue, findAllByLabelText, findAllByPlaceholderText, findAllByRole, findAllByTestId, findAllByText, findAllByTitle, findByAltText, findByDisplayValue, findByLabelText, findByPlaceholderText, findByRole, findByTestId, findByText, findByTitle, fireEvent, getAllByAltText, getAllByDisplayValue, getAllByLabelText, getAllByPlaceholderText, getAllByRole, getAllByTestId, getAllByText, getAllByTitle, getByAltText, getByDisplayValue, getByLabelText, getByPlaceholderText, getByRole, getByTestId, getByText, getByTitle, getConfig, getDefaultNormalizer, getElementError, getNodeText, getQueriesForElement, getRoles, getSuggestedQuery, isInaccessible, logDOM, logRoles, prettyDOM, prettyFormat, queries, queryAllByAltText, queryAllByAttribute, queryAllByDisplayValue, queryAllByLabelText, queryAllByPlaceholderText, queryAllByRole, queryAllByTestId, queryAllByText, queryAllByTitle, queryByAltText, queryByAttribute, queryByDisplayValue, queryByLabelText, queryByPlaceholderText, queryByRole, queryByTestId, queryByText, queryByTitle, queryHelpers, screen, userEvent, waitFor, waitForElementToBeRemoved, within };
+export { EnhancedSpy, MaybeMocked, MaybeMockedConstructor, MaybeMockedDeep, MaybePartiallyMocked, MaybePartiallyMockedDeep, Mock, MockContext, MockInstance, Mocked, MockedClass, MockedFunction, MockedFunctionDeep, MockedObject, MockedObjectDeep, PartialMock, PartiallyMockedFunction, PartiallyMockedFunctionDeep, SpyInstance, buildQueries, configure, createEvent, expect, findAllByAltText, findAllByDisplayValue, findAllByLabelText, findAllByPlaceholderText, findAllByRole, findAllByTestId, findAllByText, findAllByTitle, findByAltText, findByDisplayValue, findByLabelText, findByPlaceholderText, findByRole, findByTestId, findByText, findByTitle, fireEvent, fn, getAllByAltText, getAllByDisplayValue, getAllByLabelText, getAllByPlaceholderText, getAllByRole, getAllByTestId, getAllByText, getAllByTitle, getByAltText, getByDisplayValue, getByLabelText, getByPlaceholderText, getByRole, getByTestId, getByText, getByTitle, getConfig, getDefaultNormalizer, getElementError, getNodeText, getQueriesForElement, getRoles, getSuggestedQuery, isInaccessible, isMockFunction, logDOM, logRoles, prettyDOM, prettyFormat, queries, queryAllByAltText, queryAllByAttribute, queryAllByDisplayValue, queryAllByLabelText, queryAllByPlaceholderText, queryAllByRole, queryAllByTestId, queryAllByText, queryAllByTitle, queryByAltText, queryByAttribute, queryByDisplayValue, queryByLabelText, queryByPlaceholderText, queryByRole, queryByTestId, queryByText, queryByTitle, queryHelpers, screen, spies, spyOn, userEvent, waitFor, waitForElementToBeRemoved, within };