@kazzle/app 0.1.929 → 0.1.930

package/dist/sdk.d.ts

@@ -1 +1 @@
-export * from 'kazzle';
+export * from './vendor/kazzle/index.js';

package/dist/sdk.js

@@ -4,7 +4,10 @@
 // (server/apps/apps.runtime-env.ts), so `new Kazzle()` needs no arguments
 // there: the key scopes every call to the app's space.
 //
-// The implementation lives in the `kazzle` package (packages/kazzle-sdk) — an
-// optional peer dependency, so apps that do not drive computers or browsers do
-// not install it.
-export * from 'kazzle';
+// The implementation lives in the `kazzle` package (packages/kazzle-sdk). In
+// the monorepo this resolves to the workspace package; the PUBLISHED build
+// vendors the SDK's dist under dist/vendor/kazzle and rewrites this entry to
+// point at it (scripts/build.ts), so app code installed from npm never needs a
+// separate `kazzle` install.
+// Published build: the SDK is vendored (see scripts/build.ts).
+export * from './vendor/kazzle/index.js';

package/dist/vendor/kazzle/browsers.d.ts

@@ -0,0 +1,56 @@
+import { type KazzleHttp } from './http';
+import { TabsApi } from './browsers.tabs';
+import { ProfilesApi } from './browsers.profiles';
+import type { ActionResult, BrowserCreateOptions, BrowserCreateResponse, BrowserRow, BrowserState, ListResponse, TabOpenResponse, TabRow } from './sdk.types';
+/**
+ * Handle for one browser session, bound to the first tab from the create
+ * response. Use `kazzle.browsers.tabs.*` with other tab ids for multi-tab work.
+ */
+export declare class Browser {
+    private readonly api;
+    /** Browser session id. */
+    readonly id: string;
+    /** The session's first tab — the target of nav()/screenshot() below. */
+    readonly tabId: string;
+    /** Host computer, or null for a stealth cloud browser. */
+    readonly computerId: string | null;
+    readonly provider: string;
+    /** Open this URL in a browser of your own to watch the session live. */
+    readonly liveViewUrl: string | null;
+    constructor(api: BrowsersApi, created: BrowserCreateResponse);
+    /** Navigate the first tab. */
+    nav(url: string): Promise<ActionResult>;
+    /** Screenshot the first tab. Returns PNG (or JPEG) bytes. */
+    screenshot(): Promise<Uint8Array>;
+    /** Any tab action on the first tab by its URL segment, e.g. action('click', { ref }). */
+    action(segment: string, body?: Record<string, unknown>): Promise<ActionResult>;
+    /** List the session's open tabs. */
+    tabs(): Promise<ListResponse<TabRow>>;
+    /** Open another tab. The new tab id is the response's tab_id. */
+    openTab(options?: {
+        url?: string;
+    }): Promise<TabOpenResponse>;
+    /** Close the browser session. The profile (logins, cookies) survives. */
+    close(): Promise<ActionResult>;
+}
+export declare class BrowsersApi {
+    private readonly http;
+    readonly tabs: TabsApi;
+    readonly profiles: ProfilesApi;
+    constructor(http: KazzleHttp);
+    /**
+     * Open a browser session. No options means a stealth cloud browser
+     * (anti-bot, proxies) for the real web; pass computerId for that computer's
+     * built-in browser (its own pages: app previews, localhost). Returns a
+     * Browser handle bound to the first tab.
+     */
+    create(options?: BrowserCreateOptions): Promise<Browser>;
+    /** List browser sessions in the API key's space. */
+    list(options?: {
+        computerId?: string;
+    }): Promise<ListResponse<BrowserRow>>;
+    /** State of a browser session plus its live_view_url and tabs. */
+    get(browserId: string): Promise<BrowserState>;
+    /** Close the browser session and delete its tabs. The profile survives. */
+    close(browserId: string): Promise<ActionResult>;
+}

package/dist/vendor/kazzle/browsers.js

@@ -0,0 +1,88 @@
+// kazzle.browsers.* — browser sessions (/browsers). A browser id is a session
+// id; the durable identity is the profile. create() returns a Browser handle
+// bound to the session's first tab for the common drive-one-page flow.
+import { apiPath } from './http';
+import { TabsApi } from './browsers.tabs';
+import { ProfilesApi } from './browsers.profiles';
+/**
+ * Handle for one browser session, bound to the first tab from the create
+ * response. Use `kazzle.browsers.tabs.*` with other tab ids for multi-tab work.
+ */
+export class Browser {
+    api;
+    /** Browser session id. */
+    id;
+    /** The session's first tab — the target of nav()/screenshot() below. */
+    tabId;
+    /** Host computer, or null for a stealth cloud browser. */
+    computerId;
+    provider;
+    /** Open this URL in a browser of your own to watch the session live. */
+    liveViewUrl;
+    constructor(api, created) {
+        this.api = api;
+        this.id = created.id;
+        this.tabId = created.tab_id;
+        this.computerId = created.computer_id;
+        this.provider = created.provider;
+        this.liveViewUrl = created.live_view_url;
+    }
+    /** Navigate the first tab. */
+    nav(url) {
+        return this.api.tabs.nav(this.id, this.tabId, { url });
+    }
+    /** Screenshot the first tab. Returns PNG (or JPEG) bytes. */
+    screenshot() {
+        return this.api.tabs.screenshot(this.id, this.tabId);
+    }
+    /** Any tab action on the first tab by its URL segment, e.g. action('click', { ref }). */
+    action(segment, body = {}) {
+        return this.api.tabs.action(this.id, this.tabId, segment, body);
+    }
+    /** List the session's open tabs. */
+    tabs() {
+        return this.api.tabs.list(this.id);
+    }
+    /** Open another tab. The new tab id is the response's tab_id. */
+    openTab(options = {}) {
+        return this.api.tabs.open(this.id, options);
+    }
+    /** Close the browser session. The profile (logins, cookies) survives. */
+    close() {
+        return this.api.close(this.id);
+    }
+}
+export class BrowsersApi {
+    http;
+    tabs;
+    profiles;
+    constructor(http) {
+        this.http = http;
+        this.tabs = new TabsApi(http);
+        this.profiles = new ProfilesApi(http);
+    }
+    /**
+     * Open a browser session. No options means a stealth cloud browser
+     * (anti-bot, proxies) for the real web; pass computerId for that computer's
+     * built-in browser (its own pages: app previews, localhost). Returns a
+     * Browser handle bound to the first tab.
+     */
+    async create(options = {}) {
+        const created = await this.http.json('POST', '/browsers', options);
+        return new Browser(this, created);
+    }
+    /** List browser sessions in the API key's space. */
+    list(options = {}) {
+        return this.http.json('GET', '/browsers', undefined, {
+            computer_id: options.computerId,
+        });
+    }
+    /** State of a browser session plus its live_view_url and tabs. */
+    get(browserId) {
+        return this.http.json('GET', apiPath `/browsers/${browserId}`);
+    }
+    /** Close the browser session and delete its tabs. The profile survives. */
+    close(browserId) {
+        return this.http.json('DELETE', apiPath `/browsers/${browserId}`);
+    }
+}

package/dist/vendor/kazzle/browsers.profiles.d.ts

@@ -0,0 +1,16 @@
+import { type KazzleHttp } from './http';
+import type { ListResponse, OkResponse, ProfileCreateOptions, ProfileCreateResponse, ProfileRow } from './sdk.types';
+export declare class ProfilesApi {
+    private readonly http;
+    constructor(http: KazzleHttp);
+    /**
+     * Ensure the durable profile for a browser backend. No computerId means the
+     * space's stealth profile. Idempotent: an existing profile comes back with
+     * `created: false`.
+     */
+    create(options?: ProfileCreateOptions): Promise<ProfileCreateResponse>;
+    /** List the browser profiles in the API key's space. */
+    list(): Promise<ListResponse<ProfileRow>>;
+    /** Delete a profile. Cascades its sessions and tabs; saved logins and cookies are gone. */
+    delete(profileId: string): Promise<OkResponse>;
+}

package/dist/vendor/kazzle/browsers.profiles.js

@@ -0,0 +1,26 @@
+// kazzle.browsers.profiles.* — durable browsing identities (/browsers/profiles).
+// Profiles hold logins and cookies; they outlive browser sessions and are
+// shared across them.
+import { apiPath } from './http';
+export class ProfilesApi {
+    http;
+    constructor(http) {
+        this.http = http;
+    }
+    /**
+     * Ensure the durable profile for a browser backend. No computerId means the
+     * space's stealth profile. Idempotent: an existing profile comes back with
+     * `created: false`.
+     */
+    create(options = {}) {
+        return this.http.json('POST', '/browsers/profiles', options);
+    }
+    /** List the browser profiles in the API key's space. */
+    list() {
+        return this.http.json('GET', '/browsers/profiles');
+    }
+    /** Delete a profile. Cascades its sessions and tabs; saved logins and cookies are gone. */
+    delete(profileId) {
+        return this.http.json('DELETE', apiPath `/browsers/profiles/${profileId}`);
+    }
+}

package/dist/vendor/kazzle/browsers.tabs.d.ts

@@ -0,0 +1,62 @@
+import { type KazzleHttp } from './http';
+import type { ActionResult, ListResponse, TabOpenResponse, TabRow } from './sdk.types';
+type Body = Record<string, unknown>;
+export declare class TabsApi {
+    private readonly http;
+    constructor(http: KazzleHttp);
+    /** List the open tabs of a browser session. */
+    list(browserId: string): Promise<ListResponse<TabRow>>;
+    /** Open a new tab. The new tab id is the response's tab_id. */
+    open(browserId: string, options?: {
+        url?: string;
+    }): Promise<TabOpenResponse>;
+    /** POST one tab action by its URL segment. The named methods below all funnel through this. */
+    action(browserId: string, tabId: string, segment: string, body?: Body): Promise<ActionResult>;
+    private binary;
+    nav(browserId: string, tabId: string, body: {
+        url: string;
+    }): Promise<ActionResult>;
+    back(browserId: string, tabId: string): Promise<ActionResult>;
+    forward(browserId: string, tabId: string): Promise<ActionResult>;
+    reload(browserId: string, tabId: string): Promise<ActionResult>;
+    /** Returns PNG (or JPEG) bytes. */
+    screenshot(browserId: string, tabId: string, body?: Body): Promise<Uint8Array>;
+    /** Returns PDF bytes. */
+    pdf(browserId: string, tabId: string, body?: Body): Promise<Uint8Array>;
+    /** Accessibility snapshot. Element refs from it target later click/type calls. */
+    snapshot(browserId: string, tabId: string, body?: Body): Promise<ActionResult>;
+    eval(browserId: string, tabId: string, body: {
+        function: string;
+        arguments?: unknown[];
+        timeoutSeconds?: number;
+    }): Promise<ActionResult>;
+    click(browserId: string, tabId: string, body: Body): Promise<ActionResult>;
+    type(browserId: string, tabId: string, body: Body): Promise<ActionResult>;
+    select(browserId: string, tabId: string, body: Body): Promise<ActionResult>;
+    fillForm(browserId: string, tabId: string, body: Body): Promise<ActionResult>;
+    check(browserId: string, tabId: string, body: Body): Promise<ActionResult>;
+    uncheck(browserId: string, tabId: string, body: Body): Promise<ActionResult>;
+    hover(browserId: string, tabId: string, body: Body): Promise<ActionResult>;
+    drag(browserId: string, tabId: string, body: Body): Promise<ActionResult>;
+    upload(browserId: string, tabId: string, body: Body): Promise<ActionResult>;
+    dialog(browserId: string, tabId: string, body: Body): Promise<ActionResult>;
+    key(browserId: string, tabId: string, body: Body): Promise<ActionResult>;
+    scroll(browserId: string, tabId: string, body: Body): Promise<ActionResult>;
+    content(browserId: string, tabId: string, body?: Body): Promise<ActionResult>;
+    dom(browserId: string, tabId: string, body: Body): Promise<ActionResult>;
+    extract(browserId: string, tabId: string, body: Body): Promise<ActionResult>;
+    find(browserId: string, tabId: string, body: Body): Promise<ActionResult>;
+    options(browserId: string, tabId: string, body: Body): Promise<ActionResult>;
+    console(browserId: string, tabId: string, body?: Body): Promise<ActionResult>;
+    network(browserId: string, tabId: string, body?: Body): Promise<ActionResult>;
+    wait(browserId: string, tabId: string, body: Body): Promise<ActionResult>;
+    status(browserId: string, tabId: string, body?: Body): Promise<ActionResult>;
+    download(browserId: string, tabId: string, body: Body): Promise<ActionResult>;
+    /** Live view URL for the tab. */
+    live(browserId: string, tabId: string, body?: Body): Promise<ActionResult>;
+    focus(browserId: string, tabId: string): Promise<ActionResult>;
+    move(browserId: string, tabId: string, body: Body): Promise<ActionResult>;
+    /** Close the tab (DELETE /browsers/{id}/tabs/{tid}; POST .../close does the same). */
+    close(browserId: string, tabId: string): Promise<ActionResult>;
+}
+export {};

package/dist/vendor/kazzle/browsers.tabs.js

@@ -0,0 +1,132 @@
+// kazzle.browsers.tabs.* — tab-scoped browser actions
+// (/browsers/{id}/tabs/{tid}/{action}). Each method maps to exactly one
+// endpoint; action() is the generic escape hatch for the same set.
+import { apiPath } from './http';
+export class TabsApi {
+    http;
+    constructor(http) {
+        this.http = http;
+    }
+    /** List the open tabs of a browser session. */
+    list(browserId) {
+        return this.http.json('GET', apiPath `/browsers/${browserId}/tabs`);
+    }
+    /** Open a new tab. The new tab id is the response's tab_id. */
+    open(browserId, options = {}) {
+        return this.http.json('POST', apiPath `/browsers/${browserId}/tabs`, options);
+    }
+    /** POST one tab action by its URL segment. The named methods below all funnel through this. */
+    action(browserId, tabId, segment, body = {}) {
+        return this.http.json('POST', `${apiPath `/browsers/${browserId}/tabs/${tabId}/`}${segment}`, body);
+    }
+    binary(browserId, tabId, segment, body) {
+        return this.http.binary(`${apiPath `/browsers/${browserId}/tabs/${tabId}/`}${segment}`, body);
+    }
+    nav(browserId, tabId, body) {
+        return this.action(browserId, tabId, 'nav', body);
+    }
+    back(browserId, tabId) {
+        return this.action(browserId, tabId, 'back');
+    }
+    forward(browserId, tabId) {
+        return this.action(browserId, tabId, 'forward');
+    }
+    reload(browserId, tabId) {
+        return this.action(browserId, tabId, 'reload');
+    }
+    /** Returns PNG (or JPEG) bytes. */
+    screenshot(browserId, tabId, body = {}) {
+        return this.binary(browserId, tabId, 'screenshot', body);
+    }
+    /** Returns PDF bytes. */
+    pdf(browserId, tabId, body = {}) {
+        return this.binary(browserId, tabId, 'pdf', body);
+    }
+    /** Accessibility snapshot. Element refs from it target later click/type calls. */
+    snapshot(browserId, tabId, body = {}) {
+        return this.action(browserId, tabId, 'snapshot', body);
+    }
+    eval(browserId, tabId, body) {
+        return this.action(browserId, tabId, 'eval', body);
+    }
+    click(browserId, tabId, body) {
+        return this.action(browserId, tabId, 'click', body);
+    }
+    type(browserId, tabId, body) {
+        return this.action(browserId, tabId, 'type', body);
+    }
+    select(browserId, tabId, body) {
+        return this.action(browserId, tabId, 'select', body);
+    }
+    fillForm(browserId, tabId, body) {
+        return this.action(browserId, tabId, 'fill_form', body);
+    }
+    check(browserId, tabId, body) {
+        return this.action(browserId, tabId, 'check', body);
+    }
+    uncheck(browserId, tabId, body) {
+        return this.action(browserId, tabId, 'uncheck', body);
+    }
+    hover(browserId, tabId, body) {
+        return this.action(browserId, tabId, 'hover', body);
+    }
+    drag(browserId, tabId, body) {
+        return this.action(browserId, tabId, 'drag', body);
+    }
+    upload(browserId, tabId, body) {
+        return this.action(browserId, tabId, 'upload', body);
+    }
+    dialog(browserId, tabId, body) {
+        return this.action(browserId, tabId, 'dialog', body);
+    }
+    key(browserId, tabId, body) {
+        return this.action(browserId, tabId, 'key', body);
+    }
+    scroll(browserId, tabId, body) {
+        return this.action(browserId, tabId, 'scroll', body);
+    }
+    content(browserId, tabId, body = {}) {
+        return this.action(browserId, tabId, 'content', body);
+    }
+    dom(browserId, tabId, body) {
+        return this.action(browserId, tabId, 'dom', body);
+    }
+    extract(browserId, tabId, body) {
+        return this.action(browserId, tabId, 'extract', body);
+    }
+    find(browserId, tabId, body) {
+        return this.action(browserId, tabId, 'find', body);
+    }
+    options(browserId, tabId, body) {
+        return this.action(browserId, tabId, 'options', body);
+    }
+    console(browserId, tabId, body = {}) {
+        return this.action(browserId, tabId, 'console', body);
+    }
+    network(browserId, tabId, body = {}) {
+        return this.action(browserId, tabId, 'network', body);
+    }
+    wait(browserId, tabId, body) {
+        return this.action(browserId, tabId, 'wait', body);
+    }
+    status(browserId, tabId, body = {}) {
+        return this.action(browserId, tabId, 'status', body);
+    }
+    download(browserId, tabId, body) {
+        return this.action(browserId, tabId, 'download', body);
+    }
+    /** Live view URL for the tab. */
+    live(browserId, tabId, body = {}) {
+        return this.action(browserId, tabId, 'live', body);
+    }
+    focus(browserId, tabId) {
+        return this.action(browserId, tabId, 'focus');
+    }
+    move(browserId, tabId, body) {
+        return this.action(browserId, tabId, 'move', body);
+    }
+    /** Close the tab (DELETE /browsers/{id}/tabs/{tid}; POST .../close does the same). */
+    close(browserId, tabId) {
+        return this.http.json('DELETE', apiPath `/browsers/${browserId}/tabs/${tabId}`);
+    }
+}

package/dist/vendor/kazzle/computers.d.ts

@@ -0,0 +1,35 @@
+import { type KazzleHttp } from './http';
+import { ExecStream } from './sse';
+import { FsApi } from './computers.fs';
+import { TerminalsApi } from './computers.terminals';
+import { DesktopApi } from './computers.desktop';
+import type { ComputerCreateResponse, ComputerRow, ExecOptions, ListResponse, OkResponse } from './sdk.types';
+export declare class ComputersApi {
+    private readonly http;
+    readonly fs: FsApi;
+    readonly terminals: TerminalsApi;
+    readonly desktop: DesktopApi;
+    constructor(http: KazzleHttp);
+    /** Create a cloud computer. It boots with a persistent disk; state is "offline" until it comes up. */
+    create(): Promise<ComputerCreateResponse>;
+    /** List the computers in the API key's space. */
+    list(): Promise<ListResponse<ComputerRow>>;
+    get(computerId: string): Promise<ComputerRow>;
+    /** Resume a suspended computer from its snapshot. Wakes take seconds; the disk is preserved. */
+    wake(computerId: string): Promise<OkResponse & {
+        id: string;
+    }>;
+    /** Suspend the computer. The disk is kept; wake it later to resume. */
+    stop(computerId: string): Promise<OkResponse>;
+    /** Re-provision a computer whose sandbox is missing or wedged. The persistent volume is reattached. */
+    repair(computerId: string): Promise<OkResponse>;
+    /** Destroy the computer and delete its disk. Permanent; use stop() to keep the files. */
+    destroy(computerId: string): Promise<OkResponse>;
+    /**
+     * Run one command and stream the result. Returns an ExecStream: iterate the
+     * SSE events (`stdout`/`error`/`exit`), or call `.text()` for the joined
+     * stdout and exit code. stderr is merged into stdout (PTY). For long-running
+     * processes use terminals instead.
+     */
+    exec(computerId: string, options: ExecOptions): ExecStream;
+}

package/dist/vendor/kazzle/computers.desktop.d.ts

@@ -0,0 +1,152 @@
+import { type KazzleHttp } from './http';
+import type { ActionResult, ListResponse } from './sdk.types';
+declare class DesktopSessionsApi {
+    private readonly http;
+    constructor(http: KazzleHttp);
+    /** Create a live desktop session (virtual display) for input actions. */
+    create(computerId: string, options?: {
+        name?: string;
+        resolution?: string;
+    }): Promise<ActionResult>;
+    list(computerId: string): Promise<ListResponse<Record<string, unknown>> & ActionResult>;
+    close(computerId: string, sessionId: string): Promise<ActionResult>;
+}
+/** Mouse and keyboard input inside a live session. Every body carries the sessionId. */
+declare class DesktopInputApi {
+    private readonly http;
+    constructor(http: KazzleHttp);
+    private post;
+    click(computerId: string, body: {
+        sessionId: string;
+        x: number;
+        y: number;
+        button?: string;
+    }): Promise<ActionResult>;
+    doubleClick(computerId: string, body: {
+        sessionId: string;
+        x: number;
+        y: number;
+    }): Promise<ActionResult>;
+    mouseDown(computerId: string, body: {
+        sessionId: string;
+        x: number;
+        y: number;
+        button?: string;
+    }): Promise<ActionResult>;
+    mouseUp(computerId: string, body: {
+        sessionId: string;
+        x: number;
+        y: number;
+        button?: string;
+    }): Promise<ActionResult>;
+    move(computerId: string, body: {
+        sessionId: string;
+        x: number;
+        y: number;
+    }): Promise<ActionResult>;
+    drag(computerId: string, body: {
+        sessionId: string;
+        x: number;
+        y: number;
+        toX: number;
+        toY: number;
+    }): Promise<ActionResult>;
+    scroll(computerId: string, body: {
+        sessionId: string;
+        deltaX?: number;
+        deltaY?: number;
+        x?: number;
+        y?: number;
+    }): Promise<ActionResult>;
+    type(computerId: string, body: {
+        sessionId: string;
+        text: string;
+    }): Promise<ActionResult>;
+    /** Press a key combo, e.g. "ctrl+c". */
+    key(computerId: string, body: {
+        sessionId: string;
+        key: string;
+    }): Promise<ActionResult>;
+}
+/** Structured control of applications (attach, inspect the UI tree, press elements). */
+declare class DesktopAppsApi {
+    private readonly http;
+    constructor(http: KazzleHttp);
+    private post;
+    /** List the applications available on the computer with their bundle ids. */
+    list(computerId: string): Promise<ActionResult>;
+    /** Start (attach to) an application. The result row carries controlled_app_session_id. */
+    start(computerId: string, body: {
+        bundleId: string;
+        windowTitle?: string;
+        physicalInput?: boolean;
+    }): Promise<ActionResult>;
+    stop(computerId: string, body: {
+        controlledAppSessionId: string;
+    }): Promise<ActionResult>;
+    status(computerId: string, body: {
+        controlledAppSessionId: string;
+    }): Promise<ActionResult>;
+    /** Accessibility-tree inspection of the controlled application. */
+    inspect(computerId: string, body: {
+        controlledAppSessionId: string;
+        depth?: number;
+    }): Promise<ActionResult>;
+    press(computerId: string, body: {
+        controlledAppSessionId: string;
+        elementPath: string;
+    }): Promise<ActionResult>;
+    setValue(computerId: string, body: {
+        controlledAppSessionId: string;
+        elementPath: string;
+        value: string;
+    }): Promise<ActionResult>;
+    /** Screenshot the controlled application's window. Returns PNG bytes. */
+    capture(computerId: string, body: {
+        controlledAppSessionId: string;
+    }): Promise<Uint8Array>;
+}
+declare class DesktopWindowsApi {
+    private readonly http;
+    constructor(http: KazzleHttp);
+    /** The active window in a live session. */
+    active(computerId: string, body: {
+        sessionId: string;
+    }): Promise<ActionResult>;
+    /** Raise a window of a controlled application. */
+    raise(computerId: string, body: {
+        controlledAppSessionId: string;
+        windowPath: string;
+    }): Promise<ActionResult>;
+    /** Move/resize a window inside a live session. */
+    place(computerId: string, body: {
+        sessionId: string;
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+        controlledAppSessionId?: string;
+        windowPath?: string;
+    }): Promise<ActionResult>;
+}
+export declare class DesktopApi {
+    private readonly http;
+    readonly sessions: DesktopSessionsApi;
+    readonly input: DesktopInputApi;
+    readonly apps: DesktopAppsApi;
+    readonly windows: DesktopWindowsApi;
+    constructor(http: KazzleHttp);
+    /** Screenshot a display. Omit displayId for the primary display. Returns PNG bytes. */
+    capture(computerId: string, options?: {
+        displayId?: string;
+    }): Promise<Uint8Array>;
+    /** List the computer's displays with ids for capture(). */
+    displays(computerId: string): Promise<ActionResult>;
+    /** Check screen-recording / input permissions on the computer. */
+    permissions(computerId: string): Promise<ActionResult>;
+    /** Screen geometry for a live session. */
+    screen(computerId: string, body: {
+        sessionId: string;
+    }): Promise<ActionResult>;
+}
+export {};