@voidzero-dev/vite-plus-test 0.1.9 → 0.1.10

package/dist/@vitest/browser-webdriverio/index.d.ts

@@ -1,6 +1,6 @@
 import { CustomComparatorsRegistry } from '../browser/index.js';
 export { defineBrowserCommand } from '../browser/index.js';
-import { ScreenshotMatcherOptions, ScreenshotComparatorRegistry } from '../browser/index.js';
+import { SelectorOptions, ScreenshotMatcherOptions, ScreenshotComparatorRegistry } from '../browser/index.js';
 import { BrowserProvider, TestProject, CDPSession, BrowserProviderOption } from '../../node.js';
 import { ClickOptions, MoveToOptions, DragAndDropOptions, remote } from 'webdriverio';
 
@@ -39,14 +39,27 @@ declare class WebdriverBrowserProvider implements BrowserProvider {
 	getCDPSession(_sessionId: string): Promise<CDPSession>;
 }
 declare module "vitest/browser" {
-	interface UserEventClickOptions extends Partial<ClickOptions> {}
-	interface UserEventHoverOptions extends MoveToOptions {}
+	interface UserEventClickOptions extends Partial<ClickOptions>, SelectorOptions {}
+	interface UserEventHoverOptions extends MoveToOptions, SelectorOptions {}
 	interface UserEventDragAndDropOptions extends DragAndDropOptions {
 		sourceX?: number;
 		sourceY?: number;
 		targetX?: number;
 		targetY?: number;
 	}
+	interface UserEventFillOptions extends SelectorOptions {}
+	interface UserEventSelectOptions extends SelectorOptions {}
+	interface UserEventClearOptions extends SelectorOptions {}
+	interface UserEventDoubleClickOptions extends SelectorOptions {}
+	interface UserEventTripleClickOptions extends SelectorOptions {}
+	interface UserEventWheelBaseOptions extends SelectorOptions {}
+	interface LocatorScreenshotOptions extends SelectorOptions {}
+}
+interface WebdriverCDPSession {
+	send: (method: string, params?: Record<string, unknown>) => Promise<unknown>;
+	on: (event: string, listener: (...args: unknown[]) => void) => void;
+	once: (event: string, listener: (...args: unknown[]) => void) => void;
+	off: (event: string, listener: (...args: unknown[]) => void) => void;
 }
 declare module "vitest/node" {
 	interface BrowserCommandContext {
@@ -57,6 +70,7 @@ declare module "vitest/node" {
 	}
 	interface ToMatchScreenshotOptions extends Omit<ScreenshotMatcherOptions, "comparatorName" | "comparatorOptions">, CustomComparatorsRegistry {}
 	interface ToMatchScreenshotComparators extends ScreenshotComparatorRegistry {}
+	interface CDPSession extends WebdriverCDPSession {}
 }
 
 export { WebdriverBrowserProvider, webdriverio };

package/dist/@vitest/browser-webdriverio/index.js

@@ -367,11 +367,29 @@ const viewport = async (context, options) => {
   await context.provider.setViewport(options);
 };
 
+const wheel = async (context, selector, options) => {
+  const browser = context.browser;
+  const times = options.times ?? 1;
+  const deltaX = options.delta.x ?? 0;
+  const deltaY = options.delta.y ?? 0;
+  let action = browser.action("wheel");
+  const wheelOptions = {
+    deltaX,
+    deltaY,
+    origin: browser.$(selector)
+  };
+  for (let count = 0; count < times; count += 1) {
+    action = action.scroll(wheelOptions);
+  }
+  await action.perform();
+};
+
 var commands = {
   __vitest_upload: upload,
   __vitest_click: click,
   __vitest_dblClick: dblClick,
   __vitest_tripleClick: tripleClick,
+  __vitest_wheel: wheel,
   __vitest_takeScreenshot: takeScreenshot,
   __vitest_type: type,
   __vitest_clear: clear,
@@ -538,8 +556,10 @@ class WebdriverBrowserProvider {
       const port = inspector.port || 9229;
       const host = inspector.host || "127.0.0.1";
       args.push(`--remote-debugging-port=${port}`);
-      args.push(`--remote-debugging-address=${host}`);
-      this.project.vitest.logger.log(`Debugger listening on ws://${host}:${port}`);
+      if (host !== "localhost" && host !== "127.0.0.1" && host !== "::1") {
+        this.project.vitest.logger.warn(`Custom inspector host "${host}" will be ignored. Chrome only allows remote debugging on localhost.`);
+      }
+      this.project.vitest.logger.log(`Debugger listening on ws://127.0.0.1:${port}`);
       capabilities[key] ??= {};
       capabilities[key].args = args;
     }

package/dist/@vitest/browser-webdriverio/locators.js

@@ -1,4 +1,4 @@
-import { selectorEngine, getByTitleSelector, getByTextSelector, getByPlaceholderSelector, getByAltTextSelector, getByTestIdSelector, getByRoleSelector, getByLabelSelector, Locator, convertElementToCssSelector, getIframeScale } from '../browser/locators.js';
+import { selectorEngine, getByTitleSelector, getByTextSelector, getByPlaceholderSelector, getByAltTextSelector, getByTestIdSelector, getByRoleSelector, getByLabelSelector, Locator, convertElementToCssSelector, ensureAwaited, triggerCommandWithTrace, getIframeScale } from '../browser/locators.js';
 import { page } from '../browser/context.js';
 import { utils } from '../browser/index.js';
 import { __INTERNAL } from '../../browser.js';
@@ -9,6 +9,12 @@ class WebdriverIOLocator extends Locator {
     this._pwSelector = _pwSelector;
     this._container = _container;
   }
+  // This exists to avoid calling `this.elements` in `this.selector`'s getter in interactive actions
+  withElement(element, error) {
+    const pwSelector = selectorEngine.generateSelectorSimple(element);
+    const cssSelector = convertElementToCssSelector(element);
+    return new ElementWebdriverIOLocator(cssSelector, error, pwSelector, element);
+  }
   get selector() {
     const selectors = this.elements().map((element) => convertElementToCssSelector(element));
     if (!selectors.length) {
@@ -25,24 +31,75 @@ class WebdriverIOLocator extends Locator {
     return (hasShadowRoot ? ">>>" : "") + newSelectors.join(", ");
   }
   click(options) {
-    return super.click(processClickOptions(options));
+    return ensureAwaited(async (error) => {
+      const element = await this.findElement(options);
+      return this.withElement(element, error).click(processClickOptions(options));
+    });
   }
   dblClick(options) {
-    return super.dblClick(processClickOptions(options));
+    return ensureAwaited(async (error) => {
+      const element = await this.findElement(options);
+      return this.withElement(element, error).dblClick(processClickOptions(options));
+    });
   }
   tripleClick(options) {
-    return super.tripleClick(processClickOptions(options));
+    return ensureAwaited(async (error) => {
+      const element = await this.findElement(options);
+      return this.withElement(element, error).tripleClick(processClickOptions(options));
+    });
   }
   selectOptions(value, options) {
-    const values = getWebdriverioSelectOptions(this.element(), value);
-    return this.triggerCommand("__vitest_selectOptions", this.selector, values, options);
+    return ensureAwaited(async (error) => {
+      const element = await this.findElement(options);
+      const values = getWebdriverioSelectOptions(element, value);
+      return triggerCommandWithTrace({
+        name: "__vitest_selectOptions",
+        arguments: [
+          convertElementToCssSelector(element),
+          values,
+          options
+        ],
+        errorSource: error
+      });
+    });
   }
   hover(options) {
-    return super.hover(processHoverOptions(options));
+    return ensureAwaited(async (error) => {
+      const element = await this.findElement(options);
+      return this.withElement(element, error).hover(processHoverOptions(options));
+    });
   }
   dropTo(target, options) {
+    // playwright doesn't enforce a single element, it selects the first one,
+    // so we just follow the behavior
     return super.dropTo(target, processDragAndDropOptions(options));
   }
+  wheel(options) {
+    return ensureAwaited(async (error) => {
+      const element = await this.findElement(options);
+      return this.withElement(element, error).wheel(options);
+    });
+  }
+  clear(options) {
+    return ensureAwaited(async (error) => {
+      const element = await this.findElement(options);
+      return this.withElement(element, error).clear(options);
+    });
+  }
+  fill(text, options) {
+    return ensureAwaited(async (error) => {
+      const element = await this.findElement(options);
+      return this.withElement(element, error).fill(text, options);
+    });
+  }
+  screenshot(options) {
+    return ensureAwaited(async (error) => {
+      const element = await this.findElement(options);
+      return this.withElement(element, error).screenshot(options);
+    });
+  }
+  // playwright doesn't enforce a single element in upload
+  // public override async upload(): Promise<void>
   locator(selector) {
     return new WebdriverIOLocator(`${this._pwSelector} >> ${selector}`, this._container);
   }
@@ -50,6 +107,26 @@ class WebdriverIOLocator extends Locator {
     return new WebdriverIOLocator(selectorEngine.generateSelectorSimple(element), element);
   }
 }
+const kElementLocator = Symbol.for("$$vitest:locator-resolved");
+class ElementWebdriverIOLocator extends Locator {
+  [kElementLocator] = true;
+  constructor(_cssSelector, _errorSource, _pwSelector, _container) {
+    super();
+    this._cssSelector = _cssSelector;
+    this._errorSource = _errorSource;
+    this._pwSelector = _pwSelector;
+    this._container = _container;
+  }
+  get selector() {
+    return this._cssSelector;
+  }
+  locator(_selector) {
+    throw new Error(`should not be called`);
+  }
+  elementLocator(_element) {
+    throw new Error(`should not be called`);
+  }
+}
 page.extend({
   getByLabelText(text, options) {
     return new WebdriverIOLocator(getByLabelSelector(text, options));

package/dist/@vitest/expect/index.d.ts

@@ -1,7 +1,6 @@
 /// <reference types="chai" />
 import { Test } from '../runner/index.js';
 import { MockInstance } from '../spy/index.js';
-import { Constructable } from '../utils/index.js';
 import { Formatter } from '../../vendor/tinyrainbow.mjs';
 import { StandardSchemaV1 } from '@standard-schema/spec';
 import { diff, printDiffOrStringify } from '../utils/diff.js';
@@ -10,11 +9,6 @@ import { stringify } from '../utils/display.js';
 import * as chai from '../../vendor/chai.mjs';
 export { chai };
 
-declare const MATCHERS_OBJECT: unique symbol;
-declare const JEST_MATCHERS_OBJECT: unique symbol;
-declare const GLOBAL_EXPECT: unique symbol;
-declare const ASYMMETRIC_MATCHERS_OBJECT: unique symbol;
-
 interface AsymmetricMatcherInterface {
 	asymmetricMatch: (other: unknown, customTesters?: Array<Tester>) => boolean;
 	toString: () => string;
@@ -132,9 +126,18 @@ interface MatcherState {
 	customTesters: Array<Tester>;
 	assertionCalls: number;
 	currentTestName?: string;
+	/**
+	* @deprecated exists only in types
+	*/
 	dontThrow?: () => void;
+	/**
+	* @deprecated exists only in types
+	*/
 	error?: Error;
 	equals: (a: unknown, b: unknown, customTesters?: Array<Tester>, strictCheck?: boolean) => boolean;
+	/**
+	* @deprecated exists only in types
+	*/
 	expand?: boolean;
 	expectedAssertionsNumber?: number | null;
 	expectedAssertionsNumberErrorGen?: (() => Error) | null;
@@ -142,6 +145,9 @@ interface MatcherState {
 	isExpectingAssertionsError?: Error | null;
 	isNot: boolean;
 	promise: string;
+	/**
+	* @deprecated exists only in types
+	*/
 	suppressedErrors: Array<Error>;
 	testPath?: string;
 	utils: ReturnType<typeof getMatcherUtils> & {
@@ -235,8 +241,6 @@ interface AsymmetricMatchersContaining extends CustomMatcher {
 	/**
 	* Matches if the received number is within a certain precision of the expected number.
 	*
-	* @param precision - Optional decimal precision for comparison. Default is 2.
-	*
 	* @example
 	* expect(10.45).toEqual(expect.closeTo(10.5, 1));
 	* expect(5.11).toEqual(expect.closeTo(5.12)); // with default precision
@@ -453,6 +457,7 @@ interface JestAssertion<T = any> extends jest.Matchers<void, T>, CustomMatcher {
 	*
 	* @example
 	* expect(mockFunc).toBeCalledTimes(2);
+	* @deprecated Use `toHaveBeenCalledTimes` instead
 	*/
 	toBeCalledTimes: (times: number) => void;
 	/**
@@ -471,6 +476,7 @@ interface JestAssertion<T = any> extends jest.Matchers<void, T>, CustomMatcher {
 	*
 	* @example
 	* expect(mockFunc).toBeCalled();
+	* @deprecated Use `toHaveBeenCalled` instead
 	*/
 	toBeCalled: () => void;
 	/**
@@ -489,6 +495,7 @@ interface JestAssertion<T = any> extends jest.Matchers<void, T>, CustomMatcher {
 	*
 	* @example
 	* expect(mockFunc).toBeCalledWith('arg1', 42);
+	* @deprecated Use `toHaveBeenCalledWith` instead
 	*/
 	toBeCalledWith: <E extends any[]>(...args: E) => void;
 	/**
@@ -501,15 +508,6 @@ interface JestAssertion<T = any> extends jest.Matchers<void, T>, CustomMatcher {
 	*/
 	toHaveBeenNthCalledWith: <E extends any[]>(n: number, ...args: E) => void;
 	/**
-	* Ensure that a mock function is called with specific arguments on an Nth call.
-	*
-	* Alias for `expect.toHaveBeenNthCalledWith`.
-	*
-	* @example
-	* expect(mockFunc).nthCalledWith(2, 'secondArg');
-	*/
-	nthCalledWith: <E extends any[]>(nthCall: number, ...args: E) => void;
-	/**
 	* If you have a mock function, you can use `.toHaveBeenLastCalledWith`
 	* to test what arguments it was last called with.
 	*
@@ -520,16 +518,6 @@ interface JestAssertion<T = any> extends jest.Matchers<void, T>, CustomMatcher {
 	*/
 	toHaveBeenLastCalledWith: <E extends any[]>(...args: E) => void;
 	/**
-	* If you have a mock function, you can use `.lastCalledWith`
-	* to test what arguments it was last called with.
-	*
-	* Alias for `expect.toHaveBeenLastCalledWith`.
-	*
-	* @example
-	* expect(mockFunc).lastCalledWith('lastArg');
-	*/
-	lastCalledWith: <E extends any[]>(...args: E) => void;
-	/**
 	* Used to test that a function throws when it is called.
 	*
 	* Also under the alias `expect.toThrowError`.
@@ -537,8 +525,9 @@ interface JestAssertion<T = any> extends jest.Matchers<void, T>, CustomMatcher {
 	* @example
 	* expect(() => functionWithError()).toThrow('Error message');
 	* expect(() => parseJSON('invalid')).toThrow(SyntaxError);
+	* expect(() => { throw 42 }).toThrow(42);
 	*/
-	toThrow: (expected?: string | Constructable | RegExp | Error) => void;
+	toThrow: (expected?: any) => void;
 	/**
 	* Used to test that a function throws when it is called.
 	*
@@ -547,8 +536,10 @@ interface JestAssertion<T = any> extends jest.Matchers<void, T>, CustomMatcher {
 	* @example
 	* expect(() => functionWithError()).toThrowError('Error message');
 	* expect(() => parseJSON('invalid')).toThrowError(SyntaxError);
+	* expect(() => { throw 42 }).toThrowError(42);
+	* @deprecated Use `toThrow` instead
 	*/
-	toThrowError: (expected?: string | Constructable | RegExp | Error) => void;
+	toThrowError: (expected?: any) => void;
 	/**
 	* Use to test that the mock function successfully returned (i.e., did not throw an error) at least one time
 	*
@@ -556,6 +547,7 @@ interface JestAssertion<T = any> extends jest.Matchers<void, T>, CustomMatcher {
 	*
 	* @example
 	* expect(mockFunc).toReturn();
+	* @deprecated Use `toHaveReturned` instead
 	*/
 	toReturn: () => void;
 	/**
@@ -575,6 +567,7 @@ interface JestAssertion<T = any> extends jest.Matchers<void, T>, CustomMatcher {
 	*
 	* @example
 	* expect(mockFunc).toReturnTimes(3);
+	* @deprecated Use `toHaveReturnedTimes` instead
 	*/
 	toReturnTimes: (times: number) => void;
 	/**
@@ -594,6 +587,7 @@ interface JestAssertion<T = any> extends jest.Matchers<void, T>, CustomMatcher {
 	*
 	* @example
 	* expect(mockFunc).toReturnWith('returnValue');
+	* @deprecated Use `toHaveReturnedWith` instead
 	*/
 	toReturnWith: <E>(value: E) => void;
 	/**
@@ -617,17 +611,6 @@ interface JestAssertion<T = any> extends jest.Matchers<void, T>, CustomMatcher {
 	*/
 	toHaveLastReturnedWith: <E>(value: E) => void;
 	/**
-	* Use to test the specific value that a mock function last returned.
-	* If the last call to the mock function threw an error, then this matcher will fail
-	* no matter what value you provided as the expected return value.
-	*
-	* Alias for `expect.toHaveLastReturnedWith`.
-	*
-	* @example
-	* expect(mockFunc).lastReturnedWith('lastValue');
-	*/
-	lastReturnedWith: <E>(value: E) => void;
-	/**
 	* Use to test the specific value that a mock function returned for the nth call.
 	* If the nth call to the mock function threw an error, then this matcher will fail
 	* no matter what value you provided as the expected return value.
@@ -638,17 +621,6 @@ interface JestAssertion<T = any> extends jest.Matchers<void, T>, CustomMatcher {
 	* expect(mockFunc).toHaveNthReturnedWith(2, 'nthValue');
 	*/
 	toHaveNthReturnedWith: <E>(nthCall: number, value: E) => void;
-	/**
-	* Use to test the specific value that a mock function returned for the nth call.
-	* If the nth call to the mock function threw an error, then this matcher will fail
-	* no matter what value you provided as the expected return value.
-	*
-	* Alias for `expect.toHaveNthReturnedWith`.
-	*
-	* @example
-	* expect(mockFunc).nthReturnedWith(2, 'nthValue');
-	*/
-	nthReturnedWith: <E>(nthCall: number, value: E) => void;
 }
 type VitestAssertion<
 	A,
@@ -656,7 +628,7 @@ type VitestAssertion<
 > = { [K in keyof A] : A[K] extends Chai.Assertion ? Assertion<T> : A[K] extends (...args: any[]) => any ? A[K] : VitestAssertion<A[K], T> } & ((type: string, message?: string) => Assertion);
 type Promisify<O> = { [K in keyof O] : O[K] extends (...args: infer A) => infer R ? Promisify<O[K]> & ((...args: A) => Promise<R>) : O[K] };
 type PromisifyAssertion<T> = Promisify<Assertion<T>>;
-interface Assertion<T = any> extends VitestAssertion<Chai.Assertion, T>, JestAssertion<T>, Matchers<T> {
+interface Assertion<T = any> extends VitestAssertion<Chai.Assertion, T>, JestAssertion<T>, ChaiMockAssertion, Matchers<T> {
 	/**
 	* Ensures a value is of a specific type.
 	*
@@ -760,6 +732,140 @@ interface Assertion<T = any> extends VitestAssertion<Chai.Assertion, T>, JestAss
 	*/
 	rejects: PromisifyAssertion<T>;
 }
+/**
+* Chai-style assertions for spy/mock testing.
+* These provide sinon-chai compatible assertion names that delegate to Jest-style implementations.
+*/
+interface ChaiMockAssertion {
+	/**
+	* Checks that a spy was called at least once.
+	* Chai-style equivalent of `toHaveBeenCalled`.
+	*
+	* @example
+	* expect(spy).to.have.been.called
+	*/
+	readonly called: Assertion;
+	/**
+	* Checks that a spy was called a specific number of times.
+	* Chai-style equivalent of `toHaveBeenCalledTimes`.
+	*
+	* @example
+	* expect(spy).to.have.callCount(3)
+	*/
+	callCount: (count: number) => void;
+	/**
+	* Checks that a spy was called with specific arguments at least once.
+	* Chai-style equivalent of `toHaveBeenCalledWith`.
+	*
+	* @example
+	* expect(spy).to.have.been.calledWith('arg1', 'arg2')
+	*/
+	calledWith: <E extends any[]>(...args: E) => void;
+	/**
+	* Checks that a spy was called exactly once.
+	* Chai-style equivalent of `toHaveBeenCalledOnce`.
+	*
+	* @example
+	* expect(spy).to.have.been.calledOnce
+	*/
+	readonly calledOnce: Assertion;
+	/**
+	* Checks that a spy was called exactly once with specific arguments.
+	* Chai-style equivalent of `toHaveBeenCalledExactlyOnceWith`.
+	*
+	* @example
+	* expect(spy).to.have.been.calledOnceWith('arg1', 'arg2')
+	*/
+	calledOnceWith: <E extends any[]>(...args: E) => void;
+	/**
+	* Checks that the last call to a spy was made with specific arguments.
+	* Chai-style equivalent of `toHaveBeenLastCalledWith`.
+	*
+	* @example
+	* expect(spy).to.have.been.lastCalledWith('arg1', 'arg2')
+	*/
+	lastCalledWith: <E extends any[]>(...args: E) => void;
+	/**
+	* Checks that the nth call to a spy was made with specific arguments.
+	* Chai-style equivalent of `toHaveBeenNthCalledWith`.
+	*
+	* @example
+	* expect(spy).to.have.been.nthCalledWith(2, 'arg1', 'arg2')
+	*/
+	nthCalledWith: <E extends any[]>(n: number, ...args: E) => void;
+	/**
+	* Checks that a spy returned successfully at least once.
+	* Chai-style equivalent of `toHaveReturned`.
+	*
+	* @example
+	* expect(spy).to.have.returned
+	*/
+	readonly returned: Assertion;
+	/**
+	* Checks that a spy returned a specific value at least once.
+	* Chai-style equivalent of `toHaveReturnedWith`.
+	*
+	* @example
+	* expect(spy).to.have.returnedWith('value')
+	*/
+	returnedWith: <E>(value: E) => void;
+	/**
+	* Checks that a spy returned successfully a specific number of times.
+	* Chai-style equivalent of `toHaveReturnedTimes`.
+	*
+	* @example
+	* expect(spy).to.have.returnedTimes(3)
+	*/
+	returnedTimes: (count: number) => void;
+	/**
+	* Checks that the last return value of a spy matches the expected value.
+	* Chai-style equivalent of `toHaveLastReturnedWith`.
+	*
+	* @example
+	* expect(spy).to.have.lastReturnedWith('value')
+	*/
+	lastReturnedWith: <E>(value: E) => void;
+	/**
+	* Checks that the nth return value of a spy matches the expected value.
+	* Chai-style equivalent of `toHaveNthReturnedWith`.
+	*
+	* @example
+	* expect(spy).to.have.nthReturnedWith(2, 'value')
+	*/
+	nthReturnedWith: <E>(n: number, value: E) => void;
+	/**
+	* Checks that a spy was called before another spy.
+	* Chai-style equivalent of `toHaveBeenCalledBefore`.
+	*
+	* @example
+	* expect(spy1).to.have.been.calledBefore(spy2)
+	*/
+	calledBefore: (mock: MockInstance, failIfNoFirstInvocation?: boolean) => void;
+	/**
+	* Checks that a spy was called after another spy.
+	* Chai-style equivalent of `toHaveBeenCalledAfter`.
+	*
+	* @example
+	* expect(spy1).to.have.been.calledAfter(spy2)
+	*/
+	calledAfter: (mock: MockInstance, failIfNoFirstInvocation?: boolean) => void;
+	/**
+	* Checks that a spy was called exactly twice.
+	* Chai-style equivalent of `toHaveBeenCalledTimes(2)`.
+	*
+	* @example
+	* expect(spy).to.have.been.calledTwice
+	*/
+	readonly calledTwice: Assertion;
+	/**
+	* Checks that a spy was called exactly three times.
+	* Chai-style equivalent of `toHaveBeenCalledTimes(3)`.
+	*
+	* @example
+	* expect(spy).to.have.been.calledThrice
+	*/
+	readonly calledThrice: Assertion;
+}
 declare global {
 	namespace jest {
 		interface Matchers<
@@ -769,6 +875,13 @@ declare global {
 	}
 }
 
+declare const ChaiStyleAssertions: ChaiPlugin;
+
+declare const MATCHERS_OBJECT: unique symbol;
+declare const JEST_MATCHERS_OBJECT: unique symbol;
+declare const GLOBAL_EXPECT: unique symbol;
+declare const ASYMMETRIC_MATCHERS_OBJECT: unique symbol;
+
 declare const customMatchers: MatchersObject;
 
 declare const JestChaiExpect: ChaiPlugin;
@@ -778,6 +891,7 @@ declare const JestExtend: ChaiPlugin;
 declare function equals(a: unknown, b: unknown, customTesters?: Array<Tester>, strictCheck?: boolean): boolean;
 declare function isAsymmetric(obj: any): obj is AsymmetricMatcher<any>;
 declare function hasAsymmetric(obj: any, seen?: Set<any>): boolean;
+declare function isError(value: unknown): value is Error;
 declare function isA(typeName: string, value: unknown): boolean;
 declare function fnNameFor(func: Function): string;
 declare function hasProperty(obj: object | null, property: string): boolean;
@@ -803,5 +917,9 @@ declare function isStandardSchema(obj: any): obj is StandardSchemaV1;
 declare function getState<State extends MatcherState = MatcherState>(expect: ExpectStatic): State;
 declare function setState<State extends MatcherState = MatcherState>(state: Partial<State>, expect: ExpectStatic): void;
 
-export { ASYMMETRIC_MATCHERS_OBJECT, Any, Anything, ArrayContaining, AsymmetricMatcher, GLOBAL_EXPECT, JEST_MATCHERS_OBJECT, JestAsymmetricMatchers, JestChaiExpect, JestExtend, MATCHERS_OBJECT, ObjectContaining, SchemaMatching, StringContaining, StringMatching, addCustomEqualityTesters, arrayBufferEquality, customMatchers, equals, fnNameFor, generateToBeMessage, getObjectKeys, getObjectSubset, getState, hasAsymmetric, hasProperty, isA, isAsymmetric, isImmutableUnorderedKeyed, isImmutableUnorderedSet, isStandardSchema, iterableEquality, pluralize, setState, sparseArrayEquality, subsetEquality, typeEquality };
-export type { Assertion, AsymmetricMatcherInterface, AsymmetricMatchersContaining, AsyncExpectationResult, ChaiPlugin, DeeplyAllowMatchers, ExpectStatic, ExpectationResult, JestAssertion, MatcherHintOptions, MatcherState, Matchers, MatchersObject, PromisifyAssertion, RawMatcherFn, SyncExpectationResult, Tester, TesterContext };
+declare function createAssertionMessage(util: Chai.ChaiUtils, assertion: Assertion, hasArgs: boolean): string;
+declare function recordAsyncExpect(_test: any, promise: Promise<any>, assertion: string, error: Error, isSoft?: boolean): Promise<any>;
+declare function wrapAssertion(utils: Chai.ChaiUtils, name: string, fn: (this: Chai.AssertionStatic & Assertion, ...args: any[]) => void | PromiseLike<void>): (this: Chai.AssertionStatic & Assertion, ...args: any[]) => void | PromiseLike<void>;
+
+export { ASYMMETRIC_MATCHERS_OBJECT, Any, Anything, ArrayContaining, AsymmetricMatcher, ChaiStyleAssertions, GLOBAL_EXPECT, JEST_MATCHERS_OBJECT, JestAsymmetricMatchers, JestChaiExpect, JestExtend, MATCHERS_OBJECT, ObjectContaining, SchemaMatching, StringContaining, StringMatching, addCustomEqualityTesters, arrayBufferEquality, createAssertionMessage, customMatchers, equals, fnNameFor, generateToBeMessage, getObjectKeys, getObjectSubset, getState, hasAsymmetric, hasProperty, isA, isAsymmetric, isError, isImmutableUnorderedKeyed, isImmutableUnorderedSet, isStandardSchema, iterableEquality, pluralize, recordAsyncExpect, setState, sparseArrayEquality, subsetEquality, typeEquality, wrapAssertion };
+export type { Assertion, AsymmetricMatcherInterface, AsymmetricMatchersContaining, AsyncExpectationResult, ChaiMockAssertion, ChaiPlugin, DeeplyAllowMatchers, ExpectStatic, ExpectationResult, JestAssertion, MatcherHintOptions, MatcherState, Matchers, MatchersObject, PromisifyAssertion, RawMatcherFn, SyncExpectationResult, Tester, TesterContext };