export declare const VIEWPORT_SNAPSHOT_REQUEST = "replo:viewport-snapshot:request";
export declare const VIEWPORT_SNAPSHOT_RESPONSE = "replo:viewport-snapshot:response";
export declare const VIEWPORT_CONTEXT_REQUEST = "replo:viewport-context:request";
export declare const VIEWPORT_CONTEXT_RESPONSE = "replo:viewport-context:response";
/**
 * Levels of iframe nesting a capture request fans out to below the requester.
 * 2 covers the deepest product surface: agent-ui → miniapp → builder preview.
 */
export declare const VIEWPORT_SNAPSHOT_MAX_DEPTH = 2;
export interface ViewportSnapshotRequestMessage {
    type: typeof VIEWPORT_SNAPSHOT_REQUEST | typeof VIEWPORT_CONTEXT_REQUEST;
    requestId: string;
    frameIndex: number;
    remainingDepth: number;
}
export interface ViewportFrameRect {
    x: number;
    y: number;
    width: number;
    height: number;
}
/** One frame's serialized DOM plus its own captured child frames, recursively. */
export interface ViewportFrameCapture {
    snapshot: unknown;
    childFrames: ViewportChildFrame[];
    context?: ViewportFrameContext;
}
export interface ViewportFrameContext {
    viewport: {
        width: number;
        height: number;
    };
    scroll: {
        x: number;
        y: number;
        maximumX: number;
        maximumY: number;
    };
}
export interface ViewportChildFrame {
    frameIndex: number;
    rect: ViewportFrameRect;
    capture: ViewportFrameCapture;
}
export interface ViewportSnapshotResponseMessage {
    type: typeof VIEWPORT_SNAPSHOT_RESPONSE | typeof VIEWPORT_CONTEXT_RESPONSE;
    requestId: string;
    frameIndex: number;
    capture: ViewportFrameCapture | null;
}
interface RelayMessageListener {
    (event: {
        data: unknown;
        source: unknown;
        origin?: string;
    }): void;
}
interface RelayWindow {
    readonly parent: unknown;
    readonly frames: ArrayLike<{
        postMessage: (message: unknown, targetOrigin: string) => void;
    }>;
    addEventListener(type: "message", listener: RelayMessageListener): void;
    removeEventListener(type: "message", listener: RelayMessageListener): void;
    setTimeout(listener: () => void, timeout: number): number;
    clearTimeout(timeoutId: number): void;
}
/**
 * Default trust check for who may request this frame's DOM: Replo app origins
 * plus local dev hosts. Runtimes embedded in arbitrary third-party pages
 * (published sites) silently ignore requests from anything else.
 */
export declare function isTrustedViewportSnapshotRequester(origin: string): boolean;
/**
 * Ask every direct child frame for its capture (each child cascades to its own
 * children while `remainingDepth` allows) and collect the responses. Resolves
 * at the timeout with whatever arrived — a frame running an older runtime
 * simply never answers and is omitted.
 */
export declare function requestChildViewportSnapshots({ targetWindow, requestId, timeoutMs, remainingDepth, requestType, }: {
    targetWindow: RelayWindow;
    requestId: string;
    timeoutMs: number;
    remainingDepth?: number;
    requestType?: ViewportSnapshotRequestMessage["type"];
}): Promise<{
    frameIndex: number;
    capture: ViewportFrameCapture;
}[]>;
export declare function requestChildViewportContexts(input: Parameters<typeof requestChildViewportSnapshots>[0]): Promise<{
    frameIndex: number;
    capture: ViewportFrameCapture;
}[]>;
/**
 * Child-side responder: on a trusted parent request, capture this frame's DOM
 * or lightweight viewing context, cascade to child frames, and answer only the
 * requesting origin.
 */
export declare function startViewportSnapshotResponder({ targetWindow, takeSnapshot, measureFrameRect, measureViewportContext, isTrustedRequester, cascadeTimeoutMs, }: {
    targetWindow: RelayWindow;
    takeSnapshot: () => unknown | Promise<unknown>;
    measureFrameRect: (frameIndex: number) => ViewportFrameRect | null;
    measureViewportContext?: () => ViewportFrameContext;
    isTrustedRequester?: (origin: string) => boolean;
    cascadeTimeoutMs?: number;
}): () => void;
export {};