import type { Browser, BrowserContext, Page } from "playwright";
import type { PageListenerManager } from "./page-listener-manager.js";
import type { ScreencastManager } from "./screencast-manager.js";
import type { StepArchive } from "./step-archive.js";

export declare const DEFAULT_BROWSER_ID = "default";

export type JsonValue = string | number | boolean | null | JsonValue[] | {
    [key: string]: JsonValue;
};

export type JsonObject = {
    [key: string]: JsonValue;
};

export interface ScreencastFrame {
    
    dataUrl: string;
    
    base64: string;
    
    width: number;
    
    height: number;
    
    timestamp: number;
    
    url: string;
    
    binaryFrame?: Buffer;
}

export type FrameSubscriber = (frame: ScreencastFrame) => void;

export interface SessionBrowser {
    
    agentId: string;
    
    scopeKey: string;
    
    browserId: string;
    
    title: string;
    
    browser: Browser;
    
    context: BrowserContext;
    
    pages: Page[];
    
    activePageIndex: number;
    
    screencast: ScreencastManager;
    
    archive: StepArchive;
    
    launchedAt: number;
    
    lastActivityAt: number;
    
    humanTakeover: boolean;
    
    takeoverClientId?: string;
    
    qualityPreset: QualityPreset;
    
    listenerManager: PageListenerManager;
    
    autoSaveTimer?: ReturnType<typeof setInterval>;
}

export declare function makeBrowserKey(agentId: string, browserId: string): string;

export declare function parseBrowserKey(key: string): {
    agentId: string;
    browserId: string;
} | null;

export interface ScreencastConfig {
    
    quality?: number;
    
    maxWidth?: number;
    
    maxHeight?: number;
    
    everyNthFrame?: number;
    
    maxFramesPerSecond?: number;
    
    format?: "jpeg" | "png";
    
    tileMode?: boolean;
}

export interface StepArchiveConfig {
    
    maxSteps?: number;
    
    screenshotQuality?: number;
}

export interface SsrfConfig {
    
    allowPrivate?: boolean;
    
    blocklist?: string[];
    
    allowlist?: string[];
}

export interface WsServerConfig {
    
    port?: number;
    
    host?: string;
    
    maxSendBytes?: number;
    
    idleTimeoutMs?: number;
    
    heartbeatMs?: number;
}

export interface BrowserPoolConfig {
    
    headless?: boolean;
    
    executablePath?: string;
    
    stealth?: boolean;
    
    viewportWidth?: number;
    
    viewportHeight?: number;
    
    maxPagesPerSession?: number;
    
    maxSessionDurationMs?: number;
    
    idleTimeoutMs?: number;
    
    launchArgs?: string[];
    
    screencastConfig?: ScreencastConfig;
    
    archiveConfig?: StepArchiveConfig;
    
    ssrfConfig?: SsrfConfig;
    
    userAgent?: string;
    
    locale?: string;
    
    timezone?: string;
    
    profileDir?: string;
}

export declare const MAX_SESSIONS = 8;

export declare const MAX_SESSIONS_PER_AGENT = 4;

export declare const MAX_PAGES_PER_SESSION = 5;

export declare const SESSION_TIMEOUT_MS = 0;

export declare const IDLE_TIMEOUT_MS = 0;

export declare const WS_PORT = 7891;

export declare const WS_HOST = "127.0.0.1";

export declare const WS_DEFAULT_MAX_SEND_BYTES: number;

export declare const WS_DEFAULT_HEARTBEAT_MS: number;

export declare const WS_DEFAULT_IDLE_TIMEOUT_MS: number;

export declare const IDLE_CHECK_INTERVAL_MS: number;

export type QualityPreset = "original" | "hd" | "smooth";

export interface QualityPresetConfig {
    
    quality: number;
    
    maxWidth: number;
    
    maxHeight: number;
}

export declare const QUALITY_PRESETS: Record<QualityPreset, QualityPresetConfig>;

export declare function isQualityPreset(value: unknown): value is QualityPreset;

export declare const TILE_DIFF_CONFIG: {
    
    readonly tileSize: 160;
    
    readonly sampleStep: 8;
    
    readonly diffThreshold: 24;
    
    readonly minChangedSamples: 1;
    
    readonly fullFrameFallbackRatio: 0.5;
    
    readonly encodeConcurrency: 8;
};

export interface ScreencastTileFrame {
    kind: "tile";
    
    width: number;
    
    height: number;
    
    tiles: Array<{
        x: number;
        y: number;
        w: number;
        h: number;
        data: Buffer;
    }>;
}

export interface ScreencastFullFrame {
    kind: "full";
    
    width: number;
    
    height: number;
    
    data: Buffer;
}

export type ScreencastDiffFrame = ScreencastTileFrame | ScreencastFullFrame;