import { WEBDRIVER_ELEMENT_ID_KEY } from '@midscene/shared/constants';

export declare abstract class BaseServiceManager implements WebDriverServiceManager {
    protected port: number;
    protected host: string;
    constructor(port: number, host?: string);
    abstract start(): Promise<void>;
    abstract stop(): Promise<void>;
    abstract isRunning(): boolean;
    restart(): Promise<void>;
    getEndpoint(): string;
    getPort(): number;
    getHost(): string;
}

export declare interface DeviceInfo {
    udid: string;
    name: string;
    model: string;
}

export declare function makeWebDriverRequest(baseUrl: string, method: string, endpoint: string, data?: any, timeout?: number): Promise<any>;

export declare interface Point {
    x: number;
    y: number;
}

export declare interface Size {
    width: number;
    height: number;
}

export declare interface WDAConfig {
    port: number;
    host?: string;
    wdaPath?: string;
    bundleId?: string;
    usePrebuiltWDA?: boolean;
}

export declare interface WDAElement {
    ELEMENT: string;
    [WEBDRIVER_ELEMENT_ID_KEY]: string;
}

export declare interface WDAElementInfo {
    type: string;
    name: string;
    label: string;
    value: string;
    rect: {
        x: number;
        y: number;
        width: number;
        height: number;
    };
    enabled: boolean;
    visible: boolean;
}

export declare class WDAManager extends BaseServiceManager {
    private static instances;
    private config;
    private isStarted;
    private constructor();
    static getInstance(port?: number, host?: string): WDAManager;
    start(): Promise<void>;
    stop(): Promise<void>;
    isRunning(): boolean;
    private startWDA;
    private checkWDAPreparation;
    private isWDARunning;
    private waitForWDA;
}

export declare interface WDASession {
    sessionId: string;
    capabilities: Record<string, any>;
}

export declare class WebDriverClient {
    protected baseUrl: string;
    protected sessionId: string | null;
    protected ownsSession: boolean;
    protected port: number;
    protected host: string;
    protected timeout: number;
    constructor(options?: WebDriverOptions);
    get sessionInfo(): WDASession | null;
    createSession(capabilities?: any): Promise<WDASession>;
    deleteSession(): Promise<void>;
    takeScreenshot(): Promise<string>;
    getWindowSize(): Promise<Size>;
    getDeviceInfo(): Promise<DeviceInfo | null>;
    protected makeRequest(method: string, endpoint: string, data?: any, options?: WebDriverRequestOptions): Promise<any>;
    /**
     * Build a session-scoped endpoint path.
     * If the endpoint already starts with `/session/`, return as-is;
     * otherwise prepend `/session/${sessionId}`.
     */
    protected buildSessionEndpoint(endpoint: string): string;
    protected ensureSession(): void;
}

export declare interface WebDriverOptions {
    port?: number;
    host?: string;
    timeout?: number;
    /**
     * Existing WebDriver session ID to attach to instead of creating a new one.
     * Sessions provided by the caller are detached locally on cleanup and are not
     * deleted from the remote WebDriver server.
     */
    sessionId?: string;
}

export declare class WebDriverRequestError extends Error {
    status?: number | undefined;
    response?: any | undefined;
    constructor(message: string, status?: number | undefined, response?: any | undefined);
}

/** Per-request overrides for WebDriver transport calls. */
export declare interface WebDriverRequestOptions {
    /** Override the client-wide timeout for this request only. */
    timeout?: number;
}

export declare interface WebDriverServiceManager {
    start(): Promise<void>;
    stop(): Promise<void>;
    restart(): Promise<void>;
    isRunning(): boolean;
    getEndpoint(): string;
    getPort(): number;
    getHost(): string;
}

export { }