import type { Locator, StepFn } from './locator.js';
import { Page } from './page.js';
import { WebLocator } from './web-locator.js';
export interface ExpectOptions {
    timeout?: number;
}
export type ExpectMessage = string | {
    message?: string;
};
export type SoftFailureHandler = (error: ExpectError) => void;
export declare function setSoftFailureHandler(handler: SoftFailureHandler): void;
/**
 * Playwright-style expect for mobile locators, web locators, pages, and plain values.
 *
 * Usage:
 *   expect(locator).toBeVisible()
 *   expect(page).toHaveURL(/dashboard/)
 *   expect(webLocator).toHaveText('Hello')
 *   expect(42).toBe(42)
 *   expect(locator, 'checkout button should appear').toBeVisible()
 *   expect.soft(locator).toBeVisible()   // records the failure, test keeps running
 */
export declare function expect(actual: Page, message?: ExpectMessage): PageAssertions;
export declare function expect(actual: WebLocator, message?: ExpectMessage): WebLocatorAssertions;
export declare function expect(actual: Locator, message?: ExpectMessage): LocatorAssertions;
export declare function expect<T>(actual: T, message?: ExpectMessage): ValueAssertions<T>;
export declare namespace expect {
    var soft: {
        (actual: Page, message?: ExpectMessage): PageAssertions;
        (actual: WebLocator, message?: ExpectMessage): WebLocatorAssertions;
        (actual: Locator, message?: ExpectMessage): LocatorAssertions;
        <T>(actual: T, message?: ExpectMessage): ValueAssertions<T>;
    };
}
interface LocatorLike {
    isVisible(opts?: {
        timeout?: number;
    }): Promise<boolean>;
    isEnabled(opts?: {
        timeout?: number;
    }): Promise<boolean>;
    isChecked(opts?: {
        timeout?: number;
    }): Promise<boolean>;
    isSelected?(opts?: {
        timeout?: number;
    }): Promise<boolean>;
    isFocused?(opts?: {
        timeout?: number;
    }): Promise<boolean>;
    getText(opts?: {
        timeout?: number;
    }): Promise<string>;
    getValue(opts?: {
        timeout?: number;
    }): Promise<string>;
    count(): Promise<number>;
    expectTimeout?: number;
    _stepFn?: StepFn | null;
}
declare class LocatorAssertions {
    protected readonly locator: LocatorLike;
    protected readonly negated: boolean;
    constructor(locator: LocatorLike, negated: boolean);
    _message?: string;
    _soft?: boolean;
    get not(): LocatorAssertions;
    private assertionTimeout;
    protected _wrapAssertion<T>(method: string, fn: () => Promise<T>): Promise<T>;
    toBeVisible(opts?: ExpectOptions): Promise<void>;
    toBeHidden(opts?: ExpectOptions): Promise<void>;
    toBeEnabled(opts?: ExpectOptions): Promise<void>;
    toBeDisabled(opts?: ExpectOptions): Promise<void>;
    toBeSelected(opts?: ExpectOptions): Promise<void>;
    toBeFocused(opts?: ExpectOptions): Promise<void>;
    toBeChecked(opts?: ExpectOptions): Promise<void>;
    toHaveText(expected: string | RegExp, opts?: ExpectOptions): Promise<void>;
    toContainText(expected: string, opts?: ExpectOptions): Promise<void>;
    toHaveCount(expected: number, opts?: ExpectOptions): Promise<void>;
    toBeEmpty(opts?: ExpectOptions): Promise<void>;
    toHaveValue(expected: string | RegExp, opts?: ExpectOptions): Promise<void>;
    protected assertBoolean(name: string, poll: () => Promise<boolean>, opts?: ExpectOptions): Promise<void>;
    protected assertText(predicate: (text: string) => boolean, expected: string | RegExp, opts?: ExpectOptions): Promise<void>;
    private assertStringMatch;
    protected retryAssertion<T>(poll: () => Promise<T>, predicate: (value: T) => boolean, timeout: number, failMessage: string | (() => string)): Promise<void>;
}
declare class ValueAssertions<T> {
    private readonly actual;
    private readonly negated;
    constructor(actual: T, negated: boolean);
    get not(): ValueAssertions<T>;
    toBe(expected: T): void;
    toEqual(expected: T): void;
    toBeTruthy(): void;
    toBeFalsy(): void;
    toBeGreaterThan(expected: number): void;
    toBeLessThan(expected: number): void;
    toBeCloseTo(expected: number, precision?: number): void;
    toContain(expected: unknown): void;
    toBeNull(): void;
    toBeUndefined(): void;
    toMatch(pattern: RegExp | string): void;
    toBeInstanceOf(expected: Function): void;
    toBeDefined(): void;
    toBeGreaterThanOrEqual(expected: number): void;
    toBeLessThanOrEqual(expected: number): void;
    toBeNaN(): void;
    toContainEqual(expected: unknown): void;
    toHaveLength(expected: number): void;
    toHaveProperty(key: string, value?: unknown): void;
    toMatchObject(expected: Record<string, unknown>): void;
    toStrictEqual(expected: T): void;
    toThrow(expected?: string | RegExp): void;
    private assert;
}
declare class PageAssertions {
    private readonly page;
    private readonly negated;
    constructor(page: Page, negated: boolean);
    _message?: string;
    _soft?: boolean;
    get not(): PageAssertions;
    private _wrapAssertion;
    private matches;
    toHaveURL(url: string | RegExp, opts?: ExpectOptions): Promise<void>;
    toHaveTitle(title: string | RegExp, opts?: ExpectOptions): Promise<void>;
}
declare class WebLocatorAssertions {
    private readonly webLocator;
    private readonly negated;
    constructor(webLocator: WebLocator, negated: boolean);
    _message?: string;
    _soft?: boolean;
    get not(): WebLocatorAssertions;
    private assertionTimeout;
    private runMatcher;
    toBeVisible(opts?: ExpectOptions): Promise<void>;
    toBeHidden(opts?: ExpectOptions): Promise<void>;
    toBeEnabled(opts?: ExpectOptions): Promise<void>;
    toBeDisabled(opts?: ExpectOptions): Promise<void>;
    toBeEditable(opts?: ExpectOptions): Promise<void>;
    toBeFocused(opts?: ExpectOptions): Promise<void>;
    toBeAttached(opts?: ExpectOptions): Promise<void>;
    toBeInViewport(opts?: ExpectOptions & {
        ratio?: number;
    }): Promise<void>;
    toBeChecked(opts?: ExpectOptions): Promise<void>;
    toBeEmpty(opts?: ExpectOptions): Promise<void>;
    toHaveText(expected: string | RegExp, opts?: ExpectOptions): Promise<void>;
    toContainText(expected: string | RegExp, opts?: ExpectOptions): Promise<void>;
    toHaveValue(expected: string | RegExp, opts?: ExpectOptions): Promise<void>;
    toHaveCount(expected: number, opts?: ExpectOptions): Promise<void>;
    toHaveAttribute(name: string, expected: string | RegExp, opts?: ExpectOptions): Promise<void>;
    toHaveClass(expected: string | RegExp, opts?: ExpectOptions): Promise<void>;
    toContainClass(expected: string | RegExp, opts?: ExpectOptions): Promise<void>;
    toHaveCSS(name: string, expected: string | RegExp, opts?: ExpectOptions): Promise<void>;
    toHaveId(expected: string | RegExp, opts?: ExpectOptions): Promise<void>;
    toHaveJSProperty(name: string, expected: unknown, opts?: ExpectOptions): Promise<void>;
}
export declare class ExpectError extends Error {
    constructor(message: string);
}
export {};
//# sourceMappingURL=expect.d.ts.map