ex-pw 0.0.1

package/dist/index.d.ts

@@ -0,0 +1,1116 @@
+import * as playwright_test from 'playwright/test';
+import { ExpectMatcherState, Locator, TestType, Page, APIResponse } from '@playwright/test';
+import { ZodSchema } from 'zod';
+
+interface ToBeClickableOptions {
+    timeout?: number;
+}
+/**
+ * Asserts that an element is in a clickable state.
+ * Uses Playwright's `click({ trial: true })` which performs all actionability checks
+ * without actually clicking - including visibility, enabled state, and not being obscured.
+ *
+ * @example
+ * await expect(page.getByRole('button')).toBeClickable();
+ * await expect(page.getByRole('button')).toBeClickable({ timeout: 5000 });
+ */
+declare function toBeClickable(this: ExpectMatcherState, locator: Locator, options?: ToBeClickableOptions): Promise<{
+    pass: boolean;
+    message: () => string;
+    name: string;
+}>;
+
+interface ToBeCheckableOptions {
+    timeout?: number;
+}
+/**
+ * Asserts that a checkbox or radio button is in a checkable state.
+ * Uses Playwright's `check({ trial: true })` which performs all actionability checks
+ * without actually checking - including visibility, enabled state, and not being obscured.
+ *
+ * @example
+ * await expect(page.getByRole('checkbox')).toBeCheckable();
+ * await expect(page.getByRole('radio')).toBeCheckable({ timeout: 5000 });
+ */
+declare function toBeCheckable(this: ExpectMatcherState, locator: Locator, options?: ToBeCheckableOptions): Promise<{
+    pass: boolean;
+    message: () => string;
+    name: string;
+}>;
+
+interface ToBeRequiredOptions {
+    timeout?: number;
+    intervals?: number[];
+}
+/**
+ * Asserts that a form element is required.
+ * Checks multiple conditions for comprehensive coverage:
+ * - `required` HTML attribute
+ * - `aria-required="true"` attribute
+ * - Element's `required` property (covers dynamic JS-set required)
+ *
+ * @example
+ * await expect(page.getByLabel('Email')).toBeRequired();
+ * await expect(page.getByLabel('Optional')).not.toBeRequired();
+ */
+declare function toBeRequired(this: ExpectMatcherState, locator: Locator, options?: ToBeRequiredOptions): Promise<{
+    pass: boolean;
+    message: () => string;
+    name: string;
+}>;
+
+interface ToBeInvalidOptions {
+    timeout?: number;
+    intervals?: number[];
+}
+/**
+ * Asserts that a form element is in an invalid validation state.
+ * Checks multiple validation indicators:
+ * - `aria-invalid="true"` attribute
+ * - `element.validity.valid === false` (native validation)
+ * - Framework-specific classes: ng-invalid (Angular), is-invalid (Bootstrap), etc.
+ *
+ * @example
+ * await expect(page.getByLabel('Email')).toBeInvalid();
+ * await expect(page.getByLabel('Valid Field')).not.toBeInvalid();
+ */
+declare function toBeInvalid(this: ExpectMatcherState, locator: Locator, options?: ToBeInvalidOptions): Promise<{
+    pass: boolean;
+    message: () => string;
+    name: string;
+}>;
+
+interface ToBeValidOptions {
+    timeout?: number;
+    intervals?: number[];
+}
+/**
+ * Asserts that a form element is in a valid validation state.
+ * This is the opposite of toBeInvalid - checks that:
+ * - `aria-invalid` is NOT "true"
+ * - `element.validity.valid === true` (native validation)
+ * - No framework-specific invalid classes present
+ *
+ * @example
+ * await expect(page.getByLabel('Email')).toBeValid();
+ * await expect(page.getByLabel('Invalid Field')).not.toBeValid();
+ */
+declare function toBeValid(this: ExpectMatcherState, locator: Locator, options?: ToBeValidOptions): Promise<{
+    pass: boolean;
+    message: () => string;
+    name: string;
+}>;
+
+interface CountOptions {
+    timeout?: number;
+    intervals?: number[];
+}
+/**
+ * Asserts that a locator matches more than N elements.
+ *
+ * @example
+ * await expect(page.locator('.item')).toHaveCountGreaterThan(3);
+ * await expect(page.locator('.item')).toHaveCountGreaterThan(0, { timeout: 5000 });
+ */
+declare function toHaveCountGreaterThan(this: ExpectMatcherState, locator: Locator, count: number, options?: CountOptions): Promise<{
+    pass: boolean;
+    message: () => string;
+    name: string;
+    expected: string;
+    actual: number;
+}>;
+/**
+ * Asserts that a locator matches N or more elements.
+ *
+ * @example
+ * await expect(page.locator('.item')).toHaveCountGreaterThanOrEqual(5);
+ */
+declare function toHaveCountGreaterThanOrEqual(this: ExpectMatcherState, locator: Locator, count: number, options?: CountOptions): Promise<{
+    pass: boolean;
+    message: () => string;
+    name: string;
+    expected: string;
+    actual: number;
+}>;
+/**
+ * Asserts that a locator matches fewer than N elements.
+ *
+ * @example
+ * await expect(page.locator('.item')).toHaveCountLessThan(10);
+ */
+declare function toHaveCountLessThan(this: ExpectMatcherState, locator: Locator, count: number, options?: CountOptions): Promise<{
+    pass: boolean;
+    message: () => string;
+    name: string;
+    expected: string;
+    actual: number;
+}>;
+/**
+ * Asserts that a locator matches N or fewer elements.
+ *
+ * @example
+ * await expect(page.locator('.item')).toHaveCountLessThanOrEqual(5);
+ */
+declare function toHaveCountLessThanOrEqual(this: ExpectMatcherState, locator: Locator, count: number, options?: CountOptions): Promise<{
+    pass: boolean;
+    message: () => string;
+    name: string;
+    expected: string;
+    actual: number;
+}>;
+
+// Options interfaces
+interface TimeoutOptions {
+  timeout?: number;
+  intervals?: number[];
+}
+
+interface ToHaveCookieOptions$1 {
+  value?: string | RegExp;
+  domain?: string;
+  timeout?: number;
+  intervals?: number[];
+}
+
+interface ToHaveStorageOptions {
+  value?: unknown;
+  timeout?: number;
+  intervals?: number[];
+}
+
+interface ToHaveNoErrorsOptions$1 {
+  ignore?: RegExp;
+}
+
+interface ToBeURLAsymmetricOptions {
+  protocol?: string | string[];
+}
+
+interface ToHaveRequestOptions$1 {
+  method?: string;
+  status?: number;
+  url?: string | RegExp;
+  timeout?: number;
+  intervals?: number[];
+}
+
+type ConsoleMessageType$1 = 'log' | 'debug' | 'info' | 'error' | 'warning' | 'dir' | 'dirxml' | 'table' | 'trace' | 'clear' | 'startGroup' | 'startGroupCollapsed' | 'endGroup' | 'assert' | 'profile' | 'profileEnd' | 'count' | 'timeEnd';
+
+interface ToHaveConsoleMessageOptions$1 {
+  type?: ConsoleMessageType$1;
+  text?: string | RegExp;
+  timeout?: number;
+  intervals?: number[];
+}
+
+interface ToHavePageErrorOptions$1 {
+  message?: string | RegExp;
+  name?: string;
+  timeout?: number;
+  intervals?: number[];
+}
+
+// Locator matchers
+interface ExPwLocatorMatchers {
+  /**
+   * Asserts that an element is in a clickable state.
+   * Uses Playwright's `click({ trial: true })` which performs all actionability checks.
+   */
+  toBeClickable(options?: TimeoutOptions): Promise<void>;
+
+  /**
+   * Asserts that a checkbox or radio button is in a checkable state.
+   * Uses Playwright's `check({ trial: true })` which performs all actionability checks.
+   */
+  toBeCheckable(options?: TimeoutOptions): Promise<void>;
+
+  /**
+   * Asserts that a form element is required.
+   * Checks `required` attribute, `aria-required`, and element's required property.
+   */
+  toBeRequired(options?: TimeoutOptions): Promise<void>;
+
+  /**
+   * Asserts that a form element is in an invalid validation state.
+   * Checks `aria-invalid`, native validity, and framework classes (ng-invalid, is-invalid, etc).
+   */
+  toBeInvalid(options?: TimeoutOptions): Promise<void>;
+
+  /**
+   * Asserts that a form element is in a valid validation state.
+   */
+  toBeValid(options?: TimeoutOptions): Promise<void>;
+
+  /**
+   * Asserts that a locator matches more than N elements.
+   */
+  toHaveCountGreaterThan(count: number, options?: TimeoutOptions): Promise<void>;
+
+  /**
+   * Asserts that a locator matches N or more elements.
+   */
+  toHaveCountGreaterThanOrEqual(count: number, options?: TimeoutOptions): Promise<void>;
+
+  /**
+   * Asserts that a locator matches fewer than N elements.
+   */
+  toHaveCountLessThan(count: number, options?: TimeoutOptions): Promise<void>;
+
+  /**
+   * Asserts that a locator matches N or fewer elements.
+   */
+  toHaveCountLessThanOrEqual(count: number, options?: TimeoutOptions): Promise<void>;
+
+  /**
+   * Asserts that an element has a specific width.
+   */
+  toHaveWidth(expected: number, options?: TimeoutOptions): Promise<void>;
+
+  /**
+   * Asserts that an element has a specific height.
+   */
+  toHaveHeight(expected: number, options?: TimeoutOptions): Promise<void>;
+
+  /**
+   * Asserts that an element has a specific size.
+   */
+  toHaveSize(width: number, height: number, options?: TimeoutOptions): Promise<void>;
+
+  /**
+   * Asserts that an img element has loaded its image (complete and naturalWidth > 0).
+   */
+  toHaveLoadedImage(options?: TimeoutOptions): Promise<void>;
+}
+
+
+
+
+// Page matchers
+interface ExPwPageMatchers {
+  /**
+   * Asserts that the page's context has a specific cookie.
+   */
+  toHaveCookie(name: string, options?: ToHaveCookieOptions$1): Promise<void>;
+
+  /**
+   * Asserts that localStorage contains a specific key.
+   */
+  toHaveLocalStorage(key: string, options?: ToHaveStorageOptions): Promise<void>;
+
+  /**
+   * Asserts that sessionStorage contains a specific key.
+   */
+  toHaveSessionStorage(key: string, options?: ToHaveStorageOptions): Promise<void>;
+
+  /**
+   * Asserts that the clipboard has specific text.
+   */
+  toHaveClipboardText(expected: string | RegExp, options?: TimeoutOptions): Promise<void>;
+
+  /**
+   * Asserts that the page has made a network request matching the specified criteria.
+   * Uses `page.requests()` to check already captured requests.
+   * 
+   * **Limitations:**
+   * - Only returns up to 100 most recent requests (Playwright limit)
+   * - Does not wait for future requests; only checks already captured ones
+   */
+  toHaveRequest(options?: ToHaveRequestOptions$1): Promise<void>;
+
+  /**
+   * Asserts that the page has a console message matching the specified criteria.
+   * Uses `page.consoleMessages()` to check already captured console output.
+   * 
+   * **Limitations:**
+   * - Only returns up to 200 most recent console messages (Playwright limit)
+   * - Does not wait for future messages; only checks already captured ones
+   */
+  toHaveConsoleMessage(options?: ToHaveConsoleMessageOptions$1): Promise<void>;
+
+  /**
+   * Asserts that the page has encountered a JavaScript error matching the specified criteria.
+   * Uses `page.pageErrors()` to check already captured uncaught exceptions.
+   * 
+   * **Limitations:**
+   * - Only returns up to 200 most recent page errors (Playwright limit)
+   * - Does not wait for future errors; only checks already captured ones
+   */
+  toHavePageError(options?: ToHavePageErrorOptions$1): Promise<void>;
+}
+
+
+
+// Test matchers (when T is test object)
+interface ExPwTestMatchers {
+  /**
+   * Asserts that there are no test errors (useful with soft assertions).
+   * Pass the `test` object and it calls `.info()` internally to check for errors.
+   * 
+   * @example
+   * await expect(test).toHaveNoErrors();
+   */
+  toHaveNoErrors(options?: ToHaveNoErrorsOptions$1): void;
+}
+
+// API matchers
+interface ExPwAPIMatchers {
+  /**
+   * Asserts that an API response body matches the expected JSON.
+   */
+  toMatchJSON(expected: unknown): Promise<void>;
+
+  /**
+   * Asserts that an API response body matches a Zod schema.
+   */
+  toMatchSchema(schema: ZodSchema): Promise<void>;
+
+  /**
+   * Asserts that an API response has a specific HTTP status code.
+   */
+  toHaveStatus(expected: number | { min: number; max: number }): Promise<void>;
+
+  /**
+   * Asserts that an API response has a specific header.
+   */
+  toHaveHeader(name: string, options?: { value?: string | RegExp }): Promise<void>;
+
+  /**
+   * Asserts that an API request/response responds within a specified timeout.
+   * Expects a Promise or function returning a Promise.
+   */
+  toRespondWithin(timeout: number): Promise<void>;
+}
+
+
+// General matchers
+interface ToBeSortedOptions$1 {
+  descending?: boolean;
+  /**
+   * For array of objects, extract value using this key or function.
+   */
+  key?: string | ((item: any) => any);
+  /**
+   * When used with Locator, use allTextContents() instead of allInnerTexts().
+   * @default false
+   */
+  useTextContent?: boolean;
+  /**
+   * Whether to parse values as numbers for comparison.
+   * @default false
+   */
+  compareAsNumbers?: boolean;
+  timeout?: number;
+  intervals?: number[];
+}
+
+
+// Asymmetric matchers (added to expect object)
+interface ExPwAsymmetricMatchers {
+  /**
+   * Asymmetric matcher that checks if a number is within a specified range.
+   */
+  toBeWithinRange(min: number, max: number): any;
+
+  /**
+   * Asymmetric matcher that checks if a string is a valid UUID.
+   */
+  toBeUUID(version?: 'v1' | 'v4' | 'v5'): any;
+
+  /**
+   * Asymmetric matcher that checks if a string is a valid ISO 8601 date.
+   */
+  toBeISODate(): any;
+
+  /**
+   * Asymmetric matcher that checks if a string matches a date format.
+   */
+  toBeDateString(format: string): any;
+
+  /**
+   * Asymmetric matcher that checks if a string is a valid email address.
+   */
+  toBeEmail(): any;
+
+  /**
+   * Asymmetric matcher that checks if a string is a valid URL.
+   */
+  toBeURL(options?: ToBeURLAsymmetricOptions): any;
+
+  /**
+   * Matches any string that is valid JSON.
+   */
+  toBeJSON(): any;
+
+  /**
+   * Matches string starting with expected prefix
+   */
+  toStartWith(expected: string): any;
+
+  /**
+   * Matches string ending with expected suffix
+   */
+  toEndWith(expected: string): any;
+
+  /**
+   * Matches any string that is uppercase
+   */
+  toBeUpperCase(): any;
+
+  /**
+   * Matches any string that is lowercase
+   */
+  toBeLowerCase(): any;
+
+  /**
+   * Matches any string that is kebab-case
+   */
+  toBeKebabCase(): any;
+
+  /**
+   * Matches any string that is camelCase
+   */
+  toBeCamelCase(): any;
+
+  /**
+   * Matches any string that is snake_case
+   */
+  toBeSnakeCase(): any;
+
+  /**
+   * Matches any string that is PascalCase
+   */
+  toBePascalCase(): any;
+}
+
+
+// Augment Playwright's types
+declare module '@playwright/test' {
+  interface Matchers<R, T = unknown> {
+    // Locator matchers (when T is Locator)
+    toBeClickable(options?: TimeoutOptions): Promise<R>;
+    toBeCheckable(options?: TimeoutOptions): Promise<R>;
+    toBeRequired(options?: TimeoutOptions): Promise<R>;
+    toBeInvalid(options?: TimeoutOptions): Promise<R>;
+    toBeValid(options?: TimeoutOptions): Promise<R>;
+    toHaveCountGreaterThan(count: number, options?: TimeoutOptions): Promise<R>;
+    toHaveCountGreaterThanOrEqual(count: number, options?: TimeoutOptions): Promise<R>;
+    toHaveCountLessThan(count: number, options?: TimeoutOptions): Promise<R>;
+    toHaveCountLessThanOrEqual(count: number, options?: TimeoutOptions): Promise<R>;
+    toHaveWidth(expected: number, options?: TimeoutOptions): Promise<R>;
+    toHaveHeight(expected: number, options?: TimeoutOptions): Promise<R>;
+    toHaveSize(width: number, height: number, options?: TimeoutOptions): Promise<R>;
+    toHaveLoadedImage(options?: TimeoutOptions): Promise<R>;
+
+
+    // Page matchers (when T is Page)
+    toHaveCookie(name: string, options?: ToHaveCookieOptions$1): Promise<R>;
+    toHaveLocalStorage(key: string, options?: ToHaveStorageOptions): Promise<R>;
+    toHaveSessionStorage(key: string, options?: ToHaveStorageOptions): Promise<R>;
+    toHaveClipboardText(expected: string | RegExp, options?: TimeoutOptions): Promise<R>;
+    toHaveRequest(options?: ToHaveRequestOptions$1): Promise<R>;
+    toHaveConsoleMessage(options?: ToHaveConsoleMessageOptions$1): Promise<R>;
+    toHavePageError(options?: ToHavePageErrorOptions$1): Promise<R>;
+
+
+    // TestInfo matchers (when T is TestInfo)
+    toHaveNoErrors(options?: ToHaveNoErrorsOptions$1): R;
+
+    // API matchers (when T is APIResponse)
+    toMatchJSON(expected: unknown): Promise<R>;
+    toMatchSchema(schema: ZodSchema): Promise<R>;
+    toHaveStatus(expected: number | { min: number; max: number }): Promise<R>;
+    toHaveHeader(name: string, options?: { value?: string | RegExp }): Promise<R>;
+    toRespondWithin(timeout: number): Promise<R>;
+
+    // General matchers (when T is Array or Locator)
+    toBeSorted(options?: ToBeSortedOptions$1): Promise<R>;
+
+    // Asymmetric matchers available as symmetric matchers
+    toBeWithinRange(min: number, max: number): R;
+    toBeUUID(version?: 'v1' | 'v4' | 'v5'): R;
+    toBeISODate(): R;
+    toBeDateString(format: string): R;
+    toBeEmail(): R;
+    toBeURL(options?: ToBeURLAsymmetricOptions): R;
+    toBeJSON(): R;
+    toStartWith(expected: string): R;
+    toEndWith(expected: string): R;
+    toBeUpperCase(): R;
+    toBeLowerCase(): R;
+    toBeKebabCase(): R;
+    toBeCamelCase(): R;
+    toBeSnakeCase(): R;
+    toBePascalCase(): R;
+  }
+
+
+  interface Expect extends ExPwAsymmetricMatchers { }
+}
+
+declare function toHaveWidth(this: ExpectMatcherState, locator: Locator, expected: number, options?: TimeoutOptions): Promise<{
+    message: () => string;
+    pass: boolean;
+}>;
+
+declare function toHaveHeight(this: ExpectMatcherState, locator: Locator, expected: number, options?: TimeoutOptions): Promise<{
+    message: () => string;
+    pass: boolean;
+}>;
+
+declare function toHaveSize(this: ExpectMatcherState, locator: Locator, width: number, height: number, options?: TimeoutOptions): Promise<{
+    message: () => string;
+    pass: boolean;
+}>;
+
+declare function toHaveLoadedImage(this: ExpectMatcherState, locator: Locator, options?: TimeoutOptions): Promise<{
+    message: () => string;
+    pass: boolean;
+}>;
+
+declare const locatorMatchers: {
+    toBeClickable: typeof toBeClickable;
+    toBeCheckable: typeof toBeCheckable;
+    toBeRequired: typeof toBeRequired;
+    toBeInvalid: typeof toBeInvalid;
+    toBeValid: typeof toBeValid;
+    toHaveCountGreaterThan: typeof toHaveCountGreaterThan;
+    toHaveCountGreaterThanOrEqual: typeof toHaveCountGreaterThanOrEqual;
+    toHaveCountLessThan: typeof toHaveCountLessThan;
+    toHaveCountLessThanOrEqual: typeof toHaveCountLessThanOrEqual;
+    toHaveWidth: typeof toHaveWidth;
+    toHaveHeight: typeof toHaveHeight;
+    toHaveSize: typeof toHaveSize;
+    toHaveLoadedImage: typeof toHaveLoadedImage;
+};
+
+interface ToHaveNoErrorsOptions {
+    ignore?: RegExp;
+}
+/**
+ * Asserts that there are no test errors (useful with soft assertions).
+ * Pass the `test` object and it will call `.info()` internally to check for errors.
+ *
+ * @example
+ * await expect.soft(page.getByTestId('status')).toHaveText('Success');
+ * await expect.soft(page.getByTestId('eta')).toHaveText('1 day');
+ * await expect(test).toHaveNoErrors();
+ *
+ * @example
+ * // Ignore specific errors
+ * await expect(test).toHaveNoErrors({ ignore: /Warning:/ });
+ */
+declare function toHaveNoErrors(this: ExpectMatcherState, testObject: TestType<any, any>, options?: ToHaveNoErrorsOptions): {
+    pass: boolean;
+    message: () => string;
+    name: string;
+    expected: number;
+    actual: number;
+};
+
+interface ToHaveCookieOptions {
+    value?: string | RegExp;
+    domain?: string;
+    timeout?: number;
+    intervals?: number[];
+}
+/**
+ * Asserts that the page's context has a specific cookie.
+ * Optionally matches by value and/or domain.
+ *
+ * @example
+ * await expect(page).toHaveCookie('session');
+ * await expect(page).toHaveCookie('session', { value: 'abc123' });
+ * await expect(page).toHaveCookie('session', { value: /^abc/ });
+ * await expect(page).toHaveCookie('session', { domain: 'example.com' });
+ */
+declare function toHaveCookie(this: ExpectMatcherState, page: Page, name: string, options?: ToHaveCookieOptions): Promise<{
+    pass: boolean;
+    message: () => string;
+    name: string;
+    expected: string | RegExp;
+    actual: string | undefined;
+}>;
+
+interface ToHaveLocalStorageOptions {
+    value?: unknown;
+    timeout?: number;
+    intervals?: number[];
+}
+/**
+ * Asserts that localStorage contains a specific key with optional value matching.
+ * Uses `page.context().storageState()` to retrieve localStorage.
+ *
+ * @example
+ * await expect(page).toHaveLocalStorage('authToken');
+ * await expect(page).toHaveLocalStorage('authToken', { value: 'secret' });
+ * await expect(page).toHaveLocalStorage('settings', { value: expect.objectContaining({ theme: 'dark' }) });
+ */
+declare function toHaveLocalStorage(this: ExpectMatcherState, page: Page, key: string, options?: ToHaveLocalStorageOptions): Promise<{
+    pass: boolean;
+    message: () => string;
+    name: string;
+    expected: {};
+    actual: unknown;
+}>;
+
+interface ToHaveSessionStorageOptions {
+    value?: unknown;
+    timeout?: number;
+    intervals?: number[];
+}
+/**
+ * Asserts that sessionStorage contains a specific key with optional value matching.
+ * Note: sessionStorage is not included in storageState(), so this uses page.evaluate().
+ *
+ * @example
+ * await expect(page).toHaveSessionStorage('tempData');
+ * await expect(page).toHaveSessionStorage('cart', { value: expect.arrayContaining([{ id: 1 }]) });
+ */
+declare function toHaveSessionStorage(this: ExpectMatcherState, page: Page, key: string, options?: ToHaveSessionStorageOptions): Promise<{
+    pass: boolean;
+    message: () => string;
+    name: string;
+    expected: {};
+    actual: unknown;
+}>;
+
+/**
+ * Asserts that the clipboard contains the expected text.
+ *
+ * @note This matcher requires clipboard permissions to be granted in the browser context.
+ * Make sure to set `permissions: ["clipboard-read"]` when launching the browser.
+ *
+ * @example
+ * ```ts
+ * // playwright.config.ts
+ * export default defineConfig({
+ *  use: {
+ *    permissions: ["clipboard-read"],
+ *  },
+ * });
+ * ```
+ */
+declare function toHaveClipboardText(this: ExpectMatcherState, page: Page, expected: string | RegExp, options?: TimeoutOptions): Promise<{
+    message: () => string;
+    pass: boolean;
+}>;
+
+interface ToHaveRequestOptions {
+    method?: string;
+    status?: number;
+    url?: string | RegExp;
+    timeout?: number;
+    intervals?: number[];
+}
+/**
+ * Asserts that the page has made a network request matching the specified criteria.
+ * Uses `page.requests()` with polling to wait for matching requests.
+ *
+ * **Limitations:**
+ * - Only returns up to 100 most recent requests (Playwright limit)
+ * - Requests may be garbage collected if not accessed promptly
+ * - Collected requests may have limited information available
+ *
+ * @example
+ * await expect(page).toHaveRequest({ url: /api\/users/ });
+ * await expect(page).toHaveRequest({ method: 'POST', url: /api\/login/ });
+ * await expect(page).toHaveRequest({ url: 'https://example.com/api', status: 200 });
+ */
+declare function toHaveRequest(this: ExpectMatcherState, page: Page, options?: ToHaveRequestOptions): Promise<{
+    pass: boolean;
+    message: () => string;
+    name: string;
+}>;
+
+type ConsoleMessageType = 'log' | 'debug' | 'info' | 'error' | 'warning' | 'dir' | 'dirxml' | 'table' | 'trace' | 'clear' | 'startGroup' | 'startGroupCollapsed' | 'endGroup' | 'assert' | 'profile' | 'profileEnd' | 'count' | 'timeEnd';
+interface ToHaveConsoleMessageOptions {
+    type?: ConsoleMessageType;
+    text?: string | RegExp;
+    timeout?: number;
+    intervals?: number[];
+}
+/**
+ * Asserts that the page has a console message matching the specified criteria.
+ * Uses `page.consoleMessages()` with polling to wait for matching messages.
+ *
+ * **Limitations:**
+ * - Only returns up to 200 most recent console messages (Playwright limit)
+ *
+ * @example
+ * await expect(page).toHaveConsoleMessage({ text: 'Hello' });
+ * await expect(page).toHaveConsoleMessage({ type: 'error' });
+ * await expect(page).toHaveConsoleMessage({ type: 'warning', text: /deprecated/ });
+ */
+declare function toHaveConsoleMessage(this: ExpectMatcherState, page: Page, options?: ToHaveConsoleMessageOptions): Promise<{
+    pass: boolean;
+    message: () => string;
+    name: string;
+}>;
+
+interface ToHavePageErrorOptions {
+    message?: string | RegExp;
+    name?: string;
+    timeout?: number;
+    intervals?: number[];
+}
+/**
+ * Asserts that the page has encountered a JavaScript error matching the specified criteria.
+ * Uses `page.pageErrors()` with polling to wait for matching errors.
+ *
+ * **Limitations:**
+ * - Only returns up to 200 most recent page errors (Playwright limit)
+ * - Only captures uncaught exceptions in the page's JavaScript context
+ *
+ * @example
+ * await expect(page).toHavePageError();
+ * await expect(page).toHavePageError({ message: 'undefined is not a function' });
+ * await expect(page).toHavePageError({ message: /TypeError/, name: 'TypeError' });
+ */
+declare function toHavePageError(this: ExpectMatcherState, page: Page, options?: ToHavePageErrorOptions): Promise<{
+    pass: boolean;
+    message: () => string;
+    name: string;
+}>;
+
+declare const pageMatchers: {
+    toHaveNoErrors: typeof toHaveNoErrors;
+    toHaveCookie: typeof toHaveCookie;
+    toHaveLocalStorage: typeof toHaveLocalStorage;
+    toHaveSessionStorage: typeof toHaveSessionStorage;
+    toHaveClipboardText: typeof toHaveClipboardText;
+    toHaveRequest: typeof toHaveRequest;
+    toHaveConsoleMessage: typeof toHaveConsoleMessage;
+    toHavePageError: typeof toHavePageError;
+};
+
+/**
+ * Asserts that an API response body matches the expected JSON.
+ * Supports asymmetric matchers like expect.toBeEmail(), expect.toBeUUID(), etc.
+ *
+ * @example
+ * const response = await request.get('/api/user');
+ * await expect(response).toMatchJSON({ id: 1, name: 'John' });
+ * await expect(response).toMatchJSON(expect.objectContaining({ id: 1 }));
+ * await expect(response).toMatchJSON({
+ *   email: expect.toBeEmail(),
+ *   id: expect.toBeUUID()
+ * });
+ */
+declare function toMatchJSON(this: ExpectMatcherState, response: APIResponse, expected: unknown): Promise<{
+    pass: boolean;
+    message: () => string;
+    name: string;
+    expected: unknown;
+    actual: unknown;
+}>;
+
+/**
+ * Asserts that an API response body matches a Zod schema.
+ * Provides detailed validation error messages.
+ *
+ * @example
+ * import { z } from 'zod';
+ *
+ * const UserSchema = z.object({
+ *   id: z.number(),
+ *   name: z.string(),
+ *   email: z.string().email(),
+ * });
+ *
+ * const response = await request.get('/api/user');
+ * await expect(response).toMatchSchema(UserSchema);
+ */
+declare function toMatchSchema(this: ExpectMatcherState, response: APIResponse, schema: ZodSchema): Promise<{
+    pass: boolean;
+    message: () => string;
+    name: string;
+    expected: string;
+    actual: unknown;
+}>;
+
+/**
+ * Asserts that an API response has a specific HTTP status code.
+ * Supports exact match or range matching.
+ *
+ * @example
+ * await expect(response).toHaveStatus(200);
+ * await expect(response).toHaveStatus({ min: 200, max: 299 }); // Any 2xx
+ */
+declare function toHaveStatus(this: ExpectMatcherState, response: APIResponse, expected: number | {
+    min: number;
+    max: number;
+}): Promise<{
+    pass: boolean;
+    message: () => string;
+    name: string;
+    expected: string;
+    actual: number;
+}>;
+
+interface ToHaveHeaderOptions {
+    value?: string | RegExp;
+}
+/**
+ * Asserts that an API response has a specific header.
+ * Optionally matches by value.
+ *
+ * @example
+ * await expect(response).toHaveHeader('content-type');
+ * await expect(response).toHaveHeader('content-type', { value: 'application/json' });
+ * await expect(response).toHaveHeader('content-type', { value: /json/ });
+ */
+declare function toHaveHeader(this: ExpectMatcherState, response: APIResponse, name: string, options?: ToHaveHeaderOptions): Promise<{
+    pass: boolean;
+    message: () => string;
+    name: string;
+    expected: string | RegExp;
+    actual: string | undefined;
+}>;
+
+declare function toRespondWithin(response: APIResponse | Promise<APIResponse> | (() => Promise<APIResponse>), timeout: number): Promise<{
+    message: () => string;
+    pass: boolean;
+}>;
+
+declare const apiMatchers: {
+    toMatchJSON: typeof toMatchJSON;
+    toMatchSchema: typeof toMatchSchema;
+    toHaveStatus: typeof toHaveStatus;
+    toHaveHeader: typeof toHaveHeader;
+    toRespondWithin: typeof toRespondWithin;
+};
+
+interface ToBeSortedOptions {
+    descending?: boolean;
+    /**
+     * For array of objects, extract value using this key or function.
+     */
+    key?: string | ((item: any) => any);
+    /**
+     * When used with Locator, specifies which method to use for extracting text.
+     * - false (default): uses allInnerTexts() - excludes hidden elements
+     * - true: uses allTextContents() - includes hidden elements
+     * @default false
+     */
+    useTextContent?: boolean;
+    /**
+     * Whether to parse values as numbers for comparison.
+     * @default false - compares as strings
+     */
+    compareAsNumbers?: boolean;
+    timeout?: number;
+    intervals?: number[];
+}
+/**
+ * Asserts that an array or locator elements are sorted.
+ *
+ * When used with a Locator, it extracts text from all matching elements
+ * using `allInnerTexts()` (default) or `allTextContents()`.
+ *
+ * @example
+ * // With arrays
+ * expect([1, 2, 3]).toBeSorted();
+ * expect(['c', 'b', 'a']).toBeSorted({ descending: true });
+ * expect([{ val: 1 }, { val: 2 }]).toBeSorted({ key: 'val' });
+ *
+ * @example
+ * // With Locators
+ * await expect(page.locator('.price')).toBeSorted({ compareAsNumbers: true });
+ * await expect(page.locator('.name')).toBeSorted({ descending: true });
+ */
+declare function toBeSorted(this: ExpectMatcherState, received: Locator | any[], options?: ToBeSortedOptions): Promise<{
+    message: () => string;
+    pass: boolean;
+}>;
+
+declare const generalMatchers: {
+    toBeSorted: typeof toBeSorted;
+};
+
+declare function toBeWithinRange(received: unknown, min: number, max: number): {
+    message: () => string;
+    pass: boolean;
+};
+
+declare function toBeUUID(received: unknown, version?: 'v1' | 'v4' | 'v5'): {
+    message: () => string;
+    pass: boolean;
+};
+
+declare function toBeISODate(received: unknown): {
+    message: () => string;
+    pass: boolean;
+};
+
+declare function toBeDateString(received: unknown, format: string): {
+    message: () => string;
+    pass: boolean;
+};
+
+declare function toBeEmail(received: unknown): {
+    message: () => string;
+    pass: boolean;
+};
+
+interface ToBeURLOptions {
+    protocol?: string | string[];
+}
+declare function toBeURL(received: unknown, options?: ToBeURLOptions): {
+    message: () => string;
+    pass: boolean;
+};
+
+declare function toBeJSON(received: unknown): {
+    message: () => string;
+    pass: boolean;
+};
+
+declare function toStartWith(received: unknown, expected: string): {
+    message: () => string;
+    pass: boolean;
+};
+
+declare function toEndWith(received: unknown, expected: string): {
+    message: () => string;
+    pass: boolean;
+};
+
+declare function toBeUpperCase(received: unknown): {
+    message: () => string;
+    pass: boolean;
+};
+
+declare function toBeLowerCase(received: unknown): {
+    message: () => string;
+    pass: boolean;
+};
+
+declare function toBeKebabCase(received: unknown): {
+    message: () => string;
+    pass: boolean;
+};
+
+declare function toBeCamelCase(received: unknown): {
+    message: () => string;
+    pass: boolean;
+};
+
+declare function toBeSnakeCase(received: unknown): {
+    message: () => string;
+    pass: boolean;
+};
+
+declare function toBePascalCase(received: unknown): {
+    message: () => string;
+    pass: boolean;
+};
+
+declare const asymmetricMatchers: {
+    toBeWithinRange: typeof toBeWithinRange;
+    toBeUUID: typeof toBeUUID;
+    toBeISODate: typeof toBeISODate;
+    toBeDateString: typeof toBeDateString;
+    toBeEmail: typeof toBeEmail;
+    toBeURL: typeof toBeURL;
+    toBeJSON: typeof toBeJSON;
+    toStartWith: typeof toStartWith;
+    toEndWith: typeof toEndWith;
+    toBeUpperCase: typeof toBeUpperCase;
+    toBeLowerCase: typeof toBeLowerCase;
+    toBeKebabCase: typeof toBeKebabCase;
+    toBeCamelCase: typeof toBeCamelCase;
+    toBeSnakeCase: typeof toBeSnakeCase;
+    toBePascalCase: typeof toBePascalCase;
+};
+
+declare const exPwExpect: playwright_test.Expect<{
+    toBeWithinRange: typeof toBeWithinRange;
+    toBeUUID: typeof toBeUUID;
+    toBeISODate: typeof toBeISODate;
+    toBeDateString: typeof toBeDateString;
+    toBeEmail: typeof toBeEmail;
+    toBeURL: typeof toBeURL;
+    toBeJSON: typeof toBeJSON;
+    toStartWith: typeof toStartWith;
+    toEndWith: typeof toEndWith;
+    toBeUpperCase: typeof toBeUpperCase;
+    toBeLowerCase: typeof toBeLowerCase;
+    toBeKebabCase: typeof toBeKebabCase;
+    toBeCamelCase: typeof toBeCamelCase;
+    toBeSnakeCase: typeof toBeSnakeCase;
+    toBePascalCase: typeof toBePascalCase;
+    toBeSorted: typeof toBeSorted;
+    toMatchJSON: typeof toMatchJSON;
+    toMatchSchema: typeof toMatchSchema;
+    toHaveStatus: typeof toHaveStatus;
+    toHaveHeader: typeof toHaveHeader;
+    toRespondWithin: typeof toRespondWithin;
+    toHaveNoErrors: typeof toHaveNoErrors;
+    toHaveCookie: typeof toHaveCookie;
+    toHaveLocalStorage: typeof toHaveLocalStorage;
+    toHaveSessionStorage: typeof toHaveSessionStorage;
+    toHaveClipboardText: typeof toHaveClipboardText;
+    toHaveRequest: typeof toHaveRequest;
+    toHaveConsoleMessage: typeof toHaveConsoleMessage;
+    toHavePageError: typeof toHavePageError;
+    toBeClickable: typeof toBeClickable;
+    toBeCheckable: typeof toBeCheckable;
+    toBeRequired: typeof toBeRequired;
+    toBeInvalid: typeof toBeInvalid;
+    toBeValid: typeof toBeValid;
+    toHaveCountGreaterThan: typeof toHaveCountGreaterThan;
+    toHaveCountGreaterThanOrEqual: typeof toHaveCountGreaterThanOrEqual;
+    toHaveCountLessThan: typeof toHaveCountLessThan;
+    toHaveCountLessThanOrEqual: typeof toHaveCountLessThanOrEqual;
+    toHaveWidth: typeof toHaveWidth;
+    toHaveHeight: typeof toHaveHeight;
+    toHaveSize: typeof toHaveSize;
+    toHaveLoadedImage: typeof toHaveLoadedImage;
+}>;
+declare const expect: typeof exPwExpect & ExPwAsymmetricMatchers;
+declare const exPw: {
+    toBeWithinRange: typeof toBeWithinRange;
+    toBeUUID: typeof toBeUUID;
+    toBeISODate: typeof toBeISODate;
+    toBeDateString: typeof toBeDateString;
+    toBeEmail: typeof toBeEmail;
+    toBeURL: typeof toBeURL;
+    toBeJSON: typeof toBeJSON;
+    toStartWith: typeof toStartWith;
+    toEndWith: typeof toEndWith;
+    toBeUpperCase: typeof toBeUpperCase;
+    toBeLowerCase: typeof toBeLowerCase;
+    toBeKebabCase: typeof toBeKebabCase;
+    toBeCamelCase: typeof toBeCamelCase;
+    toBeSnakeCase: typeof toBeSnakeCase;
+    toBePascalCase: typeof toBePascalCase;
+    toBeSorted: typeof toBeSorted;
+    toMatchJSON: typeof toMatchJSON;
+    toMatchSchema: typeof toMatchSchema;
+    toHaveStatus: typeof toHaveStatus;
+    toHaveHeader: typeof toHaveHeader;
+    toRespondWithin: typeof toRespondWithin;
+    toHaveNoErrors: typeof toHaveNoErrors;
+    toHaveCookie: typeof toHaveCookie;
+    toHaveLocalStorage: typeof toHaveLocalStorage;
+    toHaveSessionStorage: typeof toHaveSessionStorage;
+    toHaveClipboardText: typeof toHaveClipboardText;
+    toHaveRequest: typeof toHaveRequest;
+    toHaveConsoleMessage: typeof toHaveConsoleMessage;
+    toHavePageError: typeof toHavePageError;
+    toBeClickable: typeof toBeClickable;
+    toBeCheckable: typeof toBeCheckable;
+    toBeRequired: typeof toBeRequired;
+    toBeInvalid: typeof toBeInvalid;
+    toBeValid: typeof toBeValid;
+    toHaveCountGreaterThan: typeof toHaveCountGreaterThan;
+    toHaveCountGreaterThanOrEqual: typeof toHaveCountGreaterThanOrEqual;
+    toHaveCountLessThan: typeof toHaveCountLessThan;
+    toHaveCountLessThanOrEqual: typeof toHaveCountLessThanOrEqual;
+    toHaveWidth: typeof toHaveWidth;
+    toHaveHeight: typeof toHaveHeight;
+    toHaveSize: typeof toHaveSize;
+    toHaveLoadedImage: typeof toHaveLoadedImage;
+};
+
+export { type ExPwAPIMatchers, type ExPwAsymmetricMatchers, type ExPwLocatorMatchers, type ExPwPageMatchers, type ExPwTestMatchers, type TimeoutOptions, type ToBeSortedOptions$1 as ToBeSortedOptions, type ToBeURLAsymmetricOptions, type ToHaveConsoleMessageOptions$1 as ToHaveConsoleMessageOptions, type ToHaveCookieOptions$1 as ToHaveCookieOptions, type ToHaveNoErrorsOptions$1 as ToHaveNoErrorsOptions, type ToHavePageErrorOptions$1 as ToHavePageErrorOptions, type ToHaveRequestOptions$1 as ToHaveRequestOptions, type ToHaveStorageOptions, apiMatchers, asymmetricMatchers, exPw as default, expect, generalMatchers, locatorMatchers, pageMatchers, toBeCamelCase, toBeCheckable, toBeClickable, toBeDateString, toBeEmail, toBeISODate, toBeInvalid, toBeJSON, toBeKebabCase, toBeLowerCase, toBePascalCase, toBeRequired, toBeSnakeCase, toBeSorted, toBeURL, toBeUUID, toBeUpperCase, toBeValid, toBeWithinRange, toEndWith, toHaveClipboardText, toHaveConsoleMessage, toHaveCookie, toHaveCountGreaterThan, toHaveCountGreaterThanOrEqual, toHaveCountLessThan, toHaveCountLessThanOrEqual, toHaveHeader, toHaveHeight, toHaveLoadedImage, toHaveLocalStorage, toHaveNoErrors, toHavePageError, toHaveRequest, toHaveSessionStorage, toHaveSize, toHaveStatus, toHaveWidth, toMatchJSON, toMatchSchema, toRespondWithin, toStartWith };