@miosa/sdk 3.5.0 → 3.6.0

package/dist/computer-CKDK0Ahy.d.ts

@@ -0,0 +1,3689 @@
+import * as ws from 'ws';
+import EventEmitter from 'node:events';
+
+interface RequestOptions {
+    method?: string;
+    headers?: Record<string, string>;
+    body?: unknown;
+    timeout?: number;
+    /** Cancel this request and its response stream without retrying. */
+    signal?: AbortSignal | undefined;
+    /** Override retries for operations which cannot safely be replayed. */
+    maxRetries?: number;
+    /** Return raw Response instead of parsing JSON */
+    rawResponse?: boolean;
+    /** Send body as multipart/form-data */
+    formData?: FormData;
+    /** Expected response is binary */
+    binary?: boolean;
+}
+/** One parsed Server-Sent Events frame: its `event:` name plus `data:` payload. */
+interface SseFrame<T> {
+    /** The SSE `event:` name, or `null` when the frame carried no event field. */
+    event: string | null;
+    /** The parsed JSON payload from the frame's `data:` line(s). */
+    data: T;
+}
+interface HttpClientConfig {
+    baseUrl: string;
+    apiKey: string;
+    tenant?: string;
+    /**
+     * Replaces the default `@miosa/sdk/<version>` User-Agent. A platform that
+     * resells MIOSA under its own name sets this to its own product string.
+     */
+    userAgent?: string;
+    timeout: number;
+    maxRetries: number;
+}
+declare class HttpClient {
+    /** Public for WebSocket clients that need to derive their own URL. */
+    readonly baseUrl: string;
+    /** Public for WebSocket clients that need to send the same auth. */
+    readonly apiKey: string;
+    readonly tenant: string | undefined;
+    readonly userAgent: string;
+    private readonly timeout;
+    private readonly maxRetries;
+    constructor(config: HttpClientConfig);
+    private buildUrl;
+    private baseHeaders;
+    request<T>(path: string, options?: RequestOptions): Promise<T>;
+    get<T>(path: string, query?: Record<string, string | number | boolean | undefined>): Promise<T>;
+    post<T>(path: string, body?: unknown): Promise<T>;
+    patch<T>(path: string, body?: unknown): Promise<T>;
+    put<T>(path: string, body?: unknown): Promise<T>;
+    delete<T>(path: string, body?: unknown): Promise<T>;
+    getBinary(path: string): Promise<Uint8Array>;
+    postFormData<T>(path: string, formData: FormData): Promise<T>;
+    /**
+     * Open a Server-Sent Events stream and yield each frame's parsed `data:`
+     * payload together with its SSE `event:` name (when present). Most callers
+     * want {@link stream}; use this when the event name carries meaning — e.g. the
+     * sandbox exec stream tags frames as `stdout` / `stderr` / `exit`. The caller
+     * is responsible for breaking the loop.
+     */
+    streamFrames<T>(path: string, options?: RequestOptions): AsyncIterableIterator<SseFrame<T>>;
+    /**
+     * Open a Server-Sent Events stream. Returns an AsyncIterableIterator of
+     * parsed event data objects. The caller is responsible for breaking the loop.
+     */
+    stream<T>(path: string, options?: RequestOptions): AsyncIterableIterator<T>;
+}
+
+/**
+ * Per-computer shares: invite a person by email, or mint a link anyone with
+ * the link can accept. Roles are `viewer`, `editor` and `admin`. Routes:
+ * `/computers/:id/shares`, `/shared/:token`, `/shared/:token/accept`.
+ */
+type ShareRole = "viewer" | "editor" | "admin";
+interface ComputerShare {
+    id: string;
+    kind: "user" | "link";
+    role: ShareRole;
+    email?: string | null;
+    expires_at?: string | null;
+    accepted_at?: string | null;
+    created_at?: string;
+    [key: string]: unknown;
+}
+type ComputerShareCreateParams = {
+    kind: "user";
+    email: string;
+    role: ShareRole;
+    expiresInHours?: number;
+} | {
+    kind: "link";
+    role: ShareRole;
+    expiresInHours?: number;
+};
+declare class ComputerShares {
+    private readonly http;
+    private readonly computerId;
+    constructor(http: HttpClient, computerId: string);
+    private get base();
+    list(): Promise<ComputerShare[]>;
+    /**
+     * `POST /computers/:id/shares`. A `link` share also returns `share_url`; the
+     * raw token inside it is shown once.
+     */
+    create(params: ComputerShareCreateParams): Promise<{
+        data: ComputerShare;
+        share_url?: string;
+    }>;
+    update(shareId: string, patch: {
+        role?: ShareRole;
+        expiresAt?: string | null;
+    }): Promise<ComputerShare>;
+    delete(shareId: string): Promise<{
+        id: string;
+        deleted: boolean;
+    }>;
+}
+/** Redeem a share link (`/shared/:token`). */
+declare class SharedLinks {
+    private readonly http;
+    constructor(http: HttpClient);
+    /** `GET /shared/:token`: unauthenticated preview of what the link grants. */
+    resolve(token: string): Promise<{
+        computer: {
+            id: string;
+            name: string;
+            template_type: string;
+            size: string;
+            status: string;
+        };
+        role: ShareRole;
+        expires_at: string | null;
+    }>;
+    /** `POST /shared/:token/accept`: needs a signed-in user. */
+    accept(token: string): Promise<{
+        computer_id: string;
+        role: ShareRole;
+    }>;
+}
+
+/**
+ * Pieces shared by sandboxes and computers: environment selection on create,
+ * resume, fork, start and clone; the machine JSON fields environments and
+ * setup scripts add; the synchronous commands endpoint; and agent steering.
+ */
+/** Which environment a machine is created or started from. */
+interface EnvironmentSelectionParams {
+    /** Environment name. With none named, create uses the default and resume/start keeps the current pin. */
+    environment?: string;
+    /** Environment id. Alias `env_id` is accepted on the wire; the SDK sends `environment_id`. */
+    environmentId?: string;
+    environment_id?: string;
+    /** Nothing of the owner's passes to this machine, permanently (same as a `safe_for_third_parties` environment). */
+    noEnv?: boolean;
+    no_env?: boolean;
+    /**
+     * Shed load instead of queueing: when no ready machine is free, the server
+     * answers `503 no_ready_machine` at once (a {@link NoReadyMachineError}) and
+     * the request is not retried by the client or counted against start limits.
+     */
+    failFast?: boolean;
+    fail_fast?: boolean;
+}
+type EnvironmentStatus = "pending" | "applying" | "securing" | "applied" | "failed";
+/** Fields every machine JSON carries once environments are enabled. */
+interface MachineEnvironmentFields {
+    /** Environment name, or `null` for a machine that predates environments. */
+    environment?: string | null;
+    environment_id?: string | null;
+    environment_version?: number | null;
+    environment_latest_version?: number | null;
+    environment_base_id?: string | null;
+    environment_base_version?: number | null;
+    environment_upgrade_available?: boolean;
+    environment_protected?: boolean;
+    environment_status?: EnvironmentStatus | null;
+    /** Short machine-readable reason when `environment_status` is `failed`. Never a secret. */
+    environment_error?: string | null;
+}
+type SetupStatus = "pending" | "running" | "done" | "failed";
+interface SetupRepoStep {
+    repo: string;
+    path: string;
+    blocking: boolean;
+    status: SetupStatus;
+    error: string | null;
+    started_at: string | null;
+    finished_at: string | null;
+}
+interface SetupEnvironmentStep {
+    blocking: boolean;
+    status: SetupStatus;
+    error: string | null;
+    started_at: string | null;
+    finished_at: string | null;
+}
+interface SetupCliToolsStep extends SetupEnvironmentStep {
+    tools: Record<string, string>;
+}
+/** Setup status fields on the machine JSON. The script itself is never returned. */
+interface MachineSetupFields {
+    /** `null` means no setup. Combines the setup file and the environment steps. */
+    setup_status?: SetupStatus | null;
+    setup_error?: string | null;
+    setup_file_status?: SetupStatus | null;
+    setup_file_error?: string | null;
+    setup_started_at?: string | null;
+    setup_finished_at?: string | null;
+    setup_repos?: SetupRepoStep[];
+    setup_environment?: SetupEnvironmentStep | null;
+    setup_cli_tools?: SetupCliToolsStep | null;
+}
+/** Per-request billing override for creates. See {@link BillTo}. */
+interface BillToParam {
+    /** Organization id, slug or name (case-insensitive). Sent as the `X-Miosa-Bill-To` header. */
+    billTo?: string;
+    bill_to?: string;
+}
+interface MachineCommandOptions {
+    /** Absolute, or relative to the work directory (`/workspace`, or the command user's home for a computer). */
+    cwd?: string;
+    /** 1 to 600, default 60. Larger values are refused with `422 TIMEOUT_TOO_LONG`. */
+    timeoutSeconds?: number;
+    /** Text for the command's standard input, at most 32768 bytes. */
+    stdin?: string;
+}
+interface MachineCommandResult {
+    stdout: string;
+    stderr: string;
+    exit_code: number;
+    duration_ms: number;
+    /** True, with `exit_code` -1, when the command was killed at its deadline. */
+    timed_out: boolean;
+    stdout_truncated?: boolean;
+    stderr_truncated?: boolean;
+}
+interface AgentPromptQueued {
+    queued: boolean;
+    after_run_id: string | null;
+    runner: string;
+}
+/**
+ * Steer the agent run attached to a machine (its newest queued or running
+ * harness run). With none attached both calls fail with `NoAgentRunError`.
+ */
+declare class MachineAgent {
+    private readonly http;
+    private readonly base;
+    constructor(http: HttpClient, base: string);
+    /** `POST .../agent/prompts`: queue a message as the next turn of the agent's chat. */
+    prompt(prompt: string): Promise<AgentPromptQueued>;
+    /** `POST .../agent/stop`: halt the agent run. Resolves with the canceled run. */
+    stop(): Promise<Record<string, unknown>>;
+}
+
+/** Producer names that can be subscribed to. */
+type EventProducer = "window" | "clipboard" | "file" | "process" | "idle";
+/** Options for `Events.subscribe()`. */
+interface EventSubscribeOptions {
+    /** At least one producer is required. */
+    subscribe: EventProducer[];
+    /** Paths to watch for the `file` producer. Defaults to `["/home/user"]`. */
+    paths?: string[];
+    /** Idle threshold in seconds for the `idle` producer. Defaults to 30. */
+    idleThresholdSec?: number;
+}
+interface WindowFocusChangedPayload {
+    window_id: string;
+    pid: string;
+    title: string;
+}
+interface WindowOpenedPayload {
+    window_id: string;
+    pid: string;
+    title: string;
+}
+interface WindowClosedPayload {
+    window_id: string;
+    pid: string;
+    title: string;
+}
+interface ClipboardChangedPayload {
+    size_bytes: number;
+}
+interface FileCreatedPayload {
+    path: string;
+}
+interface FileModifiedPayload {
+    path: string;
+}
+interface FileDeletedPayload {
+    path: string;
+}
+interface ProcessStartedPayload {
+    pid: number;
+    cmd: string;
+    ppid: string;
+}
+interface ProcessStoppedPayload {
+    pid: number;
+    cmd: string;
+}
+interface IdleInactivePayload {
+    idle_ms: number;
+}
+interface IdleActivePayload {
+    idle_ms: number;
+}
+interface ProducerUnavailablePayload {
+    producer: EventProducer;
+    reason: string;
+}
+/** Union of all typed event envelopes. */
+type ComputerEvent = {
+    type: "window.focus_changed";
+    timestamp: string;
+    payload: WindowFocusChangedPayload;
+} | {
+    type: "window.opened";
+    timestamp: string;
+    payload: WindowOpenedPayload;
+} | {
+    type: "window.closed";
+    timestamp: string;
+    payload: WindowClosedPayload;
+} | {
+    type: "clipboard.changed";
+    timestamp: string;
+    payload: ClipboardChangedPayload;
+} | {
+    type: "file.created";
+    timestamp: string;
+    payload: FileCreatedPayload;
+} | {
+    type: "file.modified";
+    timestamp: string;
+    payload: FileModifiedPayload;
+} | {
+    type: "file.deleted";
+    timestamp: string;
+    payload: FileDeletedPayload;
+} | {
+    type: "process.started";
+    timestamp: string;
+    payload: ProcessStartedPayload;
+} | {
+    type: "process.stopped";
+    timestamp: string;
+    payload: ProcessStoppedPayload;
+} | {
+    type: "idle.inactive";
+    timestamp: string;
+    payload: IdleInactivePayload;
+} | {
+    type: "idle.active";
+    timestamp: string;
+    payload: IdleActivePayload;
+} | {
+    type: "producer.unavailable";
+    timestamp: string;
+    payload: ProducerUnavailablePayload;
+};
+type EventMap = {
+    [K in ComputerEvent["type"]]: [
+        Extract<ComputerEvent, {
+            type: K;
+        }>["payload"]
+    ];
+} & {
+    error: [Error];
+    close: [{
+        code: number;
+        reason: string;
+    }];
+};
+/**
+ * Typed event stream returned by `computer.events.subscribe()`.
+ *
+ * ```ts
+ * const stream = computer.events.subscribe({ subscribe: ["file", "process"] });
+ * stream.on("file.created", e => console.log("created:", e.path));
+ * stream.on("process.started", e => console.log("pid:", e.pid));
+ * stream.on("error", err => console.error(err));
+ * await stream.close();
+ * ```
+ */
+declare class EventStream extends EventEmitter<EventMap> {
+    private ws;
+    private closed;
+    /** @internal — use `Events.subscribe()` instead. */
+    constructor(ws: WebSocket | ws.WebSocket);
+    private attachHandlers;
+    /** Close the event stream. Idempotent. */
+    close(): Promise<void>;
+    /** Whether the stream has been closed (by client or server). */
+    get isClosed(): boolean;
+}
+/**
+ * Events resource attached to every `Computer` instance.
+ * Exposes `subscribe()` for real-time in-VM event streaming.
+ */
+declare class Events {
+    private readonly baseUrl;
+    private readonly apiKey;
+    private readonly computerId;
+    constructor(baseUrl: string, apiKey: string, computerId: string);
+    /**
+     * Open a WebSocket subscription for the specified producers.
+     *
+     * ```ts
+     * const stream = computer.events.subscribe({
+     *   subscribe: ["window", "clipboard", "file"],
+     *   paths: ["/home/user", "/workspace"],
+     * });
+     * stream.on("window.focus_changed", e => ...);
+     * stream.on("file.created", e => ...);
+     * stream.on("error", err => ...);
+     * await stream.close();
+     * ```
+     */
+    subscribe(options: EventSubscribeOptions): EventStream;
+    private buildWsUrl;
+}
+
+type CustomDomainStatus = "pending" | "verified" | "active" | "failed" | "removed";
+interface CustomDomainData {
+    id: string;
+    computer_id: string;
+    tenant_id: string;
+    fqdn: string;
+    status: CustomDomainStatus;
+    /** The CNAME target the user must point their DNS record at. */
+    verification_target: string;
+    /** Human-readable DNS setup instructions. */
+    instructions: string;
+    verified_at: string | null;
+    tls_issued_at: string | null;
+    created_at: string;
+    updated_at: string;
+}
+/**
+ * Custom domain management for a Computer.
+ *
+ * Accessed via `computer.domains`.
+ *
+ * ## Workflow
+ * ```ts
+ * // 1. Register the domain
+ * const domain = await computer.domains.register("app.example.com");
+ * console.log(domain.instructions);
+ * // => "Add a CNAME record: app.example.com → <slug>.sandbox.miosa.ai"
+ *
+ * // 2. Add the CNAME in your DNS registrar, then...
+ *
+ * // 3. Verify ownership
+ * const verified = await computer.domains.verify(domain.id);
+ * // Caddy auto-issues a TLS certificate after this point.
+ * ```
+ */
+declare class CustomDomains {
+    private readonly http;
+    private readonly computerId;
+    constructor(http: HttpClient, computerId: string);
+    private base;
+    /**
+     * Register a custom FQDN for this computer.
+     *
+     * Returns the domain record with `verification_target` and `instructions`
+     * showing which CNAME record to add. The domain starts in `pending` status.
+     *
+     * @param fqdn - The fully-qualified domain name to register
+     *   (e.g. `"app.example.com"`). Must be lowercase RFC 1123, ≤ 253 chars,
+     *   and must NOT end with `miosa.ai`.
+     */
+    register(fqdn: string): Promise<CustomDomainData>;
+    /**
+     * List all custom domains registered for this computer.
+     */
+    list(): Promise<CustomDomainData[]>;
+    /**
+     * Verify DNS ownership of a registered domain.
+     *
+     * The control plane resolves the domain's CNAME and confirms it points to
+     * the expected `verification_target`. On success the domain transitions to
+     * `verified` status and Caddy will auto-issue a TLS certificate on the next
+     * inbound request.
+     *
+     * @param id - The custom domain record id (from `register()` or `list()`).
+     * @throws `ApiError` with code `CNAME_MISMATCH` if the CNAME doesn't match.
+     * @throws `ApiError` with code `DNS_LOOKUP_FAILED` if DNS is unreachable.
+     */
+    verify(id: string): Promise<CustomDomainData>;
+    /**
+     * Delete a custom domain mapping.
+     *
+     * The domain is immediately removed from the routing cache and Caddy will
+     * stop serving it on the next cert renewal cycle.
+     *
+     * @param id - The custom domain record id.
+     */
+    delete(id: string): Promise<void>;
+}
+
+type ComputerId = string & {
+    readonly __brand: "ComputerId";
+};
+type SessionId = string & {
+    readonly __brand: "SessionId";
+};
+type TenantId = string & {
+    readonly __brand: "TenantId";
+};
+type ComputerSize = "xs" | "small" | "medium" | "large" | "xl";
+type ComputerSizeInput = ComputerSize | "xlarge";
+/**
+ * Lifecycle states emitted by the control plane.
+ *
+ * Canonical states (what the server actually emits):
+ *   provisioning  — VM is being created + booted (~30-50s on small tier)
+ *   active        — running and reachable (same as legacy "running")
+ *   paused        — RAM snapshot on disk, cold start available
+ *   stopped       — explicitly halted
+ *   error         — terminal failure; destroy and retry
+ *   destroyed     — terminal; gone
+ *
+ * Legacy aliases (`running`, `starting`, `creating`, `stopping`) are kept
+ * in the union so older callers still typecheck, but the server will emit
+ * the canonical names. Treat `active` and `running` as synonymous.
+ */
+type ComputerStatus = "provisioning" | "active" | "paused" | "stopped" | "error" | "destroyed" | "creating" | "starting" | "running" | "stopping";
+/**
+ * Template slug for the rootfs a computer boots into.
+ *
+ * - `miosa-desktop` — full KasmVNC + Xfce GUI (default)
+ * - `miosa-sandbox` — lightweight code-exec rootfs, no desktop
+ *
+ * Additional templates can be added at the platform level; the type is kept
+ * open so future templates don't require an SDK release.
+ */
+type ComputerTemplateType = "miosa-desktop" | "miosa-sandbox" | (string & {});
+/**
+ * Controls who can access the computer's HTTP preview URL.
+ *
+ * - `public`  — unauthenticated access to preview paths (default)
+ * - `tenant`  — requires a valid JWT with matching tenant_id
+ * - `key`     — requires a Bearer `msk_u_*` key matching the owner tenant
+ *
+ * Sensitive paths (`/api/*`, `/vnc/*`, `/term/*`) are always auth-gated
+ * regardless of visibility mode.
+ */
+type ComputerVisibility = "public" | "tenant" | "key";
+interface ComputerCreateParams extends EnvironmentSelectionParams, BillToParam {
+    name: string;
+    /**
+     * A script to run once, in the background, after the computer is ready (from
+     * a login shell, in the command user's home). At most 64 KiB, no NUL byte.
+     */
+    setupFile?: string;
+    setup_file?: string;
+    /** Per-machine variables merged on top of the environment's. */
+    env?: Record<string, string>;
+    template_type?: ComputerTemplateType;
+    /** Canonical sizes are xs/small/medium/large/xl. `xlarge` is accepted as a legacy input alias. */
+    size?: ComputerSizeInput;
+    visibility?: ComputerVisibility;
+    metadata?: Record<string, string>;
+    /**
+     * Explicit agent runtime profile to mount into this computer. When omitted,
+     * MIOSA applies the workspace/tenant default profile that targets computers.
+     */
+    agentRuntimeProfileId?: string;
+    agent_runtime_profile_id?: string;
+    /** Back-compat shorthand for agentRuntimeProfileId. */
+    agentProfileId?: string;
+    agent_profile_id?: string;
+    /** Opt out of the default agent runtime profile for this create call. */
+    skipRuntimeProfile?: boolean;
+    skipAgentRuntimeProfile?: boolean;
+    skip_agent_runtime_profile?: boolean;
+}
+interface ComputerUpdateParams {
+    name?: string;
+    visibility?: ComputerVisibility;
+    metadata?: Record<string, string>;
+}
+interface ComputerData extends MachineEnvironmentFields, MachineSetupFields {
+    id: ComputerId;
+    name: string;
+    /**
+     * URL-safe identifier used in preview URLs: `https://{port}-{slug}.sandbox.{preview_domain}`.
+     * Falls back to the computer id when no slug is assigned. The domain is the
+     * tenant's white-label `preview_domain` (server-provided) — never hardcode it.
+     */
+    slug: string;
+    status: ComputerStatus;
+    template_type: ComputerTemplateType;
+    size: ComputerSize;
+    tenant_id: TenantId;
+    ip_address: string | null;
+    metadata: Record<string, string>;
+    /** Controls who can access the HTTP preview URL. Defaults to `"public"`. */
+    visibility: ComputerVisibility;
+    /** Public ingress root, e.g. `https://<slug>.sandbox.<preview_domain>` (server-provided). */
+    sandbox_url?: string;
+    /** Tenant's white-label preview/base domain (e.g. `cliniciq.com`). Use to build preview URLs. */
+    preview_domain?: string;
+    /** KasmVNC URL for desktop templates. */
+    desktop_url?: string;
+    created_at: string;
+    updated_at: string;
+}
+interface ComputerViewerPasswordStatus {
+    computer_id?: ComputerId | string;
+    password_set: boolean;
+    password_set_at?: string | null;
+    viewer_password_set_at?: string | null;
+    rotated_at?: string | null;
+}
+interface ComputerViewerPasswordRotation extends ComputerViewerPasswordStatus {
+    viewer_password: string;
+    password?: string;
+}
+type NetworkPolicyEffect = "allow" | "deny";
+type NetworkPolicyProtocol = "tcp" | "udp" | "any";
+/**
+ * A single egress rule.
+ *
+ * - `effect`      — `"allow"` or `"deny"`
+ * - `destination` — CIDR (`"10.0.0.0/8"`), IP, domain (`"example.com"`),
+ *                   wildcard (`"*.example.com"`), or `"any"`
+ * - `ports`       — optional: `"80"`, `"80,443"`, `"8000-9000"` (omit = all ports)
+ * - `protocol`    — `"tcp"` | `"udp"` | `"any"` (default `"any"`)
+ */
+interface NetworkPolicyRule {
+    effect: NetworkPolicyEffect;
+    destination: string;
+    ports?: string;
+    protocol?: NetworkPolicyProtocol;
+}
+interface NetworkPolicySetParams {
+    /** Rules evaluated top-to-bottom. */
+    rules: NetworkPolicyRule[];
+    /**
+     * Verdict when no rule matches.
+     * `"allow"` = allowlist entries, deny everything else.
+     * `"deny"`  = blocklist entries, allow everything else (default).
+     */
+    default_effect?: NetworkPolicyEffect;
+}
+interface NetworkPolicyData {
+    computer_id: ComputerId;
+    tenant_id: TenantId;
+    rules: NetworkPolicyRule[];
+    default_effect: NetworkPolicyEffect;
+    inserted_at?: string;
+    updated_at?: string;
+}
+interface ComputerListResponse {
+    data: ComputerData[];
+    meta: {
+        total: number;
+        page: number;
+        per_page: number;
+    };
+}
+interface ComputerListParams {
+    page?: number;
+    per_page?: number;
+    status?: ComputerStatus;
+    /** Computers in this workspace. */
+    workspaceId?: string;
+    projectId?: string;
+    /** Your own identifiers for the end user, workspace and project that own the machine. */
+    externalWorkspaceId?: string;
+    externalUserId?: string;
+    externalProjectId?: string;
+}
+type MouseButton = "left" | "right" | "middle";
+type ScrollDirection = "up" | "down" | "left" | "right";
+interface ClickParams$1 {
+    x: number;
+    y: number;
+    button?: MouseButton;
+}
+interface DoubleClickParams {
+    x: number;
+    y: number;
+}
+interface TypeParams {
+    text: string;
+    delay?: number;
+}
+interface KeyParams {
+    key: string;
+}
+interface ScrollParams {
+    x?: number;
+    y?: number;
+    direction: ScrollDirection;
+    clicks?: number;
+}
+interface DragParams {
+    from_x: number;
+    from_y: number;
+    to_x: number;
+    to_y: number;
+}
+interface WaitParams {
+    seconds: number;
+}
+interface WindowInfo {
+    id: string;
+    title: string;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    is_focused: boolean;
+}
+interface CursorInfo {
+    x: number;
+    y: number;
+}
+interface WindowFocusParams {
+    window_id: string;
+}
+interface LaunchParams {
+    app_name: string;
+}
+interface DesktopActionResult {
+    success: boolean;
+}
+interface ExecParams {
+    command: string;
+    timeout?: number;
+}
+interface ExecPythonParams {
+    code: string;
+    timeout?: number;
+}
+/**
+ * Result of `exec.bash()` / `exec.python()`.
+ *
+ * The server returns stdout and stderr separately (what every other
+ * runtime does too) — the older `{output, success}` shape was never
+ * actually emitted. `output` is kept as a read-only alias of `stdout`
+ * for backwards compatibility; new code should use `stdout` + `stderr`.
+ */
+interface ExecResult {
+    /** Standard output from the command. */
+    stdout: string;
+    /** Standard error from the command. Empty string when no error output. */
+    stderr: string;
+    /** Process exit code. 0 = success. */
+    exit_code: number;
+    /** @deprecated alias for `stdout`; prefer `stdout` in new code. */
+    output?: string;
+    /** @deprecated derive from `exit_code === 0` in new code. */
+    success?: boolean;
+}
+interface FileEntry {
+    name: string;
+    path: string;
+    size: number;
+    is_dir: boolean;
+    modified_at: string;
+}
+interface FileListParams {
+    path: string;
+}
+interface FileDownloadParams {
+    path: string;
+}
+interface FileDeleteParams {
+    path: string;
+}
+interface FileExportParams {
+    path: string;
+}
+interface FileExportResult {
+    url: string;
+    expires_at: string;
+}
+interface FileListResult {
+    entries: FileEntry[];
+    path: string;
+}
+interface FileStat {
+    path: string;
+    /** File size in bytes. */
+    size: number;
+    /** Unix mode bits (e.g. 0o100644 for a regular file with rw-r--r--). */
+    mode: number;
+    is_dir: boolean;
+    is_symlink: boolean;
+    /** Populated when is_symlink is true. */
+    symlink_target?: string;
+    modified_at: string;
+}
+interface DirEntry {
+    name: string;
+    is_dir: boolean;
+    is_symlink: boolean;
+    size: number;
+    modified_at: string;
+}
+interface MkdirParams {
+    /** Create parent directories as needed. Defaults to true. */
+    recursive?: boolean;
+    /** Octal mode bits (e.g. 0o755). Defaults to 0o755. */
+    mode?: number;
+}
+interface CopyParams {
+    /** Copy directory trees recursively. Defaults to false. */
+    recursive?: boolean;
+}
+interface DirListResult {
+    data: {
+        entries: DirEntry[];
+        path: string;
+    };
+}
+type AgentSessionStatus = "pending" | "running" | "completed" | "failed" | "cancelled";
+interface AgentSessionCreateParams {
+    goal: string;
+    model_id?: string;
+    max_turns?: number;
+}
+interface AgentSessionData {
+    id: SessionId;
+    computer_id: ComputerId;
+    goal: string;
+    model_id: string;
+    status: AgentSessionStatus;
+    max_turns: number;
+    turns_used: number;
+    created_at: string;
+    updated_at: string;
+    completed_at: string | null;
+    error: string | null;
+}
+interface AgentSessionListResponse {
+    data: AgentSessionData[];
+}
+type AgentEventType = "session_started" | "turn_started" | "thinking" | "tool_call" | "tool_result" | "streaming_token" | "agent_response" | "turn_completed" | "session_completed" | "session_failed" | "done" | "error";
+interface AgentEvent {
+    type: AgentEventType;
+    session_id: SessionId;
+    data: unknown;
+    timestamp: string;
+}
+interface CreditBalance {
+    balance: number;
+    expires_at: string | null;
+}
+interface CreditTransaction {
+    id: string;
+    amount: number;
+    type: "credit" | "debit";
+    description: string;
+    created_at: string;
+}
+interface CreditTransactionListResponse {
+    data: CreditTransaction[];
+    meta: {
+        total: number;
+        page: number;
+        per_page: number;
+    };
+}
+interface CreditUsage {
+    period_start: string;
+    period_end: string;
+    compute_credits: number;
+    ai_credits: number;
+    total_credits: number;
+}
+
+interface MiosaClientConfig {
+    /** Defaults to the `MIOSA_API_KEY` environment variable. */
+    apiKey?: string;
+    /** User JWT required for organization switching. */
+    accessToken?: string;
+    /** Organization UUID or slug sent as X-MIOSA-Tenant on every request. Defaults to `MIOSA_TENANT`. */
+    tenant?: string;
+    /** Defaults to the `MIOSA_BASE_URL` environment variable, then `https://api.miosa.ai/api/v1`. */
+    baseUrl?: string;
+    /**
+     * Replaces the default `@miosa/sdk/<version>` User-Agent on every request.
+     * A platform that resells MIOSA under its own name sets this to its own
+     * product string; the SDK adds no other identifying header.
+     */
+    userAgent?: string;
+    timeout?: number;
+    maxRetries?: number;
+    /**
+     * Opt-in SOMA one-hop runner path (ONE-HOP-RUNNER-DESIGN-2026-10-02.md).
+     * When enabled, `Miosa.runner` talks straight to `run-<region>.miosa.ai`
+     * for sandbox create/exec/destroy, bypassing the control-plane hop.
+     * Also enabled by the `MIOSA_RUNNER_MODE=1` environment variable.
+     * Every other client path (`miosa.sandboxes`, etc.) is unaffected either way.
+     */
+    runner?: {
+        enabled?: boolean;
+        /** Defaults to `us` (C5: not carried in the key this release); also settable via `MIOSA_RUNNER_REGION`. */
+        region?: string;
+        /** Overrides `miosa.ai` - for self-hosted / test deployments. */
+        baseDomain?: string;
+        /**
+         * Pin each runner session group to one resolved IPv4 address, so
+         * `run-<region>.miosa.ai`'s several A records are all used. Set `false`
+         * to dial the hostname and let the OS resolver choose instead.
+         * Defaults to `true`.
+         */
+        pinAddresses?: boolean;
+    };
+}
+
+type SnapshotStatus = "creating" | "uploading" | "ready" | "restoring" | "failed" | "deleted";
+interface SnapshotData {
+    id: string;
+    computer_id: string;
+    tenant_id: string;
+    comment: string | null;
+    status: SnapshotStatus;
+    state_size_bytes: number | null;
+    memory_size_bytes: number | null;
+    rootfs_size_bytes: number | null;
+    compressed_size_bytes: number | null;
+    s3_bucket: string | null;
+    s3_prefix: string | null;
+    parent_snapshot_id: string | null;
+    error: string | null;
+    created_at: string;
+    updated_at: string;
+}
+interface SnapshotCreateParams {
+    /** Optional human-readable label for this checkpoint. */
+    comment?: string;
+}
+interface SnapshotRestoreResult {
+    /** The newly provisioned Computer booted from this snapshot. */
+    data: ComputerData;
+    /** The source snapshot used for the restore. */
+    snapshot: SnapshotData;
+}
+interface SnapshotListResponse {
+    data: SnapshotData[];
+}
+type SnapshotProgressEvent = {
+    type: "snapshot_progress";
+    snapshot_id: string;
+    status: SnapshotStatus | string;
+    step?: string;
+    progress?: number;
+    error?: string;
+};
+/**
+ * Firecracker microVM checkpoint management for a Computer.
+ *
+ * Accessed via `computer.checkpoints`.
+ *
+ * @example
+ * ```ts
+ * const snap = await computer.checkpoints.create({ comment: "before upgrade" });
+ * // ... do risky work ...
+ * const fresh = await computer.checkpoints.restore(snap.id);
+ * ```
+ */
+declare class Checkpoints {
+    private readonly http;
+    private readonly computerId;
+    constructor(http: HttpClient, computerId: string);
+    private base;
+    /**
+     * Create a checkpoint of the running computer.
+     *
+     * The returned snapshot starts in `creating` status and progresses
+     * through `uploading` → `ready` asynchronously. Poll `get()` or subscribe
+     * to progress events via `onProgress` to know when it's ready.
+     *
+     * @param params - Optional `comment` label.
+     * @param onProgress - Optional callback fired for each SSE progress event.
+     *   Only called if a SSE ticket is available (the `events` endpoint requires
+     *   a prior `POST /api/v1/auth/sse-ticket` call).
+     */
+    create(params?: SnapshotCreateParams, onProgress?: (event: SnapshotProgressEvent) => void): Promise<SnapshotData>;
+    /**
+     * List all non-deleted checkpoints for this computer.
+     */
+    list(): Promise<SnapshotData[]>;
+    /**
+     * Fetch a single checkpoint by id.
+     */
+    get(id: string): Promise<SnapshotData>;
+    /**
+     * Delete a checkpoint.
+     *
+     * Transitions the snapshot to `deleted` and schedules S3 cleanup on the
+     * server. After deletion the snapshot object is returned with
+     * `status: "deleted"`.
+     */
+    delete(id: string): Promise<SnapshotData>;
+    /**
+     * Restore a checkpoint onto a fresh Computer.
+     *
+     * The returned Computer starts in `provisioning` status. Use
+     * `computer.checkpoints.restore(id, onProgress)` to subscribe to restore
+     * progress events.
+     *
+     * @param id - Snapshot id to restore (must be in `ready` status).
+     * @param onProgress - Optional callback for SSE progress events during restore.
+     * @returns A `SnapshotRestoreResult` containing the new Computer and the
+     *   source snapshot.
+     */
+    restore(id: string, onProgress?: (event: SnapshotProgressEvent) => void): Promise<SnapshotRestoreResult>;
+    /**
+     * Subscribe to Server-Sent Events for a snapshot's progress.
+     *
+     * Yields `SnapshotProgressEvent` objects until the stream closes or
+     * `status` reaches a terminal state (`ready`, `failed`, `deleted`).
+     *
+     * Requires a valid SSE ticket obtained via
+     * `POST /api/v1/auth/sse-ticket` and passed as `?ticket=<token>`.
+     *
+     * @param id - Snapshot id to watch.
+     * @param ticket - Short-lived SSE ticket from the auth endpoint.
+     */
+    events(id: string, ticket: string): AsyncIterableIterator<SnapshotProgressEvent>;
+    /**
+     * Internal: subscribe to SSE progress events and call `cb` for each.
+     *
+     * Resolves when the stream closes. Any auth/network errors are silently
+     * swallowed so the caller isn't blocked on progress-tracking failures.
+     */
+    private subscribeProgress;
+}
+
+/**
+ * ComputerAutoStop — read/update idle-timeout config.
+ *
+ * Routes:
+ *   GET   /computers/:id/auto-stop
+ *   PATCH /computers/:id/auto-stop
+ */
+
+declare class ComputerAutoStop {
+    private readonly http;
+    private readonly computerId;
+    constructor(http: HttpClient, computerId: string);
+    /** Return the current auto-stop configuration. */
+    get(): Promise<Record<string, unknown>>;
+    /** Set the idle timeout in seconds (0 disables auto-stop). */
+    update(seconds: number): Promise<Record<string, unknown>>;
+}
+
+/**
+ * ComputerEnv — encrypted env var CRUD scoped to one Computer.
+ *
+ * Routes:
+ *   GET    /computers/:id/env           → list
+ *   POST   /computers/:id/env           → create (single)
+ *   PATCH  /computers/:id/env/:name     → update value
+ *   DELETE /computers/:id/env/:name     → remove
+ *
+ * bulkSet falls back to N individual POSTs (no bulk endpoint yet).
+ */
+
+declare class ComputerEnv {
+    private readonly http;
+    private readonly computerId;
+    constructor(http: HttpClient, computerId: string);
+    private base;
+    /** List all env vars (values may be masked depending on server policy). */
+    list(): Promise<Record<string, unknown>[]>;
+    /** Create a new env var. Use update() to change an existing one. */
+    set(name: string, value: string): Promise<Record<string, unknown>>;
+    /** Patch the value of an existing env var by name. */
+    update(name: string, value: string): Promise<Record<string, unknown>>;
+    /** Remove an env var by name. */
+    delete(name: string): Promise<void>;
+    /** Convenience: create one env var per entry. */
+    bulkSet(env: Record<string, string>): Promise<Record<string, unknown>[]>;
+}
+
+/**
+ * ComputerLogs — read + stream VM logs.
+ *
+ * Routes:
+ *   GET /computers/:id/logs         — JSON snapshot (last N lines)
+ *   GET /computers/:id/logs/stream  — text/event-stream of new lines (SSE)
+ */
+
+interface ComputerLogsGetParams {
+    lines?: number;
+    since?: string;
+}
+declare class ComputerLogs {
+    private readonly http;
+    private readonly computerId;
+    constructor(http: HttpClient, computerId: string);
+    /** Fetch the most recent log snapshot. */
+    get(params?: ComputerLogsGetParams): Promise<Record<string, unknown>>;
+    /** Stream live log events as SSE dicts `{type, data, id}`. */
+    stream(): AsyncIterableIterator<Record<string, unknown>>;
+}
+
+/**
+ * ComputerOsa — task dispatch to the in-VM OSA agent.
+ *
+ * Routes:
+ *   POST   /computers/:id/osa/task
+ *   DELETE /computers/:id/osa/task
+ *   GET    /computers/:id/osa/status
+ *   POST   /computers/:id/osa/configure
+ */
+
+declare class ComputerOsa {
+    private readonly http;
+    private readonly computerId;
+    constructor(http: HttpClient, computerId: string);
+    /** Submit a free-form task to the in-VM OSA agent. */
+    submitTask(task: string, params?: Record<string, unknown>): Promise<Record<string, unknown>>;
+    /** Cancel the currently-running OSA task, if any. */
+    cancelTask(): Promise<Record<string, unknown>>;
+    /** Return OSA's current task / configuration / health snapshot. */
+    status(): Promise<Record<string, unknown>>;
+    /** Update OSA runtime configuration (model, tools, secrets, etc.). */
+    configure(config: Record<string, unknown>): Promise<Record<string, unknown>>;
+}
+
+/**
+ * ComputerPorts — per-port visibility control.
+ *
+ * Routes:
+ *   GET    /computers/:id/ports        — list
+ *   POST   /computers/:id/ports        — create
+ *   PATCH  /computers/:id/ports/:port  — update
+ *   DELETE /computers/:id/ports/:port  — delete
+ *
+ * The backend does not expose a single-port GET; get() filters the list
+ * response client-side for ergonomics.
+ */
+
+declare class ComputerPorts {
+    private readonly http;
+    private readonly computerId;
+    constructor(http: HttpClient, computerId: string);
+    private base;
+    list(): Promise<Record<string, unknown>[]>;
+    /** Return the port record for port, or null if not exposed. */
+    get(port: number): Promise<Record<string, unknown> | null>;
+    /** Expose port with the given visibility options. */
+    create(port: number, opts?: Record<string, unknown>): Promise<Record<string, unknown>>;
+    /** Patch visibility / auth options for port. */
+    update(port: number, opts: Record<string, unknown>): Promise<Record<string, unknown>>;
+    /** Stop exposing port. */
+    delete(port: number): Promise<void>;
+}
+
+/**
+ * ComputerTerminal — PTY session management for a Computer.
+ *
+ * Routes:
+ *   POST /computers/:id/terminal
+ *   POST /computers/:id/pty/:sessionId/resize
+ */
+
+interface TerminalCreateParams {
+    cols?: number;
+    rows?: number;
+    shell?: string;
+    cwd?: string;
+    env?: Record<string, string>;
+}
+declare class ComputerTerminal {
+    private readonly http;
+    private readonly computerId;
+    constructor(http: HttpClient, computerId: string);
+    /** Open a new PTY session. Returns the server payload (session id, etc.). */
+    create(params?: TerminalCreateParams): Promise<Record<string, unknown>>;
+    /** Resize an existing PTY session. */
+    resize(sessionId: string, cols: number, rows: number): Promise<Record<string, unknown>>;
+}
+
+/**
+ * ComputerVolumes — per-computer volume attachment.
+ *
+ * Routes:
+ *   GET    /computers/:id/volumes          — list attachments
+ *   POST   /computers/:id/volumes          — attach a volume
+ *   DELETE /computers/:id/volumes/:aid     — detach an attachment
+ */
+
+declare class ComputerVolumes {
+    private readonly http;
+    private readonly computerId;
+    constructor(http: HttpClient, computerId: string);
+    private base;
+    list(): Promise<Record<string, unknown>[]>;
+    /** Attach volumeId at mountPath inside the VM. */
+    attach(volumeId: string, mountPath: string): Promise<Record<string, unknown>>;
+    /** Detach an existing attachment by attachment id. */
+    detach(attachmentId: string): Promise<void>;
+}
+
+/**
+ * MIOSA Connect — provider connectors and runtime tokens.
+ *
+ * Connect is the product-facing credential layer. Egress remains the runtime
+ * enforcement layer underneath it.
+ */
+
+type ConnectorSubject = {
+    type: "app";
+} | {
+    type: "user";
+    id: string;
+    issuer?: string;
+} | {
+    type: "jwt-bearer";
+    sub: string;
+    iss?: string;
+    aud?: string;
+    additionalClaims?: Record<string, unknown>;
+};
+interface ConnectorData {
+    id?: string;
+    uid?: string;
+    name?: string;
+    provider?: string;
+    type?: string;
+    scope?: string;
+    status?: string;
+    managed?: boolean;
+    display_name?: string;
+    displayName?: string;
+    masked_value?: string | null;
+    expires_at?: string | null;
+    metadata?: Record<string, unknown>;
+    [key: string]: unknown;
+}
+interface ExternalAttributionParams {
+    externalUserId?: string;
+    external_user_id?: string;
+    externalWorkspaceId?: string;
+    external_workspace_id?: string;
+    externalProjectId?: string;
+    external_project_id?: string;
+}
+interface ConnectorListParams extends ExternalAttributionParams {
+    scope?: string;
+    workspaceId?: string;
+    workspace_id?: string;
+    ownerUserId?: string;
+    owner_user_id?: string;
+}
+interface ConnectorCreateParams extends ExternalAttributionParams {
+    provider: string;
+    name?: string;
+    uid?: string;
+    type?: string;
+    scope?: string;
+    workspaceId?: string;
+    workspace_id?: string;
+    ownerUserId?: string;
+    owner_user_id?: string;
+    value?: string;
+    token?: string;
+    apiKey?: string;
+    api_key?: string;
+    credential?: {
+        field?: string;
+        value: string;
+        [key: string]: unknown;
+    };
+    [key: string]: unknown;
+}
+interface ConnectorTokenParams extends ExternalAttributionParams {
+    subject?: ConnectorSubject;
+    installationId?: string;
+    installation_id?: string;
+    projectId?: string;
+    project_id?: string;
+    environment?: string;
+    resourceType?: string;
+    resource_type?: string;
+    resourceId?: string;
+    resource_id?: string;
+    scopes?: string[];
+    scope?: string[];
+    audience?: string[];
+    validityBufferMs?: number;
+    validity_buffer_ms?: number;
+}
+interface ConnectorTokenResponse {
+    token: string;
+    expires_at?: string | number | null;
+    expiresAt?: string | number | null;
+    connector?: {
+        id?: string;
+        uid?: string;
+        type?: string;
+        [key: string]: unknown;
+    };
+    name?: string;
+    installation_id?: string;
+    installationId?: string;
+    subject?: ConnectorSubject | Record<string, unknown>;
+    scopes?: string[];
+    metadata?: Record<string, unknown>;
+    [key: string]: unknown;
+}
+interface ConnectorInstallation {
+    id?: string;
+    connector_id?: string;
+    connectorId?: string;
+    installation_id?: string;
+    installationId?: string;
+    workspace_id?: string | null;
+    workspaceId?: string | null;
+    subject_type?: string;
+    subjectType?: string;
+    scope?: string;
+    status?: string;
+    scopes?: string[];
+    metadata?: Record<string, unknown>;
+    [key: string]: unknown;
+}
+interface ConnectorOauthProvider {
+    id?: string;
+    provider?: string;
+    display_name?: string;
+    displayName?: string;
+    scopes?: string[];
+    branding?: Record<string, unknown>;
+    enabled?: boolean;
+    [key: string]: unknown;
+}
+interface ConnectorOauthStartParams extends ExternalAttributionParams {
+    provider: string;
+    scope?: string;
+    exposeAsEnv?: boolean;
+    expose_as_env?: boolean;
+    ownerUserId?: string;
+    owner_user_id?: string;
+}
+interface ConnectorOauthStartResponse {
+    authorize_url?: string;
+    authorizeUrl?: string;
+    state?: string;
+    [key: string]: unknown;
+}
+interface ConnectorProjectLink {
+    id?: string;
+    connector_id?: string;
+    connectorId?: string;
+    installation_id?: string | null;
+    installationId?: string | null;
+    workspace_id?: string | null;
+    workspaceId?: string | null;
+    project_id?: string | null;
+    projectId?: string | null;
+    environment?: string;
+    resource_type?: string | null;
+    resourceType?: string | null;
+    resource_id?: string | null;
+    resourceId?: string | null;
+    allowed_subjects?: string[];
+    allowedSubjects?: string[];
+    allowed_scopes?: string[];
+    allowedScopes?: string[];
+    mode?: string;
+    effect?: string;
+    external_workspace_id?: string | null;
+    externalWorkspaceId?: string | null;
+    external_user_id?: string | null;
+    externalUserId?: string | null;
+    external_project_id?: string | null;
+    externalProjectId?: string | null;
+    metadata?: Record<string, unknown>;
+    [key: string]: unknown;
+}
+interface ConnectorProjectLinkParams extends ExternalAttributionParams {
+    connector?: string;
+    connectorId?: string;
+    connector_id?: string;
+    installationId?: string;
+    installation_id?: string;
+    workspaceId?: string;
+    workspace_id?: string;
+    projectId?: string;
+    project_id?: string;
+    environment?: string;
+    resourceType?: string;
+    resource_type?: string;
+    resourceId?: string;
+    resource_id?: string;
+    allowedSubjects?: string[];
+    allowed_subjects?: string[];
+    allowedScopes?: string[];
+    allowed_scopes?: string[];
+    mode?: "token-api" | "token_api" | "brokered-env" | "brokered_env" | "plain-env" | "plain_env" | string;
+    effect?: "allow" | "deny" | string;
+    metadata?: Record<string, unknown>;
+}
+interface ConnectorLinkListParams extends ExternalAttributionParams {
+    workspaceId?: string;
+    workspace_id?: string;
+    projectId?: string;
+    project_id?: string;
+    connectorId?: string;
+    connector_id?: string;
+    environment?: string;
+    status?: string;
+}
+interface ConnectorDefault extends ConnectorProjectLink {
+    default_scope?: string;
+    defaultScope?: string;
+    target?: string;
+}
+interface ConnectorDefaultParams extends ConnectorProjectLinkParams {
+    defaultScope?: string;
+    default_scope?: string;
+    target?: "all" | "sandbox" | "computer" | "agent" | "deployment" | string;
+}
+interface ConnectorDefaultListParams extends ConnectorLinkListParams {
+    defaultScope?: string;
+    default_scope?: string;
+    target?: string;
+}
+interface ConnectorTrigger {
+    id?: string;
+    connector_id?: string;
+    connectorId?: string;
+    workspace_id?: string | null;
+    workspaceId?: string | null;
+    project_id?: string | null;
+    projectId?: string | null;
+    environment?: string;
+    destination_path?: string | null;
+    destinationPath?: string | null;
+    destination_url?: string | null;
+    destinationUrl?: string | null;
+    event_types?: string[];
+    eventTypes?: string[];
+    status?: string;
+    provider_adapter?: "generic" | "github" | "slack" | string;
+    providerAdapter?: "generic" | "github" | "slack" | string;
+    signing_secret_preview?: string | null;
+    signingSecretPreview?: string | null;
+    webhook_signing_secret?: string;
+    webhookSigningSecret?: string;
+    metadata?: Record<string, unknown>;
+    webhook_token?: string;
+    webhookToken?: string;
+    [key: string]: unknown;
+}
+interface ConnectorTriggerParams extends ExternalAttributionParams {
+    connector?: string;
+    connectorId?: string;
+    connector_id?: string;
+    workspaceId?: string;
+    workspace_id?: string;
+    projectId?: string;
+    project_id?: string;
+    environment?: string;
+    destinationPath?: string;
+    destination_path?: string;
+    destinationUrl?: string;
+    destination_url?: string;
+    eventTypes?: string[];
+    event_types?: string[];
+    status?: string;
+    providerAdapter?: "generic" | "github" | "slack" | string;
+    provider_adapter?: "generic" | "github" | "slack" | string;
+    webhookSigningSecret?: string;
+    webhook_signing_secret?: string;
+    metadata?: Record<string, unknown>;
+}
+interface ConnectorTriggerListParams extends ConnectorLinkListParams {
+}
+interface ConnectorTriggerDelivery {
+    id?: string;
+    trigger_id?: string;
+    triggerId?: string;
+    connector_id?: string;
+    connectorId?: string;
+    event_type?: string;
+    eventType?: string;
+    provider_delivery_id?: string | null;
+    providerDeliveryId?: string | null;
+    state?: string;
+    attempts?: number;
+    destination_url?: string | null;
+    destinationUrl?: string | null;
+    status_code?: number | null;
+    statusCode?: number | null;
+    error?: string | null;
+    latency_ms?: number | null;
+    latencyMs?: number | null;
+    delivered_at?: string | null;
+    deliveredAt?: string | null;
+    metadata?: Record<string, unknown>;
+    [key: string]: unknown;
+}
+interface ConnectorTriggerDeliveryListParams extends ConnectorLinkListParams {
+    triggerId?: string;
+    trigger_id?: string;
+    eventType?: string;
+    event_type?: string;
+}
+interface ConnectorApplicableDefaultParams extends ExternalAttributionParams {
+    workspaceId?: string;
+    workspace_id?: string;
+    projectId?: string;
+    project_id?: string;
+    environment?: string;
+    target?: "all" | "sandbox" | "computer" | "agent" | "deployment" | string;
+    resourceType?: string;
+    resource_type?: string;
+    resourceId?: string;
+    resource_id?: string;
+}
+interface ConnectorMaterializeDefaultsParams extends ConnectorApplicableDefaultParams {
+    envName?: string;
+    env_name?: string;
+}
+interface ConnectorMaterializeDefaultsResult {
+    applied?: number;
+    results?: Array<Record<string, unknown>>;
+    [key: string]: unknown;
+}
+interface SandboxConnectorBinding {
+    id?: string;
+    secret_id?: string;
+    connector?: string;
+    resource_id?: string;
+    resource_type?: string;
+    exposure?: string;
+    expose_as_env?: string;
+    env?: string;
+    sync?: Record<string, unknown>;
+    [key: string]: unknown;
+}
+interface SandboxConnectorAttachParams {
+    connector: string;
+    env: string;
+    mode?: "brokered-env" | "brokered_env" | "plain-env" | "plain_env" | string;
+    installationId?: string;
+    installation_id?: string;
+    projectId?: string;
+    project_id?: string;
+    environment?: string;
+    externalUserId?: string;
+    external_user_id?: string;
+    externalWorkspaceId?: string;
+    external_workspace_id?: string;
+    externalProjectId?: string;
+    external_project_id?: string;
+}
+interface SandboxConnectorPreflightParams {
+    connector?: string;
+    provider?: string;
+}
+interface SandboxConnectorPreflightResult {
+    sandbox_id?: string;
+    sandboxId?: string;
+    provider?: string;
+    connector?: string;
+    status?: Record<string, unknown>;
+    sync?: Record<string, unknown>;
+    [key: string]: unknown;
+}
+declare class Connectors {
+    private readonly http;
+    constructor(http: HttpClient);
+    /** List Connect provider connectors visible to the current tenant/workspace. */
+    list(params?: ConnectorListParams): Promise<ConnectorData[]>;
+    /** Show one connector by UID or id. */
+    get(connector: string): Promise<ConnectorData>;
+    show(connector: string): Promise<ConnectorData>;
+    /** Create an API-key backed connector. Raw values are never returned later. */
+    create(provider: string, params: Omit<ConnectorCreateParams, "provider">): Promise<ConnectorData>;
+    /** Request a runtime provider token for a connector. */
+    getToken(connector: string, params?: ConnectorTokenParams): Promise<ConnectorTokenResponse>;
+    token(connector: string, params?: ConnectorTokenParams): Promise<ConnectorTokenResponse>;
+    /** List OAuth app providers available for end-user authorization. */
+    oauthProviders(): Promise<ConnectorOauthProvider[]>;
+    /** Start an OAuth authorization flow for a provider-backed connector. */
+    startOauth(params: ConnectorOauthStartParams): Promise<ConnectorOauthStartResponse>;
+    /** List connector installations/grants. */
+    installations(params?: ConnectorLinkListParams): Promise<ConnectorInstallation[]>;
+    /** List project/environment connector links. */
+    projectLinks(params?: ConnectorLinkListParams): Promise<ConnectorProjectLink[]>;
+    /** List inherited connector defaults for tenant/workspace/project runtimes. */
+    defaults(params?: ConnectorDefaultListParams): Promise<ConnectorDefault[]>;
+    /** Resolve inherited connector defaults that apply to a runtime target. */
+    applicableDefaults(params?: ConnectorApplicableDefaultParams): Promise<ConnectorDefault[]>;
+    /** Materialize inherited connector defaults onto one runtime resource. */
+    materializeDefaults(params: ConnectorMaterializeDefaultsParams): Promise<ConnectorMaterializeDefaultsResult>;
+    /** Create an inherited connector default for future runtime resources. */
+    createDefault(params: ConnectorDefaultParams): Promise<ConnectorDefault>;
+    /** Delete an inherited connector default. */
+    deleteDefault(id: string): Promise<void>;
+    /** List inbound provider trigger forwarding definitions. */
+    triggers(params?: ConnectorTriggerListParams): Promise<ConnectorTrigger[]>;
+    /** Create an inbound provider trigger forwarding definition. */
+    createTrigger(params: ConnectorTriggerParams): Promise<ConnectorTrigger>;
+    /**
+     * List inbound provider trigger delivery attempts.
+     *
+     * The platform serves deliveries per trigger (`GET /connect/triggers/:id/deliveries`).
+     * With a `triggerId` this is one call; without one it reads every trigger's
+     * deliveries and merges them, newest first.
+     */
+    triggerDeliveries(params?: ConnectorTriggerDeliveryListParams): Promise<ConnectorTriggerDelivery[]>;
+    /** List delivery attempts for one trigger. */
+    triggerDeliveryHistory(triggerId: string): Promise<ConnectorTriggerDelivery[]>;
+    /** Delete an inbound provider trigger forwarding definition. */
+    deleteTrigger(id: string): Promise<void>;
+    /** Link a connector to a project/environment/resource. */
+    createProjectLink(params: ConnectorProjectLinkParams): Promise<ConnectorProjectLink>;
+    /** Delete a project connector link. */
+    deleteProjectLink(id: string): Promise<void>;
+}
+declare class RuntimeConnectors {
+    private readonly http;
+    private readonly basePath;
+    constructor(http: HttpClient, basePath: string);
+    /** List provider connector bindings for this runtime resource. */
+    list(): Promise<SandboxConnectorBinding[]>;
+    /** Attach a connector to this runtime resource as a brokered env var. */
+    attach(params: SandboxConnectorAttachParams): Promise<SandboxConnectorBinding>;
+    /** Detach a connector binding by binding id or connector UID. */
+    detach(bindingOrConnector: string): Promise<void>;
+    /** Sync or materialize connector placeholder env vars for this runtime resource. */
+    sync(): Promise<Record<string, unknown>>;
+    /** Verify a required connector is attached before agent work begins. */
+    preflight(params?: SandboxConnectorPreflightParams): Promise<SandboxConnectorPreflightResult>;
+}
+declare class SandboxConnectors extends RuntimeConnectors {
+    constructor(http: HttpClient, sandboxId: string);
+}
+declare class ComputerConnectors extends RuntimeConnectors {
+    constructor(http: HttpClient, computerId: string);
+}
+declare class DeploymentConnectors extends RuntimeConnectors {
+    constructor(http: HttpClient, deploymentId: string);
+}
+
+interface ScreenSize {
+    width: number;
+    height: number;
+}
+interface DesktopEnvironmentInfo {
+    name?: string;
+    [key: string]: unknown;
+}
+interface WindowSize {
+    width: number;
+    height: number;
+}
+interface WindowPosition {
+    x: number;
+    y: number;
+}
+type DesktopMouseButton = "left" | "right" | "middle";
+declare class Desktop {
+    private readonly http;
+    private readonly computerId;
+    constructor(http: HttpClient, computerId: string);
+    private base;
+    /** Capture a screenshot of the desktop. Returns raw PNG bytes. */
+    screenshot(): Promise<Uint8Array>;
+    /** Click at the given coordinates. */
+    click(x: number, y: number, button?: ClickParams$1["button"]): Promise<DesktopActionResult>;
+    /** Explicit left-button click. Alias for click(x, y, "left"). */
+    leftClick(x: number, y: number): Promise<DesktopActionResult>;
+    /** Right-button click. Alias for click(x, y, "right"). */
+    rightClick(x: number, y: number): Promise<DesktopActionResult>;
+    /** Middle-button click. Alias for click(x, y, "middle"). */
+    middleClick(x: number, y: number): Promise<DesktopActionResult>;
+    /** Double-click at the given coordinates. */
+    doubleClick(x: number, y: number): Promise<DesktopActionResult>;
+    /** Move the mouse pointer without clicking. */
+    moveMouse(x: number, y: number): Promise<DesktopActionResult>;
+    /** Type text into the currently focused element. */
+    type(text: string, delay?: number): Promise<DesktopActionResult>;
+    /** Alias for `type(text)` used by simple computer-control loops. */
+    write(text: string, delay?: number): Promise<DesktopActionResult>;
+    /** Send a key or key combination (e.g. "Enter", "ctrl+c"). */
+    key(key: string): Promise<DesktopActionResult>;
+    /** Alias for `key(key)` used by simple computer-control loops. */
+    press(key: string): Promise<DesktopActionResult>;
+    /** Scroll in a direction at an optional position. */
+    scroll(direction: ScrollParams["direction"], clicks?: number, x?: number, y?: number): Promise<DesktopActionResult>;
+    /** Click and drag from one coordinate to another. */
+    drag(fromX: number, fromY: number, toX: number, toY: number): Promise<DesktopActionResult>;
+    /** Wait for the given number of seconds. */
+    wait(seconds: number): Promise<DesktopActionResult>;
+    /** List all open windows on the desktop. */
+    windows(): Promise<WindowInfo[]>;
+    /** Get the current cursor position. */
+    cursor(): Promise<CursorInfo>;
+    /** Bring the given window into focus. */
+    focusWindow(windowId: string): Promise<DesktopActionResult>;
+    /** Launch an application by name. */
+    launch(appName: string): Promise<DesktopActionResult>;
+    /** Press several keys at once, for example `hotkey("ctrl", "c")`. `POST /desktop/hotkey`. */
+    hotkey(...keys: string[]): Promise<DesktopActionResult>;
+    /** Press a key and keep it down until {@link keyUp}. `POST /desktop/key-down`. */
+    keyDown(key: string): Promise<DesktopActionResult>;
+    /** Release a key held by {@link keyDown}. `POST /desktop/key-up`. */
+    keyUp(key: string): Promise<DesktopActionResult>;
+    /** Press a mouse button without releasing it. `POST /desktop/mouse-down`. */
+    mouseDown(x: number, y: number, button?: DesktopMouseButton): Promise<DesktopActionResult>;
+    /** Release a mouse button. `POST /desktop/mouse-up`. */
+    mouseUp(x: number, y: number, button?: DesktopMouseButton): Promise<DesktopActionResult>;
+    /** Screen dimensions in pixels. `GET /desktop/screen-size`. */
+    screenSize(): Promise<ScreenSize>;
+    /** PNG bytes of one rectangle of the screen. `POST /desktop/screenshot/region`. */
+    screenshotRegion(x: number, y: number, width: number, height: number): Promise<Uint8Array>;
+    /** The accessibility tree of the focused application. Cheaper to read than a screenshot. */
+    accessibilityTree(): Promise<Record<string, unknown>>;
+    /** The desktop environment (name and details). `GET /desktop/environment`. */
+    environment(): Promise<DesktopEnvironmentInfo>;
+    /** Set the wallpaper from an image path inside the computer. `POST /desktop/wallpaper`. */
+    setWallpaper(path: string): Promise<DesktopActionResult>;
+    /** Read the clipboard text. `GET /desktop/clipboard`. */
+    getClipboard(): Promise<string>;
+    /** Replace the clipboard text. `POST /desktop/clipboard`. */
+    setClipboard(text: string): Promise<DesktopActionResult>;
+    private windowPath;
+    windowSize(windowId: string): Promise<WindowSize>;
+    windowPosition(windowId: string): Promise<WindowPosition>;
+    resizeWindow(windowId: string, width: number, height: number): Promise<DesktopActionResult>;
+    moveWindow(windowId: string, x: number, y: number): Promise<DesktopActionResult>;
+    maximizeWindow(windowId: string): Promise<DesktopActionResult>;
+    minimizeWindow(windowId: string): Promise<DesktopActionResult>;
+    closeWindow(windowId: string): Promise<DesktopActionResult>;
+}
+
+interface MiosaErrorBody {
+    error?: string | {
+        code?: string;
+        message?: string;
+        details?: unknown;
+        retryable?: boolean;
+        request_id?: string;
+        retry_after_ms?: number;
+    };
+    message?: string;
+    code?: string;
+    detail?: string;
+    details?: unknown;
+    reason?: string;
+    request_id?: string;
+    retryable?: boolean;
+    retry_after_ms?: number;
+}
+declare class MiosaError extends Error {
+    readonly status: number;
+    readonly code: string;
+    readonly details: unknown;
+    readonly requestId: string | undefined;
+    readonly retryable: boolean;
+    /**
+     * Server-supplied retry hint in milliseconds, taken from the canonical
+     * error shape's `retry_after_ms` (nested under `error` or top-level) or,
+     * failing that, the HTTP `Retry-After` header. `undefined` when the
+     * response carried neither, in which case a caller should fall back to
+     * its own backoff policy.
+     */
+    retryAfterMs: number | undefined;
+    constructor(message: string, status: number, code: string, details?: unknown, requestId?: string, retryable?: boolean, retryAfterMs?: number);
+    /**
+     * @param retryAfterHeaderMs The `Retry-After` header value, already
+     *   converted to milliseconds by the caller. Used only when the body does
+     *   not carry the more precise `retry_after_ms`.
+     */
+    static fromResponse(status: number, body: MiosaErrorBody, requestId?: string, retryAfterHeaderMs?: number): MiosaError;
+}
+declare class AuthError extends MiosaError {
+    constructor(message: string, status?: number, code?: string, details?: unknown, requestId?: string, retryable?: boolean);
+}
+declare class NotFoundError extends MiosaError {
+    constructor(message: string, code?: string, details?: unknown, requestId?: string, retryable?: boolean);
+}
+declare class RateLimitError extends MiosaError {
+    readonly retryAfter: number | undefined;
+    constructor(message: string, details?: unknown, requestId?: string, retryAfter?: number, retryable?: boolean, code?: string);
+}
+declare class InsufficientCreditsError extends MiosaError {
+    constructor(message: string, details?: unknown, requestId?: string, retryable?: boolean, code?: string);
+}
+declare class ValidationError extends MiosaError {
+    constructor(message: string, status: number, code?: string, details?: unknown, requestId?: string, retryable?: boolean);
+}
+declare class TimeoutError extends MiosaError {
+    constructor(message?: string);
+}
+declare class NetworkError extends MiosaError {
+    readonly cause: Error;
+    constructor(message: string, cause: Error);
+}
+declare class ProjectNotLinkedError extends MiosaError {
+    constructor(message: string, status?: number, details?: unknown, requestId?: string, retryable?: boolean);
+}
+declare class SubjectNotAllowedError extends MiosaError {
+    constructor(message: string, status?: number, details?: unknown, requestId?: string, retryable?: boolean);
+}
+declare class ScopeNotAllowedError extends MiosaError {
+    constructor(message: string, status?: number, details?: unknown, requestId?: string, retryable?: boolean);
+}
+declare class ManagedProviderBindingOnlyError extends MiosaError {
+    constructor(message: string, status?: number, details?: unknown, requestId?: string, retryable?: boolean);
+}
+declare class InstallationRequiredError extends MiosaError {
+    constructor(message: string, status?: number, details?: unknown, requestId?: string, retryable?: boolean);
+}
+declare class UserAuthorizationRequiredError extends MiosaError {
+    constructor(message: string, status?: number, details?: unknown, requestId?: string, retryable?: boolean);
+}
+declare class EgressHostNotAllowedError extends MiosaError {
+    constructor(message: string, status?: number, details?: unknown, requestId?: string, retryable?: boolean);
+}
+declare class TokenRefreshFailedError extends MiosaError {
+    constructor(message: string, status?: number, details?: unknown, requestId?: string, retryable?: boolean);
+}
+/**
+ * `503 no_ready_machine`: a `failFast` request found no ready machine. The
+ * server answers in about 1.5 seconds instead of queueing, and the request
+ * does not count against start limits. Retryable later; the client does not
+ * retry it for you, since shedding load is the point.
+ */
+declare class NoReadyMachineError extends MiosaError {
+    constructor(message: string, status?: number, details?: unknown, requestId?: string, retryable?: boolean, retryAfterMs?: number);
+}
+/** `400 INVALID_ID`: a path or body id is not a well-formed identifier. */
+declare class InvalidIdError extends ValidationError {
+    constructor(message: string, status?: number, details?: unknown, requestId?: string, retryable?: boolean);
+}
+/**
+ * `422 OWN_CREDENTIALS_REQUIRED`: the harness has no credential of the
+ * account's own. MIOSA platform keys are never used for agent runs, so connect
+ * a credential (`miosa.agentSettings.putCredential`) and retry.
+ */
+declare class OwnCredentialsRequiredError extends ValidationError {
+    constructor(message: string, status?: number, details?: unknown, requestId?: string, retryable?: boolean);
+}
+/** `404 ENVIRONMENT_NOT_FOUND`: unknown id or name on an environment route. */
+declare class EnvironmentNotFoundError extends NotFoundError {
+    constructor(message: string, details?: unknown, requestId?: string, retryable?: boolean);
+}
+/**
+ * `422 ENVIRONMENT_NOT_FOUND` on a machine route: the `environment` or
+ * `environment_id` named on a create, resume, fork, start or clone does not
+ * exist. Nothing was created or changed. A validation error, as it was before.
+ */
+declare class UnknownEnvironmentError extends ValidationError {
+    constructor(message: string, status?: number, details?: unknown, requestId?: string, retryable?: boolean);
+}
+/** `409 ENVIRONMENT_NAME_TAKEN`. */
+declare class EnvironmentNameTakenError extends ValidationError {
+    constructor(message: string, status?: number, details?: unknown, requestId?: string, retryable?: boolean);
+}
+/** `409 ENVIRONMENT_IS_DEFAULT`: the organization default cannot be deleted. */
+declare class EnvironmentIsDefaultError extends ValidationError {
+    constructor(message: string, status?: number, details?: unknown, requestId?: string, retryable?: boolean);
+}
+/**
+ * `409 ENVIRONMENT_SCRUB_FAILED`: the machine's delivered secrets could not be
+ * removed before a snapshot or fork, so nothing was saved. Retryable.
+ */
+declare class EnvironmentScrubFailedError extends ValidationError {
+    constructor(message: string, status?: number, details?: unknown, requestId?: string, retryable?: boolean);
+}
+/**
+ * `409 ENVIRONMENT_MEMORY_WITHHELD`: a sandbox fork, restore or deploy whose
+ * environment withholds something the source received. Not retryable as is.
+ */
+declare class EnvironmentMemoryWithheldError extends ValidationError {
+    constructor(message: string, status?: number, details?: unknown, requestId?: string, retryable?: boolean);
+    /** `details.reasons`: why the memory was withheld. Empty when absent. */
+    get reasons(): string[];
+}
+/** `403 MACHINE_KEY_SCOPE`: a machine key called something outside its machine's lifecycle. */
+declare class MachineKeyScopeError extends AuthError {
+    constructor(message: string, status?: number, details?: unknown, requestId?: string, retryable?: boolean);
+}
+/**
+ * `409 SANDBOX_STARTING` / `409 COMPUTER_STARTING`: the machine is not ready for
+ * a command yet. Retryable; `retryAfterMs` carries the server's hint (the
+ * client already retries these using it).
+ */
+declare class MachineStartingError extends ValidationError {
+    constructor(message: string, status?: number, code?: string, details?: unknown, requestId?: string, retryable?: boolean);
+}
+declare class SandboxStartingError extends MachineStartingError {
+    constructor(message: string, status?: number, details?: unknown, requestId?: string, retryable?: boolean);
+}
+declare class ComputerStartingError extends MachineStartingError {
+    constructor(message: string, status?: number, details?: unknown, requestId?: string, retryable?: boolean);
+}
+/** `402 CREDIT_REQUIRED`: the action needs credit (for example a named snapshot past the free allowance). */
+declare class CreditRequiredError extends InsufficientCreditsError {
+    constructor(message: string, details?: unknown, requestId?: string, retryable?: boolean);
+}
+/** `402 TEAM_MEMBER_CAP_REACHED`: the caller's usage cap in the billed organization is reached. */
+declare class TeamMemberCapReachedError extends InsufficientCreditsError {
+    constructor(message: string, details?: unknown, requestId?: string, retryable?: boolean);
+}
+/** `429 MEMBER_LIMIT_REACHED`: the caller's concurrent-sandbox cap is reached. Not retryable until a sandbox stops. */
+declare class MemberLimitReachedError extends RateLimitError {
+    constructor(message: string, details?: unknown, requestId?: string, retryAfter?: number, retryable?: boolean);
+}
+/** `403 BILL_TO_LOCKED`: this credential is locked to its own organization. */
+declare class BillToLockedError extends AuthError {
+    constructor(message: string, status?: number, details?: unknown, requestId?: string, retryable?: boolean);
+}
+/** `403 BILL_TO_FORBIDDEN`: the caller's role in that organization cannot create resources. */
+declare class BillToForbiddenError extends AuthError {
+    constructor(message: string, status?: number, details?: unknown, requestId?: string, retryable?: boolean);
+}
+/** `403 BILL_TO_SUSPENDED`: the organization to bill is suspended. */
+declare class BillToSuspendedError extends AuthError {
+    constructor(message: string, status?: number, details?: unknown, requestId?: string, retryable?: boolean);
+}
+/** `404 ORG_NOT_FOUND`: the bill-to organization does not exist for the caller. */
+declare class OrgNotFoundError extends NotFoundError {
+    constructor(message: string, details?: unknown, requestId?: string, retryable?: boolean);
+}
+/** `409 AMBIGUOUS_ORG`: two organizations share the name; use the id. */
+declare class AmbiguousOrgError extends ValidationError {
+    constructor(message: string, status?: number, details?: unknown, requestId?: string, retryable?: boolean);
+}
+/** `409 SNAPSHOT_IN_USE`: something still depends on the snapshot; see {@link dependents}. */
+declare class SnapshotInUseError extends ValidationError {
+    constructor(message: string, status?: number, details?: unknown, requestId?: string, retryable?: boolean);
+    /** `details.dependents`: every thing that still needs the snapshot's bytes. */
+    get dependents(): Array<{
+        type: string;
+        id: string;
+        label?: string;
+    }>;
+}
+/** `409 RUN_SESSION_NOT_RESUMABLE`: `details.reason` says why (`not_found`, `still_running`, ...). */
+declare class RunSessionNotResumableError extends ValidationError {
+    constructor(message: string, status?: number, details?: unknown, requestId?: string, retryable?: boolean);
+    get reason(): string | undefined;
+}
+/** `409 CHAT_BUSY`: the chat's latest run has not finished. Retryable once it has. */
+declare class ChatBusyError extends ValidationError {
+    constructor(message: string, status?: number, details?: unknown, requestId?: string, retryable?: boolean);
+}
+/** `409 NO_AGENT_RUN`: no agent run is attached to the machine. Not retryable. */
+declare class NoAgentRunError extends ValidationError {
+    constructor(message: string, status?: number, details?: unknown, requestId?: string, retryable?: boolean);
+}
+/** `422 INVALID_SETUP_FILE`: `details.reason` is `setup_file_too_large`, `setup_file_not_string`, `setup_file_not_utf8` or `setup_file_has_nul`. */
+declare class InvalidSetupFileError extends ValidationError {
+    constructor(message: string, status?: number, details?: unknown, requestId?: string, retryable?: boolean);
+    get reason(): string | undefined;
+}
+
+/**
+ * One typed dispatcher over the desktop routes, named after the members of
+ * Anthropic's `computer_toolset_20260801` so the same names work in an agent
+ * loop and in `computer.act()`.
+ */
+/** Every action `act()` understands. */
+declare const ACTION_NAMES: readonly ["screenshot", "zoom", "cursor_position", "left_click", "right_click", "middle_click", "double_click", "triple_click", "left_click_drag", "mouse_move", "left_mouse_down", "left_mouse_up", "scroll", "type", "key", "hold_key", "wait"];
+type ActionName = (typeof ACTION_NAMES)[number];
+/** `[x, y]` in screenshot pixels. */
+type Coordinate = readonly [number, number] | readonly number[];
+interface ClickParams {
+    /** Where to click. Omitted: the current pointer position. */
+    coordinate?: Coordinate;
+    /** A modifier key held during the click, for example `"shift"`. */
+    text?: string;
+}
+interface ActParamsMap {
+    screenshot: Record<string, never>;
+    zoom: {
+        region: readonly [number, number, number, number] | readonly number[];
+    };
+    cursor_position: Record<string, never>;
+    left_click: ClickParams;
+    right_click: ClickParams;
+    middle_click: ClickParams;
+    double_click: ClickParams;
+    triple_click: ClickParams;
+    left_click_drag: {
+        start_coordinate: Coordinate;
+        coordinate: Coordinate;
+        text?: string;
+    };
+    mouse_move: {
+        coordinate: Coordinate;
+    };
+    left_mouse_down: Record<string, never>;
+    left_mouse_up: Record<string, never>;
+    scroll: {
+        scroll_direction: "up" | "down" | "left" | "right";
+        scroll_amount: number;
+        coordinate?: Coordinate;
+        text?: string;
+    };
+    type: {
+        text: string;
+    };
+    key: {
+        text: string;
+        repeat?: number;
+    };
+    hold_key: {
+        text: string;
+        duration: number;
+    };
+    wait: {
+        duration: number;
+    };
+}
+interface ActionBase<A extends ActionName> {
+    ok: true;
+    action: A;
+    /** Client-measured time for the whole action, including the round trips. */
+    durationMs: number;
+}
+interface ScreenshotActionResult<A extends "screenshot" | "zoom" = "screenshot" | "zoom"> extends ActionBase<A> {
+    imageBase64: string;
+    mediaType: "image/png";
+    /** Pixels, read from the PNG header. */
+    width: number;
+    height: number;
+    takenAt: string;
+}
+interface CursorActionResult extends ActionBase<"cursor_position"> {
+    x: number;
+    y: number;
+}
+/** An action that moved or clicked the pointer. `coordinate` is where it ended. */
+interface PointerActionResult<A extends ActionName> extends ActionBase<A> {
+    coordinate: [number, number];
+}
+type ActionResultMap = {
+    [A in ActionName]: A extends "screenshot" | "zoom" ? ScreenshotActionResult<A> : A extends "cursor_position" ? CursorActionResult : A extends "left_click" | "right_click" | "middle_click" | "double_click" | "triple_click" | "left_click_drag" | "mouse_move" | "left_mouse_down" | "left_mouse_up" | "scroll" ? PointerActionResult<A> : ActionBase<A>;
+};
+/** What `act()` returns, discriminated on `action`. */
+type ActionResult = ActionResultMap[ActionName];
+/** Parameters are optional only for actions that take none. */
+type ActArgs<A extends ActionName> = A extends "screenshot" | "cursor_position" | "left_mouse_down" | "left_mouse_up" ? [params?: ActParamsMap[A]] : A extends "left_click" | "right_click" | "middle_click" | "double_click" | "triple_click" ? [params?: ActParamsMap[A]] : [params: ActParamsMap[A]];
+declare class InvalidActionInputError extends MiosaError {
+    constructor(action: string, message: string);
+}
+/** Width and height from a PNG's IHDR chunk; `[0, 0]` for anything else. */
+declare function pngSize(bytes: Uint8Array): [number, number];
+/** Run one action against a desktop. */
+declare function performAction<A extends ActionName>(desktop: Desktop, action: A, ...args: ActArgs<A>): Promise<ActionResultMap[A]>;
+
+/**
+ * Helpers an agent loop needs around a computer: wait until it can be driven,
+ * look at it cheaply, and get a viewer link.
+ */
+interface WaitOptions {
+    /** Give up after this long. */
+    timeoutMs?: number;
+    /** Time between polls. */
+    pollMs?: number;
+    signal?: AbortSignal;
+}
+interface WaitIdleOptions extends WaitOptions {
+    /** The screen must not change for this long. Default 1000. */
+    quietMs?: number;
+}
+interface LookOptions {
+    /** Include the accessibility tree. Default true. A failure here does not fail the call. */
+    includeTree?: boolean;
+    /** Include a screenshot. Default true. */
+    includeImage?: boolean;
+}
+interface LookResult {
+    imageBase64?: string;
+    mediaType?: "image/png";
+    width?: number;
+    height?: number;
+    tree?: Record<string, unknown>;
+    /** Set when the tree was asked for and could not be read. */
+    treeError?: string;
+    takenAt: string;
+}
+interface ViewerOptions {
+    /** Link lifetime. The server accepts its own bounds and answers `INVALID_TTL` outside them. */
+    ttlSeconds?: number;
+}
+interface ComputerViewer {
+    /** Open this in a browser or an iframe. */
+    url: string;
+    /** Direct desktop URL with the token in the query string. */
+    desktopUrl: string;
+    wsUrl: string;
+    token: string;
+    /** Unix seconds. */
+    expiresAtUnix: number;
+    /** ISO 8601. */
+    expiresAt: string;
+    ttlSeconds: number;
+    mode: "vnc";
+}
+
+/**
+ * Egress audit log — paginated query + live tail.
+ *
+ * Backed by:
+ *   GET    /api/v1/egress/audit
+ *   GET    /api/v1/egress/audit/:id
+ *
+ * `client.audit.tail()` long-polls the REST endpoint and yields new
+ * events as they arrive. The sandbox-scoped variant
+ * (`sandbox.audit.tail()`) upgrades to a live SSE connection backed by
+ * `GET /sandboxes/:id/audit/stream` so the tail latency is
+ * sub-second.
+ */
+
+interface EgressAuditEvent {
+    id: string;
+    action?: string;
+    effect?: string;
+    host?: string;
+    method?: string;
+    path?: string;
+    status_code?: number;
+    actor_id?: string;
+    resource_id?: string;
+    resource_type?: string;
+    policy_id?: string;
+    rule_id?: string;
+    external_user_id?: string;
+    external_workspace_id?: string;
+    metadata?: Record<string, unknown>;
+    inserted_at?: string;
+    timestamp?: string;
+    [key: string]: unknown;
+}
+interface AuditListParams {
+    resourceId?: string;
+    resource_id?: string;
+    resourceType?: string;
+    resource_type?: string;
+    host?: string;
+    action?: string;
+    since?: string;
+    until?: string;
+    limit?: number;
+    cursor?: string;
+    externalUserId?: string;
+    external_user_id?: string;
+    externalWorkspaceId?: string;
+    external_workspace_id?: string;
+}
+interface AuditTailParams extends AuditListParams {
+    pollIntervalMs?: number;
+}
+declare class EgressAudit {
+    protected readonly http: HttpClient;
+    constructor(http: HttpClient);
+    /** List audit events with optional filters. */
+    list(params?: AuditListParams): Promise<EgressAuditEvent[]>;
+    /** Get a single audit event by id. */
+    get(id: string): Promise<EgressAuditEvent>;
+    /**
+     * Long-poll the audit endpoint and yield new events as they appear.
+     *
+     * Tenant-wide `client.audit.tail()` is REST-based long polling. A
+     * live WebSocket / SSE tail is only available for the sandbox-scoped
+     * variant — see {@link SandboxAudit.tail}.
+     */
+    tail(params?: AuditTailParams): AsyncIterableIterator<EgressAuditEvent>;
+}
+/**
+ * Sandbox-bound view of {@link EgressAudit}. `list()` pre-scopes
+ * `resource_id` + `resource_type="sandbox"`. `tail()` upgrades to the
+ * per-sandbox SSE stream for sub-second tail latency.
+ */
+declare class SandboxAudit {
+    protected readonly http: HttpClient;
+    protected readonly resourceId: string;
+    protected readonly resourceType: string;
+    private readonly delegate;
+    constructor(http: HttpClient, resourceId: string);
+    list(params?: AuditListParams): Promise<EgressAuditEvent[]>;
+    get(id: string): Promise<EgressAuditEvent>;
+    /**
+     * Tail this resource's egress audit events. The platform has no per-resource
+     * stream route, so this follows the tenant-wide audit tail filtered to the
+     * resource.
+     */
+    tail(params?: AuditTailParams): AsyncIterableIterator<EgressAuditEvent>;
+}
+/** Computer-bound audit — same surface, `resource_type="computer"`. */
+declare class ComputerAudit extends SandboxAudit {
+    protected readonly resourceType: string;
+}
+
+/**
+ * Egress network — policies, allowlist, suggestions.
+ *
+ * Backed by:
+ *   GET    /api/v1/egress/policies
+ *   POST   /api/v1/egress/policies
+ *   PATCH  /api/v1/egress/policies/:id
+ *
+ *   GET    /api/v1/egress/allowlist
+ *   POST   /api/v1/egress/allowlist
+ *   DELETE /api/v1/egress/allowlist/:id
+ *
+ *   GET    /api/v1/egress/audit/suggestions
+ */
+
+type EgressPolicyMode = "enforce" | "audit_only";
+type EgressRuleEffect = "allow" | "deny";
+interface EgressAllowlistRule {
+    id: string;
+    host: string;
+    effect: EgressRuleEffect | string;
+    methods?: string[];
+    path_glob?: string | null;
+    policy_id?: string | null;
+    resource_id?: string | null;
+    resource_type?: string | null;
+    note?: string | null;
+    created_at?: string;
+    [key: string]: unknown;
+}
+interface EgressPolicyData {
+    id: string;
+    name?: string;
+    mode: EgressPolicyMode | string;
+    default_effect: EgressRuleEffect | string;
+    description?: string | null;
+    resource_id?: string | null;
+    resource_type?: string | null;
+    rules?: EgressAllowlistRule[];
+    created_at?: string;
+    updated_at?: string;
+    [key: string]: unknown;
+}
+interface EgressSuggestion {
+    host: string;
+    methods?: string[];
+    path_glob?: string | null;
+    count?: number;
+    first_seen?: string;
+    last_seen?: string;
+    resource_id?: string | null;
+    [key: string]: unknown;
+}
+interface AllowParams {
+    methods?: string[];
+    pathGlob?: string;
+    path_glob?: string;
+    policyId?: string;
+    policy_id?: string;
+    resourceId?: string;
+    resource_id?: string;
+    resourceType?: string;
+    resource_type?: string;
+    note?: string;
+}
+interface PolicyCreateParams {
+    name: string;
+    mode?: EgressPolicyMode | string;
+    defaultEffect?: EgressRuleEffect | string;
+    default_effect?: EgressRuleEffect | string;
+    resourceId?: string;
+    resource_id?: string;
+    resourceType?: string;
+    resource_type?: string;
+    description?: string;
+}
+interface PolicyUpdateParams {
+    mode?: EgressPolicyMode | string;
+    defaultEffect?: EgressRuleEffect | string;
+    default_effect?: EgressRuleEffect | string;
+    name?: string;
+    description?: string;
+}
+interface ModeParams {
+    policyId?: string;
+    policy_id?: string;
+    resourceId?: string;
+    resource_id?: string;
+    resourceType?: string;
+    resource_type?: string;
+}
+interface SuggestionsParams {
+    resourceId?: string;
+    resource_id?: string;
+    resourceType?: string;
+    resource_type?: string;
+    since?: string;
+}
+interface PolicyListParams {
+    resourceId?: string;
+    resource_id?: string;
+    resourceType?: string;
+    resource_type?: string;
+}
+interface RulesListParams {
+    policyId?: string;
+    policy_id?: string;
+    resourceId?: string;
+    resource_id?: string;
+    resourceType?: string;
+    resource_type?: string;
+}
+declare class EgressNetwork {
+    protected readonly http: HttpClient;
+    constructor(http: HttpClient);
+    /** Add an `allow` rule for `host` to the allowlist. */
+    allow(host: string, params?: AllowParams): Promise<EgressAllowlistRule>;
+    /** Add a `deny` rule for `host` to the allowlist. */
+    deny(host: string, params?: AllowParams): Promise<EgressAllowlistRule>;
+    /** List allowlist rules. */
+    rules(params?: RulesListParams): Promise<EgressAllowlistRule[]>;
+    /** Delete an allowlist rule by id. */
+    removeRule(ruleId: string): Promise<void>;
+    /** List egress policies. */
+    policies(params?: PolicyListParams): Promise<EgressPolicyData[]>;
+    /** Create an egress policy. */
+    createPolicy(params: PolicyCreateParams): Promise<EgressPolicyData>;
+    /** Update an egress policy by id. */
+    updatePolicy(policyId: string, params: PolicyUpdateParams): Promise<EgressPolicyData>;
+    /** Set the policy to `mode="enforce"` — denied egress is blocked. */
+    lockdown(params?: ModeParams): Promise<EgressPolicyData>;
+    /** Set the policy to `mode="audit_only"` — log but do not block. */
+    observe(params?: ModeParams): Promise<EgressPolicyData>;
+    private setMode;
+    /** AI-generated allowlist suggestions from recent denied egress. */
+    suggestions(params?: SuggestionsParams): Promise<EgressSuggestion[]>;
+}
+/**
+ * Sandbox-bound view of {@link EgressNetwork}. Pre-scopes
+ * `resource_id` + `resource_type="sandbox"` on every call.
+ */
+declare class SandboxNetwork {
+    protected readonly resourceId: string;
+    protected readonly resourceType: string;
+    private readonly delegate;
+    constructor(http: HttpClient, resourceId: string);
+    private resolvedResourceId;
+    private resolvedResourceType;
+    allow(host: string, params?: AllowParams): Promise<EgressAllowlistRule>;
+    deny(host: string, params?: AllowParams): Promise<EgressAllowlistRule>;
+    rules(params?: RulesListParams): Promise<EgressAllowlistRule[]>;
+    removeRule(ruleId: string): Promise<void>;
+    lockdown(params?: {
+        policyId?: string;
+    }): Promise<EgressPolicyData>;
+    observe(params?: {
+        policyId?: string;
+    }): Promise<EgressPolicyData>;
+    suggestions(params?: {
+        since?: string;
+    }): Promise<EgressSuggestion[]>;
+    policies(): Promise<EgressPolicyData[]>;
+}
+/** Computer-bound network — same surface, `resource_type="computer"`. */
+declare class ComputerNetwork extends SandboxNetwork {
+    protected readonly resourceType: string;
+}
+
+/**
+ * Egress secrets — encrypted API key + OAuth credential vault.
+ *
+ * Backed by:
+ *   POST   /api/v1/egress/secrets
+ *   GET    /api/v1/egress/secrets
+ *   GET    /api/v1/egress/secrets/:id
+ *   PATCH  /api/v1/egress/secrets/:id     (rotate)
+ *   DELETE /api/v1/egress/secrets/:id
+ *
+ *   POST   /api/v1/egress/bindings
+ *   GET    /api/v1/egress/bindings
+ *   DELETE /api/v1/egress/bindings/:id
+ *
+ *   GET    /api/v1/egress/oauth/providers
+ *   POST   /api/v1/egress/oauth/start
+ *   GET    /api/v1/egress/oauth/status?state=...
+ */
+
+type EgressSecretType = "api_key" | "oauth_token" | "bearer" | "basic" | "generic";
+type EgressSecretScope = "user" | "workspace" | "tenant" | "external_user" | "external_workspace";
+interface EgressSecretData {
+    id: string;
+    name?: string;
+    type?: EgressSecretType | string;
+    scope?: EgressSecretScope | string;
+    workspace_id?: string | null;
+    owner_user_id?: string | null;
+    external_user_id?: string | null;
+    external_workspace_id?: string | null;
+    resource_id?: string | null;
+    resource_type?: string | null;
+    masked_value?: string | null;
+    expires_at?: string | null;
+    metadata?: Record<string, unknown>;
+    created_at?: string;
+    updated_at?: string;
+    [key: string]: unknown;
+}
+interface EgressBindingData {
+    id: string;
+    secret_id: string;
+    resource_id: string;
+    resource_type: string;
+    expose_as_env: string;
+    created_at?: string;
+    [key: string]: unknown;
+}
+interface OauthProvider {
+    name: string;
+    display_name?: string;
+    scopes?: string[];
+    [key: string]: unknown;
+}
+interface SecretSetParams {
+    name: string;
+    value: string;
+    type?: EgressSecretType | string;
+    scope?: EgressSecretScope | string;
+    exposeAsEnv?: string;
+    expose_as_env?: string;
+    workspaceId?: string;
+    workspace_id?: string;
+    ownerUserId?: string;
+    owner_user_id?: string;
+    externalUserId?: string;
+    external_user_id?: string;
+    externalWorkspaceId?: string;
+    external_workspace_id?: string;
+    resourceId?: string;
+    resource_id?: string;
+    resourceType?: string;
+    resource_type?: string;
+    refreshToken?: string;
+    refresh_token?: string;
+    expiresAt?: string;
+    expires_at?: string;
+    metadata?: Record<string, unknown>;
+}
+interface SecretListParams {
+    scope?: string;
+    type?: string;
+    workspaceId?: string;
+    workspace_id?: string;
+    ownerUserId?: string;
+    owner_user_id?: string;
+    externalUserId?: string;
+    external_user_id?: string;
+    externalWorkspaceId?: string;
+    external_workspace_id?: string;
+    resourceId?: string;
+    resource_id?: string;
+    resourceType?: string;
+    resource_type?: string;
+}
+interface SecretRotateParams {
+    newValue?: string;
+    new_value?: string;
+    value?: string;
+    refreshToken?: string;
+    refresh_token?: string;
+    expiresAt?: string;
+    expires_at?: string;
+}
+interface BindingCreateParams {
+    secretId?: string;
+    secret_id?: string;
+    resourceId?: string;
+    resource_id?: string;
+    resourceType?: string;
+    resource_type?: string;
+    exposeAsEnv?: string;
+    expose_as_env?: string;
+}
+interface BindingListParams {
+    resourceId?: string;
+    resource_id?: string;
+    resourceType?: string;
+    resource_type?: string;
+    secretId?: string;
+    secret_id?: string;
+}
+interface OauthConnectParams {
+    provider: string;
+    exposeAsEnv?: string;
+    expose_as_env?: string;
+    scope?: string;
+    ownerUserId?: string;
+    owner_user_id?: string;
+    externalUserId?: string;
+    external_user_id?: string;
+    externalWorkspaceId?: string;
+    external_workspace_id?: string;
+    resourceId?: string;
+    resource_id?: string;
+    resourceType?: string;
+    resource_type?: string;
+    redirectUri?: string;
+    redirect_uri?: string;
+}
+interface OauthStartResult {
+    authorize_url: string;
+    authorizeUrl?: string;
+    state: string;
+    provider?: string;
+    expires_at?: string;
+    [key: string]: unknown;
+}
+interface OauthStatusResult {
+    status: string;
+    state?: string;
+    secret_id?: string;
+    error?: string;
+    message?: string;
+    [key: string]: unknown;
+}
+/**
+ * A pending OAuth flow.
+ *
+ * The SDK does NOT auto-open a browser — the caller is responsible for
+ * surfacing `authorizeUrl` to the end user. Once the user grants
+ * consent, call `waitForCompletion()` to poll the upstream provider
+ * status.
+ */
+declare class OAuthFlow {
+    readonly authorizeUrl: string;
+    readonly state: string;
+    readonly provider?: string;
+    readonly data: OauthStartResult;
+    private readonly http;
+    private readonly startedAt;
+    constructor(http: HttpClient, payload: OauthStartResult, provider?: string);
+    /**
+     * Wait for the user to finish the provider's consent screen.
+     *
+     * The platform has no status route for a pending flow (the callback redirects
+     * the browser), so this polls `GET /egress/secrets` until an OAuth secret for
+     * this provider appears that was created after the flow started. Resolves with
+     * `{ status: "completed", secret_id }`. Rejects if the flow does not finish
+     * within `timeoutSec` seconds.
+     */
+    waitForCompletion(options?: {
+        timeoutSec?: number;
+        pollIntervalMs?: number;
+    }): Promise<OauthStatusResult>;
+}
+declare class EgressSecrets {
+    protected readonly http: HttpClient;
+    constructor(http: HttpClient);
+    /**
+     * Create a secret. When `exposeAsEnv` is provided together with
+     * `resourceId` the backend also creates a binding so the value is
+     * injected as an env-var on that resource.
+     */
+    set(params: SecretSetParams): Promise<EgressSecretData>;
+    /** List secrets. */
+    list(params?: SecretListParams): Promise<EgressSecretData[]>;
+    /** Get a single secret by id. */
+    get(id: string): Promise<EgressSecretData>;
+    /** Rotate the secret's value. */
+    rotate(id: string, params: SecretRotateParams | string): Promise<EgressSecretData>;
+    /** Delete a secret. */
+    delete(id: string): Promise<void>;
+    /** Bind a secret to a resource as an env var. */
+    createBinding(params: BindingCreateParams): Promise<EgressBindingData>;
+    /** List secret bindings. */
+    listBindings(params?: BindingListParams): Promise<EgressBindingData[]>;
+    /** Delete a binding. */
+    deleteBinding(id: string): Promise<void>;
+    /** List OAuth providers visible to the current tenant. */
+    providers(): Promise<OauthProvider[]>;
+    /**
+     * Start an OAuth Connect flow.
+     *
+     * Returns an {@link OAuthFlow} — the caller must surface
+     * `flow.authorizeUrl` to the end user (the SDK does NOT open the
+     * browser) and then call `flow.waitForCompletion()` to receive the
+     * resulting secret id.
+     */
+    connect(params: OauthConnectParams): Promise<OAuthFlow>;
+}
+/**
+ * Sandbox-bound view of {@link EgressSecrets}. Pre-scopes
+ * `resource_id` + `resource_type="sandbox"` on every call.
+ */
+declare class SandboxSecrets {
+    protected readonly resourceId: string;
+    protected readonly resourceType: string;
+    private readonly delegate;
+    constructor(http: HttpClient, resourceId: string);
+    private resolvedResourceId;
+    private resolvedResourceType;
+    set(params: SecretSetParams): Promise<EgressSecretData>;
+    list(params?: SecretListParams): Promise<EgressSecretData[]>;
+    get(id: string): Promise<EgressSecretData>;
+    rotate(id: string, params: SecretRotateParams | string): Promise<EgressSecretData>;
+    delete(id: string): Promise<void>;
+    connect(params: OauthConnectParams): Promise<OAuthFlow>;
+    listBindings(params?: BindingListParams): Promise<EgressBindingData[]>;
+}
+/** Computer-bound secrets — same shape, `resource_type="computer"`. */
+declare class ComputerSecrets extends SandboxSecrets {
+    protected readonly resourceType: string;
+}
+
+/** Options for `Exec.stream()`. */
+interface ExecStreamOptions {
+    /** Command to execute. */
+    command: string;
+    /** Optional arguments. */
+    args?: string[];
+    /** Optional environment variables as KEY=VALUE strings. */
+    env?: string[];
+    /** Working directory inside the VM. */
+    cwd?: string;
+    /** Allocate a PTY. Defaults to false. */
+    tty?: boolean;
+    /** Terminal rows (when tty=true). */
+    rows?: number;
+    /** Terminal columns (when tty=true). */
+    cols?: number;
+}
+type ExecStreamEventMap = {
+    stdout: [data: Uint8Array];
+    stderr: [data: Uint8Array];
+    exit: [code: number];
+    error: [err: Error];
+    close: [code: number, reason: string];
+};
+/**
+ * Live bidirectional exec stream backed by a `miosa-exec-v1` WebSocket.
+ *
+ * The binary wire protocol (1-byte frame ID) is handled by the server-side
+ * proxy and envd. The SDK exposes typed events on the received frames:
+ *
+ * - `stdout` — chunk of stdout bytes
+ * - `stderr` — chunk of stderr bytes
+ * - `exit`   — process exit code (stream ends after this)
+ * - `error`  — WebSocket error
+ * - `close`  — WebSocket closed
+ *
+ * Obtain via `computer.exec.stream({ command: "bash", tty: true })`.
+ *
+ * ```ts
+ * const s = computer.exec.stream({ command: "python3", args: ["script.py"] });
+ * s.on("stdout", chunk => process.stdout.write(chunk));
+ * s.on("exit",   code  => console.log("exit:", code));
+ * s.sendStdin(new TextEncoder().encode("hello\n"));
+ * await s.close();
+ * ```
+ */
+declare class ExecStreamHandle {
+    private ws;
+    private closed;
+    private readonly listeners;
+    private static readonly FRAME_STDIN;
+    private static readonly FRAME_STDOUT;
+    private static readonly FRAME_STDERR;
+    private static readonly FRAME_EXIT;
+    /** @internal — use `Exec.stream()` instead. */
+    constructor(ws: WebSocket | ws.WebSocket);
+    on<K extends keyof ExecStreamEventMap>(event: K, handler: (...args: ExecStreamEventMap[K]) => void): this;
+    off<K extends keyof ExecStreamEventMap>(event: K, handler: (...args: ExecStreamEventMap[K]) => void): this;
+    private emit;
+    /**
+     * Send stdin bytes to the running process.
+     * Prepends the 0x00 frame ID byte automatically.
+     */
+    sendStdin(data: Uint8Array): void;
+    /**
+     * Send a terminal resize event.
+     * Encodes as 0x05 + rows (u16 BE) + cols (u16 BE).
+     */
+    sendResize(rows: number, cols: number): void;
+    /** Close the stream. Idempotent. */
+    close(): Promise<void>;
+    /** Whether the stream has ended (by client or server). */
+    get isClosed(): boolean;
+    private attachHandlers;
+}
+/**
+ * Exec resource attached to every `Computer` instance.
+ * Exposes `bash()`, `python()`, and `stream()` for command execution.
+ */
+declare class Exec {
+    private readonly http;
+    private readonly computerId;
+    constructor(http: HttpClient, computerId: string);
+    private base;
+    /**
+     * Run a shell command inside the computer.
+     * @param command - Shell command string to execute.
+     * @param timeout - Optional timeout in seconds.
+     */
+    bash(command: string, timeout?: number): Promise<ExecResult>;
+    /**
+     * Execute Python code inside the computer.
+     * @param code - Python source code string.
+     * @param timeout - Optional timeout in seconds.
+     */
+    python(code: string, timeout?: number): Promise<ExecResult>;
+    /**
+     * Open a live binary exec stream using the `miosa-exec-v1` subprotocol.
+     *
+     * The WebSocket negotiates `Sec-WebSocket-Protocol: miosa-exec-v1` to
+     * ensure version compatibility. Future protocol versions can be added
+     * server-side without breaking v1 clients.
+     *
+     * ```ts
+     * const stream = computer.exec.stream({ command: "bash", tty: true, rows: 24, cols: 80 });
+     * stream.on("stdout", data => process.stdout.write(data));
+     * stream.on("exit",   code => console.log("done:", code));
+     * stream.sendStdin(new TextEncoder().encode("echo hello\n"));
+     * ```
+     */
+    stream(options: ExecStreamOptions): ExecStreamHandle;
+    private buildWsUrl;
+}
+
+declare class Files {
+    private readonly http;
+    private readonly computerId;
+    constructor(http: HttpClient, computerId: string);
+    private base;
+    /**
+     * Upload a local file to the computer.
+     *
+     * In a Node.js environment pass a Buffer or Blob; in a browser pass a File
+     * or Blob.  The remote path is where the file will be written inside the VM.
+     *
+     * @param content  - File content as Blob, Buffer, Uint8Array, or string.
+     * @param remotePath - Absolute path inside the VM (e.g. /home/user/file.txt).
+     * @param filename - Optional filename hint (defaults to basename of remotePath).
+     */
+    upload(content: Blob | Uint8Array | string, remotePath: string, _filename?: string): Promise<FileEntry>;
+    /**
+     * Upload through the multipart route (`POST /computers/:id/files/upload`),
+     * which suits large and binary files better than base64 JSON.
+     */
+    uploadFile(content: Blob | Uint8Array | string, remotePath: string, filename?: string): Promise<FileEntry>;
+    /**
+     * List files and directories at the given path inside the VM.
+     */
+    list(path: string): Promise<FileListResult>;
+    /**
+     * Download a file from the computer. Returns raw bytes.
+     */
+    download(path: string): Promise<Uint8Array>;
+    /**
+     * Export a file from the computer and receive a temporary signed URL.
+     */
+    export(path: string): Promise<FileExportResult>;
+    /**
+     * Delete a file or directory inside the computer.
+     */
+    delete(path: string): Promise<void>;
+    /**
+     * Stat a path inside the computer. Does not follow symlinks (lstat semantics).
+     *
+     * Returns `{path, size, mode, is_dir, is_symlink, symlink_target?, modified_at}`.
+     */
+    stat(path: string): Promise<FileStat>;
+    /**
+     * Create a directory inside the computer.
+     *
+     * @param path    - Absolute path to create (e.g. `/home/user/project`).
+     * @param options - `{ recursive?: boolean, mode?: number }`. Defaults: recursive=true, mode=0o755.
+     */
+    mkdir(path: string, options?: MkdirParams): Promise<void>;
+    /**
+     * Rename (move) a path inside the computer.
+     *
+     * Creates the destination parent directory if it does not exist.
+     */
+    rename(from: string, to: string): Promise<void>;
+    /**
+     * Copy a file or directory inside the computer.
+     *
+     * @param from    - Source absolute path.
+     * @param to      - Destination absolute path.
+     * @param options - `{ recursive?: boolean }`. Required when source is a directory.
+     */
+    copy(from: string, to: string, options?: CopyParams): Promise<void>;
+    /**
+     * Change permissions on a path inside the computer.
+     *
+     * @param path - Absolute path inside the VM.
+     * @param mode - Unix mode bits as an octal integer (e.g. `0o755`) or string (`"0755"`).
+     */
+    chmod(path: string, mode: number | string): Promise<void>;
+    /**
+     * Return a rich directory listing for the given path.
+     *
+     * Each entry includes `{name, is_dir, is_symlink, size, modified_at}`.
+     * Richer than `list()` which uses `find` under the hood.
+     *
+     * @param path        - Absolute path to list.
+     * @param _withTypes  - Kept for API symmetry; types are always returned.
+     */
+    readdir(path: string, _withTypes?: boolean): Promise<DirEntry[]>;
+    /**
+     * Write a UTF-8 string to a file inside the computer.
+     * Convenience wrapper around `upload()`.
+     */
+    writeFile(path: string, content: string): Promise<void>;
+    /**
+     * Read a file from the computer and return its contents as a UTF-8 string.
+     */
+    readFile(path: string): Promise<string>;
+}
+
+/**
+ * Manage egress network policy for a computer.
+ *
+ * A policy is a list of rules evaluated top-to-bottom, with a `default_effect`
+ * applied when no rule matches.
+ *
+ * Example — block IMDS and allow everything else:
+ * ```ts
+ * await computer.networkPolicy.set({
+ *   default_effect: "allow",
+ *   rules: [
+ *     { effect: "deny", destination: "169.254.169.254/32" },
+ *     { effect: "deny", destination: "metadata.google.internal" },
+ *   ],
+ * });
+ * ```
+ *
+ * Example — allowlist mode (deny all by default, allow only example.com):
+ * ```ts
+ * await computer.networkPolicy.set({
+ *   default_effect: "deny",
+ *   rules: [
+ *     { effect: "allow", destination: "example.com", ports: "443", protocol: "tcp" },
+ *   ],
+ * });
+ * ```
+ */
+declare class NetworkPolicy {
+    private readonly http;
+    private readonly computerId;
+    constructor(http: HttpClient, computerId: string);
+    /**
+     * Get the current network policy.
+     * Returns an empty allow-all policy if none is set.
+     */
+    get(): Promise<NetworkPolicyData>;
+    /**
+     * Set (create or replace) the network policy.
+     * Triggers immediate nftables update on the host — running VMs pick up
+     * the new rules without a restart.
+     */
+    set(params: NetworkPolicySetParams): Promise<NetworkPolicyData>;
+    /**
+     * Reset to the default policy (allow all egress).
+     * Idempotent — safe to call even if no policy was set.
+     */
+    reset(): Promise<void>;
+}
+
+type AgentRunTargetKind = "sandbox" | "computer";
+type AgentRunStatus = "running" | "succeeded" | "failed" | "canceled";
+interface AgentRun {
+    id: string;
+    agent_run_group_id?: string;
+    parent_agent_run_id?: string;
+    orchestration_role?: string;
+    external_workspace_id?: string | null;
+    external_user_id?: string | null;
+    external_project_id?: string | null;
+    target_kind: AgentRunTargetKind;
+    target_id: string;
+    provider: string;
+    prompt: string;
+    status: AgentRunStatus;
+    output?: string;
+    stderr?: string;
+    exit_code?: number;
+    metadata?: Record<string, unknown>;
+    started_at?: string;
+    finished_at?: string;
+    created_at?: string;
+    updated_at?: string;
+    [key: string]: unknown;
+}
+interface AgentRunArtifact {
+    id: string;
+    agent_run_id?: string;
+    target_kind?: AgentRunTargetKind;
+    target_id?: string;
+    path: string;
+    kind?: string;
+    mime_type?: string;
+    size_bytes?: number;
+    sha256?: string;
+    status?: string;
+    persisted?: boolean;
+    storage_backend?: string | null;
+    persisted_at?: string | null;
+    created_at?: string;
+    updated_at?: string;
+    [key: string]: unknown;
+}
+interface AgentRunEvent {
+    id: string;
+    agent_run_id?: string;
+    sequence?: number;
+    type: string;
+    message?: string | null;
+    payload?: Record<string, unknown>;
+    created_at?: string | null;
+    [key: string]: unknown;
+}
+interface AgentRunExecutionPacket {
+    goal?: string;
+    context?: Record<string, unknown>;
+    plan?: unknown;
+    constraints?: unknown;
+    acceptance_criteria?: unknown;
+    [key: string]: unknown;
+}
+interface AgentRunOutputContract {
+    artifacts?: Array<string | Partial<AgentRunArtifact>>;
+    artifact_paths?: string[];
+    preview_port?: number;
+    required_files?: string[];
+    [key: string]: unknown;
+}
+interface AgentRunApprovalPolicy {
+    publish?: "manual" | "automatic" | string;
+    external_write?: "manual" | "automatic" | string;
+    destructive_actions?: "forbidden" | "manual" | "automatic" | string;
+    [key: string]: unknown;
+}
+interface AgentRunCreateParams {
+    prompt: string;
+    targetKind?: AgentRunTargetKind;
+    targetId?: string;
+    sandboxId?: string;
+    /** Shortcut for a computer-backed Agent Run. */
+    computerId?: string;
+    provider?: string;
+    model?: string;
+    command?: string;
+    runtimeCommand?: string;
+    cwd?: string;
+    timeout?: number;
+    wait?: boolean;
+    env?: Record<string, string>;
+    /** Claude Code: `--output-format`, e.g. "json" or "stream-json". */
+    outputFormat?: "text" | "json" | "stream-json" | string;
+    output_format?: "text" | "json" | "stream-json" | string;
+    /** Claude Code: `--resume <session_id>`. */
+    resumeSessionId?: string;
+    resume_session_id?: string;
+    /** Codex: pass `--json` for JSONL event output. */
+    json?: boolean;
+    /** Codex: path to a JSON Schema file inside the runtime. */
+    outputSchema?: string;
+    output_schema?: string;
+    /** Codex: path to an image file inside the runtime. */
+    image?: string;
+    agentRuntimeProfileId?: string;
+    agentProfileId?: string;
+    agentRunGroupId?: string;
+    parentAgentRunId?: string;
+    orchestrationRole?: string;
+    externalWorkspaceId?: string;
+    external_workspace_id?: string;
+    externalUserId?: string;
+    external_user_id?: string;
+    externalProjectId?: string;
+    external_project_id?: string;
+    skipAgentRuntimeProfile?: boolean;
+    executionPacket?: AgentRunExecutionPacket;
+    outputContract?: AgentRunOutputContract;
+    approvalPolicy?: AgentRunApprovalPolicy;
+    capabilityRequirements?: string[];
+    metadata?: Record<string, unknown>;
+}
+interface AgentRunListParams {
+    targetKind?: AgentRunTargetKind;
+    targetId?: string;
+    sandboxId?: string;
+    computerId?: string;
+    agentRunGroupId?: string;
+    externalWorkspaceId?: string;
+    external_workspace_id?: string;
+    externalUserId?: string;
+    external_user_id?: string;
+    externalProjectId?: string;
+    external_project_id?: string;
+    status?: AgentRunStatus | string;
+}
+interface AgentRunWaitOptions {
+    timeoutMs?: number;
+    pollIntervalMs?: number;
+    terminalStatuses?: string[];
+}
+declare class AgentRuns {
+    private readonly http;
+    constructor(http: HttpClient);
+    list(params?: AgentRunListParams): Promise<AgentRun[]>;
+    get(id: string): Promise<AgentRun>;
+    artifacts(id: string): Promise<AgentRunArtifact[]>;
+    downloadArtifact(id: string, artifactId: string, options?: {
+        inline?: boolean;
+    }): Promise<Uint8Array>;
+    events(id: string): Promise<AgentRunEvent[]>;
+    streamEvents(id: string): AsyncIterableIterator<AgentRunEvent>;
+    waitForCompletion(id: string, options?: AgentRunWaitOptions): Promise<AgentRun>;
+    run(params: AgentRunCreateParams): Promise<AgentRun>;
+    cancel(id: string): Promise<AgentRun>;
+}
+
+type RunTargetKind = "sandbox" | "computer";
+type RunStatus = "running" | "succeeded" | "failed" | "canceled";
+interface Run {
+    id: string;
+    agent_definition_id?: string | null;
+    agent_version_id?: string | null;
+    configuration_receipt?: Record<string, unknown> | null;
+    run_group_id?: string;
+    parent_run_id?: string;
+    orchestration_role?: string;
+    external_workspace_id?: string | null;
+    external_user_id?: string | null;
+    external_project_id?: string | null;
+    target_kind: RunTargetKind;
+    target_id: string;
+    runner: string;
+    provider?: string | null;
+    model?: string | null;
+    instruction: string;
+    status: RunStatus;
+    metadata?: Record<string, unknown>;
+    /** MIOSA's conversation id; every run of a chat shares it. */
+    chat_id?: string | null;
+    /** The harness's own session id (Claude Code `session_id`, Codex `thread_id`, OSA session id). */
+    harness_session_id?: string | null;
+    continued_from_run_id?: string | null;
+    /** `new`, `resumed` or `reseeded`; `null` for runs that are not harness runs. */
+    session_mode?: RunSessionMode | null;
+    /** True when the harness ran with its approval bypass. */
+    overdrive?: boolean | null;
+    /** The user's own provider spend for this run; `null` while running or when no usage was reported. */
+    provider_cost?: RunProviderCost | null;
+    /** Context-window use of this run (one run is one chat turn). */
+    context?: RunContext | null;
+    started_at?: string;
+    finished_at?: string;
+    created_at?: string;
+    updated_at?: string;
+    [key: string]: unknown;
+}
+type RunSessionMode = "new" | "resumed" | "reseeded";
+interface RunProviderCost {
+    input_tokens: number;
+    output_tokens: number;
+    cache_read_tokens: number;
+    cache_write_tokens: number;
+    /** `null` for a subscription login and for a model the catalog has no price for. */
+    estimated_usd: number | null;
+    /** `harness`: the harness reported the cost. `catalog`: tokens times the catalog price. */
+    source: "harness" | "catalog";
+    model: string;
+    billed_to: "own_key" | "subscription";
+}
+interface RunContext {
+    context_tokens: number | null;
+    context_window: number | null;
+    used_ratio: number | null;
+    compactions: number | null;
+    compacted: boolean;
+    window_mode: "1m" | "standard" | null;
+    compaction_events: Array<{
+        before_tokens: number | null;
+        after_tokens: number | null;
+    }>;
+}
+interface RunFile {
+    id: string;
+    run_id?: string;
+    target_kind?: RunTargetKind;
+    target_id?: string;
+    path: string;
+    kind?: string;
+    mime_type?: string;
+    size_bytes?: number;
+    sha256?: string;
+    status?: string;
+    persisted?: boolean;
+    storage_backend?: string | null;
+    persisted_at?: string | null;
+    created_at?: string;
+    updated_at?: string;
+    [key: string]: unknown;
+    name?: string | null;
+    download_url?: string | null;
+    signed_download_url?: string | null;
+}
+interface RunMessage {
+    id?: string;
+    role?: string;
+    type?: string;
+    text?: string;
+    content?: string;
+    created_at?: string | null;
+    [key: string]: unknown;
+}
+interface RunCommandOutput {
+    stdout?: string | null;
+    stderr?: string | null;
+    exit_code?: number | null;
+}
+interface RunDownload {
+    id?: string;
+    file_id: string;
+    name?: string | null;
+    path?: string;
+    url: string;
+    mime_type?: string | null;
+    size_bytes?: number | null;
+    status?: string;
+    [key: string]: unknown;
+}
+interface RunPreview {
+    id: string;
+    run_id?: string;
+    file_id?: string;
+    type: string;
+    title?: string | null;
+    path?: string | null;
+    url?: string | null;
+    mime_type?: string | null;
+    status?: string;
+    metadata?: Record<string, unknown>;
+    [key: string]: unknown;
+}
+interface RunDiagnostic {
+    id: string;
+    run_id?: string;
+    code: string;
+    message?: string | null;
+    retryable?: boolean;
+    [key: string]: unknown;
+}
+interface RunOutputs {
+    run_id: string;
+    task_run_id?: string;
+    status: RunStatus;
+    result?: Record<string, unknown> | null;
+    message?: string | null;
+    messages: RunMessage[];
+    command_output: RunCommandOutput;
+    activity: RunActivity[];
+    files: RunFile[];
+    downloads: RunDownload[];
+    previews: RunPreview[];
+    diagnostics: RunDiagnostic[];
+    [key: string]: unknown;
+}
+interface RunActivity {
+    id: string;
+    run_id?: string;
+    sequence?: number;
+    type: string;
+    message?: string | null;
+    payload?: Record<string, unknown>;
+    created_at?: string | null;
+    [key: string]: unknown;
+}
+interface RunExecutionPacket {
+    goal?: string;
+    context?: Record<string, unknown>;
+    plan?: unknown;
+    constraints?: unknown;
+    acceptance_criteria?: unknown;
+    [key: string]: unknown;
+}
+interface RunExpectedFile {
+    path: string;
+    name?: string;
+    kind?: string;
+    mime_type?: string;
+    preview?: boolean;
+    [key: string]: unknown;
+}
+interface RunExpectedOutputs {
+    messages?: boolean;
+    files?: Array<string | RunExpectedFile>;
+    previews?: boolean | unknown[];
+    [key: string]: unknown;
+}
+interface RunApprovalPolicy {
+    publish?: "manual" | "automatic" | string;
+    external_write?: "manual" | "automatic" | string;
+    destructive_actions?: "forbidden" | "manual" | "automatic" | string;
+    [key: string]: unknown;
+}
+interface RunCreateParams {
+    instruction?: string;
+    targetKind?: RunTargetKind;
+    targetId?: string;
+    runtimeId?: string;
+    sandboxId?: string;
+    /** Shortcut for a computer-backed run. */
+    computerId?: string;
+    /** Optional model/vendor configuration, not the runner selector. */
+    provider?: string;
+    runner?: string;
+    model?: string;
+    command?: string;
+    runtimeCommand?: string;
+    cwd?: string;
+    timeout?: number;
+    wait?: boolean;
+    env?: Record<string, string>;
+    agentRuntimeProfileId?: string;
+    agentProfileId?: string;
+    agentDefinitionId?: string;
+    agentVersionId?: string;
+    configurationReceipt?: Record<string, unknown>;
+    runGroupId?: string;
+    parentRunId?: string;
+    orchestrationRole?: string;
+    externalWorkspaceId?: string;
+    external_workspace_id?: string;
+    externalUserId?: string;
+    external_user_id?: string;
+    externalProjectId?: string;
+    external_project_id?: string;
+    skipRuntimeProfile?: boolean;
+    executionPacket?: RunExecutionPacket;
+    expectedOutputs?: RunExpectedOutputs;
+    approvalPolicy?: RunApprovalPolicy;
+    capabilityRequirements?: string[];
+    metadata?: Record<string, unknown>;
+    /**
+     * The chat this run belongs to: 1 to 128 characters, `^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$`.
+     * Generate one (a UUID) when a chat starts and send it with every run. Sending
+     * `chat_id` alone continues the chat's single harness session.
+     */
+    chatId?: string;
+    /** Resume a specific earlier run's session. Optional once `chatId` is sent. */
+    continueFromRunId?: string;
+    /** One of `max xhigh high medium low minimal none`, and one the model takes. */
+    reasoningEffort?: string;
+    /** Environment to pin the run's machine to (when the run starts its own machine). */
+    environment?: string;
+    environmentId?: string;
+    noEnv?: boolean;
+}
+interface RunListParams {
+    targetKind?: RunTargetKind;
+    targetId?: string;
+    runtimeId?: string;
+    sandboxId?: string;
+    computerId?: string;
+    runGroupId?: string;
+    externalWorkspaceId?: string;
+    external_workspace_id?: string;
+    externalUserId?: string;
+    external_user_id?: string;
+    externalProjectId?: string;
+    external_project_id?: string;
+    status?: RunStatus | string;
+    agentDefinitionId?: string;
+    agentVersionId?: string;
+    /** `claude-code`, `codex`, `osa` or `custom` (maps to runner `gateway`). */
+    harness?: string;
+    harnessSessionId?: string;
+    /** Load a chat's history: `{ chatId, limit: 200 }`. Newest first. */
+    chatId?: string;
+    limit?: number;
+}
+type RunUsageGroupBy = "agent" | "chat" | "workspace" | "day" | "model" | "harness";
+interface RunUsageParams {
+    /** Any of `agent chat workspace day model harness`. Two or more group by every combination. */
+    groupBy?: RunUsageGroupBy[];
+    /** ISO 8601 datetime or date (a date is UTC midnight). Window is `[from, to)` on `finished_at`; default last 30 days, at most 366. */
+    from?: string;
+    to?: string;
+    agentDefinitionId?: string;
+    workspaceId?: string;
+    chatId?: string;
+    harness?: string;
+    model?: string;
+    billedTo?: "own_key" | "subscription";
+    /** Groups returned, default 500, at most 2000. */
+    limit?: number;
+}
+interface RunUsageCounters {
+    runs: number;
+    input_tokens: number;
+    output_tokens: number;
+    cache_read_tokens: number;
+    cache_write_tokens: number;
+    total_tokens: number;
+    /** Sum over runs with a known price; 0.0 when there are none. */
+    estimated_usd: number;
+    priced_runs: number;
+    subscription_runs: number;
+    /** Own-key runs on a model the catalog does not price: show tokens, say the cost is unknown. */
+    unpriced_runs: number;
+}
+interface RunUsageGroup extends RunUsageCounters {
+    key: {
+        agent_definition_id?: string | null;
+        chat_id?: string | null;
+        workspace_id?: string | null;
+        day?: string | null;
+        model?: string | null;
+        harness?: string | null;
+    };
+}
+interface RunUsage {
+    from: string;
+    to: string;
+    group_by: string[];
+    totals: RunUsageCounters;
+    groups: RunUsageGroup[];
+    /** True when `limit` groups came back and more may exist. */
+    truncated: boolean;
+}
+interface RunWaitOptions {
+    timeoutMs?: number;
+    pollIntervalMs?: number;
+    terminalStatuses?: string[];
+}
+declare class Runs {
+    private readonly http;
+    constructor(http: HttpClient);
+    list(params?: RunListParams): Promise<Run[]>;
+    get(id: string): Promise<Run>;
+    /**
+     * `GET /runs/usage`: the user's own provider spend over finished runs,
+     * overall and grouped. Agents are bring-your-own-key: this is spend reported
+     * for tracking, separate from the MIOSA credits a run used.
+     */
+    usage(params?: RunUsageParams): Promise<RunUsage>;
+    outputs(id: string): Promise<RunOutputs>;
+    files(id: string): Promise<RunFile[]>;
+    downloadFile(id: string, fileId: string, options?: {
+        inline?: boolean;
+    }): Promise<Uint8Array>;
+    messages(id: string): Promise<RunMessage[]>;
+    commandOutput(id: string): Promise<RunCommandOutput>;
+    activity(id: string): Promise<RunActivity[]>;
+    previews(id: string): Promise<RunPreview[]>;
+    diagnostics(id: string): Promise<RunDiagnostic[]>;
+    streamActivity(id: string): AsyncIterableIterator<RunActivity>;
+    waitForCompletion(id: string, options?: RunWaitOptions): Promise<Run>;
+    run(params: RunCreateParams): Promise<Run>;
+    cancel(id: string): Promise<Run>;
+}
+
+/**
+ * Per-computer inbox config (GET/PATCH /computers/:id/inbox).
+ * Defined inline because it has no separate file (small surface).
+ */
+declare class ComputerInbox {
+    private readonly http;
+    private readonly computerId;
+    constructor(http: HttpClient, computerId: string);
+    get(): Promise<Record<string, unknown>>;
+    update(fields: Record<string, unknown>): Promise<Record<string, unknown>>;
+}
+type ComputerRunOptions = Omit<RunCreateParams, "instruction" | "targetKind" | "targetId" | "sandboxId" | "computerId">;
+type ComputerPromptOptions = Omit<AgentRunCreateParams, "prompt" | "targetKind" | "targetId" | "sandboxId" | "computerId">;
+/**
+ * A Computer instance bound to a specific computer ID.
+ *
+ * Returned by `miosa.computers.create()`, `miosa.computers.get()`, and
+ * `miosa.computers.list()`. Exposes all per-computer actions as methods and
+ * sub-resources as properties.
+ */
+declare class Computer {
+    /** Raw data from the API. Refresh with `await computer.reload()`. */
+    data: ComputerData;
+    /** Desktop control — screenshot, click, type, drag, etc. */
+    readonly desktop: Desktop;
+    /** Execute shell and Python commands. */
+    readonly exec: Exec;
+    /** File operations — upload, download, list, delete. */
+    readonly files: Files;
+    /** Firecracker checkpoint (snapshot) management. */
+    readonly checkpoints: Checkpoints;
+    /** Egress network policy — allow/deny rules applied at the host TAP level. */
+    readonly networkPolicy: NetworkPolicy;
+    /** Real-time event subscription (window, clipboard, file, process, idle). */
+    readonly events: Events;
+    /** Custom domain management — map your own FQDNs to this sandbox. */
+    readonly domains: CustomDomains;
+    /** PTY session management — create/resize. */
+    readonly terminal: ComputerTerminal;
+    /** In-VM OSA agent dispatch — submitTask, cancelTask, status, configure. */
+    readonly osa: ComputerOsa;
+    /** Idle auto-stop config — get/update. */
+    readonly autoStop: ComputerAutoStop;
+    /** Per-computer inbox config — get/update. */
+    readonly inbox: ComputerInbox;
+    /** Encrypted env var CRUD — list, set, update, delete, bulkSet. */
+    readonly env: ComputerEnv;
+    /** VM log read + SSE stream. */
+    readonly logs: ComputerLogs;
+    /** Per-port visibility control — list, get, create, update, delete. */
+    readonly ports: ComputerPorts;
+    /** Volume attachment — list, attach, detach. */
+    readonly volumes: ComputerVolumes;
+    /** MIOSA Connect provider bindings scoped to this computer. */
+    readonly connectors: ComputerConnectors;
+    /** Encrypted secrets + OAuth credentials scoped to this computer. */
+    readonly secrets: ComputerSecrets;
+    /** Egress allowlist + policies scoped to this computer. */
+    readonly network: ComputerNetwork;
+    /** Egress audit log + live tail scoped to this computer. */
+    readonly audit: ComputerAudit;
+    /** Steer the agent run attached to this computer (queue a prompt, stop it). */
+    readonly agent: MachineAgent;
+    /** Share this computer with a person or through a link. */
+    readonly shares: ComputerShares;
+    private readonly http;
+    constructor(http: HttpClient, data: ComputerData);
+    get id(): ComputerId;
+    get name(): string;
+    get status(): ComputerData["status"];
+    /** URL-safe slug; falls back to the raw id when unset. */
+    get slug(): string;
+    /**
+     * Public HTTPS URL that forwards to a given port inside the VM.
+     *
+     * Example — expose a dev server running on port 3000:
+     * ```ts
+     * await computer.exec.bash("npm run dev &");
+     * const url = computer.previewUrl(3000);
+     * // => https://3000-<slug>.sandbox.<tenant-domain>
+     * ```
+     *
+     * Works for any TCP HTTP listener. Public (no auth required); anyone with
+     * the URL can see it. Served over the ingress proxy so it inherits the
+     * tenant's white-label preview domain — no per-sandbox certs to manage.
+     */
+    previewUrl(port: number, path?: string): string;
+    /** Root preview URL — serves whatever is on the default app port. */
+    get publicUrl(): string;
+    /** Tenant's preview/base domain, white-label aware. */
+    get previewDomain(): string;
+    /**
+     * Start the computer. Pass `environment`/`environmentId`/`noEnv` to pin a
+     * different environment; with none named the machine keeps its current pin.
+     */
+    start(options?: EnvironmentSelectionParams & {
+        env?: Record<string, string>;
+    }): Promise<Computer>;
+    /**
+     * `POST /computers/:id/commands`: run a command synchronously (capped at 600
+     * seconds). A computer that is not ready answers a retryable
+     * `ComputerStartingError`, which the client retries using the server's hint.
+     */
+    runCommand(command: string, options?: MachineCommandOptions): Promise<MachineCommandResult>;
+    /** Setup progress (`setup_status`, per-step status) from the machine JSON, refreshed. */
+    setupStatus(): Promise<MachineSetupFields>;
+    /** Wait until setup is final: `done`, `failed`, or `null` when there is no setup. */
+    waitForSetup(options?: {
+        timeoutMs?: number;
+        pollMs?: number;
+    }): Promise<MachineSetupFields>;
+    /** Stop the computer. */
+    stop(): Promise<Computer>;
+    /** Restart the computer. */
+    restart(): Promise<Computer>;
+    /** Permanently destroy the computer. After this call the instance is invalid. */
+    destroy(): Promise<void>;
+    /** Reload metadata from the API and update `this.data`. */
+    reload(): Promise<Computer>;
+    /**
+     * Run an AI agent inside this Computer.
+     *
+     * The Computer is the graphical desktop VM product. This dispatches the
+     * same Runs API as `miosa agent run --computer`, scoped to this VM.
+     */
+    run(instruction: string, options?: ComputerRunOptions): Promise<Run>;
+    /**
+     * Dispatch a prompt into this Computer through the Agent Runs API.
+     */
+    prompt(prompt: string, options?: ComputerPromptOptions): Promise<AgentRun>;
+    /**
+     * Capture a desktop screenshot as PNG bytes.
+     * Shortcut for `computer.desktop.screenshot()`.
+     */
+    screenshot(): Promise<Uint8Array>;
+    /**
+     * Capture a desktop screenshot encoded as a base64 string.
+     * Convenience for AI agents that pass screenshots to LLMs.
+     */
+    screenshotBase64(): Promise<string>;
+    /**
+     * Click at the given coordinates (default left button).
+     * Shortcut for `computer.desktop.click(x, y)`.
+     */
+    click(x: number, y: number): Promise<void>;
+    /** Explicit left-button click. Alias for `click(x, y)`. */
+    leftClick(x: number, y: number): Promise<void>;
+    /** Right-button click. */
+    rightClick(x: number, y: number): Promise<void>;
+    /** Double-click at the given coordinates. */
+    doubleClick(x: number, y: number): Promise<void>;
+    /** Middle-button click. */
+    middleClick(x: number, y: number): Promise<void>;
+    /** Move the pointer without clicking. */
+    moveMouse(x: number, y: number): Promise<void>;
+    /**
+     * Type text into the focused element.
+     * Shortcut for `computer.desktop.type(text)`.
+     */
+    type(text: string): Promise<void>;
+    /** Alias for `type(text)`. */
+    write(text: string): Promise<void>;
+    /**
+     * Send a key or key combo.
+     * Shortcut for `computer.desktop.key(key)`.
+     */
+    key(key: string): Promise<void>;
+    /** Alias for `key(key)`. */
+    press(key: string): Promise<void>;
+    /**
+     * Scroll in a direction.
+     * Shortcut for `computer.desktop.scroll(direction, clicks)`.
+     */
+    scroll(direction: Parameters<Desktop["scroll"]>[0], clicks?: number): Promise<void>;
+    /**
+     * Click and drag between two points.
+     * Shortcut for `computer.desktop.drag(fromX, fromY, toX, toY)`.
+     */
+    drag(fromX: number, fromY: number, toX: number, toY: number): Promise<void>;
+    /**
+     * Wait for N seconds inside the desktop environment.
+     * Shortcut for `computer.desktop.wait(seconds)`.
+     */
+    wait(seconds: number): Promise<void>;
+    /**
+     * Run a shell command.
+     * Shortcut for `computer.exec.bash(command)`.
+     */
+    bash(command: string, timeout?: number): Promise<ExecResult>;
+    /**
+     * Run Python code.
+     * Shortcut for `computer.exec.python(code)`.
+     */
+    python(code: string, timeout?: number): Promise<ExecResult>;
+    /** List open windows on the desktop. */
+    windows(): Promise<Awaited<ReturnType<Desktop["windows"]>>>;
+    /** Get the current cursor position. */
+    cursor(): Promise<Awaited<ReturnType<Desktop["cursor"]>>>;
+    /** Focus a specific window by ID. */
+    focusWindow(windowId: string): Promise<void>;
+    /** Launch an installed app inside the VM. */
+    launch(appName: string): Promise<void>;
+    /**
+     * Return a `ScopedFs` bound to `workingDir`.  All path arguments to
+     * `readFile`, `writeFile`, and `readdir` are resolved relative to that
+     * directory — no need to repeat the prefix on every call.
+     *
+     * ```ts
+     * const fs = computer.fs("/workspace");
+     * await fs.writeFile("main.py", "print(1)");
+     * const src = await fs.readFile("main.py");
+     * const entries = await fs.readdir(".");
+     * ```
+     */
+    fs(workingDir: string): ScopedFs;
+    /** Get VNC credentials for this computer. */
+    vncCredentials(): Promise<Record<string, unknown>>;
+    /**
+     * Return whether the external/raw desktop viewer password is set.
+     *
+     * Authenticated MIOSA platform users should use the platform desktop entry
+     * URL and do not need this password. This is only for raw external viewer
+     * links such as `*.computer.miosa.ai/desktop/index.html`.
+     */
+    viewerPassword(): Promise<ComputerViewerPasswordStatus>;
+    /**
+     * Rotate the external/raw desktop viewer password and return the plaintext
+     * one time. Store it if you need to share the raw viewer URL.
+     */
+    rotateViewerPassword(): Promise<ComputerViewerPasswordRotation>;
+    /** List installed apps inside the VM. */
+    apps(): Promise<Record<string, unknown>>;
+    /** Get URL map for this computer (VNC, preview, etc.). */
+    urls(): Promise<Record<string, unknown>>;
+    /** Mint a short-lived stream token for this computer. */
+    streamToken(): Promise<Record<string, unknown>>;
+    /**
+     * Mint a passwordless browser embed URL for authenticated platform sessions.
+     *
+     * Use this inside MIOSA or tenant apps. Raw shared desktop URLs can still use
+     * the viewer password flow when opened outside an authenticated platform.
+     */
+    embed(options?: {
+        ttlSeconds?: number;
+    }): Promise<Record<string, unknown>>;
+    /** A typed, expiring viewer link. See {@link ComputerViewer}. */
+    viewerUrl(options?: ViewerOptions): Promise<ComputerViewer>;
+    /**
+     * Run one desktop action by name and get a typed result. The names are the
+     * members of Anthropic's `computer_toolset_20260801`:
+     *
+     * ```ts
+     * const shot = await computer.act("screenshot");      // imageBase64, width, height
+     * const at = await computer.act("cursor_position");    // x, y
+     * await computer.act("left_click", { coordinate: [512, 384] });
+     * ```
+     */
+    act<A extends ActionName>(action: A, ...args: ActArgs<A>): Promise<ActionResultMap[A]>;
+    /** A screenshot and the accessibility tree in one call. */
+    look(options?: LookOptions): Promise<LookResult>;
+    /** Wait until the computer is `active` or `running`. */
+    waitUntilReady(options?: WaitOptions): Promise<Computer>;
+    /** Wait until the computer is ready and its desktop answers. */
+    waitForDesktop(options?: WaitOptions): Promise<Computer>;
+    /** Wait until the screen stops changing. */
+    waitUntilIdle(options?: WaitIdleOptions): Promise<void>;
+    /**
+     * `await using computer = await miosa.computers.create(...)` destroys the
+     * computer when the scope ends. A computer that is already gone is ignored.
+     */
+    [Symbol.asyncDispose](): Promise<void>;
+    /**
+     * `DELETE /computers/:id/stream-tokens`: revoke every viewer stream token
+     * minted for this computer (see {@link streamToken}).
+     */
+    revokeStreamTokens(): Promise<void>;
+    /** Clone this computer into a new one. */
+    clone(opts?: Record<string, unknown>): Promise<Computer>;
+    /** Resize the computer (change CPU/memory/disk). */
+    resize(size: string): Promise<Computer>;
+    /** Move the computer to a different region or host. */
+    move(opts: Record<string, unknown>): Promise<Computer>;
+    /** Capture a region of the desktop as PNG bytes. */
+    screenshotRegion(x: number, y: number, width: number, height: number): Promise<Uint8Array>;
+    /** Get time-series metrics (window: "1h" | "24h" | "7d"). */
+    metrics(window?: string): Promise<Record<string, unknown>>;
+    toJSON(): ComputerData;
+    toString(): string;
+}
+/**
+ * A thin filesystem wrapper that prepends a fixed working directory to all
+ * path arguments, mirroring the Node.js `fs/promises` surface.
+ *
+ * Obtain via `computer.fs("/workspace")`.
+ */
+declare class ScopedFs {
+    private readonly files;
+    private readonly workingDir;
+    constructor(files: Files, workingDir: string);
+    /** Resolve a relative or absolute path against `workingDir`. */
+    private resolve;
+    /** Write a UTF-8 string to a file (relative or absolute path). */
+    writeFile(path: string, content: string): Promise<void>;
+    /** Read a file and return its UTF-8 contents (relative or absolute path). */
+    readFile(path: string): Promise<string>;
+    /** List a directory (relative or absolute path). */
+    readdir(path: string): Promise<DirEntry[]>;
+    /** Stat a path (relative or absolute). */
+    stat(path: string): Promise<FileStat>;
+    /** Create a directory (relative or absolute). */
+    mkdir(path: string, options?: MkdirParams): Promise<void>;
+}
+
+export { type ComputerTemplateType as $, ACTION_NAMES as A, BillToForbiddenError as B, ChatBusyError as C, Computer as D, ComputerAudit as E, ComputerAutoStop as F, ComputerConnectors as G, type ComputerCreateParams as H, type ComputerData as I, ComputerEnv as J, type ComputerId as K, ComputerInbox as L, type ComputerListParams as M, type ComputerListResponse as N, ComputerLogs as O, type ComputerLogsGetParams as P, ComputerNetwork as Q, type RunExpectedOutputs as R, ComputerOsa as S, ComputerPorts as T, ComputerSecrets as U, type ComputerShare as V, type ComputerShareCreateParams as W, ComputerShares as X, type ComputerSize as Y, ComputerStartingError as Z, type ComputerStatus as _, type RunTargetKind as a, type FileExportResult as a$, ComputerTerminal as a0, type ComputerUpdateParams as a1, type ComputerViewer as a2, type ComputerVisibility as a3, ComputerVolumes as a4, type ConnectorApplicableDefaultParams as a5, type ConnectorCreateParams as a6, type ConnectorData as a7, type ConnectorDefault as a8, type ConnectorDefaultListParams as a9, type EgressAuditEvent as aA, type EgressBindingData as aB, EgressHostNotAllowedError as aC, EgressNetwork as aD, type EgressPolicyData as aE, type EgressPolicyMode as aF, type EgressRuleEffect as aG, type EgressSecretData as aH, type EgressSecretScope as aI, type EgressSecretType as aJ, EgressSecrets as aK, type EgressSuggestion as aL, EnvironmentIsDefaultError as aM, EnvironmentMemoryWithheldError as aN, EnvironmentNameTakenError as aO, EnvironmentNotFoundError as aP, EnvironmentScrubFailedError as aQ, type EnvironmentSelectionParams as aR, type EnvironmentStatus as aS, Exec as aT, type ExecParams as aU, type ExecPythonParams as aV, type ExecResult as aW, type FileDeleteParams as aX, type FileDownloadParams as aY, type FileEntry as aZ, type FileExportParams as a_, type ConnectorDefaultParams as aa, type ConnectorListParams as ab, type ConnectorSubject as ac, type ConnectorTokenParams as ad, type ConnectorTokenResponse as ae, Connectors as af, type Coordinate as ag, type CopyParams as ah, type CreditBalance as ai, CreditRequiredError as aj, type CreditTransaction as ak, type CreditTransactionListResponse as al, type CreditUsage as am, type CursorActionResult as an, type CursorInfo as ao, DeploymentConnectors as ap, Desktop as aq, type DesktopActionResult as ar, type DesktopEnvironmentInfo as as, type DesktopMouseButton as at, type DirEntry as au, type DirListResult as av, type DoubleClickParams as aw, type DragParams as ax, type EgressAllowlistRule as ay, EgressAudit as az, type RunCreateParams as b, type RunProviderCost as b$, type FileListParams as b0, type FileListResult as b1, type FileStat as b2, Files as b3, InstallationRequiredError as b4, InsufficientCreditsError as b5, InvalidActionInputError as b6, InvalidIdError as b7, InvalidSetupFileError as b8, type KeyParams as b9, NoReadyMachineError as bA, NotFoundError as bB, OAuthFlow as bC, type OauthConnectParams as bD, type OauthProvider as bE, type OauthStartResult as bF, type OauthStatusResult as bG, OrgNotFoundError as bH, OwnCredentialsRequiredError as bI, type PointerActionResult as bJ, type PolicyCreateParams as bK, type PolicyListParams as bL, type PolicyUpdateParams as bM, ProjectNotLinkedError as bN, RateLimitError as bO, type RulesListParams as bP, type Run as bQ, type RunActivity as bR, type RunCommandOutput as bS, type RunContext as bT, type RunDiagnostic as bU, type RunDownload as bV, type RunFile as bW, type RunListParams as bX, type RunMessage as bY, type RunOutputs as bZ, type RunPreview as b_, type LaunchParams as ba, type LookOptions as bb, type LookResult as bc, MachineAgent as bd, type MachineCommandOptions as be, type MachineCommandResult as bf, type MachineEnvironmentFields as bg, MachineKeyScopeError as bh, type MachineSetupFields as bi, MachineStartingError as bj, ManagedProviderBindingOnlyError as bk, MemberLimitReachedError as bl, type MiosaClientConfig as bm, MiosaError as bn, type MiosaErrorBody as bo, type MkdirParams as bp, type ModeParams as bq, type MouseButton as br, NetworkError as bs, NetworkPolicy as bt, type NetworkPolicyData as bu, type NetworkPolicyEffect as bv, type NetworkPolicyProtocol as bw, type NetworkPolicyRule as bx, type NetworkPolicySetParams as by, NoAgentRunError as bz, type ActArgs as c, type ComputerEvent as c$, type RunSessionMode as c0, RunSessionNotResumableError as c1, type RunStatus as c2, type RunUsage as c3, type RunUsageCounters as c4, type RunUsageGroup as c5, type RunUsageGroupBy as c6, type RunUsageParams as c7, type RunWaitOptions as c8, Runs as c9, type SnapshotData as cA, SnapshotInUseError as cB, type SnapshotListResponse as cC, type SnapshotProgressEvent as cD, type SnapshotRestoreResult as cE, type SnapshotStatus as cF, SubjectNotAllowedError as cG, type SuggestionsParams as cH, TeamMemberCapReachedError as cI, type TenantId as cJ, type TerminalCreateParams as cK, TimeoutError as cL, TokenRefreshFailedError as cM, type TypeParams as cN, UnknownEnvironmentError as cO, UserAuthorizationRequiredError as cP, ValidationError as cQ, type ViewerOptions as cR, type WaitIdleOptions as cS, type WaitOptions as cT, type WaitParams as cU, type WindowFocusParams as cV, type WindowInfo as cW, type WindowPosition as cX, type WindowSize as cY, performAction as cZ, pngSize as c_, SandboxAudit as ca, type SandboxConnectorAttachParams as cb, type SandboxConnectorBinding as cc, type SandboxConnectorPreflightParams as cd, type SandboxConnectorPreflightResult as ce, SandboxConnectors as cf, SandboxNetwork as cg, SandboxSecrets as ch, SandboxStartingError as ci, ScopeNotAllowedError as cj, ScopedFs as ck, type ScreenSize as cl, type ScreenshotActionResult as cm, type ScrollDirection as cn, type ScrollParams as co, type SecretListParams as cp, type SecretRotateParams as cq, type SecretSetParams as cr, type SessionId as cs, type SetupCliToolsStep as ct, type SetupEnvironmentStep as cu, type SetupRepoStep as cv, type SetupStatus as cw, type ShareRole as cx, SharedLinks as cy, type SnapshotCreateParams as cz, type ActParamsMap as d, HttpClient as d0, type AgentRun as d1, type AgentRunCreateParams as d2, type AgentRunArtifact as d3, type ComputerViewerPasswordStatus as d4, type ComputerViewerPasswordRotation as d5, AgentRuns as d6, type ActionName as e, type ActionResult as f, type ActionResultMap as g, type AgentEvent as h, type AgentEventType as i, type AgentPromptQueued as j, type AgentSessionCreateParams as k, type AgentSessionData as l, type AgentSessionListResponse as m, type AgentSessionStatus as n, type AllowParams as o, AmbiguousOrgError as p, type AuditListParams as q, type AuditTailParams as r, AuthError as s, BillToLockedError as t, type BillToParam as u, BillToSuspendedError as v, type BindingCreateParams as w, type BindingListParams as x, Checkpoints as y, type ClickParams$1 as z };