import type { UiObserverRef } from '@farmslot/protocol';
import { type UiPoint } from '../adapters/gesture.js';
import type { StandardUiAction, UiActionTransport } from '../adapters/ui.js';
import type { ActionExecutionContext, RecipeObservationResult } from '../core/types.js';
export declare function sleep(ms: number): Promise<void>;
export declare function dataTestId(testId: string): string;
export interface CdpTargetInfo {
    id: string;
    type: string;
    title?: string;
    url?: string;
    webSocketDebuggerUrl?: string;
    devtoolsFrontendUrl?: string;
    description?: string;
}
export interface RetryJsonGetOptions {
    timeoutMs?: number;
    intervalMs?: number;
}
export interface JsonGetOptions {
    timeoutMs?: number;
}
export interface SelectCdpTargetOptions {
    host?: string;
    port: number;
    type?: string;
    urlIncludes?: string;
    titleIncludes?: string;
    predicate?: (target: CdpTargetInfo) => boolean;
}
interface CdpCallOptions {
    timeoutMs?: number;
}
export declare function jsonGet<T = unknown>(url: string, options?: JsonGetOptions): Promise<T>;
export declare function retryJsonGet<T = unknown>(url: string, options?: RetryJsonGetOptions): Promise<T>;
export declare function listCdpTargets(host: string, port: number): Promise<CdpTargetInfo[]>;
export declare function selectCdpTarget(options: SelectCdpTargetOptions): Promise<CdpTargetInfo>;
export type CdpEventHandler = (params: Record<string, unknown>) => void;
export declare class CdpSession {
    #private;
    private constructor();
    static connect(webSocketDebuggerUrl: string, options?: {
        timeoutMs?: number;
    }): Promise<CdpSession>;
    call<T = unknown>(method: string, params?: Record<string, unknown>, options?: CdpCallOptions): Promise<T>;
    on(method: string, handler: CdpEventHandler): () => void;
    close(): void;
}
export interface CdpCompositorProbe {
    status: 'ready' | 'suspended' | 'not-interactive';
    frameAdvanced: boolean;
    interactiveTargetFound: boolean;
    hitTestOk: boolean | null;
    reason?: string;
}
interface CdpCallSession {
    call<T = unknown>(method: string, params?: Record<string, unknown>, options?: CdpCallOptions): Promise<T>;
}
/**
 * Distinguish a reachable JavaScript context from a renderable, interactive
 * browser page. Hardened pages are retried in an isolated world so page policy
 * cannot hide requestAnimationFrame from the readiness probe. Navigation races
 * return a suspended report rather than rejecting the probe.
 */
export declare function probeCdpCompositorInteractivity(session: CdpCallSession, timeoutMs?: number): Promise<CdpCompositorProbe>;
export declare class CdpWebPage {
    readonly session: CdpSession;
    constructor(session: CdpSession);
    static connectToTarget(target: CdpTargetInfo): Promise<CdpWebPage>;
    navigate(url: string, timeoutMs?: number): Promise<unknown>;
    private currentNavigationUrl;
    private waitForNavigationUrlChange;
    waitForDocumentReady(options: {
        expectedUrl?: string;
        timeoutMs?: number;
    }): Promise<void>;
    waitForDomSettled(timeoutMs?: number): Promise<void>;
    evaluate<T = unknown>(expression: string): Promise<T>;
    evaluateInIsolatedWorld<T = unknown>(expression: string, worldName: string): Promise<T>;
    click(selector: string): Promise<unknown>;
    clickText(text: string): Promise<unknown>;
    setInput(selector: string, value: string): Promise<unknown>;
    keyPress(key: string): Promise<unknown>;
    clickPoint(x: number, y: number): Promise<void>;
    resolveGesturePoint(target: string | UiPoint): Promise<UiPoint>;
    scroll(options: {
        selector?: string;
        deltaX?: number;
        deltaY?: number;
        intoView?: boolean;
    }): Promise<unknown>;
    waitFor(options: {
        selector?: string;
        text?: string;
        expected?: string;
        timeoutMs?: number;
    }): Promise<unknown>;
    waitForSelector(selector: string, options?: {
        timeoutMs?: number;
    }): Promise<unknown>;
    waitForExpression(expression: string, options?: {
        timeoutMs?: number;
    }): Promise<unknown>;
    screenshot(context?: ActionExecutionContext, relPath?: string, metadata?: Record<string, unknown>): Promise<string | {
        path: string;
        type: string;
        nodeId: string;
        label?: string;
        category?: string;
        mimeType: string;
    }>;
    observe(refs: readonly UiObserverRef[]): Promise<RecipeObservationResult>;
    close(): void;
}
export interface CdpWebUiTransportInput {
    action: StandardUiAction;
    node: Record<string, unknown>;
    context: ActionExecutionContext;
}
export interface CreateCdpWebUiTransportOptions {
    getPage?(input: CdpWebUiTransportInput): Promise<CdpWebPage>;
    withPage?<T>(input: CdpWebUiTransportInput, callback: (page: CdpWebPage) => Promise<T>): Promise<T>;
}
export declare function createCdpWebUiTransport(options: CreateCdpWebUiTransportOptions): UiActionTransport;
export declare function selectorForUiInput(node: Record<string, unknown>): string | undefined;
export {};
//# sourceMappingURL=cdp.d.ts.map