ex-pw 0.0.1 → 0.0.2

package/README.md

@@ -25,15 +25,6 @@ import exPw from "ex-pw";
 expect.extend(exPw);
 ```
 
-### Option 2: Import Individual Matchers
-
-```typescript
-import { expect } from "@playwright/test";
-import { toBeClickable, toBeRequired, toMatchSchema } from "ex-pw";
-
-expect.extend({ toBeClickable, toBeRequired, toMatchSchema });
-```
-
 ---
 
 ## Locator Matchers
@@ -516,13 +507,6 @@ await expect(request).toRespondWithin(1000);
 Asymmetric matchers can be used both in `expect().toEqual()` assertions and as
 standalone matchers.
 
-> **Note:** To use asymmetric matchers like `expect.toBeEmail()`, you need to
-> import `expect` directly from ex-pw:
->
-> ```typescript
-> import { expect } from "ex-pw";
-> ```
-
 ### String Matchers
 
 #### toStartWith

package/dist/index.d.mts

@@ -483,68 +483,434 @@ interface ExPwAsymmetricMatchers {
 }
 
 
-// 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;
+// Augment Playwright's types using global namespace
+declare global {
+  namespace PlaywrightTest {
+    interface Matchers<R, T = unknown> {
+      // Locator matchers (when T is Locator)
+
+      /**
+       * Asserts that an element is visible, enabled, stable, and not obscured.
+       * @example
+       * await expect(page.getByRole('button')).toBeClickable();
+       */
+      toBeClickable(options?: TimeoutOptions): Promise<R>;
+
+      /**
+       * Asserts that a checkbox or radio button is in a checkable state.
+       * @example
+       * await expect(page.getByRole('checkbox')).toBeCheckable();
+       */
+      toBeCheckable(options?: TimeoutOptions): Promise<R>;
+
+      /**
+       * Asserts that a form element is required.
+       * @example
+       * await expect(page.getByLabel('Email')).toBeRequired();
+       */
+      toBeRequired(options?: TimeoutOptions): Promise<R>;
+
+      /**
+       * Asserts that a form element is in an invalid validation state.
+       * @example
+       * await expect(page.getByRole('textbox')).toBeInvalid();
+       */
+      toBeInvalid(options?: TimeoutOptions): Promise<R>;
+
+      /**
+       * Asserts that a form element is in a valid validation state.
+       * @example
+       * await expect(page.getByRole('textbox')).toBeValid();
+       */
+      toBeValid(options?: TimeoutOptions): Promise<R>;
+
+      /**
+       * Asserts that a locator resolves to more than the specified number of elements.
+       * @example
+       * await expect(page.locator('li')).toHaveCountGreaterThan(3);
+       */
+      toHaveCountGreaterThan(count: number, options?: TimeoutOptions): Promise<R>;
+
+      /**
+       * Asserts that a locator resolves to at least the specified number of elements.
+       * @example
+       * await expect(page.locator('li')).toHaveCountGreaterThanOrEqual(1);
+       */
+      toHaveCountGreaterThanOrEqual(count: number, options?: TimeoutOptions): Promise<R>;
+
+      /**
+       * Asserts that a locator resolves to fewer than the specified number of elements.
+       * @example
+       * await expect(page.locator('.loading')).toHaveCountLessThan(1);
+       */
+      toHaveCountLessThan(count: number, options?: TimeoutOptions): Promise<R>;
+
+      /**
+       * Asserts that a locator resolves to at most the specified number of elements.
+       * @example
+       * await expect(page.locator('.result')).toHaveCountLessThanOrEqual(5);
+       */
+      toHaveCountLessThanOrEqual(count: number, options?: TimeoutOptions): Promise<R>;
+
+      /**
+       * Asserts that an element has a specific width in pixels.
+       * @example
+       * await expect(page.locator('#box')).toHaveWidth(100);
+       */
+      toHaveWidth(expected: number, options?: TimeoutOptions): Promise<R>;
+
+      /**
+       * Asserts that an element has a specific height in pixels.
+       * @example
+       * await expect(page.locator('#box')).toHaveHeight(200);
+       */
+      toHaveHeight(expected: number, options?: TimeoutOptions): Promise<R>;
+
+      /**
+       * Asserts that an element has a specific width and height in pixels.
+       * @example
+       * await expect(page.locator('#box')).toHaveSize(100, 200);
+       */
+      toHaveSize(width: number, height: number, options?: TimeoutOptions): Promise<R>;
+
+      /**
+       * Asserts that an image element has fully loaded.
+       * @example
+       * await expect(page.locator('img.logo')).toHaveLoadedImage();
+       */
+      toHaveLoadedImage(options?: TimeoutOptions): Promise<R>;
+
+      // Page matchers (when T is Page)
+
+      /**
+       * Asserts that the page has a cookie with the specified name.
+       * @example
+       * await expect(page).toHaveCookie('session_id');
+       * await expect(page).toHaveCookie('csrf', { value: /.+/ });
+       */
+      toHaveCookie(name: string, options?: ToHaveCookieOptions$1): Promise<R>;
+
+      /**
+       * Asserts that localStorage has a specific key.
+       * @example
+       * await expect(page).toHaveLocalStorage('token');
+       */
+      toHaveLocalStorage(key: string, options?: ToHaveStorageOptions): Promise<R>;
+
+      /**
+       * Asserts that sessionStorage has a specific key.
+       * @example
+       * await expect(page).toHaveSessionStorage('cart_id');
+       */
+      toHaveSessionStorage(key: string, options?: ToHaveStorageOptions): Promise<R>;
+
+      /**
+       * Asserts that the clipboard contains the specified text.
+       * @example
+       * await expect(page).toHaveClipboardText('copied text');
+       */
+      toHaveClipboardText(expected: string | RegExp, options?: TimeoutOptions): Promise<R>;
+
+      /**
+       * Asserts that a network request matching the criteria was made.
+       * @example
+       * await expect(page).toHaveRequest({ url: '/api/login', method: 'POST' });
+       */
+      toHaveRequest(options?: ToHaveRequestOptions$1): Promise<R>;
+
+      /**
+       * Asserts that a console message matching the criteria was logged.
+       * @example
+       * await expect(page).toHaveConsoleMessage({ type: 'error', text: /failed/ });
+       */
+      toHaveConsoleMessage(options?: ToHaveConsoleMessageOptions$1): Promise<R>;
+
+      /**
+       * Asserts that the page threw an uncaught exception.
+       * @example
+       * await expect(page).toHavePageError({ message: /ReferenceError/ });
+       */
+      toHavePageError(options?: ToHavePageErrorOptions$1): Promise<R>;
+
+      // TestInfo matchers (when T is TestInfo)
+
+      /**
+       * Asserts that there are no errors in the current test execution. Common with soft assertions.
+       * @example
+       * await expect(test).toHaveNoErrors();
+       */
+      toHaveNoErrors(options?: ToHaveNoErrorsOptions$1): R;
+
+      // API matchers (when T is APIResponse)
+
+      /**
+       * Asserts that the API response body matches the expected JSON.
+       * @example
+       * await expect(response).toMatchJSON({ success: true });
+       */
+      toMatchJSON(expected: unknown): Promise<R>;
+
+      /**
+       * Asserts that the API response body matches a Zod schema.
+       * @example
+       * await expect(response).toMatchSchema(UserSchema);
+       */
+      toMatchSchema(schema: ZodSchema): Promise<R>;
+
+      /**
+       * Asserts that the API response has the specified status code or is within range.
+       * @example
+       * await expect(response).toHaveStatus(200);
+       * await expect(response).toHaveStatus({ min: 200, max: 299 });
+       */
+      toHaveStatus(expected: number | { min: number; max: number }): Promise<R>;
+
+      /**
+       * Asserts that the API response contains a specific header.
+       * @example
+       * await expect(response).toHaveHeader('content-type', { value: /json/ });
+       */
+      toHaveHeader(name: string, options?: { value?: string | RegExp }): Promise<R>;
+
+      /**
+       * Asserts that the API response was received within the specified timeout.
+       * @example
+       * await expect(requestPromise).toRespondWithin(1000);
+       */
+      toRespondWithin(timeout: number): Promise<R>;
+
+      // General matchers (when T is Array or Locator)
+
+      /**
+       * Asserts that an array or items in a locator are sorted.
+       * @example
+       * await expect([1, 2, 3]).toBeSorted();
+       * await expect(page.locator('li')).toBeSorted({ descending: true });
+       */
+      toBeSorted(options?: ToBeSortedOptions$1): Promise<R>;
+
+      // Asymmetric matchers available as symmetric matchers
+
+      /**
+       * Asserts that the value is within the specified range (inclusive).
+       * @example
+       * await expect(5).toBeWithinRange(1, 10);
+       */
+      toBeWithinRange(min: number, max: number): R;
+
+      /**
+       * Asserts that the value is a valid UUID.
+       * @example
+       * await expect(uuid).toBeUUID();
+       */
+      toBeUUID(version?: 'v1' | 'v4' | 'v5'): R;
+
+      /**
+       * Asserts that the value is a valid ISO 8601 date string.
+       * @example
+       * await expect('2023-01-01T00:00:00Z').toBeISODate();
+       */
+      toBeISODate(): R;
+
+      /**
+       * Asserts that the value matches the specified date format.
+       * @example
+       * await expect('01/01/2023').toBeDateString('MM/DD/YYYY');
+       */
+      toBeDateString(format: string): R;
+
+      /**
+       * Asserts that the value is a valid email address.
+       * @example
+       * await expect('user@example.com').toBeEmail();
+       */
+      toBeEmail(): R;
+
+      /**
+       * Asserts that the value is a valid URL.
+       * @example
+       * await expect('https://example.com').toBeURL();
+       */
+      toBeURL(options?: ToBeURLAsymmetricOptions): R;
+
+      /**
+       * Asserts that the string value is valid JSON.
+       * @example
+       * await expect('{"a":1}').toBeJSON();
+       */
+      toBeJSON(): R;
+
+      /**
+       * Asserts that the string starts with the expected prefix.
+       * @example
+       * await expect('Hello World').toStartWith('Hello');
+       */
+      toStartWith(expected: string): R;
+
+      /**
+       * Asserts that the string ends with the expected suffix.
+       * @example
+       * await expect('image.png').toEndWith('.png');
+       */
+      toEndWith(expected: string): R;
+
+      /**
+       * Asserts that the string is uppercase.
+       * @example
+       * await expect('HELLO').toBeUpperCase();
+       */
+      toBeUpperCase(): R;
+
+      /**
+       * Asserts that the string is lowercase.
+       * @example
+       * await expect('hello').toBeLowerCase();
+       */
+      toBeLowerCase(): R;
+
+      /**
+       * Asserts that the string is kebab-case.
+       * @example
+       * await expect('my-class-name').toBeKebabCase();
+       */
+      toBeKebabCase(): R;
+
+      /**
+       * Asserts that the string is camelCase.
+       * @example
+       * await expect('myVariable').toBeCamelCase();
+       */
+      toBeCamelCase(): R;
+
+      /**
+       * Asserts that the string is snake_case.
+       * @example
+       * await expect('my_variable').toBeSnakeCase();
+       */
+      toBeSnakeCase(): R;
+
+      /**
+       * Asserts that the string is PascalCase.
+       * @example
+       * await expect('MyClass').toBePascalCase();
+       */
+      toBePascalCase(): R;
+    }
+
+    // Asymmetric matchers available on the expect object (e.g., expect.toBeLowerCase())
+    interface AsymmetricMatchers {
+      /**
+       * Matches any number within the specified range.
+       * @example
+       * expect(value).toEqual(expect.toBeWithinRange(1, 10));
+       */
+      toBeWithinRange(min: number, max: number): any;
+
+      /**
+       * Matches any string that is a valid UUID.
+       * @example
+       * expect(value).toEqual(expect.toBeUUID());
+       */
+      toBeUUID(version?: 'v1' | 'v4' | 'v5'): any;
+
+      /**
+       * Matches any string that is a valid ISO 8601 date.
+       * @example
+       * expect(value).toEqual(expect.toBeISODate());
+       */
+      toBeISODate(): any;
+
+      /**
+       * Matches any string that follows the specified date format.
+       * @example
+       * expect(value).toEqual(expect.toBeDateString('YYYY-MM-DD'));
+       */
+      toBeDateString(format: string): any;
+
+      /**
+       * Matches any string that is a valid email address.
+       * @example
+       * expect(value).toEqual(expect.toBeEmail());
+       */
+      toBeEmail(): any;
+
+      /**
+       * Matches any string that is a valid URL.
+       * @example
+       * expect(value).toEqual(expect.toBeURL());
+       */
+      toBeURL(options?: any): any;
+
+      /**
+       * Matches any string that is valid JSON.
+       * @example
+       * expect(value).toEqual(expect.toBeJSON());
+       */
+      toBeJSON(): any;
+
+      /**
+       * Matches any string starting with the expected prefix.
+       * @example
+       * expect(value).toEqual(expect.toStartWith('Pre'));
+       */
+      toStartWith(expected: string): any;
+
+      /**
+       * Matches any string ending with the expected suffix.
+       * @example
+       * expect(value).toEqual(expect.toEndWith('fix'));
+       */
+      toEndWith(expected: string): any;
+
+      /**
+       * Matches any string that is uppercase.
+       * @example
+       * expect(value).toEqual(expect.toBeUpperCase());
+       */
+      toBeUpperCase(): any;
+
+      /**
+       * Matches any string that is lowercase.
+       * @example
+       * expect(value).toEqual(expect.toBeLowerCase());
+       */
+      toBeLowerCase(): any;
+
+      /**
+       * Matches any string that is kebab-case.
+       * @example
+       * expect(value).toEqual(expect.toBeKebabCase());
+       */
+      toBeKebabCase(): any;
+
+      /**
+       * Matches any string that is camelCase.
+       * @example
+       * expect(value).toEqual(expect.toBeCamelCase());
+       */
+      toBeCamelCase(): any;
+
+      /**
+       * Matches any string that is snake_case.
+       * @example
+       * expect(value).toEqual(expect.toBeSnakeCase());
+       */
+      toBeSnakeCase(): any;
+
+      /**
+       * Matches any string that is PascalCase.
+       * @example
+       * expect(value).toEqual(expect.toBePascalCase());
+       */
+      toBePascalCase(): any;
+    }
   }
 
-
-  interface Expect extends ExPwAsymmetricMatchers { }
+  // Workaround for Playwright's Expect type limitation:
+  // Since Expect is a type alias intersection that cannot be augmented directly,
+  // and it is compatible with Function, we add the asymmetric matchers to the
+  // global Function interface to make them available on the expect object.
+  interface Function extends PlaywrightTest.AsymmetricMatchers { }
 }
 
 declare function toHaveWidth(this: ExpectMatcherState, locator: Locator, expected: number, options?: TimeoutOptions): Promise<{

package/dist/index.d.ts

@@ -483,68 +483,434 @@ interface ExPwAsymmetricMatchers {
 }
 
 
-// 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;
+// Augment Playwright's types using global namespace
+declare global {
+  namespace PlaywrightTest {
+    interface Matchers<R, T = unknown> {
+      // Locator matchers (when T is Locator)
+
+      /**
+       * Asserts that an element is visible, enabled, stable, and not obscured.
+       * @example
+       * await expect(page.getByRole('button')).toBeClickable();
+       */
+      toBeClickable(options?: TimeoutOptions): Promise<R>;
+
+      /**
+       * Asserts that a checkbox or radio button is in a checkable state.
+       * @example
+       * await expect(page.getByRole('checkbox')).toBeCheckable();
+       */
+      toBeCheckable(options?: TimeoutOptions): Promise<R>;
+
+      /**
+       * Asserts that a form element is required.
+       * @example
+       * await expect(page.getByLabel('Email')).toBeRequired();
+       */
+      toBeRequired(options?: TimeoutOptions): Promise<R>;
+
+      /**
+       * Asserts that a form element is in an invalid validation state.
+       * @example
+       * await expect(page.getByRole('textbox')).toBeInvalid();
+       */
+      toBeInvalid(options?: TimeoutOptions): Promise<R>;
+
+      /**
+       * Asserts that a form element is in a valid validation state.
+       * @example
+       * await expect(page.getByRole('textbox')).toBeValid();
+       */
+      toBeValid(options?: TimeoutOptions): Promise<R>;
+
+      /**
+       * Asserts that a locator resolves to more than the specified number of elements.
+       * @example
+       * await expect(page.locator('li')).toHaveCountGreaterThan(3);
+       */
+      toHaveCountGreaterThan(count: number, options?: TimeoutOptions): Promise<R>;
+
+      /**
+       * Asserts that a locator resolves to at least the specified number of elements.
+       * @example
+       * await expect(page.locator('li')).toHaveCountGreaterThanOrEqual(1);
+       */
+      toHaveCountGreaterThanOrEqual(count: number, options?: TimeoutOptions): Promise<R>;
+
+      /**
+       * Asserts that a locator resolves to fewer than the specified number of elements.
+       * @example
+       * await expect(page.locator('.loading')).toHaveCountLessThan(1);
+       */
+      toHaveCountLessThan(count: number, options?: TimeoutOptions): Promise<R>;
+
+      /**
+       * Asserts that a locator resolves to at most the specified number of elements.
+       * @example
+       * await expect(page.locator('.result')).toHaveCountLessThanOrEqual(5);
+       */
+      toHaveCountLessThanOrEqual(count: number, options?: TimeoutOptions): Promise<R>;
+
+      /**
+       * Asserts that an element has a specific width in pixels.
+       * @example
+       * await expect(page.locator('#box')).toHaveWidth(100);
+       */
+      toHaveWidth(expected: number, options?: TimeoutOptions): Promise<R>;
+
+      /**
+       * Asserts that an element has a specific height in pixels.
+       * @example
+       * await expect(page.locator('#box')).toHaveHeight(200);
+       */
+      toHaveHeight(expected: number, options?: TimeoutOptions): Promise<R>;
+
+      /**
+       * Asserts that an element has a specific width and height in pixels.
+       * @example
+       * await expect(page.locator('#box')).toHaveSize(100, 200);
+       */
+      toHaveSize(width: number, height: number, options?: TimeoutOptions): Promise<R>;
+
+      /**
+       * Asserts that an image element has fully loaded.
+       * @example
+       * await expect(page.locator('img.logo')).toHaveLoadedImage();
+       */
+      toHaveLoadedImage(options?: TimeoutOptions): Promise<R>;
+
+      // Page matchers (when T is Page)
+
+      /**
+       * Asserts that the page has a cookie with the specified name.
+       * @example
+       * await expect(page).toHaveCookie('session_id');
+       * await expect(page).toHaveCookie('csrf', { value: /.+/ });
+       */
+      toHaveCookie(name: string, options?: ToHaveCookieOptions$1): Promise<R>;
+
+      /**
+       * Asserts that localStorage has a specific key.
+       * @example
+       * await expect(page).toHaveLocalStorage('token');
+       */
+      toHaveLocalStorage(key: string, options?: ToHaveStorageOptions): Promise<R>;
+
+      /**
+       * Asserts that sessionStorage has a specific key.
+       * @example
+       * await expect(page).toHaveSessionStorage('cart_id');
+       */
+      toHaveSessionStorage(key: string, options?: ToHaveStorageOptions): Promise<R>;
+
+      /**
+       * Asserts that the clipboard contains the specified text.
+       * @example
+       * await expect(page).toHaveClipboardText('copied text');
+       */
+      toHaveClipboardText(expected: string | RegExp, options?: TimeoutOptions): Promise<R>;
+
+      /**
+       * Asserts that a network request matching the criteria was made.
+       * @example
+       * await expect(page).toHaveRequest({ url: '/api/login', method: 'POST' });
+       */
+      toHaveRequest(options?: ToHaveRequestOptions$1): Promise<R>;
+
+      /**
+       * Asserts that a console message matching the criteria was logged.
+       * @example
+       * await expect(page).toHaveConsoleMessage({ type: 'error', text: /failed/ });
+       */
+      toHaveConsoleMessage(options?: ToHaveConsoleMessageOptions$1): Promise<R>;
+
+      /**
+       * Asserts that the page threw an uncaught exception.
+       * @example
+       * await expect(page).toHavePageError({ message: /ReferenceError/ });
+       */
+      toHavePageError(options?: ToHavePageErrorOptions$1): Promise<R>;
+
+      // TestInfo matchers (when T is TestInfo)
+
+      /**
+       * Asserts that there are no errors in the current test execution. Common with soft assertions.
+       * @example
+       * await expect(test).toHaveNoErrors();
+       */
+      toHaveNoErrors(options?: ToHaveNoErrorsOptions$1): R;
+
+      // API matchers (when T is APIResponse)
+
+      /**
+       * Asserts that the API response body matches the expected JSON.
+       * @example
+       * await expect(response).toMatchJSON({ success: true });
+       */
+      toMatchJSON(expected: unknown): Promise<R>;
+
+      /**
+       * Asserts that the API response body matches a Zod schema.
+       * @example
+       * await expect(response).toMatchSchema(UserSchema);
+       */
+      toMatchSchema(schema: ZodSchema): Promise<R>;
+
+      /**
+       * Asserts that the API response has the specified status code or is within range.
+       * @example
+       * await expect(response).toHaveStatus(200);
+       * await expect(response).toHaveStatus({ min: 200, max: 299 });
+       */
+      toHaveStatus(expected: number | { min: number; max: number }): Promise<R>;
+
+      /**
+       * Asserts that the API response contains a specific header.
+       * @example
+       * await expect(response).toHaveHeader('content-type', { value: /json/ });
+       */
+      toHaveHeader(name: string, options?: { value?: string | RegExp }): Promise<R>;
+
+      /**
+       * Asserts that the API response was received within the specified timeout.
+       * @example
+       * await expect(requestPromise).toRespondWithin(1000);
+       */
+      toRespondWithin(timeout: number): Promise<R>;
+
+      // General matchers (when T is Array or Locator)
+
+      /**
+       * Asserts that an array or items in a locator are sorted.
+       * @example
+       * await expect([1, 2, 3]).toBeSorted();
+       * await expect(page.locator('li')).toBeSorted({ descending: true });
+       */
+      toBeSorted(options?: ToBeSortedOptions$1): Promise<R>;
+
+      // Asymmetric matchers available as symmetric matchers
+
+      /**
+       * Asserts that the value is within the specified range (inclusive).
+       * @example
+       * await expect(5).toBeWithinRange(1, 10);
+       */
+      toBeWithinRange(min: number, max: number): R;
+
+      /**
+       * Asserts that the value is a valid UUID.
+       * @example
+       * await expect(uuid).toBeUUID();
+       */
+      toBeUUID(version?: 'v1' | 'v4' | 'v5'): R;
+
+      /**
+       * Asserts that the value is a valid ISO 8601 date string.
+       * @example
+       * await expect('2023-01-01T00:00:00Z').toBeISODate();
+       */
+      toBeISODate(): R;
+
+      /**
+       * Asserts that the value matches the specified date format.
+       * @example
+       * await expect('01/01/2023').toBeDateString('MM/DD/YYYY');
+       */
+      toBeDateString(format: string): R;
+
+      /**
+       * Asserts that the value is a valid email address.
+       * @example
+       * await expect('user@example.com').toBeEmail();
+       */
+      toBeEmail(): R;
+
+      /**
+       * Asserts that the value is a valid URL.
+       * @example
+       * await expect('https://example.com').toBeURL();
+       */
+      toBeURL(options?: ToBeURLAsymmetricOptions): R;
+
+      /**
+       * Asserts that the string value is valid JSON.
+       * @example
+       * await expect('{"a":1}').toBeJSON();
+       */
+      toBeJSON(): R;
+
+      /**
+       * Asserts that the string starts with the expected prefix.
+       * @example
+       * await expect('Hello World').toStartWith('Hello');
+       */
+      toStartWith(expected: string): R;
+
+      /**
+       * Asserts that the string ends with the expected suffix.
+       * @example
+       * await expect('image.png').toEndWith('.png');
+       */
+      toEndWith(expected: string): R;
+
+      /**
+       * Asserts that the string is uppercase.
+       * @example
+       * await expect('HELLO').toBeUpperCase();
+       */
+      toBeUpperCase(): R;
+
+      /**
+       * Asserts that the string is lowercase.
+       * @example
+       * await expect('hello').toBeLowerCase();
+       */
+      toBeLowerCase(): R;
+
+      /**
+       * Asserts that the string is kebab-case.
+       * @example
+       * await expect('my-class-name').toBeKebabCase();
+       */
+      toBeKebabCase(): R;
+
+      /**
+       * Asserts that the string is camelCase.
+       * @example
+       * await expect('myVariable').toBeCamelCase();
+       */
+      toBeCamelCase(): R;
+
+      /**
+       * Asserts that the string is snake_case.
+       * @example
+       * await expect('my_variable').toBeSnakeCase();
+       */
+      toBeSnakeCase(): R;
+
+      /**
+       * Asserts that the string is PascalCase.
+       * @example
+       * await expect('MyClass').toBePascalCase();
+       */
+      toBePascalCase(): R;
+    }
+
+    // Asymmetric matchers available on the expect object (e.g., expect.toBeLowerCase())
+    interface AsymmetricMatchers {
+      /**
+       * Matches any number within the specified range.
+       * @example
+       * expect(value).toEqual(expect.toBeWithinRange(1, 10));
+       */
+      toBeWithinRange(min: number, max: number): any;
+
+      /**
+       * Matches any string that is a valid UUID.
+       * @example
+       * expect(value).toEqual(expect.toBeUUID());
+       */
+      toBeUUID(version?: 'v1' | 'v4' | 'v5'): any;
+
+      /**
+       * Matches any string that is a valid ISO 8601 date.
+       * @example
+       * expect(value).toEqual(expect.toBeISODate());
+       */
+      toBeISODate(): any;
+
+      /**
+       * Matches any string that follows the specified date format.
+       * @example
+       * expect(value).toEqual(expect.toBeDateString('YYYY-MM-DD'));
+       */
+      toBeDateString(format: string): any;
+
+      /**
+       * Matches any string that is a valid email address.
+       * @example
+       * expect(value).toEqual(expect.toBeEmail());
+       */
+      toBeEmail(): any;
+
+      /**
+       * Matches any string that is a valid URL.
+       * @example
+       * expect(value).toEqual(expect.toBeURL());
+       */
+      toBeURL(options?: any): any;
+
+      /**
+       * Matches any string that is valid JSON.
+       * @example
+       * expect(value).toEqual(expect.toBeJSON());
+       */
+      toBeJSON(): any;
+
+      /**
+       * Matches any string starting with the expected prefix.
+       * @example
+       * expect(value).toEqual(expect.toStartWith('Pre'));
+       */
+      toStartWith(expected: string): any;
+
+      /**
+       * Matches any string ending with the expected suffix.
+       * @example
+       * expect(value).toEqual(expect.toEndWith('fix'));
+       */
+      toEndWith(expected: string): any;
+
+      /**
+       * Matches any string that is uppercase.
+       * @example
+       * expect(value).toEqual(expect.toBeUpperCase());
+       */
+      toBeUpperCase(): any;
+
+      /**
+       * Matches any string that is lowercase.
+       * @example
+       * expect(value).toEqual(expect.toBeLowerCase());
+       */
+      toBeLowerCase(): any;
+
+      /**
+       * Matches any string that is kebab-case.
+       * @example
+       * expect(value).toEqual(expect.toBeKebabCase());
+       */
+      toBeKebabCase(): any;
+
+      /**
+       * Matches any string that is camelCase.
+       * @example
+       * expect(value).toEqual(expect.toBeCamelCase());
+       */
+      toBeCamelCase(): any;
+
+      /**
+       * Matches any string that is snake_case.
+       * @example
+       * expect(value).toEqual(expect.toBeSnakeCase());
+       */
+      toBeSnakeCase(): any;
+
+      /**
+       * Matches any string that is PascalCase.
+       * @example
+       * expect(value).toEqual(expect.toBePascalCase());
+       */
+      toBePascalCase(): any;
+    }
   }
 
-
-  interface Expect extends ExPwAsymmetricMatchers { }
+  // Workaround for Playwright's Expect type limitation:
+  // Since Expect is a type alias intersection that cannot be augmented directly,
+  // and it is compatible with Function, we add the asymmetric matchers to the
+  // global Function interface to make them available on the expect object.
+  interface Function extends PlaywrightTest.AsymmetricMatchers { }
 }
 
 declare function toHaveWidth(this: ExpectMatcherState, locator: Locator, expected: number, options?: TimeoutOptions): Promise<{

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "ex-pw",
-    "version": "0.0.1",
+    "version": "0.0.2",
     "description": "Extended Playwright expect matchers with auto-waiting and improved developer experience",
     "main": "./dist/index.js",
     "module": "./dist/index.mjs",
@@ -20,8 +20,8 @@
         "build": "tsup src/index.ts --format cjs,esm --dts --clean",
         "dev": "tsup src/index.ts --format cjs,esm --dts --watch",
         "test": "playwright test",
-        "lint": "eslint src --ext .ts",
         "prepublishOnly": "npm run build",
+        "tsc": "npx tsc --noEmit",
         "release:patch": "npm version patch -m 'chore: release %s'",
         "release:minor": "npm version minor -m 'chore: release %s'",
         "release:major": "npm version major -m 'chore: release %s'",