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

package/dist/index.d.ts

@@ -1,13 +1,499 @@
-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> = {
-    -readonly [K in keyof O]: Promisify<O[K]>;
+    [K in keyof O]: Promisify<O[K]>;
 };
 
 interface Assertion<T> extends PromisifyObject<JestAssertion<T>>, TestingLibraryMatchers<ReturnType<ExpectStatic['stringContaining']>, Promise<void>> {
@@ -31,81 +517,206 @@ interface Expect extends AsymmetricMatchersContaining {
     not: AsymmetricMatchersContaining;
 }
 
-declare const buildQueries: (queryAllBy: domTestingLibrary.GetAllBy<any[]>, getMultipleError: domTestingLibrary.GetErrorFunction<any[]>, getMissingError: domTestingLibrary.GetErrorFunction<any[]>) => Promise<domTestingLibrary.BuiltQueryMethods<any[]>>;
-declare const configure: (configDelta: domTestingLibrary.ConfigFn | Partial<domTestingLibrary.Config>) => Promise<void>;
-declare const createEvent: (eventName: string, node: Element | Node | Document | Window, init?: {} | undefined, options?: {
-    EventType?: string | undefined;
-    defaultInit?: {} | undefined;
-} | undefined) => Promise<Event>;
+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;
 declare const fireEvent: ((element: Element | Node | Document | Window, event: Event) => Promise<false> | Promise<true>) & PromisifyObject<domTestingLibrary.FireObject>;
-declare const findAllByAltText: (container: HTMLElement, id: domTestingLibrary.Matcher, options?: domTestingLibrary.MatcherOptions | undefined, waitForElementOptions?: domTestingLibrary.waitForOptions | undefined) => Promise<HTMLElement[]>;
-declare const findAllByDisplayValue: (container: HTMLElement, id: domTestingLibrary.Matcher, options?: domTestingLibrary.MatcherOptions | undefined, waitForElementOptions?: domTestingLibrary.waitForOptions | undefined) => Promise<HTMLElement[]>;
-declare const findAllByLabelText: (container: HTMLElement, id: domTestingLibrary.Matcher, options?: domTestingLibrary.SelectorMatcherOptions | undefined, waitForElementOptions?: domTestingLibrary.waitForOptions | undefined) => Promise<HTMLElement[]>;
-declare const findAllByPlaceholderText: (container: HTMLElement, id: domTestingLibrary.Matcher, options?: domTestingLibrary.MatcherOptions | undefined, waitForElementOptions?: domTestingLibrary.waitForOptions | undefined) => Promise<HTMLElement[]>;
-declare const findAllByRole: (container: HTMLElement, role: domTestingLibrary.ByRoleMatcher, options?: domTestingLibrary.ByRoleOptions | undefined, waitForElementOptions?: domTestingLibrary.waitForOptions | undefined) => Promise<HTMLElement[]>;
-declare const findAllByTestId: (container: HTMLElement, id: domTestingLibrary.Matcher, options?: domTestingLibrary.MatcherOptions | undefined, waitForElementOptions?: domTestingLibrary.waitForOptions | undefined) => Promise<HTMLElement[]>;
-declare const findAllByText: (container: HTMLElement, id: domTestingLibrary.Matcher, options?: domTestingLibrary.SelectorMatcherOptions | undefined, waitForElementOptions?: domTestingLibrary.waitForOptions | undefined) => Promise<HTMLElement[]>;
-declare const findAllByTitle: (container: HTMLElement, id: domTestingLibrary.Matcher, options?: domTestingLibrary.MatcherOptions | undefined, waitForElementOptions?: domTestingLibrary.waitForOptions | undefined) => Promise<HTMLElement[]>;
-declare const findByAltText: (container: HTMLElement, id: domTestingLibrary.Matcher, options?: domTestingLibrary.MatcherOptions | undefined, waitForElementOptions?: domTestingLibrary.waitForOptions | undefined) => Promise<HTMLElement>;
-declare const findByDisplayValue: (container: HTMLElement, id: domTestingLibrary.Matcher, options?: domTestingLibrary.MatcherOptions | undefined, waitForElementOptions?: domTestingLibrary.waitForOptions | undefined) => Promise<HTMLElement>;
-declare const findByLabelText: (container: HTMLElement, id: domTestingLibrary.Matcher, options?: domTestingLibrary.SelectorMatcherOptions | undefined, waitForElementOptions?: domTestingLibrary.waitForOptions | undefined) => Promise<HTMLElement>;
-declare const findByPlaceholderText: (container: HTMLElement, id: domTestingLibrary.Matcher, options?: domTestingLibrary.MatcherOptions | undefined, waitForElementOptions?: domTestingLibrary.waitForOptions | undefined) => Promise<HTMLElement>;
-declare const findByRole: (container: HTMLElement, role: domTestingLibrary.ByRoleMatcher, options?: domTestingLibrary.ByRoleOptions | undefined, waitForElementOptions?: domTestingLibrary.waitForOptions | undefined) => Promise<HTMLElement>;
-declare const findByTestId: (container: HTMLElement, id: domTestingLibrary.Matcher, options?: domTestingLibrary.MatcherOptions | undefined, waitForElementOptions?: domTestingLibrary.waitForOptions | undefined) => Promise<HTMLElement>;
-declare const findByText: (container: HTMLElement, id: domTestingLibrary.Matcher, options?: domTestingLibrary.SelectorMatcherOptions | undefined, waitForElementOptions?: domTestingLibrary.waitForOptions | undefined) => Promise<HTMLElement>;
-declare const findByTitle: (container: HTMLElement, id: domTestingLibrary.Matcher, options?: domTestingLibrary.MatcherOptions | undefined, waitForElementOptions?: domTestingLibrary.waitForOptions | undefined) => Promise<HTMLElement>;
-declare const getAllByAltText: (container: HTMLElement, id: domTestingLibrary.Matcher, options?: domTestingLibrary.MatcherOptions | undefined) => Promise<HTMLElement[]>;
-declare const getAllByDisplayValue: (container: HTMLElement, id: domTestingLibrary.Matcher, options?: domTestingLibrary.MatcherOptions | undefined) => Promise<HTMLElement[]>;
-declare const getAllByLabelText: (container: HTMLElement, id: domTestingLibrary.Matcher, options?: domTestingLibrary.SelectorMatcherOptions | undefined) => Promise<HTMLElement[]>;
-declare const getAllByPlaceholderText: (container: HTMLElement, id: domTestingLibrary.Matcher, options?: domTestingLibrary.MatcherOptions | undefined) => Promise<HTMLElement[]>;
-declare const getAllByRole: (container: HTMLElement, role: domTestingLibrary.ByRoleMatcher, options?: domTestingLibrary.ByRoleOptions | undefined) => Promise<HTMLElement[]>;
-declare const getAllByTestId: (container: HTMLElement, id: domTestingLibrary.Matcher, options?: domTestingLibrary.MatcherOptions | undefined) => Promise<HTMLElement[]>;
-declare const getAllByText: (container: HTMLElement, id: domTestingLibrary.Matcher, options?: domTestingLibrary.SelectorMatcherOptions | undefined) => Promise<HTMLElement[]>;
-declare const getAllByTitle: (container: HTMLElement, id: domTestingLibrary.Matcher, options?: domTestingLibrary.MatcherOptions | undefined) => Promise<HTMLElement[]>;
-declare const getByAltText: (container: HTMLElement, id: domTestingLibrary.Matcher, options?: domTestingLibrary.MatcherOptions | undefined) => Promise<HTMLElement>;
-declare const getByDisplayValue: (container: HTMLElement, id: domTestingLibrary.Matcher, options?: domTestingLibrary.MatcherOptions | undefined) => Promise<HTMLElement>;
-declare const getByLabelText: (container: HTMLElement, id: domTestingLibrary.Matcher, options?: domTestingLibrary.SelectorMatcherOptions | undefined) => Promise<HTMLElement>;
-declare const getByPlaceholderText: (container: HTMLElement, id: domTestingLibrary.Matcher, options?: domTestingLibrary.MatcherOptions | undefined) => Promise<HTMLElement>;
-declare const getByRole: (container: HTMLElement, role: domTestingLibrary.ByRoleMatcher, options?: domTestingLibrary.ByRoleOptions | undefined) => Promise<HTMLElement>;
-declare const getByTestId: (container: HTMLElement, id: domTestingLibrary.Matcher, options?: domTestingLibrary.MatcherOptions | undefined) => Promise<HTMLElement>;
-declare const getByText: (container: HTMLElement, id: domTestingLibrary.Matcher, options?: domTestingLibrary.SelectorMatcherOptions | undefined) => Promise<HTMLElement>;
-declare const getByTitle: (container: HTMLElement, id: domTestingLibrary.Matcher, options?: domTestingLibrary.MatcherOptions | undefined) => Promise<HTMLElement>;
-declare const getConfig: () => Promise<domTestingLibrary.Config>;
-declare const getDefaultNormalizer: (options?: domTestingLibrary.DefaultNormalizerOptions | undefined) => Promise<domTestingLibrary.NormalizerFn>;
-declare const getElementError: (message: string | null, container: HTMLElement) => Promise<Error>;
-declare const getNodeText: (node: HTMLElement) => Promise<string>;
+declare const findAllByAltText: typeof domTestingLibrary.findAllByAltText;
+declare const findAllByDisplayValue: typeof domTestingLibrary.findAllByDisplayValue;
+declare const findAllByLabelText: typeof domTestingLibrary.findAllByLabelText;
+declare const findAllByPlaceholderText: typeof domTestingLibrary.findAllByPlaceholderText;
+declare const findAllByRole: typeof domTestingLibrary.findAllByRole;
+declare const findAllByTestId: typeof domTestingLibrary.findAllByTestId;
+declare const findAllByText: typeof domTestingLibrary.findAllByText;
+declare const findAllByTitle: typeof domTestingLibrary.findAllByTitle;
+declare const findByAltText: typeof domTestingLibrary.findByAltText;
+declare const findByDisplayValue: typeof domTestingLibrary.findByDisplayValue;
+declare const findByLabelText: typeof domTestingLibrary.findByLabelText;
+declare const findByPlaceholderText: typeof domTestingLibrary.findByPlaceholderText;
+declare const findByRole: typeof domTestingLibrary.findByRole;
+declare const findByTestId: typeof domTestingLibrary.findByTestId;
+declare const findByText: typeof domTestingLibrary.findByText;
+declare const findByTitle: typeof domTestingLibrary.findByTitle;
+declare const getAllByAltText: typeof domTestingLibrary.getAllByAltText;
+declare const getAllByDisplayValue: typeof domTestingLibrary.getAllByDisplayValue;
+declare const getAllByLabelText: typeof domTestingLibrary.getAllByLabelText;
+declare const getAllByPlaceholderText: typeof domTestingLibrary.getAllByPlaceholderText;
+declare const getAllByRole: typeof domTestingLibrary.getAllByRole;
+declare const getAllByTestId: typeof domTestingLibrary.getAllByTestId;
+declare const getAllByText: typeof domTestingLibrary.getAllByText;
+declare const getAllByTitle: typeof domTestingLibrary.getAllByTitle;
+declare const getByAltText: typeof domTestingLibrary.getByAltText;
+declare const getByDisplayValue: typeof domTestingLibrary.getByDisplayValue;
+declare const getByLabelText: typeof domTestingLibrary.getByLabelText;
+declare const getByPlaceholderText: typeof domTestingLibrary.getByPlaceholderText;
+declare const getByRole: typeof domTestingLibrary.getByRole;
+declare const getByTestId: typeof domTestingLibrary.getByTestId;
+declare const getByText: typeof domTestingLibrary.getByText;
+declare const getByTitle: typeof domTestingLibrary.getByTitle;
+declare const getConfig: typeof domTestingLibrary.getConfig;
+declare const getDefaultNormalizer: typeof domTestingLibrary.getDefaultNormalizer;
+declare const getElementError: typeof domTestingLibrary.getElementError;
+declare const getNodeText: typeof domTestingLibrary.getNodeText;
 declare const getQueriesForElement: typeof domTestingLibrary.getQueriesForElement;
-declare const getRoles: (container: HTMLElement) => Promise<{
-    [index: string]: HTMLElement[];
-}>;
-declare const getSuggestedQuery: (element: HTMLElement, variant?: domTestingLibrary.Variant | undefined, method?: domTestingLibrary.Method | undefined) => Promise<undefined> | Promise<domTestingLibrary.Suggestion>;
-declare const isInaccessible: (element: Element) => Promise<false> | Promise<true>;
-declare const logDOM: (dom?: Element | HTMLDocument | undefined, maxLength?: number | undefined, options?: domTestingLibrary.PrettyDOMOptions | undefined) => Promise<void>;
-declare const logRoles: (container: HTMLElement) => Promise<string>;
-declare const prettyDOM: (dom?: Element | HTMLDocument | undefined, maxLength?: number | undefined, options?: domTestingLibrary.PrettyDOMOptions | undefined) => Promise<false> | Promise<string>;
+declare const getRoles: typeof domTestingLibrary.getRoles;
+declare const getSuggestedQuery: typeof domTestingLibrary.getSuggestedQuery;
+declare const isInaccessible: typeof domTestingLibrary.isInaccessible;
+declare const logDOM: typeof domTestingLibrary.logDOM;
+declare const logRoles: typeof domTestingLibrary.logRoles;
+declare const prettyDOM: typeof domTestingLibrary.prettyDOM;
 declare const queries: typeof domTestingLibrary.queries;
-declare const queryAllByAltText: (container: HTMLElement, id: domTestingLibrary.Matcher, options?: domTestingLibrary.MatcherOptions | undefined) => Promise<HTMLElement[]>;
-declare const queryAllByAttribute: (attribute: string, container: HTMLElement, id: domTestingLibrary.Matcher, options?: domTestingLibrary.MatcherOptions | undefined) => Promise<HTMLElement[]>;
-declare const queryAllByDisplayValue: (container: HTMLElement, id: domTestingLibrary.Matcher, options?: domTestingLibrary.MatcherOptions | undefined) => Promise<HTMLElement[]>;
-declare const queryAllByLabelText: (container: HTMLElement, id: domTestingLibrary.Matcher, options?: domTestingLibrary.SelectorMatcherOptions | undefined) => Promise<HTMLElement[]>;
-declare const queryAllByPlaceholderText: (container: HTMLElement, id: domTestingLibrary.Matcher, options?: domTestingLibrary.MatcherOptions | undefined) => Promise<HTMLElement[]>;
-declare const queryAllByRole: (container: HTMLElement, role: domTestingLibrary.ByRoleMatcher, options?: domTestingLibrary.ByRoleOptions | undefined) => Promise<HTMLElement[]>;
-declare const queryAllByTestId: (container: HTMLElement, id: domTestingLibrary.Matcher, options?: domTestingLibrary.MatcherOptions | undefined) => Promise<HTMLElement[]>;
-declare const queryAllByText: (container: HTMLElement, id: domTestingLibrary.Matcher, options?: domTestingLibrary.SelectorMatcherOptions | undefined) => Promise<HTMLElement[]>;
-declare const queryAllByTitle: (container: HTMLElement, id: domTestingLibrary.Matcher, options?: domTestingLibrary.MatcherOptions | undefined) => Promise<HTMLElement[]>;
-declare const queryByAltText: (container: HTMLElement, id: domTestingLibrary.Matcher, options?: domTestingLibrary.MatcherOptions | undefined) => Promise<HTMLElement> | Promise<null>;
-declare const queryByAttribute: (attribute: string, container: HTMLElement, id: domTestingLibrary.Matcher, options?: domTestingLibrary.MatcherOptions | undefined) => Promise<HTMLElement> | Promise<null>;
-declare const queryByDisplayValue: (container: HTMLElement, id: domTestingLibrary.Matcher, options?: domTestingLibrary.MatcherOptions | undefined) => Promise<HTMLElement> | Promise<null>;
-declare const queryByLabelText: (container: HTMLElement, id: domTestingLibrary.Matcher, options?: domTestingLibrary.SelectorMatcherOptions | undefined) => Promise<HTMLElement> | Promise<null>;
-declare const queryByPlaceholderText: (container: HTMLElement, id: domTestingLibrary.Matcher, options?: domTestingLibrary.MatcherOptions | undefined) => Promise<HTMLElement> | Promise<null>;
-declare const queryByRole: (container: HTMLElement, role: domTestingLibrary.ByRoleMatcher, options?: domTestingLibrary.ByRoleOptions | undefined) => Promise<HTMLElement> | Promise<null>;
-declare const queryByTestId: (container: HTMLElement, id: domTestingLibrary.Matcher, options?: domTestingLibrary.MatcherOptions | undefined) => Promise<HTMLElement> | Promise<null>;
-declare const queryByText: (container: HTMLElement, id: domTestingLibrary.Matcher, options?: domTestingLibrary.SelectorMatcherOptions | undefined) => Promise<HTMLElement> | Promise<null>;
-declare const queryByTitle: (container: HTMLElement, id: domTestingLibrary.Matcher, options?: domTestingLibrary.MatcherOptions | undefined) => Promise<HTMLElement> | Promise<null>;
+declare const queryAllByAltText: typeof domTestingLibrary.queryAllByAltText;
+declare const queryAllByAttribute: domTestingLibrary.AllByAttribute;
+declare const queryAllByDisplayValue: typeof domTestingLibrary.queryAllByDisplayValue;
+declare const queryAllByLabelText: typeof domTestingLibrary.queryAllByLabelText;
+declare const queryAllByPlaceholderText: typeof domTestingLibrary.queryAllByPlaceholderText;
+declare const queryAllByRole: typeof domTestingLibrary.queryAllByRole;
+declare const queryAllByTestId: typeof domTestingLibrary.queryAllByTestId;
+declare const queryAllByText: typeof domTestingLibrary.queryAllByText;
+declare const queryAllByTitle: typeof domTestingLibrary.queryAllByTitle;
+declare const queryByAltText: typeof domTestingLibrary.queryByAltText;
+declare const queryByAttribute: domTestingLibrary.QueryByAttribute;
+declare const queryByDisplayValue: typeof domTestingLibrary.queryByDisplayValue;
+declare const queryByLabelText: typeof domTestingLibrary.queryByLabelText;
+declare const queryByPlaceholderText: typeof domTestingLibrary.queryByPlaceholderText;
+declare const queryByRole: typeof domTestingLibrary.queryByRole;
+declare const queryByTestId: typeof domTestingLibrary.queryByTestId;
+declare const queryByText: typeof domTestingLibrary.queryByText;
+declare const queryByTitle: typeof domTestingLibrary.queryByTitle;
 declare const queryHelpers: typeof domTestingLibrary.queryHelpers;
 declare const screen: domTestingLibrary.Screen<typeof domTestingLibrary.queries>;
-declare const waitFor: (callback: () => unknown, options?: domTestingLibrary.waitForOptions | undefined) => Promise<unknown>;
-declare const waitForElementToBeRemoved: (callback: unknown, options?: domTestingLibrary.waitForOptions | undefined) => Promise<void>;
+declare const waitFor: typeof domTestingLibrary.waitFor;
+declare const waitForElementToBeRemoved: typeof domTestingLibrary.waitForElementToBeRemoved;
 declare const within: typeof domTestingLibrary.getQueriesForElement;
 declare const prettyFormat: typeof domTestingLibrary.prettyFormat;
 declare const userEvent: {
@@ -130,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 };