@srsholmes/tauri-playwright 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,935 @@
+import * as _playwright_test from '@playwright/test';
+import { Page } from '@playwright/test';
+import { Buffer } from 'node:buffer';
+
+/**
+ * Any object with TauriLocator/BrowserLocatorAdapter-compatible methods.
+ */
+interface LocatorLike {
+    isVisible(): Promise<boolean>;
+    isHidden(): Promise<boolean>;
+    isEnabled(): Promise<boolean>;
+    isDisabled(): Promise<boolean>;
+    isEditable(): Promise<boolean>;
+    isChecked(): Promise<boolean>;
+    isFocused?(): Promise<boolean>;
+    textContent(): Promise<string | null>;
+    innerText(): Promise<string>;
+    inputValue(): Promise<string>;
+    getAttribute(name: string): Promise<string | null>;
+    count(): Promise<number>;
+}
+/**
+ * Page-like object for page-level assertions (toHaveURL, toHaveTitle).
+ */
+interface PageLike {
+    url(): Promise<string>;
+    title(): Promise<string>;
+}
+/**
+ * Extended expect with Playwright-style locator assertions.
+ *
+ * Usage:
+ * ```ts
+ * await expect(locator).toBeVisible();
+ * await expect(locator).toContainText('Hello');
+ * await expect(locator).not.toBeVisible();
+ * ```
+ */
+declare const tauriExpect: _playwright_test.Expect<{
+    toBeVisible(this: _playwright_test.ExpectMatcherState, locator: LocatorLike, options?: {
+        timeout?: number;
+    }): Promise<{
+        pass: boolean;
+        name: string;
+        message: () => string;
+    }>;
+    toBeHidden(this: _playwright_test.ExpectMatcherState, locator: LocatorLike, options?: {
+        timeout?: number;
+    }): Promise<{
+        pass: boolean;
+        name: string;
+        message: () => string;
+    }>;
+    toBeEnabled(this: _playwright_test.ExpectMatcherState, locator: LocatorLike, options?: {
+        timeout?: number;
+    }): Promise<{
+        pass: boolean;
+        name: string;
+        message: () => string;
+    }>;
+    toBeDisabled(this: _playwright_test.ExpectMatcherState, locator: LocatorLike, options?: {
+        timeout?: number;
+    }): Promise<{
+        pass: boolean;
+        name: string;
+        message: () => string;
+    }>;
+    toBeEditable(this: _playwright_test.ExpectMatcherState, locator: LocatorLike, options?: {
+        timeout?: number;
+    }): Promise<{
+        pass: boolean;
+        name: string;
+        message: () => string;
+    }>;
+    toBeChecked(this: _playwright_test.ExpectMatcherState, locator: LocatorLike, options?: {
+        timeout?: number;
+    }): Promise<{
+        pass: boolean;
+        name: string;
+        message: () => string;
+    }>;
+    toBeAttached(this: _playwright_test.ExpectMatcherState, locator: LocatorLike, options?: {
+        timeout?: number;
+    }): Promise<{
+        pass: boolean;
+        name: string;
+        message: () => string;
+    }>;
+    toBeEmpty(this: _playwright_test.ExpectMatcherState, locator: LocatorLike, options?: {
+        timeout?: number;
+    }): Promise<{
+        pass: boolean;
+        name: string;
+        message: () => string;
+    }>;
+    toContainText(this: _playwright_test.ExpectMatcherState, locator: LocatorLike, expected: string | RegExp, options?: {
+        timeout?: number;
+    }): Promise<{
+        pass: boolean;
+        name: string;
+        message: () => string;
+    }>;
+    toHaveText(this: _playwright_test.ExpectMatcherState, locator: LocatorLike, expected: string | RegExp, options?: {
+        timeout?: number;
+    }): Promise<{
+        pass: boolean;
+        name: string;
+        message: () => string;
+    }>;
+    toHaveValue(this: _playwright_test.ExpectMatcherState, locator: LocatorLike, expected: string | RegExp, options?: {
+        timeout?: number;
+    }): Promise<{
+        pass: boolean;
+        name: string;
+        message: () => string;
+    }>;
+    toHaveAttribute(this: _playwright_test.ExpectMatcherState, locator: LocatorLike, name: string, value?: string | RegExp, options?: {
+        timeout?: number;
+    }): Promise<{
+        pass: boolean;
+        name: string;
+        message: () => string;
+    }>;
+    toHaveClass(this: _playwright_test.ExpectMatcherState, locator: LocatorLike, expected: string | RegExp, options?: {
+        timeout?: number;
+    }): Promise<{
+        pass: boolean;
+        name: string;
+        message: () => string;
+    }>;
+    toHaveId(this: _playwright_test.ExpectMatcherState, locator: LocatorLike, expected: string, options?: {
+        timeout?: number;
+    }): Promise<{
+        pass: boolean;
+        name: string;
+        message: () => string;
+    }>;
+    toHaveCount(this: _playwright_test.ExpectMatcherState, locator: LocatorLike, expected: number, options?: {
+        timeout?: number;
+    }): Promise<{
+        pass: boolean;
+        name: string;
+        message: () => string;
+    }>;
+    toBeFocused(this: _playwright_test.ExpectMatcherState, locator: LocatorLike, options?: {
+        timeout?: number;
+    }): Promise<{
+        pass: boolean;
+        name: string;
+        message: () => string;
+    }>;
+    toHaveCSS(this: _playwright_test.ExpectMatcherState, locator: LocatorLike, property: string, expected: string | RegExp, options?: {
+        timeout?: number;
+    }): Promise<{
+        pass: boolean;
+        name: string;
+        message: () => string;
+    }>;
+    toHaveURL(this: _playwright_test.ExpectMatcherState, page: PageLike, expected: string | RegExp, options?: {
+        timeout?: number;
+    }): Promise<{
+        pass: boolean;
+        name: string;
+        message: () => string;
+    }>;
+    toHaveTitle(this: _playwright_test.ExpectMatcherState, page: PageLike, expected: string | RegExp, options?: {
+        timeout?: number;
+    }): Promise<{
+        pass: boolean;
+        name: string;
+        message: () => string;
+    }>;
+}>;
+
+/**
+ * Client that connects to the tauri-plugin-playwright socket server.
+ * Sends newline-delimited JSON commands and receives JSON responses.
+ */
+declare class PluginClient {
+    private socketPath?;
+    private tcpPort?;
+    private socket;
+    private readline;
+    private pending;
+    private seq;
+    private responseQueue;
+    private waitingForResponse;
+    constructor(socketPath?: string | undefined, tcpPort?: number | undefined);
+    /** Connect to the plugin's socket server. */
+    connect(): Promise<void>;
+    /** Disconnect from the server. */
+    disconnect(): void;
+    /** Send a command and wait for the response. */
+    send(command: Record<string, unknown>): Promise<PluginResponse>;
+    private waitForLine;
+}
+interface PluginResponse {
+    ok: boolean;
+    data?: unknown;
+    error?: string;
+}
+
+/**
+ * A Playwright-like Page API backed by the tauri-plugin-playwright socket bridge.
+ * Commands are sent to the plugin, which injects JS into the real Tauri webview.
+ */
+type TimeoutOption = {
+    timeout?: number;
+};
+declare class TauriPage {
+    private client;
+    private _defaultTimeout;
+    constructor(client: PluginClient);
+    /** Set the default timeout for all auto-waiting operations (ms). */
+    setDefaultTimeout(timeout: number): void;
+    private _t;
+    /** Execute arbitrary JavaScript in the webview and return the result. */
+    evaluate<T = unknown>(script: string): Promise<T>;
+    /** Click an element matching the CSS selector. Auto-waits. */
+    click(selector: string, options?: TimeoutOption): Promise<void>;
+    /** Double-click an element. Auto-waits. */
+    dblclick(selector: string, options?: TimeoutOption): Promise<void>;
+    /** Hover over an element. Auto-waits. */
+    hover(selector: string, options?: TimeoutOption): Promise<void>;
+    /** Clear and fill an input element with text. Auto-waits. */
+    fill(selector: string, text: string, options?: TimeoutOption): Promise<void>;
+    /** Type text character by character into an element. Auto-waits. */
+    type(selector: string, text: string, options?: TimeoutOption): Promise<void>;
+    /** Press a key on an element (e.g., 'Enter', 'Tab', 'Escape'). Auto-waits. */
+    press(selector: string, key: string, options?: TimeoutOption): Promise<void>;
+    /** Check a checkbox or radio button. Auto-waits. */
+    check(selector: string, options?: TimeoutOption): Promise<void>;
+    /** Uncheck a checkbox. Auto-waits. */
+    uncheck(selector: string, options?: TimeoutOption): Promise<void>;
+    /** Select an option from a <select> element by value. Auto-waits. */
+    selectOption(selector: string, value: string, options?: TimeoutOption): Promise<string>;
+    /** Focus an element. Auto-waits. */
+    focus(selector: string, options?: TimeoutOption): Promise<void>;
+    /** Blur (unfocus) an element. Auto-waits. */
+    blur(selector: string, options?: TimeoutOption): Promise<void>;
+    /** Get the text content of an element. Auto-waits for element. */
+    textContent(selector: string, options?: TimeoutOption): Promise<string | null>;
+    /** Get the innerHTML of an element. Auto-waits for element. */
+    innerHTML(selector: string, options?: TimeoutOption): Promise<string>;
+    /** Get the innerText of an element (visible text only). Auto-waits for element. */
+    innerText(selector: string, options?: TimeoutOption): Promise<string>;
+    /** Get textContent of all elements matching a selector. No wait (works on zero matches). */
+    allTextContents(selector: string): Promise<string[]>;
+    /** Get innerText of all elements matching a selector. No wait (works on zero matches). */
+    allInnerTexts(selector: string): Promise<string[]>;
+    /** Get an attribute value from an element. Auto-waits for element. */
+    getAttribute(selector: string, name: string, options?: TimeoutOption): Promise<string | null>;
+    /** Get the input value of a form element. Auto-waits for element. */
+    inputValue(selector: string, options?: TimeoutOption): Promise<string>;
+    /** Get the bounding box of an element. Auto-waits for element. */
+    boundingBox(selector: string, options?: TimeoutOption): Promise<{
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    } | null>;
+    /** Check if an element matching the selector is visible. */
+    isVisible(selector: string): Promise<boolean>;
+    /** Check if an element is checked (checkbox/radio). */
+    isChecked(selector: string): Promise<boolean>;
+    /** Check if an element is disabled. */
+    isDisabled(selector: string): Promise<boolean>;
+    /** Check if an element is editable. */
+    isEditable(selector: string): Promise<boolean>;
+    /** Check if an element is hidden. */
+    isHidden(selector: string): Promise<boolean>;
+    /** Check if an element is enabled. */
+    isEnabled(selector: string): Promise<boolean>;
+    /** Wait for an element matching the selector to become visible. */
+    waitForSelector(selector: string, timeout?: number): Promise<void>;
+    /** Wait for a JS expression to return truthy. */
+    waitForFunction(expression: string, timeout?: number): Promise<void>;
+    /** Count elements matching a selector. */
+    count(selector: string): Promise<number>;
+    /** Get the page title. */
+    title(): Promise<string>;
+    /** Get the current URL. */
+    url(): Promise<string>;
+    /** Get the full page HTML. */
+    content(): Promise<string>;
+    /** Navigate to a URL. */
+    goto(url: string): Promise<void>;
+    /** Reload the page. */
+    reload(): Promise<void>;
+    /** Navigate back in history. */
+    goBack(): Promise<void>;
+    /** Navigate forward in history. */
+    goForward(): Promise<void>;
+    /** Wait for the URL to contain or match a pattern. */
+    waitForURL(pattern: string, options?: TimeoutOption): Promise<void>;
+    /** Check if an element is the active/focused element. */
+    isFocused(selector: string): Promise<boolean>;
+    /** Get a computed CSS style value from an element. Auto-waits. */
+    getComputedStyle(selector: string, property: string, options?: TimeoutOption): Promise<string>;
+    /** Dispatch a custom DOM event on an element. Auto-waits. */
+    dispatchEvent(selector: string, eventType: string, options?: TimeoutOption): Promise<void>;
+    /** Drag one element onto another. Auto-waits. */
+    dragAndDrop(source: string, target: string, options?: TimeoutOption): Promise<void>;
+    /** Set files on a file input element. */
+    setInputFiles(selector: string, files: Array<{
+        name: string;
+        mimeType: string;
+        buffer: Buffer;
+    }>, options?: TimeoutOption): Promise<number>;
+    /** Install dialog interception (alert/confirm/prompt). */
+    installDialogHandler(options?: {
+        defaultConfirm?: boolean;
+        defaultPromptText?: string;
+    }): Promise<void>;
+    /** Get captured dialogs since last check. */
+    getDialogs(): Promise<Array<{
+        type: 'alert' | 'confirm' | 'prompt';
+        message: string;
+        default?: string;
+    }>>;
+    /** Clear captured dialogs. */
+    clearDialogs(): Promise<void>;
+    /** Add a network route that intercepts matching fetch/XHR requests. */
+    route(pattern: string, response: {
+        status?: number;
+        body?: string;
+        contentType?: string;
+    }): Promise<void>;
+    /** Remove a network route. */
+    unroute(pattern: string): Promise<void>;
+    /** Clear all network routes. */
+    clearRoutes(): Promise<void>;
+    /** Get captured network requests. */
+    getNetworkRequests(): Promise<Array<{
+        url: string;
+        method: string;
+        timestamp: number;
+    }>>;
+    /** Clear captured network requests. */
+    clearNetworkRequests(): Promise<void>;
+    /** Take a native screenshot of the Tauri window. Returns PNG buffer. */
+    screenshot(options?: {
+        path?: string;
+    }): Promise<Buffer>;
+    /** Start recording the Tauri window as video (native frame capture). */
+    startRecording(options?: {
+        path?: string;
+        fps?: number;
+    }): Promise<{
+        dir: string;
+        fps: number;
+    }>;
+    /** Stop recording and return the video path (if ffmpeg is available). */
+    stopRecording(): Promise<{
+        dir: string;
+        frame_count: number;
+        fps: number;
+        video: string | null;
+    }>;
+    /** Create a locator for chained operations. */
+    locator(selector: string): TauriLocator;
+    getByTestId(testId: string): TauriLocator;
+    getByPlaceholder(text: string, options?: {
+        exact?: boolean;
+    }): TauriLocator;
+    getByAltText(text: string, options?: {
+        exact?: boolean;
+    }): TauriLocator;
+    getByTitle(text: string, options?: {
+        exact?: boolean;
+    }): TauriLocator;
+    getByRole(role: string, options?: {
+        name?: string;
+    }): TauriLocator;
+    getByText(text: string, options?: {
+        exact?: boolean;
+    }): TauriLocator;
+    getByLabel(text: string, options?: {
+        exact?: boolean;
+    }): TauriLocator;
+    readonly keyboard: TauriKeyboard;
+    readonly mouse: TauriMouse;
+    /** Send a command to the plugin and handle errors. */
+    private command;
+}
+/**
+ * A Playwright-like Locator for chained element interactions.
+ * Supports both CSS selectors and JS-based selectors (for getByText, getByLabel).
+ */
+declare class TauriLocator {
+    private page;
+    private selector;
+    private _jsFind?;
+    constructor(page: TauriPage, selector: string, options?: {
+        jsFind?: string;
+    });
+    /** Whether this locator uses JS-based element resolution. */
+    get isJsBased(): boolean;
+    /**
+     * Execute an action/query. For CSS selectors, delegates to TauriPage.
+     * For JS-based selectors, uses evaluate with the JS find expression.
+     */
+    private _eval;
+    private _actionScript;
+    private _queryScript;
+    click(options?: TimeoutOption): Promise<void>;
+    dblclick(options?: TimeoutOption): Promise<void>;
+    hover(options?: TimeoutOption): Promise<void>;
+    fill(text: string, options?: TimeoutOption): Promise<void>;
+    press(key: string, options?: TimeoutOption): Promise<void>;
+    check(options?: TimeoutOption): Promise<void>;
+    uncheck(options?: TimeoutOption): Promise<void>;
+    selectOption(value: string, options?: TimeoutOption): Promise<string>;
+    focus(options?: TimeoutOption): Promise<void>;
+    blur(options?: TimeoutOption): Promise<void>;
+    clear(): Promise<void>;
+    /** Type text character-by-character (Playwright's replacement for deprecated type()). */
+    pressSequentially(text: string, options?: {
+        delay?: number;
+    }): Promise<void>;
+    /** Dispatch a custom DOM event on the element. */
+    dispatchEvent(eventType: string, options?: TimeoutOption): Promise<void>;
+    /** Run a JS function on the matched element. The function receives `el` as argument. */
+    evaluate<T = unknown>(fn: string): Promise<T>;
+    /** Check if this element is the active/focused element. */
+    isFocused(): Promise<boolean>;
+    scrollIntoViewIfNeeded(): Promise<void>;
+    textContent(options?: TimeoutOption): Promise<string | null>;
+    innerHTML(options?: TimeoutOption): Promise<string>;
+    innerText(options?: TimeoutOption): Promise<string>;
+    getAttribute(name: string, options?: TimeoutOption): Promise<string | null>;
+    inputValue(options?: TimeoutOption): Promise<string>;
+    boundingBox(): Promise<{
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    } | null>;
+    isVisible(): Promise<boolean>;
+    isHidden(): Promise<boolean>;
+    isChecked(): Promise<boolean>;
+    isDisabled(): Promise<boolean>;
+    isEditable(): Promise<boolean>;
+    isEnabled(): Promise<boolean>;
+    waitFor(timeout?: number): Promise<void>;
+    count(): Promise<number>;
+    nth(index: number): TauriLocator;
+    first(): TauriLocator;
+    last(): TauriLocator;
+    filter(options: {
+        hasText?: string | RegExp;
+    }): TauriLocator;
+    all(): Promise<TauriLocator[]>;
+    getByTestId(testId: string): TauriLocator;
+    getByPlaceholder(text: string, options?: {
+        exact?: boolean;
+    }): TauriLocator;
+    getByText(text: string, options?: {
+        exact?: boolean;
+    }): TauriLocator;
+    getByRole(role: string, options?: {
+        name?: string;
+    }): TauriLocator;
+    locator(selector: string): TauriLocator;
+}
+declare class TauriKeyboard {
+    private page;
+    private _modifiers;
+    constructor(page: TauriPage);
+    press(key: string): Promise<void>;
+    down(key: string): Promise<void>;
+    up(key: string): Promise<void>;
+    type(text: string, options?: {
+        delay?: number;
+    }): Promise<void>;
+    insertText(text: string): Promise<void>;
+}
+declare class TauriMouse {
+    private page;
+    constructor(page: TauriPage);
+    click(x: number, y: number, options?: {
+        button?: 'left' | 'right' | 'middle';
+    }): Promise<void>;
+    dblclick(x: number, y: number): Promise<void>;
+    move(x: number, y: number): Promise<void>;
+    down(options?: {
+        button?: 'left' | 'right' | 'middle';
+    }): Promise<void>;
+    up(options?: {
+        button?: 'left' | 'right' | 'middle';
+    }): Promise<void>;
+    wheel(deltaX: number, deltaY: number): Promise<void>;
+}
+
+/**
+ * Wraps a Playwright Page to provide the same API surface as TauriPage.
+ * This allows the same tests to run in both browser-only and Tauri modes.
+ */
+declare class BrowserPageAdapter {
+    private page;
+    constructor(page: Page);
+    /** Set the default timeout for all auto-waiting operations (ms). */
+    setDefaultTimeout(timeout: number): void;
+    get playwrightPage(): Page;
+    evaluate<T = unknown>(script: string): Promise<T>;
+    click(selector: string): Promise<void>;
+    dblclick(selector: string): Promise<void>;
+    hover(selector: string): Promise<void>;
+    fill(selector: string, text: string): Promise<void>;
+    type(selector: string, text: string): Promise<void>;
+    press(selector: string, key: string): Promise<void>;
+    check(selector: string): Promise<void>;
+    uncheck(selector: string): Promise<void>;
+    selectOption(selector: string, value: string): Promise<string>;
+    focus(selector: string): Promise<void>;
+    blur(selector: string): Promise<void>;
+    textContent(selector: string): Promise<string | null>;
+    innerHTML(selector: string): Promise<string>;
+    innerText(selector: string): Promise<string>;
+    allTextContents(selector: string): Promise<string[]>;
+    allInnerTexts(selector: string): Promise<string[]>;
+    getAttribute(selector: string, name: string): Promise<string | null>;
+    inputValue(selector: string): Promise<string>;
+    boundingBox(selector: string): Promise<{
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    } | null>;
+    isVisible(selector: string): Promise<boolean>;
+    isChecked(selector: string): Promise<boolean>;
+    isDisabled(selector: string): Promise<boolean>;
+    isEditable(selector: string): Promise<boolean>;
+    isHidden(selector: string): Promise<boolean>;
+    isEnabled(selector: string): Promise<boolean>;
+    waitForSelector(selector: string, timeout?: number): Promise<void>;
+    waitForFunction(expression: string, timeout?: number): Promise<void>;
+    count(selector: string): Promise<number>;
+    title(): Promise<string>;
+    url(): Promise<string>;
+    content(): Promise<string>;
+    goto(url: string): Promise<void>;
+    reload(): Promise<void>;
+    goBack(): Promise<void>;
+    goForward(): Promise<void>;
+    waitForURL(pattern: string, options?: {
+        timeout?: number;
+    }): Promise<void>;
+    isFocused(selector: string): Promise<boolean>;
+    getComputedStyle(selector: string, property: string): Promise<string>;
+    dispatchEvent(selector: string, eventType: string): Promise<void>;
+    dragAndDrop(source: string, target: string): Promise<void>;
+    setInputFiles(selector: string, files: Array<{
+        name: string;
+        mimeType: string;
+        buffer: Buffer;
+    }>): Promise<number>;
+    private dialogHandler;
+    private capturedDialogs;
+    installDialogHandler(options?: {
+        defaultConfirm?: boolean;
+        defaultPromptText?: string;
+    }): Promise<void>;
+    getDialogs(): Promise<Array<{
+        type: string;
+        message: string;
+        default?: string;
+    }>>;
+    clearDialogs(): Promise<void>;
+    private capturedRequests;
+    private activeRoutes;
+    route(pattern: string, response: {
+        status?: number;
+        body?: string;
+        contentType?: string;
+    }): Promise<void>;
+    unroute(pattern: string): Promise<void>;
+    clearRoutes(): Promise<void>;
+    getNetworkRequests(): Promise<Array<{
+        url: string;
+        method: string;
+        timestamp: number;
+    }>>;
+    clearNetworkRequests(): Promise<void>;
+    getByTestId(testId: string): _playwright_test.Locator;
+    getByPlaceholder(text: string, options?: {
+        exact?: boolean;
+    }): _playwright_test.Locator;
+    getByAltText(text: string, options?: {
+        exact?: boolean;
+    }): _playwright_test.Locator;
+    getByTitle(text: string, options?: {
+        exact?: boolean;
+    }): _playwright_test.Locator;
+    getByRole(role: Parameters<Page['getByRole']>[0], options?: Parameters<Page['getByRole']>[1]): _playwright_test.Locator;
+    getByText(text: string, options?: {
+        exact?: boolean;
+    }): _playwright_test.Locator;
+    getByLabel(text: string, options?: {
+        exact?: boolean;
+    }): _playwright_test.Locator;
+    get keyboard(): _playwright_test.Keyboard;
+    get mouse(): _playwright_test.Mouse;
+    screenshot(options?: {
+        path?: string;
+    }): Promise<Buffer>;
+    startRecording(): Promise<{
+        dir: string;
+        fps: number;
+    }>;
+    stopRecording(): Promise<{
+        dir: string;
+        frame_count: number;
+        fps: number;
+        video: string | null;
+    }>;
+    locator(selector: string): _playwright_test.Locator;
+}
+
+/**
+ * Configuration for creating a Tauri Playwright test fixture.
+ */
+interface TauriTestConfig {
+    /**
+     * Vite/dev server URL for browser-only mode.
+     * @example 'http://localhost:1420'
+     */
+    devUrl: string;
+    /**
+     * Mock IPC handler map for browser-only mode.
+     * Keys are Tauri command names, values are functions that receive
+     * the command args and return mock data.
+     */
+    ipcMocks?: Record<string, (args?: Record<string, unknown>) => unknown>;
+    /**
+     * Command to start the Tauri app for full E2E mode.
+     * If not set, assumes the app is already running.
+     * @example 'npx tauri dev'
+     */
+    tauriCommand?: string;
+    /** Working directory for the Tauri command. */
+    tauriCwd?: string;
+    /** Cargo features to enable (e.g. ['e2e-testing']). */
+    tauriFeatures?: string[];
+    /** Plugin socket path. Default: /tmp/tauri-playwright.sock */
+    mcpSocket?: string;
+    /** Startup timeout in seconds. Default: 120 */
+    startTimeout?: number;
+    /**
+     * CDP endpoint for connecting to WebView2 on Windows.
+     * When mode is 'cdp', Playwright connects directly via Chrome DevTools Protocol.
+     * @example 'http://localhost:9222'
+     */
+    cdpEndpoint?: string;
+}
+/**
+ * Test mode selector.
+ * - 'browser': Runs against dev server with mocked Tauri IPC (headless, fast)
+ * - 'tauri': Runs against real Tauri app via plugin socket bridge (all platforms)
+ * - 'cdp': Connects to WebView2 via Chrome DevTools Protocol (Windows only, full Playwright)
+ */
+type TestMode = 'browser' | 'tauri' | 'cdp';
+/**
+ * Extended Playwright fixtures provided by tauri-playwright.
+ * In browser mode, tauriPage is a Playwright Page.
+ * In tauri mode, tauriPage is a TauriPage with Playwright-like API.
+ */
+interface TauriFixtures {
+    tauriPage: TauriPage | BrowserPageAdapter;
+    mode: TestMode;
+}
+/**
+ * Shape of a captured IPC invoke call (browser mode only).
+ */
+interface CapturedInvoke {
+    cmd: string;
+    args: Record<string, unknown>;
+    timestamp: number;
+}
+
+/**
+ * Creates a Playwright test instance with Tauri-specific fixtures.
+ *
+ * **Browser mode** (default): Headless Chromium with mocked Tauri IPC. Fast, no Rust needed.
+ * **Tauri mode**: Socket bridge to the real Tauri webview. Works on all platforms.
+ * **CDP mode**: Direct Chrome DevTools Protocol to WebView2. Windows only, full Playwright.
+ */
+declare function createTauriTest(config: TauriTestConfig): {
+    test: _playwright_test.TestType<_playwright_test.PlaywrightTestArgs & _playwright_test.PlaywrightTestOptions & TauriFixtures, _playwright_test.PlaywrightWorkerArgs & _playwright_test.PlaywrightWorkerOptions>;
+    expect: _playwright_test.Expect<{
+        toBeVisible(this: _playwright_test.ExpectMatcherState, locator: LocatorLike, options?: {
+            timeout?: number;
+        }): Promise<{
+            pass: boolean;
+            name: string;
+            message: () => string;
+        }>;
+        toBeHidden(this: _playwright_test.ExpectMatcherState, locator: LocatorLike, options?: {
+            timeout?: number;
+        }): Promise<{
+            pass: boolean;
+            name: string;
+            message: () => string;
+        }>;
+        toBeEnabled(this: _playwright_test.ExpectMatcherState, locator: LocatorLike, options?: {
+            timeout?: number;
+        }): Promise<{
+            pass: boolean;
+            name: string;
+            message: () => string;
+        }>;
+        toBeDisabled(this: _playwright_test.ExpectMatcherState, locator: LocatorLike, options?: {
+            timeout?: number;
+        }): Promise<{
+            pass: boolean;
+            name: string;
+            message: () => string;
+        }>;
+        toBeEditable(this: _playwright_test.ExpectMatcherState, locator: LocatorLike, options?: {
+            timeout?: number;
+        }): Promise<{
+            pass: boolean;
+            name: string;
+            message: () => string;
+        }>;
+        toBeChecked(this: _playwright_test.ExpectMatcherState, locator: LocatorLike, options?: {
+            timeout?: number;
+        }): Promise<{
+            pass: boolean;
+            name: string;
+            message: () => string;
+        }>;
+        toBeAttached(this: _playwright_test.ExpectMatcherState, locator: LocatorLike, options?: {
+            timeout?: number;
+        }): Promise<{
+            pass: boolean;
+            name: string;
+            message: () => string;
+        }>;
+        toBeEmpty(this: _playwright_test.ExpectMatcherState, locator: LocatorLike, options?: {
+            timeout?: number;
+        }): Promise<{
+            pass: boolean;
+            name: string;
+            message: () => string;
+        }>;
+        toContainText(this: _playwright_test.ExpectMatcherState, locator: LocatorLike, expected: string | RegExp, options?: {
+            timeout?: number;
+        }): Promise<{
+            pass: boolean;
+            name: string;
+            message: () => string;
+        }>;
+        toHaveText(this: _playwright_test.ExpectMatcherState, locator: LocatorLike, expected: string | RegExp, options?: {
+            timeout?: number;
+        }): Promise<{
+            pass: boolean;
+            name: string;
+            message: () => string;
+        }>;
+        toHaveValue(this: _playwright_test.ExpectMatcherState, locator: LocatorLike, expected: string | RegExp, options?: {
+            timeout?: number;
+        }): Promise<{
+            pass: boolean;
+            name: string;
+            message: () => string;
+        }>;
+        toHaveAttribute(this: _playwright_test.ExpectMatcherState, locator: LocatorLike, name: string, value?: string | RegExp, options?: {
+            timeout?: number;
+        }): Promise<{
+            pass: boolean;
+            name: string;
+            message: () => string;
+        }>;
+        toHaveClass(this: _playwright_test.ExpectMatcherState, locator: LocatorLike, expected: string | RegExp, options?: {
+            timeout?: number;
+        }): Promise<{
+            pass: boolean;
+            name: string;
+            message: () => string;
+        }>;
+        toHaveId(this: _playwright_test.ExpectMatcherState, locator: LocatorLike, expected: string, options?: {
+            timeout?: number;
+        }): Promise<{
+            pass: boolean;
+            name: string;
+            message: () => string;
+        }>;
+        toHaveCount(this: _playwright_test.ExpectMatcherState, locator: LocatorLike, expected: number, options?: {
+            timeout?: number;
+        }): Promise<{
+            pass: boolean;
+            name: string;
+            message: () => string;
+        }>;
+        toBeFocused(this: _playwright_test.ExpectMatcherState, locator: LocatorLike, options?: {
+            timeout?: number;
+        }): Promise<{
+            pass: boolean;
+            name: string;
+            message: () => string;
+        }>;
+        toHaveCSS(this: _playwright_test.ExpectMatcherState, locator: LocatorLike, property: string, expected: string | RegExp, options?: {
+            timeout?: number;
+        }): Promise<{
+            pass: boolean;
+            name: string;
+            message: () => string;
+        }>;
+        toHaveURL(this: _playwright_test.ExpectMatcherState, page: PageLike, expected: string | RegExp, options?: {
+            timeout?: number;
+        }): Promise<{
+            pass: boolean;
+            name: string;
+            message: () => string;
+        }>;
+        toHaveTitle(this: _playwright_test.ExpectMatcherState, page: PageLike, expected: string | RegExp, options?: {
+            timeout?: number;
+        }): Promise<{
+            pass: boolean;
+            name: string;
+            message: () => string;
+        }>;
+    }>;
+};
+/**
+ * Helper to retrieve captured IPC calls from the page (browser mode only).
+ */
+declare function getCapturedInvokes(page: Page): Promise<CapturedInvoke[]>;
+/**
+ * Clear the captured IPC call log (browser mode only).
+ */
+declare function clearCapturedInvokes(page: Page): Promise<void>;
+/**
+ * Emit a mock Tauri event into the page (browser mode only).
+ */
+declare function emitMockEvent(page: Page, event: string, payload: unknown): Promise<void>;
+
+/**
+ * IPC Mock Generator for Tauri apps running in browser-only mode.
+ *
+ * When `withGlobalTauri: true` is set in tauri.conf.json, the app accesses
+ * Tauri APIs through `window.__TAURI_INTERNALS__`. This module generates
+ * a script that mocks that global so the app runs in a plain browser.
+ *
+ * The mock intercepts:
+ * - `invoke()` calls — returns data from the mock handler map
+ * - `plugin:event|listen` — stores listeners for mock event emission
+ * - `plugin:event|unlisten` — no-ops
+ * - `convertFileSrc()` — passthrough
+ * - `transformCallback()` — creates callback IDs
+ */
+/**
+ * Generate a JavaScript string to inject via `page.addInitScript()`.
+ * This sets up `window.__TAURI_INTERNALS__` with mock implementations.
+ *
+ * Mock handlers are serialized as functions so they receive the actual
+ * invoke args at call time. This supports dynamic responses like:
+ * ```ts
+ * greet: (args) => `Hello, ${args?.name}!`
+ * ```
+ */
+declare function generateIpcMockScript(mocks: Record<string, (args?: Record<string, unknown>) => unknown>): string;
+/**
+ * Type declarations for the mock globals injected into the page.
+ */
+declare global {
+    interface Window {
+        __TAURI_MOCK_CALLS__: Array<{
+            cmd: string;
+            args: Record<string, unknown>;
+            timestamp: number;
+        }>;
+        __TAURI_MOCK_LISTENERS__: Record<string, string[]>;
+        __TAURI_EMIT_MOCK_EVENT__: (event: string, payload: unknown) => void;
+        __TAURI_GET_MOCK_CALLS__: () => Array<{
+            cmd: string;
+            args: Record<string, unknown>;
+            timestamp: number;
+        }>;
+        __TAURI_CLEAR_MOCK_CALLS__: () => void;
+        __TAURI_INTERNALS__: {
+            invoke: (cmd: string, args?: Record<string, unknown>) => Promise<unknown>;
+            convertFileSrc: (path: string) => string;
+            transformCallback: (callback: (response: unknown) => void) => string;
+            metadata: Record<string, unknown>;
+        };
+    }
+}
+
+/**
+ * Manages the lifecycle of a Tauri app process for E2E testing.
+ * Spawns the process, waits for the plugin socket to become ready,
+ * and handles cleanup.
+ */
+declare class TauriProcessManager {
+    private config;
+    private process;
+    private socketPath;
+    private tcpPort;
+    constructor(config: ProcessConfig);
+    /**
+     * Start the Tauri app and wait for the plugin socket to become available.
+     * Returns the socket path or TCP port to connect to.
+     */
+    start(): Promise<{
+        socketPath?: string;
+        tcpPort?: number;
+    }>;
+    /**
+     * Also supports connecting to an already-running Tauri app.
+     * Just waits for the socket file to appear.
+     */
+    waitForSocket(timeoutMs?: number): Promise<void>;
+    /** Kill the Tauri process. */
+    stop(): void;
+}
+interface ProcessConfig {
+    /** Command to run. Default: 'cargo' */
+    command?: string;
+    /** Command args. Default: ['tauri', 'dev'] */
+    args?: string[];
+    /** Working directory */
+    cwd?: string;
+    /** Cargo features to enable */
+    features?: string[];
+    /** Socket path. Default: /tmp/tauri-playwright.sock */
+    socketPath?: string;
+    /** TCP port (Windows fallback) */
+    tcpPort?: number;
+    /** Startup timeout in seconds. Default: 120 */
+    startTimeout?: number;
+}
+
+export { BrowserPageAdapter, type CapturedInvoke, type LocatorLike, PluginClient, type PluginResponse, type ProcessConfig, type TauriFixtures, TauriKeyboard, TauriLocator, TauriMouse, TauriPage, TauriProcessManager, type TauriTestConfig, type TestMode, type TimeoutOption, clearCapturedInvokes, createTauriTest, emitMockEvent, generateIpcMockScript, getCapturedInvokes, tauriExpect };