interface TunnelClientConfig {
    apiUrl: string;
    token: string;
    tunnelId?: string;
    cacheTtlMs?: number;
}
declare class TunnelClientError extends Error {
    readonly code: number;
    readonly requestId?: string | undefined;
    readonly isPermissionRequest: boolean;
    constructor(code: number, message: string, requestId?: string | undefined, isPermissionRequest?: boolean);
}
declare class TunnelClient {
    private apiUrl;
    private token;
    private explicitTunnelId;
    private cachedTunnelId;
    private cacheTimestamp;
    private cacheTtlMs;
    readonly fs: FsNamespace;
    readonly shell: ShellNamespace;
    readonly desktop: DesktopNamespace;
    constructor(config: TunnelClientConfig);
    rpc(method: string, params?: Record<string, unknown>): Promise<unknown>;
    rpcWithPermissionFlow(method: string, params?: Record<string, unknown>): Promise<unknown>;
    getConnections(): Promise<Array<Record<string, unknown>>>;
    resolveTunnelId(): Promise<string>;
}
declare class FsNamespace {
    private client;
    constructor(client: TunnelClient);
    read(path: string, encoding?: string): Promise<{
        content: string;
        size: number;
        path: string;
    }>;
    write(path: string, content: string, encoding?: string): Promise<{
        path: string;
        size: number;
    }>;
    list(path: string, recursive?: boolean): Promise<{
        entries: Array<{
            name: string;
            path: string;
            isDirectory: boolean;
            isFile: boolean;
        }>;
        count: number;
    }>;
    stat(path: string): Promise<Record<string, unknown>>;
    delete(path: string): Promise<Record<string, unknown>>;
}
declare class ShellNamespace {
    private client;
    constructor(client: TunnelClient);
    exec(command: string, args?: string[], options?: {
        cwd?: string;
        timeout?: number;
    }): Promise<{
        exitCode: number | null;
        signal: string | null;
        stdout: string;
        stderr: string;
        stdoutTruncated: boolean;
        stderrTruncated: boolean;
    }>;
}
declare class DesktopNamespace {
    private client;
    constructor(client: TunnelClient);
    screenshot(params?: {
        region?: {
            x: number;
            y: number;
            width: number;
            height: number;
        };
        windowId?: number;
    }): Promise<{
        image: string;
        width: number;
        height: number;
        format?: string;
    }>;
    click(params: {
        x: number;
        y: number;
        button?: string;
        clicks?: number;
        modifiers?: string[];
    }): Promise<unknown>;
    type(text: string, delay?: number): Promise<unknown>;
    key(keys: string[]): Promise<unknown>;
    mouseMove(x: number, y: number): Promise<unknown>;
    mouseDrag(fromX: number, fromY: number, toX: number, toY: number, button?: string): Promise<unknown>;
    mouseScroll(x: number, y: number, deltaX?: number, deltaY?: number): Promise<unknown>;
    windowList(): Promise<{
        windows: Array<{
            id: number;
            app: string;
            title: string;
            bounds: {
                x: number;
                y: number;
                width: number;
                height: number;
            };
            minimized: boolean;
        }>;
    }>;
    windowFocus(windowId: number): Promise<unknown>;
    appLaunch(app: string): Promise<unknown>;
    appQuit(app: string): Promise<unknown>;
    clipboardRead(): Promise<{
        text: string;
    }>;
    clipboardWrite(text: string): Promise<unknown>;
    screenInfo(): Promise<{
        width: number;
        height: number;
        scaleFactor: number;
    }>;
    cursorImage(radius?: number): Promise<{
        image: string;
        width: number;
        height: number;
        format?: string;
    }>;
    axTree(params?: {
        pid?: number;
        maxDepth?: number;
        roles?: string[];
    }): Promise<{
        root: AXElement;
        elementCount: number;
    }>;
    axAction(elementId: string, action: string, pid?: number): Promise<Record<string, unknown>>;
    axSetValue(elementId: string, value: string, pid?: number): Promise<Record<string, unknown>>;
    axFocus(elementId: string, pid?: number): Promise<Record<string, unknown>>;
    axSearch(query: string, params?: {
        role?: string;
        pid?: number;
        maxResults?: number;
    }): Promise<{
        elements: AXElement[];
    }>;
}
interface AXElement {
    id: string;
    role: string;
    title: string;
    value: string;
    description: string;
    bounds: {
        x: number;
        y: number;
        width: number;
        height: number;
    };
    children: AXElement[];
    actions: string[];
    enabled: boolean;
    focused: boolean;
}

interface TunnelToolParameter {
    type: string;
    description: string;
    required?: boolean;
    items?: {
        type: string;
    };
    enum?: string[];
}
interface TunnelToolDefinition {
    name: string;
    description: string;
    parameters: Record<string, TunnelToolParameter>;
    execute: (args: Record<string, unknown>) => Promise<string>;
}
declare function createTunnelTools(client: TunnelClient): TunnelToolDefinition[];

export { type AXElement, TunnelClient, type TunnelClientConfig, TunnelClientError, type TunnelToolDefinition, type TunnelToolParameter, createTunnelTools };