@trycua/cua 0.2.0

package/browser/cua_sdk.ts

@@ -0,0 +1,3644 @@
+// This file was autogenerated by some hot garbage in the `uniffi-bindgen-react-native` crate.
+// Trust me, you don't want to mess with it!
+/* tslint:disable */
+/* eslint-disable */
+// @ts-nocheck
+import * as wasmBundle from "./wasm-bindgen/index.js";
+import { type UniffiRustFutureContinuationCallback, type UniffiForeignFutureDroppedCallback, type UniffiForeignFutureDroppedCallbackStruct,
+} from "./cua_sdk-ffi.js";
+import { type FfiConverter, type UniffiByteArray, type UniffiGcObject, type UniffiHandle, type UniffiObjectFactory, AbstractFfiConverterByteArray, FfiConverterArray, FfiConverterArrayBuffer, FfiConverterBool, FfiConverterFloat64, FfiConverterInt32, FfiConverterInt64, FfiConverterMap, FfiConverterObject, FfiConverterOptional, FfiConverterUInt32, FfiConverterUInt64, FfiConverterUInt8, RustBuffer, UniffiAbstractObject, UniffiEnum, UniffiError, UniffiInternalError, UniffiRustCaller, destructorGuardSymbol, pointerLiteralSymbol, uniffiCreateFfiConverterString, uniffiCreateRecord, uniffiRustCallAsync, uniffiTypeNameSymbol, variantOrdinalSymbol,
+} from "@ubjs/core";
+// wasm1: wrap the wasm-bindgen namespace once so the codegen call sites can
+// uniformly reference `nativeModule().rustbuffer_alloc` / `.rustbuffer_free`.
+// For wasm1, RustBuffers are plain JS Uint8Arrays — no Rust-side allocation
+// is involved, so alloc just hands back a fresh view and free is a no-op.
+const _nativeModule = Object.assign({}, wasmBundle, {
+  rustbuffer_alloc: (n: number): Uint8Array => new Uint8Array(n),
+  rustbuffer_free: (_: Uint8Array): void => {},
+});
+const nativeModule = () => _nativeModule;
+const uniffiCaller = new UniffiRustCaller(() => new wasmBundle.RustCallStatus());
+
+const uniffiIsDebug =
+  // @ts-ignore -- The process global might not be defined
+  typeof process !== "object" ||
+  // @ts-ignore -- The process global might not be defined
+  process?.env?.NODE_ENV !== "production" ||
+  false;
+
+// Public interface members begin here.
+
+/**
+ * Version of the SDK library.
+ */
+export function cuaSdkVersion(): string {
+    return ((__rb: Uint8Array) => {
+        try {
+            return FfiConverterString.lift(__rb);
+        } finally {
+            nativeModule().rustbuffer_free(__rb);
+        }
+    })(uniffiCaller.rustCall(
+            /*caller:*/ (callStatus) => {
+                return nativeModule().ubrn_uniffi_cua_sdk_fn_func_cua_sdk_version(
+                callStatus);
+            },
+            /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString),
+    ));
+    }
+
+/**
+ * A link to the errors-reference entry of a [`CuaError`] variant, by name
+ * (`InvalidArgument`, case-insensitive). An unknown name links to the
+ * page itself. The bindings' `doc_url` / `docUrl` on `CuaError` use it.
+ */
+export function errorDocUrl(variant: string): string {
+    return ((__rb: Uint8Array) => {
+        try {
+            return FfiConverterString.lift(__rb);
+        } finally {
+            nativeModule().rustbuffer_free(__rb);
+        }
+    })(uniffiCaller.rustCall(
+            /*caller:*/ (callStatus) => {
+                return nativeModule().ubrn_uniffi_cua_sdk_fn_func_error_doc_url(
+        FfiConverterString.lower(variant, nativeModule().rustbuffer_alloc),
+                callStatus);
+            },
+            /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString),
+    ));
+    }
+
+const stringConverter = (() => {
+    const encoder = new TextEncoder();
+    const decoder = new TextDecoder();
+    return {
+        stringToBytes: (s: string) => encoder.encode(s),
+        bytesToString: (ab: UniffiByteArray) => decoder.decode(ab),
+        stringByteLength: (s: string) => encoder.encode(s).byteLength,
+        writeStringIntoBuffer: (s: string, buf: any, offset: number): number => {
+            const view = new Uint8Array(
+                buf.arrayBuffer,
+                offset,
+                buf.arrayBuffer.byteLength - offset,
+            );
+            return encoder.encodeInto(s, view).written;
+        },
+        readStringFromBuffer: (buf: any, offset: number, length: number): string =>
+            decoder.decode(new Uint8Array(buf.arrayBuffer, offset, length)),
+    };
+})();
+const FfiConverterString = uniffiCreateFfiConverterString(stringConverter);
+
+/**
+ * Fleet settings for the browser (static bearer only).
+ */
+export type FleetSettings = {
+    /**
+     * Fleet API base URL.
+     */
+    baseUrl?: string,
+    /**
+     * Bearer token.
+     */
+    token?: string
+}
+
+/**
+ * Generated factory for {@link FleetSettings} record objects.
+ */
+export const FleetSettings = (() => {
+    const defaults = () => ({
+        baseUrl: undefined,
+        token: undefined
+    });
+    const create = (() => {
+        return uniffiCreateRecord<FleetSettings, ReturnType<typeof defaults>>(defaults);
+    })();
+    return Object.freeze({
+        create,
+        new: create,
+        defaults: () => Object.freeze(defaults()) as Partial<FleetSettings>,
+    });
+})();
+
+const FfiConverterTypeFleetSettings = (() => {
+    type TypeName = FleetSettings;
+    class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+        read(from: RustBuffer): TypeName {
+            return {
+                baseUrl: FfiConverterOptionalString.read(from), 
+                token: FfiConverterOptionalString.read(from)
+            };
+        }
+        write(value: TypeName, into: RustBuffer): void {
+            FfiConverterOptionalString.write(value.baseUrl, into);
+            FfiConverterOptionalString.write(value.token, into);
+        }
+        allocationSize(value: TypeName): number {
+            return FfiConverterOptionalString.allocationSize(value.baseUrl) +
+             FfiConverterOptionalString.allocationSize(value.token);
+            
+        }
+    };
+    return new FFIConverter();
+})();
+
+/**
+ * Configuration of the browser SDK.
+ */
+export type CuaConfig = {
+    /**
+     * Fleet settings.
+     */
+    fleet?: FleetSettings
+}
+
+/**
+ * Generated factory for {@link CuaConfig} record objects.
+ */
+export const CuaConfig = (() => {
+    const defaults = () => ({
+        fleet: undefined
+    });
+    const create = (() => {
+        return uniffiCreateRecord<CuaConfig, ReturnType<typeof defaults>>(defaults);
+    })();
+    return Object.freeze({
+        create,
+        new: create,
+        defaults: () => Object.freeze(defaults()) as Partial<CuaConfig>,
+    });
+})();
+
+const FfiConverterTypeCuaConfig = (() => {
+    type TypeName = CuaConfig;
+    class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+        read(from: RustBuffer): TypeName {
+            return {
+                fleet: FfiConverterOptionalTypeFleetSettings.read(from)
+            };
+        }
+        write(value: TypeName, into: RustBuffer): void {
+            FfiConverterOptionalTypeFleetSettings.write(value.fleet, into);
+        }
+        allocationSize(value: TypeName): number {
+            return FfiConverterOptionalTypeFleetSettings.allocationSize(value.fleet);
+            
+        }
+    };
+    return new FFIConverter();
+})();
+
+/**
+ * How a process ended.
+ */
+export type ExitInfo = {
+    /**
+     * Exit code for a normal exit.
+     */
+    code?: number,
+    /**
+     * Terminating signal (`kill`, `term`, ...).
+     */
+    signal?: string,
+    /**
+     * Stopped by its timeout.
+     */
+    timedOut: boolean,
+    /**
+     * Supervisor error (for example "executable not found").
+     */
+    error?: string,
+    /**
+     * `code == 0`.
+     */
+    success: boolean
+}
+
+/**
+ * Generated factory for {@link ExitInfo} record objects.
+ */
+export const ExitInfo = (() => {
+    const defaults = () => ({
+    });
+    const create = (() => {
+        return uniffiCreateRecord<ExitInfo, ReturnType<typeof defaults>>(defaults);
+    })();
+    return Object.freeze({
+        create,
+        new: create,
+        defaults: () => Object.freeze(defaults()) as Partial<ExitInfo>,
+    });
+})();
+
+const FfiConverterTypeExitInfo = (() => {
+    type TypeName = ExitInfo;
+    class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+        read(from: RustBuffer): TypeName {
+            return {
+                code: FfiConverterOptionalInt32.read(from), 
+                signal: FfiConverterOptionalString.read(from), 
+                timedOut: FfiConverterBool.read(from), 
+                error: FfiConverterOptionalString.read(from), 
+                success: FfiConverterBool.read(from)
+            };
+        }
+        write(value: TypeName, into: RustBuffer): void {
+            FfiConverterOptionalInt32.write(value.code, into);
+            FfiConverterOptionalString.write(value.signal, into);
+            FfiConverterBool.write(value.timedOut, into);
+            FfiConverterOptionalString.write(value.error, into);
+            FfiConverterBool.write(value.success, into);
+        }
+        allocationSize(value: TypeName): number {
+            return FfiConverterOptionalInt32.allocationSize(value.code) +
+             FfiConverterOptionalString.allocationSize(value.signal) +
+             FfiConverterBool.allocationSize(value.timedOut) +
+             FfiConverterOptionalString.allocationSize(value.error) +
+             FfiConverterBool.allocationSize(value.success);
+            
+        }
+    };
+    return new FFIConverter();
+})();
+
+/**
+ * A file or directory in the guest.
+ */
+export type FileEntry = {
+    /**
+     * Base name.
+     */
+    name: string,
+    /**
+     * Absolute path.
+     */
+    path: string,
+    /**
+     * `file`, `directory`, `symlink` or `other`.
+     */
+    kind: string,
+    /**
+     * Size in bytes.
+     */
+    size: bigint,
+    /**
+     * Unix mode bits.
+     */
+    mode: number,
+    /**
+     * Modification time (Unix ms), when known.
+     */
+    modifiedMs?: bigint,
+    /**
+     * Symlink target.
+     */
+    symlinkTarget?: string
+}
+
+/**
+ * Generated factory for {@link FileEntry} record objects.
+ */
+export const FileEntry = (() => {
+    const defaults = () => ({
+    });
+    const create = (() => {
+        return uniffiCreateRecord<FileEntry, ReturnType<typeof defaults>>(defaults);
+    })();
+    return Object.freeze({
+        create,
+        new: create,
+        defaults: () => Object.freeze(defaults()) as Partial<FileEntry>,
+    });
+})();
+
+const FfiConverterTypeFileEntry = (() => {
+    type TypeName = FileEntry;
+    class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+        read(from: RustBuffer): TypeName {
+            return {
+                name: FfiConverterString.read(from), 
+                path: FfiConverterString.read(from), 
+                kind: FfiConverterString.read(from), 
+                size: FfiConverterUInt64.read(from), 
+                mode: FfiConverterUInt32.read(from), 
+                modifiedMs: FfiConverterOptionalInt64.read(from), 
+                symlinkTarget: FfiConverterOptionalString.read(from)
+            };
+        }
+        write(value: TypeName, into: RustBuffer): void {
+            FfiConverterString.write(value.name, into);
+            FfiConverterString.write(value.path, into);
+            FfiConverterString.write(value.kind, into);
+            FfiConverterUInt64.write(value.size, into);
+            FfiConverterUInt32.write(value.mode, into);
+            FfiConverterOptionalInt64.write(value.modifiedMs, into);
+            FfiConverterOptionalString.write(value.symlinkTarget, into);
+        }
+        allocationSize(value: TypeName): number {
+            return FfiConverterString.allocationSize(value.name) +
+             FfiConverterString.allocationSize(value.path) +
+             FfiConverterString.allocationSize(value.kind) +
+             FfiConverterUInt64.allocationSize(value.size) +
+             FfiConverterUInt32.allocationSize(value.mode) +
+             FfiConverterOptionalInt64.allocationSize(value.modifiedMs) +
+             FfiConverterOptionalString.allocationSize(value.symlinkTarget);
+            
+        }
+    };
+    return new FFIConverter();
+})();
+
+/**
+ * A bound Fleet sandbox.
+ */
+export type FleetSandbox = {
+    /**
+     * Sandbox name.
+     */
+    name: string,
+    /**
+     * Namespace.
+     */
+    namespace: string,
+    /**
+     * Claim name.
+     */
+    claim: string,
+    /**
+     * Declared services.
+     */
+    services: Array<string>
+}
+
+/**
+ * Generated factory for {@link FleetSandbox} record objects.
+ */
+export const FleetSandbox = (() => {
+    const defaults = () => ({
+    });
+    const create = (() => {
+        return uniffiCreateRecord<FleetSandbox, ReturnType<typeof defaults>>(defaults);
+    })();
+    return Object.freeze({
+        create,
+        new: create,
+        defaults: () => Object.freeze(defaults()) as Partial<FleetSandbox>,
+    });
+})();
+
+const FfiConverterTypeFleetSandbox = (() => {
+    type TypeName = FleetSandbox;
+    class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+        read(from: RustBuffer): TypeName {
+            return {
+                name: FfiConverterString.read(from), 
+                namespace: FfiConverterString.read(from), 
+                claim: FfiConverterString.read(from), 
+                services: FfiConverterSequenceString.read(from)
+            };
+        }
+        write(value: TypeName, into: RustBuffer): void {
+            FfiConverterString.write(value.name, into);
+            FfiConverterString.write(value.namespace, into);
+            FfiConverterString.write(value.claim, into);
+            FfiConverterSequenceString.write(value.services, into);
+        }
+        allocationSize(value: TypeName): number {
+            return FfiConverterString.allocationSize(value.name) +
+             FfiConverterString.allocationSize(value.namespace) +
+             FfiConverterString.allocationSize(value.claim) +
+             FfiConverterSequenceString.allocationSize(value.services);
+            
+        }
+    };
+    return new FFIConverter();
+})();
+
+/**
+ * Media session options.
+ */
+export type MediaOpenOptions = {
+    /**
+     * Display id (primary when unset). Ignored when `window_handle` is set.
+     */
+    display?: string,
+    /**
+     * Window handle (from `ListTargets` / `ListWindows`).
+     */
+    windowHandle?: string,
+    /**
+     * FPS cap (0 = driver default).
+     */
+    maxFps: number,
+    /**
+     * Long-edge cap (0 = native).
+     */
+    maxDimension: number,
+    /**
+     * Also negotiate desktop/app audio (Opus).
+     */
+    audio: boolean,
+    /**
+     * Audio only.
+     */
+    disableVideo: boolean,
+    /**
+     * Extra `OpenMediaRequest` fields as proto3 JSON, merged over the
+     * above (escape hatch).
+     */
+    requestJson?: string
+}
+
+/**
+ * Generated factory for {@link MediaOpenOptions} record objects.
+ */
+export const MediaOpenOptions = (() => {
+    const defaults = () => ({
+        display: undefined,
+        windowHandle: undefined,
+        maxFps: 0,
+        maxDimension: 0,
+        audio: false,
+        disableVideo: false,
+        requestJson: undefined
+    });
+    const create = (() => {
+        return uniffiCreateRecord<MediaOpenOptions, ReturnType<typeof defaults>>(defaults);
+    })();
+    return Object.freeze({
+        create,
+        new: create,
+        defaults: () => Object.freeze(defaults()) as Partial<MediaOpenOptions>,
+    });
+})();
+
+const FfiConverterTypeMediaOpenOptions = (() => {
+    type TypeName = MediaOpenOptions;
+    class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+        read(from: RustBuffer): TypeName {
+            return {
+                display: FfiConverterOptionalString.read(from), 
+                windowHandle: FfiConverterOptionalString.read(from), 
+                maxFps: FfiConverterUInt32.read(from), 
+                maxDimension: FfiConverterUInt32.read(from), 
+                audio: FfiConverterBool.read(from), 
+                disableVideo: FfiConverterBool.read(from), 
+                requestJson: FfiConverterOptionalString.read(from)
+            };
+        }
+        write(value: TypeName, into: RustBuffer): void {
+            FfiConverterOptionalString.write(value.display, into);
+            FfiConverterOptionalString.write(value.windowHandle, into);
+            FfiConverterUInt32.write(value.maxFps, into);
+            FfiConverterUInt32.write(value.maxDimension, into);
+            FfiConverterBool.write(value.audio, into);
+            FfiConverterBool.write(value.disableVideo, into);
+            FfiConverterOptionalString.write(value.requestJson, into);
+        }
+        allocationSize(value: TypeName): number {
+            return FfiConverterOptionalString.allocationSize(value.display) +
+             FfiConverterOptionalString.allocationSize(value.windowHandle) +
+             FfiConverterUInt32.allocationSize(value.maxFps) +
+             FfiConverterUInt32.allocationSize(value.maxDimension) +
+             FfiConverterBool.allocationSize(value.audio) +
+             FfiConverterBool.allocationSize(value.disableVideo) +
+             FfiConverterOptionalString.allocationSize(value.requestJson);
+            
+        }
+    };
+    return new FFIConverter();
+})();
+
+/**
+ * A point.
+ */
+export type Point = {
+    /**
+     * X.
+     */
+    x: number,
+    /**
+     * Y.
+     */
+    y: number
+}
+
+/**
+ * Generated factory for {@link Point} record objects.
+ */
+export const Point = (() => {
+    const defaults = () => ({
+    });
+    const create = (() => {
+        return uniffiCreateRecord<Point, ReturnType<typeof defaults>>(defaults);
+    })();
+    return Object.freeze({
+        create,
+        new: create,
+        defaults: () => Object.freeze(defaults()) as Partial<Point>,
+    });
+})();
+
+const FfiConverterTypePoint = (() => {
+    type TypeName = Point;
+    class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+        read(from: RustBuffer): TypeName {
+            return {
+                x: FfiConverterFloat64.read(from), 
+                y: FfiConverterFloat64.read(from)
+            };
+        }
+        write(value: TypeName, into: RustBuffer): void {
+            FfiConverterFloat64.write(value.x, into);
+            FfiConverterFloat64.write(value.y, into);
+        }
+        allocationSize(value: TypeName): number {
+            return FfiConverterFloat64.allocationSize(value.x) +
+             FfiConverterFloat64.allocationSize(value.y);
+            
+        }
+    };
+    return new FFIConverter();
+})();
+
+/**
+ * Kind of a process event.
+ */
+export enum ProcessEventKind {
+    /**
+     * stdout bytes.
+     */
+    Stdout,
+    /**
+     * stderr bytes.
+     */
+    Stderr,
+    /**
+     * PTY bytes.
+     */
+    Pty,
+    /**
+     * The process ended (always last).
+     */
+    Exit
+}
+
+const FfiConverterTypeProcessEventKind = (() => {
+    const ordinalConverter = FfiConverterInt32;
+    type TypeName = ProcessEventKind;
+    class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+        read(from: RustBuffer): TypeName {
+            switch (ordinalConverter.read(from)) {
+                case 1: return ProcessEventKind.Stdout;
+                case 2: return ProcessEventKind.Stderr;
+                case 3: return ProcessEventKind.Pty;
+                case 4: return ProcessEventKind.Exit;
+                default: throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+        write(value: TypeName, into: RustBuffer): void {
+            switch (value) {
+                case ProcessEventKind.Stdout: return ordinalConverter.write(1, into);
+                case ProcessEventKind.Stderr: return ordinalConverter.write(2, into);
+                case ProcessEventKind.Pty: return ordinalConverter.write(3, into);
+                case ProcessEventKind.Exit: return ordinalConverter.write(4, into);
+            }
+        }
+        allocationSize(value: TypeName): number {
+            return ordinalConverter.allocationSize(0);
+        }
+    }
+    return new FFIConverter();
+})();
+
+/**
+ * One output chunk or the exit.
+ */
+export type ProcessEvent = {
+    /**
+     * Kind.
+     */
+    kind: ProcessEventKind,
+    /**
+     * Combined-output offset of the first byte.
+     */
+    offset: bigint,
+    /**
+     * Bytes (empty for `Exit`).
+     */
+    data: ArrayBuffer,
+    /**
+     * Exit (only for `Exit`).
+     */
+    exit?: ExitInfo
+}
+
+/**
+ * Generated factory for {@link ProcessEvent} record objects.
+ */
+export const ProcessEvent = (() => {
+    const defaults = () => ({
+    });
+    const create = (() => {
+        return uniffiCreateRecord<ProcessEvent, ReturnType<typeof defaults>>(defaults);
+    })();
+    return Object.freeze({
+        create,
+        new: create,
+        defaults: () => Object.freeze(defaults()) as Partial<ProcessEvent>,
+    });
+})();
+
+const FfiConverterTypeProcessEvent = (() => {
+    type TypeName = ProcessEvent;
+    class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+        read(from: RustBuffer): TypeName {
+            return {
+                kind: FfiConverterTypeProcessEventKind.read(from), 
+                offset: FfiConverterUInt64.read(from), 
+                data: FfiConverterArrayBuffer.read(from), 
+                exit: FfiConverterOptionalTypeExitInfo.read(from)
+            };
+        }
+        write(value: TypeName, into: RustBuffer): void {
+            FfiConverterTypeProcessEventKind.write(value.kind, into);
+            FfiConverterUInt64.write(value.offset, into);
+            FfiConverterArrayBuffer.write(value.data, into);
+            FfiConverterOptionalTypeExitInfo.write(value.exit, into);
+        }
+        allocationSize(value: TypeName): number {
+            return FfiConverterTypeProcessEventKind.allocationSize(value.kind) +
+             FfiConverterUInt64.allocationSize(value.offset) +
+             FfiConverterArrayBuffer.allocationSize(value.data) +
+             FfiConverterOptionalTypeExitInfo.allocationSize(value.exit);
+            
+        }
+    };
+    return new FFIConverter();
+})();
+
+/**
+ * Collected output of a finished process.
+ */
+export type ProcessOutput = {
+    /**
+     * Exit.
+     */
+    exit: ExitInfo,
+    /**
+     * stdout bytes.
+     */
+    stdout: ArrayBuffer,
+    /**
+     * stderr bytes.
+     */
+    stderr: ArrayBuffer,
+    /**
+     * PTY bytes.
+     */
+    pty: ArrayBuffer
+}
+
+/**
+ * Generated factory for {@link ProcessOutput} record objects.
+ */
+export const ProcessOutput = (() => {
+    const defaults = () => ({
+    });
+    const create = (() => {
+        return uniffiCreateRecord<ProcessOutput, ReturnType<typeof defaults>>(defaults);
+    })();
+    return Object.freeze({
+        create,
+        new: create,
+        defaults: () => Object.freeze(defaults()) as Partial<ProcessOutput>,
+    });
+})();
+
+const FfiConverterTypeProcessOutput = (() => {
+    type TypeName = ProcessOutput;
+    class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+        read(from: RustBuffer): TypeName {
+            return {
+                exit: FfiConverterTypeExitInfo.read(from), 
+                stdout: FfiConverterArrayBuffer.read(from), 
+                stderr: FfiConverterArrayBuffer.read(from), 
+                pty: FfiConverterArrayBuffer.read(from)
+            };
+        }
+        write(value: TypeName, into: RustBuffer): void {
+            FfiConverterTypeExitInfo.write(value.exit, into);
+            FfiConverterArrayBuffer.write(value.stdout, into);
+            FfiConverterArrayBuffer.write(value.stderr, into);
+            FfiConverterArrayBuffer.write(value.pty, into);
+        }
+        allocationSize(value: TypeName): number {
+            return FfiConverterTypeExitInfo.allocationSize(value.exit) +
+             FfiConverterArrayBuffer.allocationSize(value.stdout) +
+             FfiConverterArrayBuffer.allocationSize(value.stderr) +
+             FfiConverterArrayBuffer.allocationSize(value.pty);
+            
+        }
+    };
+    return new FFIConverter();
+})();
+
+/**
+ * A PTY size.
+ */
+export type PtySize = {
+    /**
+     * Columns.
+     */
+    cols: number,
+    /**
+     * Rows.
+     */
+    rows: number
+}
+
+/**
+ * Generated factory for {@link PtySize} record objects.
+ */
+export const PtySize = (() => {
+    const defaults = () => ({
+    });
+    const create = (() => {
+        return uniffiCreateRecord<PtySize, ReturnType<typeof defaults>>(defaults);
+    })();
+    return Object.freeze({
+        create,
+        new: create,
+        defaults: () => Object.freeze(defaults()) as Partial<PtySize>,
+    });
+})();
+
+const FfiConverterTypePtySize = (() => {
+    type TypeName = PtySize;
+    class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+        read(from: RustBuffer): TypeName {
+            return {
+                cols: FfiConverterUInt32.read(from), 
+                rows: FfiConverterUInt32.read(from)
+            };
+        }
+        write(value: TypeName, into: RustBuffer): void {
+            FfiConverterUInt32.write(value.cols, into);
+            FfiConverterUInt32.write(value.rows, into);
+        }
+        allocationSize(value: TypeName): number {
+            return FfiConverterUInt32.allocationSize(value.cols) +
+             FfiConverterUInt32.allocationSize(value.rows);
+            
+        }
+    };
+    return new FFIConverter();
+})();
+
+/**
+ * Screenshot encoding.
+ */
+export enum ImageFormat {
+    /**
+     * PNG.
+     */
+    Png,
+    /**
+     * JPEG.
+     */
+    Jpeg,
+    /**
+     * WebP.
+     */
+    Webp
+}
+
+const FfiConverterTypeImageFormat = (() => {
+    const ordinalConverter = FfiConverterInt32;
+    type TypeName = ImageFormat;
+    class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+        read(from: RustBuffer): TypeName {
+            switch (ordinalConverter.read(from)) {
+                case 1: return ImageFormat.Png;
+                case 2: return ImageFormat.Jpeg;
+                case 3: return ImageFormat.Webp;
+                default: throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+        write(value: TypeName, into: RustBuffer): void {
+            switch (value) {
+                case ImageFormat.Png: return ordinalConverter.write(1, into);
+                case ImageFormat.Jpeg: return ordinalConverter.write(2, into);
+                case ImageFormat.Webp: return ordinalConverter.write(3, into);
+            }
+        }
+        allocationSize(value: TypeName): number {
+            return ordinalConverter.allocationSize(0);
+        }
+    }
+    return new FFIConverter();
+})();
+
+/**
+ * A captured screenshot.
+ */
+export type Screenshot = {
+    /**
+     * Encoded image.
+     */
+    image: ArrayBuffer,
+    /**
+     * Encoding.
+     */
+    format: ImageFormat,
+    /**
+     * Pixel width.
+     */
+    width: number,
+    /**
+     * Pixel height.
+     */
+    height: number,
+    /**
+     * Image pixels per logical point.
+     */
+    scale: number,
+    /**
+     * Id for screenshot-space input.
+     */
+    screenshotId: string
+}
+
+/**
+ * Generated factory for {@link Screenshot} record objects.
+ */
+export const Screenshot = (() => {
+    const defaults = () => ({
+    });
+    const create = (() => {
+        return uniffiCreateRecord<Screenshot, ReturnType<typeof defaults>>(defaults);
+    })();
+    return Object.freeze({
+        create,
+        new: create,
+        defaults: () => Object.freeze(defaults()) as Partial<Screenshot>,
+    });
+})();
+
+const FfiConverterTypeScreenshot = (() => {
+    type TypeName = Screenshot;
+    class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+        read(from: RustBuffer): TypeName {
+            return {
+                image: FfiConverterArrayBuffer.read(from), 
+                format: FfiConverterTypeImageFormat.read(from), 
+                width: FfiConverterUInt32.read(from), 
+                height: FfiConverterUInt32.read(from), 
+                scale: FfiConverterFloat64.read(from), 
+                screenshotId: FfiConverterString.read(from)
+            };
+        }
+        write(value: TypeName, into: RustBuffer): void {
+            FfiConverterArrayBuffer.write(value.image, into);
+            FfiConverterTypeImageFormat.write(value.format, into);
+            FfiConverterUInt32.write(value.width, into);
+            FfiConverterUInt32.write(value.height, into);
+            FfiConverterFloat64.write(value.scale, into);
+            FfiConverterString.write(value.screenshotId, into);
+        }
+        allocationSize(value: TypeName): number {
+            return FfiConverterArrayBuffer.allocationSize(value.image) +
+             FfiConverterTypeImageFormat.allocationSize(value.format) +
+             FfiConverterUInt32.allocationSize(value.width) +
+             FfiConverterUInt32.allocationSize(value.height) +
+             FfiConverterFloat64.allocationSize(value.scale) +
+             FfiConverterString.allocationSize(value.screenshotId);
+            
+        }
+    };
+    return new FFIConverter();
+})();
+
+/**
+ * Screenshot options.
+ */
+export type ScreenshotOptions = {
+    /**
+     * Display id (primary when unset).
+     */
+    display?: string,
+    /**
+     * Encoding (PNG when unset).
+     */
+    format?: ImageFormat,
+    /**
+     * Lossy quality 1–100.
+     */
+    quality?: number,
+    /**
+     * Long-edge cap in pixels.
+     */
+    maxDimension?: number,
+    /**
+     * Draw the cursor.
+     */
+    includeCursor: boolean
+}
+
+/**
+ * Generated factory for {@link ScreenshotOptions} record objects.
+ */
+export const ScreenshotOptions = (() => {
+    const defaults = () => ({
+        display: undefined,
+        format: undefined,
+        quality: undefined,
+        maxDimension: undefined,
+        includeCursor: false
+    });
+    const create = (() => {
+        return uniffiCreateRecord<ScreenshotOptions, ReturnType<typeof defaults>>(defaults);
+    })();
+    return Object.freeze({
+        create,
+        new: create,
+        defaults: () => Object.freeze(defaults()) as Partial<ScreenshotOptions>,
+    });
+})();
+
+const FfiConverterTypeScreenshotOptions = (() => {
+    type TypeName = ScreenshotOptions;
+    class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+        read(from: RustBuffer): TypeName {
+            return {
+                display: FfiConverterOptionalString.read(from), 
+                format: FfiConverterOptionalTypeImageFormat.read(from), 
+                quality: FfiConverterOptionalUInt32.read(from), 
+                maxDimension: FfiConverterOptionalUInt32.read(from), 
+                includeCursor: FfiConverterBool.read(from)
+            };
+        }
+        write(value: TypeName, into: RustBuffer): void {
+            FfiConverterOptionalString.write(value.display, into);
+            FfiConverterOptionalTypeImageFormat.write(value.format, into);
+            FfiConverterOptionalUInt32.write(value.quality, into);
+            FfiConverterOptionalUInt32.write(value.maxDimension, into);
+            FfiConverterBool.write(value.includeCursor, into);
+        }
+        allocationSize(value: TypeName): number {
+            return FfiConverterOptionalString.allocationSize(value.display) +
+             FfiConverterOptionalTypeImageFormat.allocationSize(value.format) +
+             FfiConverterOptionalUInt32.allocationSize(value.quality) +
+             FfiConverterOptionalUInt32.allocationSize(value.maxDimension) +
+             FfiConverterBool.allocationSize(value.includeCursor);
+            
+        }
+    };
+    return new FFIConverter();
+})();
+
+/**
+ * One capability flag.
+ */
+export type SpacesdFeature = {
+    /**
+     * Feature name (for example `a11y`, `stream.h264`, `audio.desktop`).
+     */
+    name: string,
+    /**
+     * Supported in this guest.
+     */
+    supported: boolean,
+    /**
+     * Limitation when degraded or unsupported.
+     */
+    limitation?: string,
+    /**
+     * Extra attributes.
+     */
+    attributes: Map<string, string>
+}
+
+/**
+ * Generated factory for {@link SpacesdFeature} record objects.
+ */
+export const SpacesdFeature = (() => {
+    const defaults = () => ({
+    });
+    const create = (() => {
+        return uniffiCreateRecord<SpacesdFeature, ReturnType<typeof defaults>>(defaults);
+    })();
+    return Object.freeze({
+        create,
+        new: create,
+        defaults: () => Object.freeze(defaults()) as Partial<SpacesdFeature>,
+    });
+})();
+
+const FfiConverterTypeSpacesdFeature = (() => {
+    type TypeName = SpacesdFeature;
+    class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+        read(from: RustBuffer): TypeName {
+            return {
+                name: FfiConverterString.read(from), 
+                supported: FfiConverterBool.read(from), 
+                limitation: FfiConverterOptionalString.read(from), 
+                attributes: FfiConverterMapStringString.read(from)
+            };
+        }
+        write(value: TypeName, into: RustBuffer): void {
+            FfiConverterString.write(value.name, into);
+            FfiConverterBool.write(value.supported, into);
+            FfiConverterOptionalString.write(value.limitation, into);
+            FfiConverterMapStringString.write(value.attributes, into);
+        }
+        allocationSize(value: TypeName): number {
+            return FfiConverterString.allocationSize(value.name) +
+             FfiConverterBool.allocationSize(value.supported) +
+             FfiConverterOptionalString.allocationSize(value.limitation) +
+             FfiConverterMapStringString.allocationSize(value.attributes);
+            
+        }
+    };
+    return new FFIConverter();
+})();
+
+/**
+ * `SystemService.GetCapabilities`, summarized. `json` has everything.
+ */
+export type SpacesdCapabilities = {
+    /**
+     * spacesd version.
+     */
+    version: string,
+    /**
+     * `cua.env.v1` protocol version.
+     */
+    protocolVersion: number,
+    /**
+     * Additive contract revision.
+     */
+    protocolRevision: number,
+    /**
+     * OS family (`linux`, `macos`, `windows`).
+     */
+    osFamily: string,
+    /**
+     * OS name.
+     */
+    osName: string,
+    /**
+     * OS version.
+     */
+    osVersion: string,
+    /**
+     * CPU architecture.
+     */
+    arch: string,
+    /**
+     * Guest hostname.
+     */
+    hostname: string,
+    /**
+     * `SystemService.Init` has run.
+     */
+    initialized: boolean,
+    /**
+     * Feature flags.
+     */
+    features: Array<SpacesdFeature>,
+    /**
+     * The full response as proto3 JSON.
+     */
+    json: string
+}
+
+/**
+ * Generated factory for {@link SpacesdCapabilities} record objects.
+ */
+export const SpacesdCapabilities = (() => {
+    const defaults = () => ({
+    });
+    const create = (() => {
+        return uniffiCreateRecord<SpacesdCapabilities, ReturnType<typeof defaults>>(defaults);
+    })();
+    return Object.freeze({
+        create,
+        new: create,
+        defaults: () => Object.freeze(defaults()) as Partial<SpacesdCapabilities>,
+    });
+})();
+
+const FfiConverterTypeSpacesdCapabilities = (() => {
+    type TypeName = SpacesdCapabilities;
+    class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+        read(from: RustBuffer): TypeName {
+            return {
+                version: FfiConverterString.read(from), 
+                protocolVersion: FfiConverterUInt32.read(from), 
+                protocolRevision: FfiConverterUInt32.read(from), 
+                osFamily: FfiConverterString.read(from), 
+                osName: FfiConverterString.read(from), 
+                osVersion: FfiConverterString.read(from), 
+                arch: FfiConverterString.read(from), 
+                hostname: FfiConverterString.read(from), 
+                initialized: FfiConverterBool.read(from), 
+                features: FfiConverterSequenceTypeSpacesdFeature.read(from), 
+                json: FfiConverterString.read(from)
+            };
+        }
+        write(value: TypeName, into: RustBuffer): void {
+            FfiConverterString.write(value.version, into);
+            FfiConverterUInt32.write(value.protocolVersion, into);
+            FfiConverterUInt32.write(value.protocolRevision, into);
+            FfiConverterString.write(value.osFamily, into);
+            FfiConverterString.write(value.osName, into);
+            FfiConverterString.write(value.osVersion, into);
+            FfiConverterString.write(value.arch, into);
+            FfiConverterString.write(value.hostname, into);
+            FfiConverterBool.write(value.initialized, into);
+            FfiConverterSequenceTypeSpacesdFeature.write(value.features, into);
+            FfiConverterString.write(value.json, into);
+        }
+        allocationSize(value: TypeName): number {
+            return FfiConverterString.allocationSize(value.version) +
+             FfiConverterUInt32.allocationSize(value.protocolVersion) +
+             FfiConverterUInt32.allocationSize(value.protocolRevision) +
+             FfiConverterString.allocationSize(value.osFamily) +
+             FfiConverterString.allocationSize(value.osName) +
+             FfiConverterString.allocationSize(value.osVersion) +
+             FfiConverterString.allocationSize(value.arch) +
+             FfiConverterString.allocationSize(value.hostname) +
+             FfiConverterBool.allocationSize(value.initialized) +
+             FfiConverterSequenceTypeSpacesdFeature.allocationSize(value.features) +
+             FfiConverterString.allocationSize(value.json);
+            
+        }
+    };
+    return new FFIConverter();
+})();
+
+/**
+ * A command to run in the guest.
+ */
+export type SpacesdCommand = {
+    /**
+     * Program (absolute path or `PATH` lookup).
+     */
+    program: string,
+    /**
+     * Arguments.
+     */
+    args: Array<string>,
+    /**
+     * Extra environment.
+     */
+    env: Map<string, string>,
+    /**
+     * Working directory.
+     */
+    cwd?: string,
+    /**
+     * Run as this user.
+     */
+    user?: string,
+    /**
+     * Kill after this long.
+     */
+    timeoutMs?: number,
+    /**
+     * Tag for reattaching (`attach(tag=…)`).
+     */
+    tag?: string,
+    /**
+     * Keep stdin open for `write_stdin`.
+     */
+    stdin: boolean,
+    /**
+     * Run in a PTY of this size.
+     */
+    pty?: PtySize
+}
+
+/**
+ * Generated factory for {@link SpacesdCommand} record objects.
+ */
+export const SpacesdCommand = (() => {
+    const defaults = () => ({
+        args: [],
+        env: new Map(),
+        cwd: undefined,
+        user: undefined,
+        timeoutMs: undefined,
+        tag: undefined,
+        stdin: false,
+        pty: undefined
+    });
+    const create = (() => {
+        return uniffiCreateRecord<SpacesdCommand, ReturnType<typeof defaults>>(defaults);
+    })();
+    return Object.freeze({
+        create,
+        new: create,
+        defaults: () => Object.freeze(defaults()) as Partial<SpacesdCommand>,
+    });
+})();
+
+const FfiConverterTypeSpacesdCommand = (() => {
+    type TypeName = SpacesdCommand;
+    class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+        read(from: RustBuffer): TypeName {
+            return {
+                program: FfiConverterString.read(from), 
+                args: FfiConverterSequenceString.read(from), 
+                env: FfiConverterMapStringString.read(from), 
+                cwd: FfiConverterOptionalString.read(from), 
+                user: FfiConverterOptionalString.read(from), 
+                timeoutMs: FfiConverterOptionalUInt32.read(from), 
+                tag: FfiConverterOptionalString.read(from), 
+                stdin: FfiConverterBool.read(from), 
+                pty: FfiConverterOptionalTypePtySize.read(from)
+            };
+        }
+        write(value: TypeName, into: RustBuffer): void {
+            FfiConverterString.write(value.program, into);
+            FfiConverterSequenceString.write(value.args, into);
+            FfiConverterMapStringString.write(value.env, into);
+            FfiConverterOptionalString.write(value.cwd, into);
+            FfiConverterOptionalString.write(value.user, into);
+            FfiConverterOptionalUInt32.write(value.timeoutMs, into);
+            FfiConverterOptionalString.write(value.tag, into);
+            FfiConverterBool.write(value.stdin, into);
+            FfiConverterOptionalTypePtySize.write(value.pty, into);
+        }
+        allocationSize(value: TypeName): number {
+            return FfiConverterString.allocationSize(value.program) +
+             FfiConverterSequenceString.allocationSize(value.args) +
+             FfiConverterMapStringString.allocationSize(value.env) +
+             FfiConverterOptionalString.allocationSize(value.cwd) +
+             FfiConverterOptionalString.allocationSize(value.user) +
+             FfiConverterOptionalUInt32.allocationSize(value.timeoutMs) +
+             FfiConverterOptionalString.allocationSize(value.tag) +
+             FfiConverterBool.allocationSize(value.stdin) +
+             FfiConverterOptionalTypePtySize.allocationSize(value.pty);
+            
+        }
+    };
+    return new FFIConverter();
+})();
+
+/**
+ * Result of an upload or download.
+ */
+export type TransferResult = {
+    /**
+     * Bytes transferred.
+     */
+    size: bigint,
+    /**
+     * SHA-256 (hex) of the content.
+     */
+    sha256: string,
+    /**
+     * Resumes after dropped connections.
+     */
+    resumes: number
+}
+
+/**
+ * Generated factory for {@link TransferResult} record objects.
+ */
+export const TransferResult = (() => {
+    const defaults = () => ({
+    });
+    const create = (() => {
+        return uniffiCreateRecord<TransferResult, ReturnType<typeof defaults>>(defaults);
+    })();
+    return Object.freeze({
+        create,
+        new: create,
+        defaults: () => Object.freeze(defaults()) as Partial<TransferResult>,
+    });
+})();
+
+const FfiConverterTypeTransferResult = (() => {
+    type TypeName = TransferResult;
+    class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+        read(from: RustBuffer): TypeName {
+            return {
+                size: FfiConverterUInt64.read(from), 
+                sha256: FfiConverterString.read(from), 
+                resumes: FfiConverterUInt32.read(from)
+            };
+        }
+        write(value: TypeName, into: RustBuffer): void {
+            FfiConverterUInt64.write(value.size, into);
+            FfiConverterString.write(value.sha256, into);
+            FfiConverterUInt32.write(value.resumes, into);
+        }
+        allocationSize(value: TypeName): number {
+            return FfiConverterUInt64.allocationSize(value.size) +
+             FfiConverterString.allocationSize(value.sha256) +
+             FfiConverterUInt32.allocationSize(value.resumes);
+            
+        }
+    };
+    return new FFIConverter();
+})();
+
+/**
+ * Upload options.
+ */
+export type UploadOptions = {
+    /**
+     * Fail when the file exists (instead of overwriting).
+     */
+    createNew: boolean,
+    /**
+     * Append instead of overwriting.
+     */
+    append: boolean,
+    /**
+     * Unix permissions (0 = default).
+     */
+    permissions: number,
+    /**
+     * Create missing parent directories.
+     */
+    createParents: boolean
+}
+
+/**
+ * Generated factory for {@link UploadOptions} record objects.
+ */
+export const UploadOptions = (() => {
+    const defaults = () => ({
+        createNew: false,
+        append: false,
+        permissions: 0,
+        createParents: true
+    });
+    const create = (() => {
+        return uniffiCreateRecord<UploadOptions, ReturnType<typeof defaults>>(defaults);
+    })();
+    return Object.freeze({
+        create,
+        new: create,
+        defaults: () => Object.freeze(defaults()) as Partial<UploadOptions>,
+    });
+})();
+
+const FfiConverterTypeUploadOptions = (() => {
+    type TypeName = UploadOptions;
+    class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+        read(from: RustBuffer): TypeName {
+            return {
+                createNew: FfiConverterBool.read(from), 
+                append: FfiConverterBool.read(from), 
+                permissions: FfiConverterUInt32.read(from), 
+                createParents: FfiConverterBool.read(from)
+            };
+        }
+        write(value: TypeName, into: RustBuffer): void {
+            FfiConverterBool.write(value.createNew, into);
+            FfiConverterBool.write(value.append, into);
+            FfiConverterUInt32.write(value.permissions, into);
+            FfiConverterBool.write(value.createParents, into);
+        }
+        allocationSize(value: TypeName): number {
+            return FfiConverterBool.allocationSize(value.createNew) +
+             FfiConverterBool.allocationSize(value.append) +
+             FfiConverterUInt32.allocationSize(value.permissions) +
+             FfiConverterBool.allocationSize(value.createParents);
+            
+        }
+    };
+    return new FFIConverter();
+})();
+
+
+// Flat error type: CuaError
+export enum CuaError_Tags {
+    InvalidArgument = "InvalidArgument",
+    InvalidPlacement = "InvalidPlacement",
+    NotFound = "NotFound",
+    ProviderNotConfigured = "ProviderNotConfigured",
+    Unsupported = "Unsupported",
+    SpacesdNotAvailable = "SpacesdNotAvailable",
+    Timeout = "Timeout",
+    Fleet = "Fleet",
+    FleetAdmissionDenied = "FleetAdmissionDenied",
+    CloudCreditExhausted = "CloudCreditExhausted",
+    Runtime = "Runtime",
+    Env = "Env",
+    Http = "Http",
+    Unauthenticated = "Unauthenticated",
+    PermissionDenied = "PermissionDenied",
+    Transport = "Transport",
+    DaemonNotRunning = "DaemonNotRunning",
+    Closed = "Closed",
+    CapabilityMissing = "CapabilityMissing",
+    HostCapabilityMissing = "HostCapabilityMissing",
+    TeleportRefused = "TeleportRefused",
+    PoolSpecMismatch = "PoolSpecMismatch",
+    ClaimSecretsNotDelivered = "ClaimSecretsNotDelivered",
+    Internal = "Internal",
+    AmbiguousSandbox = "AmbiguousSandbox",
+    InsufficientDisk = "InsufficientDisk",
+    ImageNotPublished = "ImageNotPublished",
+    Cancelled = "Cancelled",
+    Cloud = "Cloud"
+}
+/**
+ * Every error the SDK raises. Flat across the FFI: each language sees one
+ * exception/error type with a case per variant and the message.
+ */
+export const CuaError = (() => {
+    /**
+     * Bad input.
+     *
+     * Fix: Check the value against the reference; the message names the
+     * argument and what it accepts.
+     */
+    class InvalidArgument extends UniffiError {
+        /**
+         * @private
+         * This field is private and should not be used.
+         */
+        readonly [uniffiTypeNameSymbol]: string = "CuaError";
+        /**
+         * @private
+         * This field is private and should not be used.
+         */
+        readonly [variantOrdinalSymbol] = 1;
+
+        readonly tag = CuaError_Tags.InvalidArgument;
+
+        constructor(message: string) {
+            super("CuaError", "InvalidArgument", message);
+        }
+
+        static instanceOf(e: any): e is InvalidArgument {
+            return (
+                instanceOf(e) && (e as any)[variantOrdinalSymbol] === 1
+            );
+        }
+    }
+    /**
+     * A location, kind or runtime that does not exist, or a combination of
+     * them (or with the image) that does not. The message ends with the
+     * valid values for that context.
+     *
+     * Fix: Use one of the values the message lists, or leave `kind` and
+     * `runtime` unset (`auto`). `cua config list` shows the defaults in
+     * effect.
+     */
+    class InvalidPlacement extends UniffiError {
+        /**
+         * @private
+         * This field is private and should not be used.
+         */
+        readonly [uniffiTypeNameSymbol]: string = "CuaError";
+        /**
+         * @private
+         * This field is private and should not be used.
+         */
+        readonly [variantOrdinalSymbol] = 2;
+
+        readonly tag = CuaError_Tags.InvalidPlacement;
+
+        constructor(message: string) {
+            super("CuaError", "InvalidPlacement", message);
+        }
+
+        static instanceOf(e: any): e is InvalidPlacement {
+            return (
+                instanceOf(e) && (e as any)[variantOrdinalSymbol] === 2
+            );
+        }
+    }
+    /**
+     * No such sandbox, process, path, forward or session.
+     *
+     * Fix: Check the ref, path or id. `Sandboxes.list` (`cua sb ls`) lists the
+     * sandboxes this client can see.
+     */
+    class NotFound extends UniffiError {
+        /**
+         * @private
+         * This field is private and should not be used.
+         */
+        readonly [uniffiTypeNameSymbol]: string = "CuaError";
+        /**
+         * @private
+         * This field is private and should not be used.
+         */
+        readonly [variantOrdinalSymbol] = 3;
+
+        readonly tag = CuaError_Tags.NotFound;
+
+        constructor(message: string) {
+            super("CuaError", "NotFound", message);
+        }
+
+        static instanceOf(e: any): e is NotFound {
+            return (
+                instanceOf(e) && (e as any)[variantOrdinalSymbol] === 3
+            );
+        }
+    }
+    /**
+     * The provider is not configured (for example no Fleet credentials).
+     *
+     * Fix: Set `FLEETS_TOKEN`, or `CUA_CLIENT_ID` and `CUA_CLIENT_SECRET`, or
+     * run `cua auth login` and create the client with `fleet_from_session`.
+     */
+    class ProviderNotConfigured extends UniffiError {
+        /**
+         * @private
+         * This field is private and should not be used.
+         */
+        readonly [uniffiTypeNameSymbol]: string = "CuaError";
+        /**
+         * @private
+         * This field is private and should not be used.
+         */
+        readonly [variantOrdinalSymbol] = 4;
+
+        readonly tag = CuaError_Tags.ProviderNotConfigured;
+
+        constructor(message: string) {
+            super("CuaError", "ProviderNotConfigured", message);
+        }
+
+        static instanceOf(e: any): e is ProviderNotConfigured {
+            return (
+                instanceOf(e) && (e as any)[variantOrdinalSymbol] === 4
+            );
+        }
+    }
+    /**
+     * Not supported by this provider, guest or build.
+     *
+     * Fix: Use a provider, image or runtime that supports the call; the
+     * message names what is missing.
+     */
+    class Unsupported extends UniffiError {
+        /**
+         * @private
+         * This field is private and should not be used.
+         */
+        readonly [uniffiTypeNameSymbol]: string = "CuaError";
+        /**
+         * @private
+         * This field is private and should not be used.
+         */
+        readonly [variantOrdinalSymbol] = 5;
+
+        readonly tag = CuaError_Tags.Unsupported;
+
+        constructor(message: string) {
+            super("CuaError", "Unsupported", message);
+        }
+
+        static instanceOf(e: any): e is Unsupported {
+            return (
+                instanceOf(e) && (e as any)[variantOrdinalSymbol] === 5
+            );
+        }
+    }
+    /**
+     * No cua-spacesd answered in the sandbox or at the URL.
+     *
+     * Fix: Use an image that runs cua-spacesd (the canonical Linux image does),
+     * or reach the sandbox through the services it declares.
+     */
+    class SpacesdNotAvailable extends UniffiError {
+        /**
+         * @private
+         * This field is private and should not be used.
+         */
+        readonly [uniffiTypeNameSymbol]: string = "CuaError";
+        /**
+         * @private
+         * This field is private and should not be used.
+         */
+        readonly [variantOrdinalSymbol] = 6;
+
+        readonly tag = CuaError_Tags.SpacesdNotAvailable;
+
+        constructor(message: string) {
+            super("CuaError", "SpacesdNotAvailable", message);
+        }
+
+        static instanceOf(e: any): e is SpacesdNotAvailable {
+            return (
+                instanceOf(e) && (e as any)[variantOrdinalSymbol] === 6
+            );
+        }
+    }
+    /**
+     * A deadline elapsed.
+     *
+     * Fix: Raise the timeout (for example `ready_timeout_ms`), and check that
+     * the sandbox or service actually starts.
+     */
+    class Timeout extends UniffiError {
+        /**
+         * @private
+         * This field is private and should not be used.
+         */
+        readonly [uniffiTypeNameSymbol]: string = "CuaError";
+        /**
+         * @private
+         * This field is private and should not be used.
+         */
+        readonly [variantOrdinalSymbol] = 7;
+
+        readonly tag = CuaError_Tags.Timeout;
+
+        constructor(message: string) {
+            super("CuaError", "Timeout", message);
+        }
+
+        static instanceOf(e: any): e is Timeout {
+            return (
+                instanceOf(e) && (e as any)[variantOrdinalSymbol] === 7
+            );
+        }
+    }
+    /**
+     * Fleet API failure.
+     *
+     * Fix: Read the status in the message. Retry a transient failure; check
+     * the credentials and the account's capacity otherwise.
+     */
+    class Fleet extends UniffiError {
+        /**
+         * @private
+         * This field is private and should not be used.
+         */
+        readonly [uniffiTypeNameSymbol]: string = "CuaError";
+        /**
+         * @private
+         * This field is private and should not be used.
+         */
+        readonly [variantOrdinalSymbol] = 8;
+
+        readonly tag = CuaError_Tags.Fleet;
+
+        constructor(message: string) {
+            super("CuaError", "Fleet", message);
+        }
+
+        static instanceOf(e: any): e is Fleet {
+            return (
+                instanceOf(e) && (e as any)[variantOrdinalSymbol] === 8
+            );
+        }
+    }
+    /**
+     * Fleet's admission refused the request: a sandbox or pool size over
+     * this account's limits, or a template its policy does not admit. The
+     * message is Fleet's own and names the limit.
+     *
+     * Fix: Pick a size within the limit the message names (most accounts
+     * run 1-8 vCPUs and 1-32 GiB per sandbox), or contact Cua support to
+     * raise the account's limits.
+     */
+    class FleetAdmissionDenied extends UniffiError {
+        /**
+         * @private
+         * This field is private and should not be used.
+         */
+        readonly [uniffiTypeNameSymbol]: string = "CuaError";
+        /**
+         * @private
+         * This field is private and should not be used.
+         */
+        readonly [variantOrdinalSymbol] = 9;
+
+        readonly tag = CuaError_Tags.FleetAdmissionDenied;
+
+        constructor(message: string) {
+            super("CuaError", "FleetAdmissionDenied", message);
+        }
+
+        static instanceOf(e: any): e is FleetAdmissionDenied {
+            return (
+                instanceOf(e) && (e as any)[variantOrdinalSymbol] === 9
+            );
+        }
+    }
+    /**
+     * The account is out of Cua Cloud credit: no credit left, and no card
+     * or plan. New cloud sandboxes and Spaces are refused; running ones
+     * keep running, and local ones are never affected. The message ends
+     * with the website billing page's URL.
+     *
+     * Fix: Add credit on that page (a plan, or a card for pay as you go),
+     * or run the sandbox locally.
+     */
+    class CloudCreditExhausted extends UniffiError {
+        /**
+         * @private
+         * This field is private and should not be used.
+         */
+        readonly [uniffiTypeNameSymbol]: string = "CuaError";
+        /**
+         * @private
+         * This field is private and should not be used.
+         */
+        readonly [variantOrdinalSymbol] = 10;
+
+        readonly tag = CuaError_Tags.CloudCreditExhausted;
+
+        constructor(message: string) {
+            super("CuaError", "CloudCreditExhausted", message);
+        }
+
+        static instanceOf(e: any): e is CloudCreditExhausted {
+            return (
+                instanceOf(e) && (e as any)[variantOrdinalSymbol] === 10
+            );
+        }
+    }
+    /**
+     * Local runtime failure.
+     *
+     * Fix: Run `cua runtime doctor` (`Local.doctor`) and follow the steps it
+     * prints.
+     */
+    class Runtime extends UniffiError {
+        /**
+         * @private
+         * This field is private and should not be used.
+         */
+        readonly [uniffiTypeNameSymbol]: string = "CuaError";
+        /**
+         * @private
+         * This field is private and should not be used.
+         */
+        readonly [variantOrdinalSymbol] = 11;
+
+        readonly tag = CuaError_Tags.Runtime;
+
+        constructor(message: string) {
+            super("CuaError", "Runtime", message);
+        }
+
+        static instanceOf(e: any): e is Runtime {
+            return (
+                instanceOf(e) && (e as any)[variantOrdinalSymbol] === 11
+            );
+        }
+    }
+    /**
+     * spacesd call failure.
+     *
+     * Fix: Read the status in the message; `SpacesdClient.capabilities` tells
+     * whether this spacesd supports the call.
+     */
+    class Env extends UniffiError {
+        /**
+         * @private
+         * This field is private and should not be used.
+         */
+        readonly [uniffiTypeNameSymbol]: string = "CuaError";
+        /**
+         * @private
+         * This field is private and should not be used.
+         */
+        readonly [variantOrdinalSymbol] = 12;
+
+        readonly tag = CuaError_Tags.Env;
+
+        constructor(message: string) {
+            super("CuaError", "Env", message);
+        }
+
+        static instanceOf(e: any): e is Env {
+            return (
+                instanceOf(e) && (e as any)[variantOrdinalSymbol] === 12
+            );
+        }
+    }
+    /**
+     * HTTP failure talking to a sandbox service.
+     *
+     * Fix: Check that the service listens on its declared port and answers
+     * HTTP.
+     */
+    class Http extends UniffiError {
+        /**
+         * @private
+         * This field is private and should not be used.
+         */
+        readonly [uniffiTypeNameSymbol]: string = "CuaError";
+        /**
+         * @private
+         * This field is private and should not be used.
+         */
+        readonly [variantOrdinalSymbol] = 13;
+
+        readonly tag = CuaError_Tags.Http;
+
+        constructor(message: string) {
+            super("CuaError", "Http", message);
+        }
+
+        static instanceOf(e: any): e is Http {
+            return (
+                instanceOf(e) && (e as any)[variantOrdinalSymbol] === 13
+            );
+        }
+    }
+    /**
+     * Missing or wrong token or ticket.
+     *
+     * Fix: Pass the sandbox's env token, refresh the Fleet credentials, or run
+     * `cua auth login` again.
+     */
+    class Unauthenticated extends UniffiError {
+        /**
+         * @private
+         * This field is private and should not be used.
+         */
+        readonly [uniffiTypeNameSymbol]: string = "CuaError";
+        /**
+         * @private
+         * This field is private and should not be used.
+         */
+        readonly [variantOrdinalSymbol] = 14;
+
+        readonly tag = CuaError_Tags.Unauthenticated;
+
+        constructor(message: string) {
+            super("CuaError", "Unauthenticated", message);
+        }
+
+        static instanceOf(e: any): e is Unauthenticated {
+            return (
+                instanceOf(e) && (e as any)[variantOrdinalSymbol] === 14
+            );
+        }
+    }
+    /**
+     * The guest OS denied permission.
+     *
+     * Fix: Run the call as a guest user allowed to do it, or change the
+     * permissions of the path.
+     */
+    class PermissionDenied extends UniffiError {
+        /**
+         * @private
+         * This field is private and should not be used.
+         */
+        readonly [uniffiTypeNameSymbol]: string = "CuaError";
+        /**
+         * @private
+         * This field is private and should not be used.
+         */
+        readonly [variantOrdinalSymbol] = 15;
+
+        readonly tag = CuaError_Tags.PermissionDenied;
+
+        constructor(message: string) {
+            super("CuaError", "PermissionDenied", message);
+        }
+
+        static instanceOf(e: any): e is PermissionDenied {
+            return (
+                instanceOf(e) && (e as any)[variantOrdinalSymbol] === 15
+            );
+        }
+    }
+    /**
+     * Could not reach the daemon or the endpoint.
+     *
+     * Fix: Check the address. For a daemon client, start the daemon with `cua
+     * daemon start`.
+     */
+    class Transport extends UniffiError {
+        /**
+         * @private
+         * This field is private and should not be used.
+         */
+        readonly [uniffiTypeNameSymbol]: string = "CuaError";
+        /**
+         * @private
+         * This field is private and should not be used.
+         */
+        readonly [variantOrdinalSymbol] = 16;
+
+        readonly tag = CuaError_Tags.Transport;
+
+        constructor(message: string) {
+            super("CuaError", "Transport", message);
+        }
+
+        static instanceOf(e: any): e is Transport {
+            return (
+                instanceOf(e) && (e as any)[variantOrdinalSymbol] === 16
+            );
+        }
+    }
+    /**
+     * No `cua daemon` is running: nothing listens at its socket or
+     * port, or its discovery file (`~/.cua/daemon.json`) was left by a
+     * daemon that exited. The message says so in plain words.
+     *
+     * Fix: Start Cua (the Spaces app starts the daemon), or run `cua daemon
+     * start`. `Cua.auto` uses the runtime in this process when no daemon
+     * runs.
+     */
+    class DaemonNotRunning extends UniffiError {
+        /**
+         * @private
+         * This field is private and should not be used.
+         */
+        readonly [uniffiTypeNameSymbol]: string = "CuaError";
+        /**
+         * @private
+         * This field is private and should not be used.
+         */
+        readonly [variantOrdinalSymbol] = 17;
+
+        readonly tag = CuaError_Tags.DaemonNotRunning;
+
+        constructor(message: string) {
+            super("CuaError", "DaemonNotRunning", message);
+        }
+
+        static instanceOf(e: any): e is DaemonNotRunning {
+            return (
+                instanceOf(e) && (e as any)[variantOrdinalSymbol] === 17
+            );
+        }
+    }
+    /**
+     * The object was closed.
+     *
+     * Fix: Open a new handle or session; a closed one stays closed.
+     */
+    class Closed extends UniffiError {
+        /**
+         * @private
+         * This field is private and should not be used.
+         */
+        readonly [uniffiTypeNameSymbol]: string = "CuaError";
+        /**
+         * @private
+         * This field is private and should not be used.
+         */
+        readonly [variantOrdinalSymbol] = 18;
+
+        readonly tag = CuaError_Tags.Closed;
+
+        constructor(message: string) {
+            super("CuaError", "Closed", message);
+        }
+
+        static instanceOf(e: any): e is Closed {
+            return (
+                instanceOf(e) && (e as any)[variantOrdinalSymbol] === 18
+            );
+        }
+    }
+    /**
+     * The Space's spacesd reports a feature this call needs as
+     * unsupported (the message names it).
+     *
+     * Fix: Use a Space whose spacesd supports the feature (`Space.supports`),
+     * or update cua-spacesd on it.
+     */
+    class CapabilityMissing extends UniffiError {
+        /**
+         * @private
+         * This field is private and should not be used.
+         */
+        readonly [uniffiTypeNameSymbol]: string = "CuaError";
+        /**
+         * @private
+         * This field is private and should not be used.
+         */
+        readonly [variantOrdinalSymbol] = 19;
+
+        readonly tag = CuaError_Tags.CapabilityMissing;
+
+        constructor(message: string) {
+            super("CuaError", "CapabilityMissing", message);
+        }
+
+        static instanceOf(e: any): e is CapabilityMissing {
+            return (
+                instanceOf(e) && (e as any)[variantOrdinalSymbol] === 19
+            );
+        }
+    }
+    /**
+     * A host-side prerequisite (app-session providers, an operator
+     * display, a local runtime) is not available.
+     *
+     * Fix: Install or start the prerequisite the message names on this
+     * machine.
+     */
+    class HostCapabilityMissing extends UniffiError {
+        /**
+         * @private
+         * This field is private and should not be used.
+         */
+        readonly [uniffiTypeNameSymbol]: string = "CuaError";
+        /**
+         * @private
+         * This field is private and should not be used.
+         */
+        readonly [variantOrdinalSymbol] = 20;
+
+        readonly tag = CuaError_Tags.HostCapabilityMissing;
+
+        constructor(message: string) {
+            super("CuaError", "HostCapabilityMissing", message);
+        }
+
+        static instanceOf(e: any): e is HostCapabilityMissing {
+            return (
+                instanceOf(e) && (e as any)[variantOrdinalSymbol] === 20
+            );
+        }
+    }
+    /**
+     * The teleport consent gate refused (or the approver declined).
+     *
+     * Fix: Approve the manifest in the consent callback, or teleport a smaller
+     * scope.
+     */
+    class TeleportRefused extends UniffiError {
+        /**
+         * @private
+         * This field is private and should not be used.
+         */
+        readonly [uniffiTypeNameSymbol]: string = "CuaError";
+        /**
+         * @private
+         * This field is private and should not be used.
+         */
+        readonly [variantOrdinalSymbol] = 21;
+
+        readonly tag = CuaError_Tags.TeleportRefused;
+
+        constructor(message: string) {
+            super("CuaError", "TeleportRefused", message);
+        }
+
+        static instanceOf(e: any): e is TeleportRefused {
+            return (
+                instanceOf(e) && (e as any)[variantOrdinalSymbol] === 21
+            );
+        }
+    }
+    /**
+     * A named cloud pool's template differs from the requested sandbox
+     * fields; the message holds the diff (pass `apply` to update it).
+     *
+     * Fix: Pass the pool's own fields, or pass `apply` to update its template.
+     */
+    class PoolSpecMismatch extends UniffiError {
+        /**
+         * @private
+         * This field is private and should not be used.
+         */
+        readonly [uniffiTypeNameSymbol]: string = "CuaError";
+        /**
+         * @private
+         * This field is private and should not be used.
+         */
+        readonly [variantOrdinalSymbol] = 22;
+
+        readonly tag = CuaError_Tags.PoolSpecMismatch;
+
+        constructor(message: string) {
+            super("CuaError", "PoolSpecMismatch", message);
+        }
+
+        static instanceOf(e: any): e is PoolSpecMismatch {
+            return (
+                instanceOf(e) && (e as any)[variantOrdinalSymbol] === 22
+            );
+        }
+    }
+    /**
+     * A claim bound but its per-claim secrets (the env token) never
+     * reached the sandbox within the bounded wait; the claim was released.
+     *
+     * Fix: Retry. If it keeps failing, check the pool's claim-secrets setup
+     * and the Fleet status.
+     */
+    class ClaimSecretsNotDelivered extends UniffiError {
+        /**
+         * @private
+         * This field is private and should not be used.
+         */
+        readonly [uniffiTypeNameSymbol]: string = "CuaError";
+        /**
+         * @private
+         * This field is private and should not be used.
+         */
+        readonly [variantOrdinalSymbol] = 23;
+
+        readonly tag = CuaError_Tags.ClaimSecretsNotDelivered;
+
+        constructor(message: string) {
+            super("CuaError", "ClaimSecretsNotDelivered", message);
+        }
+
+        static instanceOf(e: any): e is ClaimSecretsNotDelivered {
+            return (
+                instanceOf(e) && (e as any)[variantOrdinalSymbol] === 23
+            );
+        }
+    }
+    /**
+     * Bug or I/O failure.
+     *
+     * Fix: Report it with the message at https://github.com/trycua/cua/issues.
+     */
+    class Internal extends UniffiError {
+        /**
+         * @private
+         * This field is private and should not be used.
+         */
+        readonly [uniffiTypeNameSymbol]: string = "CuaError";
+        /**
+         * @private
+         * This field is private and should not be used.
+         */
+        readonly [variantOrdinalSymbol] = 24;
+
+        readonly tag = CuaError_Tags.Internal;
+
+        constructor(message: string) {
+            super("CuaError", "Internal", message);
+        }
+
+        static instanceOf(e: any): e is Internal {
+            return (
+                instanceOf(e) && (e as any)[variantOrdinalSymbol] === 24
+            );
+        }
+    }
+    /**
+     * A bare sandbox name matches sandboxes in more than one location. The
+     * message ends with the qualified candidates (`use one of: local:box,
+     * cloud:box`); `ambiguous_sandbox_candidates` extracts them.
+     *
+     * Fix: Use one of the qualified refs the message lists (`local:<name>`,
+     * `cloud:<name>`).
+     */
+    class AmbiguousSandbox extends UniffiError {
+        /**
+         * @private
+         * This field is private and should not be used.
+         */
+        readonly [uniffiTypeNameSymbol]: string = "CuaError";
+        /**
+         * @private
+         * This field is private and should not be used.
+         */
+        readonly [variantOrdinalSymbol] = 25;
+
+        readonly tag = CuaError_Tags.AmbiguousSandbox;
+
+        constructor(message: string) {
+            super("CuaError", "AmbiguousSandbox", message);
+        }
+
+        static instanceOf(e: any): e is AmbiguousSandbox {
+            return (
+                instanceOf(e) && (e as any)[variantOrdinalSymbol] === 25
+            );
+        }
+    }
+    /**
+     * A pull, build or VM create would leave less than the configured
+     * minimum free disk space (`CUA_DISK_MIN_FREE`, default 5 GiB);
+     * nothing was written.
+     *
+     * Fix: Free space with `cua cache prune`, or lower `CUA_DISK_MIN_FREE`.
+     */
+    class InsufficientDisk extends UniffiError {
+        /**
+         * @private
+         * This field is private and should not be used.
+         */
+        readonly [uniffiTypeNameSymbol]: string = "CuaError";
+        /**
+         * @private
+         * This field is private and should not be used.
+         */
+        readonly [variantOrdinalSymbol] = 26;
+
+        readonly tag = CuaError_Tags.InsufficientDisk;
+
+        constructor(message: string) {
+            super("CuaError", "InsufficientDisk", message);
+        }
+
+        static instanceOf(e: any): e is InsufficientDisk {
+            return (
+                instanceOf(e) && (e as any)[variantOrdinalSymbol] === 26
+            );
+        }
+    }
+    /**
+     * A catalog image (an `Image.*` constructor, a tier or `cua sb create
+     * <word>`) that CI has not published yet. The message names the
+     * reference.
+     *
+     * Fix: Pass the reference explicitly (`Image.from_registry("<ref>")`,
+     * `cua sb create <ref>`) to use it anyway, or pick a published image
+     * (`cua images ls`).
+     */
+    class ImageNotPublished extends UniffiError {
+        /**
+         * @private
+         * This field is private and should not be used.
+         */
+        readonly [uniffiTypeNameSymbol]: string = "CuaError";
+        /**
+         * @private
+         * This field is private and should not be used.
+         */
+        readonly [variantOrdinalSymbol] = 27;
+
+        readonly tag = CuaError_Tags.ImageNotPublished;
+
+        constructor(message: string) {
+            super("CuaError", "ImageNotPublished", message);
+        }
+
+        static instanceOf(e: any): e is ImageNotPublished {
+            return (
+                instanceOf(e) && (e as any)[variantOrdinalSymbol] === 27
+            );
+        }
+    }
+    /**
+     * The create was cancelled (`Spaces.cancel_create`, Ctrl-C in `cua`,
+     * or its caller went away). What it made is gone; the message says
+     * what was removed and what stays (finished image downloads stay
+     * cached, so the next create resumes).
+     *
+     * Fix: Nothing to clean up. Create it again when you want it.
+     */
+    class Cancelled extends UniffiError {
+        /**
+         * @private
+         * This field is private and should not be used.
+         */
+        readonly [uniffiTypeNameSymbol]: string = "CuaError";
+        /**
+         * @private
+         * This field is private and should not be used.
+         */
+        readonly [variantOrdinalSymbol] = 28;
+
+        readonly tag = CuaError_Tags.Cancelled;
+
+        constructor(message: string) {
+            super("CuaError", "Cancelled", message);
+        }
+
+        static instanceOf(e: any): e is Cancelled {
+            return (
+                instanceOf(e) && (e as any)[variantOrdinalSymbol] === 28
+            );
+        }
+    }
+    /**
+     * Your own cloud account (AWS, Google Cloud, Modal) refused or failed
+     * a call Cua made for a Space there: a missing permission, a quota, a
+     * region without the machine type. The message names the cloud's own
+     * error.
+     *
+     * Fix: Fix what the message names in that account (`cua cloud test
+     * <provider>` checks it without creating anything), or connect another
+     * region or project.
+     */
+    class Cloud extends UniffiError {
+        /**
+         * @private
+         * This field is private and should not be used.
+         */
+        readonly [uniffiTypeNameSymbol]: string = "CuaError";
+        /**
+         * @private
+         * This field is private and should not be used.
+         */
+        readonly [variantOrdinalSymbol] = 29;
+
+        readonly tag = CuaError_Tags.Cloud;
+
+        constructor(message: string) {
+            super("CuaError", "Cloud", message);
+        }
+
+        static instanceOf(e: any): e is Cloud {
+            return (
+                instanceOf(e) && (e as any)[variantOrdinalSymbol] === 29
+            );
+        }
+    }
+
+    // Utility function which does not rely on instanceof.
+    function instanceOf(e: any): e is CuaError {
+        return (e as any)[uniffiTypeNameSymbol] === "CuaError";
+    }
+    return {
+        InvalidArgument,
+        InvalidPlacement,
+        NotFound,
+        ProviderNotConfigured,
+        Unsupported,
+        SpacesdNotAvailable,
+        Timeout,
+        Fleet,
+        FleetAdmissionDenied,
+        CloudCreditExhausted,
+        Runtime,
+        Env,
+        Http,
+        Unauthenticated,
+        PermissionDenied,
+        Transport,
+        DaemonNotRunning,
+        Closed,
+        CapabilityMissing,
+        HostCapabilityMissing,
+        TeleportRefused,
+        PoolSpecMismatch,
+        ClaimSecretsNotDelivered,
+        Internal,
+        AmbiguousSandbox,
+        InsufficientDisk,
+        ImageNotPublished,
+        Cancelled,
+        Cloud,
+        instanceOf,
+    };
+})();
+
+// Union type for CuaError error type.
+/**
+ * Every error the SDK raises. Flat across the FFI: each language sees one
+ * exception/error type with a case per variant and the message.
+ */
+export type CuaError = InstanceType<
+    typeof CuaError['InvalidArgument' | 'InvalidPlacement' | 'NotFound' | 'ProviderNotConfigured' | 'Unsupported' | 'SpacesdNotAvailable' | 'Timeout' | 'Fleet' | 'FleetAdmissionDenied' | 'CloudCreditExhausted' | 'Runtime' | 'Env' | 'Http' | 'Unauthenticated' | 'PermissionDenied' | 'Transport' | 'DaemonNotRunning' | 'Closed' | 'CapabilityMissing' | 'HostCapabilityMissing' | 'TeleportRefused' | 'PoolSpecMismatch' | 'ClaimSecretsNotDelivered' | 'Internal' | 'AmbiguousSandbox' | 'InsufficientDisk' | 'ImageNotPublished' | 'Cancelled' | 'Cloud']
+>;
+
+const FfiConverterTypeCuaError = (() => {
+    const intConverter = FfiConverterInt32;
+    type TypeName = CuaError;
+    class FfiConverter extends AbstractFfiConverterByteArray<TypeName> {
+        read(from: RustBuffer): TypeName {
+            switch (intConverter.read(from)) {
+                case 1: return new CuaError.InvalidArgument(
+                    FfiConverterString.read(from)
+                );
+            
+                case 2: return new CuaError.InvalidPlacement(
+                    FfiConverterString.read(from)
+                );
+            
+                case 3: return new CuaError.NotFound(
+                    FfiConverterString.read(from)
+                );
+            
+                case 4: return new CuaError.ProviderNotConfigured(
+                    FfiConverterString.read(from)
+                );
+            
+                case 5: return new CuaError.Unsupported(
+                    FfiConverterString.read(from)
+                );
+            
+                case 6: return new CuaError.SpacesdNotAvailable(
+                    FfiConverterString.read(from)
+                );
+            
+                case 7: return new CuaError.Timeout(
+                    FfiConverterString.read(from)
+                );
+            
+                case 8: return new CuaError.Fleet(
+                    FfiConverterString.read(from)
+                );
+            
+                case 9: return new CuaError.FleetAdmissionDenied(
+                    FfiConverterString.read(from)
+                );
+            
+                case 10: return new CuaError.CloudCreditExhausted(
+                    FfiConverterString.read(from)
+                );
+            
+                case 11: return new CuaError.Runtime(
+                    FfiConverterString.read(from)
+                );
+            
+                case 12: return new CuaError.Env(
+                    FfiConverterString.read(from)
+                );
+            
+                case 13: return new CuaError.Http(
+                    FfiConverterString.read(from)
+                );
+            
+                case 14: return new CuaError.Unauthenticated(
+                    FfiConverterString.read(from)
+                );
+            
+                case 15: return new CuaError.PermissionDenied(
+                    FfiConverterString.read(from)
+                );
+            
+                case 16: return new CuaError.Transport(
+                    FfiConverterString.read(from)
+                );
+            
+                case 17: return new CuaError.DaemonNotRunning(
+                    FfiConverterString.read(from)
+                );
+            
+                case 18: return new CuaError.Closed(
+                    FfiConverterString.read(from)
+                );
+            
+                case 19: return new CuaError.CapabilityMissing(
+                    FfiConverterString.read(from)
+                );
+            
+                case 20: return new CuaError.HostCapabilityMissing(
+                    FfiConverterString.read(from)
+                );
+            
+                case 21: return new CuaError.TeleportRefused(
+                    FfiConverterString.read(from)
+                );
+            
+                case 22: return new CuaError.PoolSpecMismatch(
+                    FfiConverterString.read(from)
+                );
+            
+                case 23: return new CuaError.ClaimSecretsNotDelivered(
+                    FfiConverterString.read(from)
+                );
+            
+                case 24: return new CuaError.Internal(
+                    FfiConverterString.read(from)
+                );
+            
+                case 25: return new CuaError.AmbiguousSandbox(
+                    FfiConverterString.read(from)
+                );
+            
+                case 26: return new CuaError.InsufficientDisk(
+                    FfiConverterString.read(from)
+                );
+            
+                case 27: return new CuaError.ImageNotPublished(
+                    FfiConverterString.read(from)
+                );
+            
+                case 28: return new CuaError.Cancelled(
+                    FfiConverterString.read(from)
+                );
+            
+                case 29: return new CuaError.Cloud(
+                    FfiConverterString.read(from)
+                );
+            
+                default: throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+        write(value: TypeName, into: RustBuffer): void {
+            const obj = value as any;
+            const index = obj[variantOrdinalSymbol] as number;
+            intConverter.write(index, into);
+        }
+        allocationSize(value: TypeName): number {
+            return intConverter.allocationSize(0);
+        }
+    }
+    return new FfiConverter();
+})();
+
+/**
+ * Fleet control plane (browser transport).
+ */
+export interface FleetLike {
+    
+/**
+ * Claims a sandbox from `pool` and waits for it to bind.
+ */
+    acquire(pool: string, name: string | undefined, asyncOpts_?: { signal: AbortSignal }) /*throws*/: Promise<FleetSandbox>;
+/**
+ * Claims in a namespace (JSON resources).
+ */
+    listClaims(namespace: string, asyncOpts_?: { signal: AbortSignal }) /*throws*/: Promise<Array<string>>;
+/**
+ * Pools in a namespace (JSON resources).
+ */
+    listPools(namespace: string, asyncOpts_?: { signal: AbortSignal }) /*throws*/: Promise<Array<string>>;
+/**
+ * Releases a claim.
+ */
+    release(sandbox: FleetSandbox, asyncOpts_?: { signal: AbortSignal }) /*throws*/: Promise<void>;
+}
+/**
+ * @deprecated Use `FleetLike` instead.
+ */
+export type FleetInterface = FleetLike;
+
+
+/**
+ * Fleet control plane (browser transport).
+ */
+export class Fleet extends UniffiAbstractObject implements FleetLike {
+
+    readonly [uniffiTypeNameSymbol] = "Fleet";
+    readonly [destructorGuardSymbol]: UniffiGcObject;
+    readonly [pointerLiteralSymbol]: UniffiHandle;
+    // No primary constructor declared for this class.
+private constructor(pointer: UniffiHandle) {
+    super();
+    this[pointerLiteralSymbol] = pointer;
+    this[destructorGuardSymbol] = uniffiTypeFleetObjectFactory.bless(pointer);
+}
+
+    
+
+    
+/**
+ * Claims a sandbox from `pool` and waits for it to bind.
+ */
+    async acquire(pool: string, name: string | undefined, asyncOpts_?: { signal: AbortSignal }): Promise<FleetSandbox> /*throws*/ {
+    return await uniffiRustCallAsync(
+            /*rustCaller:*/ uniffiCaller,
+            /*rustFutureFunc:*/ () => {
+                return nativeModule().ubrn_uniffi_cua_sdk_fn_method_fleet_acquire(
+                    uniffiTypeFleetObjectFactory.clonePointer(this),FfiConverterString.lower(pool, nativeModule().rustbuffer_alloc),FfiConverterOptionalString.lower(name, nativeModule().rustbuffer_alloc)
+                );
+            },
+            /*pollFunc:*/ nativeModule().ubrn_ffi_cua_sdk_rust_future_poll_rust_buffer,
+            /*cancelFunc:*/ nativeModule().ubrn_ffi_cua_sdk_rust_future_cancel_rust_buffer,
+            /*completeFunc:*/ nativeModule().ubrn_ffi_cua_sdk_rust_future_complete_rust_buffer,
+            /*freeFunc:*/ nativeModule().ubrn_ffi_cua_sdk_rust_future_free_rust_buffer,
+            // Async returns always go through the JS-side converter: the
+            // FFI symbol returns the future handle (u64), and the user-level
+            // RustBuffer comes back via the shared `rust_future_complete_*`
+            // export. The bytes the runtime hands back must be deserialized
+            // here using the per-callable return-type converter.
+            /*liftFunc:*/ FfiConverterTypeFleetSandbox.lift.bind(FfiConverterTypeFleetSandbox),
+            /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString),
+            /*asyncOpts:*/ asyncOpts_,
+            /*errorHandler:*/ FfiConverterTypeCuaError.lift.bind(FfiConverterTypeCuaError)
+        );
+    }
+    
+/**
+ * Claims in a namespace (JSON resources).
+ */
+    async listClaims(namespace: string, asyncOpts_?: { signal: AbortSignal }): Promise<Array<string>> /*throws*/ {
+    return await uniffiRustCallAsync(
+            /*rustCaller:*/ uniffiCaller,
+            /*rustFutureFunc:*/ () => {
+                return nativeModule().ubrn_uniffi_cua_sdk_fn_method_fleet_list_claims(
+                    uniffiTypeFleetObjectFactory.clonePointer(this),FfiConverterString.lower(namespace, nativeModule().rustbuffer_alloc)
+                );
+            },
+            /*pollFunc:*/ nativeModule().ubrn_ffi_cua_sdk_rust_future_poll_rust_buffer,
+            /*cancelFunc:*/ nativeModule().ubrn_ffi_cua_sdk_rust_future_cancel_rust_buffer,
+            /*completeFunc:*/ nativeModule().ubrn_ffi_cua_sdk_rust_future_complete_rust_buffer,
+            /*freeFunc:*/ nativeModule().ubrn_ffi_cua_sdk_rust_future_free_rust_buffer,
+            // Async returns always go through the JS-side converter: the
+            // FFI symbol returns the future handle (u64), and the user-level
+            // RustBuffer comes back via the shared `rust_future_complete_*`
+            // export. The bytes the runtime hands back must be deserialized
+            // here using the per-callable return-type converter.
+            /*liftFunc:*/ FfiConverterSequenceString.lift.bind(FfiConverterSequenceString),
+            /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString),
+            /*asyncOpts:*/ asyncOpts_,
+            /*errorHandler:*/ FfiConverterTypeCuaError.lift.bind(FfiConverterTypeCuaError)
+        );
+    }
+    
+/**
+ * Pools in a namespace (JSON resources).
+ */
+    async listPools(namespace: string, asyncOpts_?: { signal: AbortSignal }): Promise<Array<string>> /*throws*/ {
+    return await uniffiRustCallAsync(
+            /*rustCaller:*/ uniffiCaller,
+            /*rustFutureFunc:*/ () => {
+                return nativeModule().ubrn_uniffi_cua_sdk_fn_method_fleet_list_pools(
+                    uniffiTypeFleetObjectFactory.clonePointer(this),FfiConverterString.lower(namespace, nativeModule().rustbuffer_alloc)
+                );
+            },
+            /*pollFunc:*/ nativeModule().ubrn_ffi_cua_sdk_rust_future_poll_rust_buffer,
+            /*cancelFunc:*/ nativeModule().ubrn_ffi_cua_sdk_rust_future_cancel_rust_buffer,
+            /*completeFunc:*/ nativeModule().ubrn_ffi_cua_sdk_rust_future_complete_rust_buffer,
+            /*freeFunc:*/ nativeModule().ubrn_ffi_cua_sdk_rust_future_free_rust_buffer,
+            // Async returns always go through the JS-side converter: the
+            // FFI symbol returns the future handle (u64), and the user-level
+            // RustBuffer comes back via the shared `rust_future_complete_*`
+            // export. The bytes the runtime hands back must be deserialized
+            // here using the per-callable return-type converter.
+            /*liftFunc:*/ FfiConverterSequenceString.lift.bind(FfiConverterSequenceString),
+            /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString),
+            /*asyncOpts:*/ asyncOpts_,
+            /*errorHandler:*/ FfiConverterTypeCuaError.lift.bind(FfiConverterTypeCuaError)
+        );
+    }
+    
+/**
+ * Releases a claim.
+ */
+    async release(sandbox: FleetSandbox, asyncOpts_?: { signal: AbortSignal }): Promise<void> /*throws*/ {
+    return await uniffiRustCallAsync(
+            /*rustCaller:*/ uniffiCaller,
+            /*rustFutureFunc:*/ () => {
+                return nativeModule().ubrn_uniffi_cua_sdk_fn_method_fleet_release(
+                    uniffiTypeFleetObjectFactory.clonePointer(this),FfiConverterTypeFleetSandbox.lower(sandbox, nativeModule().rustbuffer_alloc)
+                );
+            },
+            /*pollFunc:*/ nativeModule().ubrn_ffi_cua_sdk_rust_future_poll_void,
+            /*cancelFunc:*/ nativeModule().ubrn_ffi_cua_sdk_rust_future_cancel_void,
+            /*completeFunc:*/ nativeModule().ubrn_ffi_cua_sdk_rust_future_complete_void,
+            /*freeFunc:*/ nativeModule().ubrn_ffi_cua_sdk_rust_future_free_void,
+            /*liftFunc:*/ (_v) => {},
+            /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString),
+            /*asyncOpts:*/ asyncOpts_,
+            /*errorHandler:*/ FfiConverterTypeCuaError.lift.bind(FfiConverterTypeCuaError)
+        );
+    }
+    
+
+    uniffiDestroy(): void {
+        const ptr = (this as any)[destructorGuardSymbol];
+        if (ptr !== undefined) {
+            const pointer = uniffiTypeFleetObjectFactory.pointer(this);
+            uniffiTypeFleetObjectFactory.freePointer(pointer);
+            uniffiTypeFleetObjectFactory.unbless(ptr);
+            delete (this as any)[destructorGuardSymbol];
+        }
+    }
+
+    static instanceOf(obj_: any): obj_ is Fleet {
+        return uniffiTypeFleetObjectFactory.isConcreteType(obj_);
+    }
+
+    
+}
+
+const uniffiTypeFleetObjectFactory: UniffiObjectFactory<FleetLike> = (() => {
+    
+    /// <reference lib="es2021" />
+    const registry = typeof FinalizationRegistry !== 'undefined' ? new FinalizationRegistry<UniffiHandle>((heldValue: UniffiHandle) => {
+        uniffiTypeFleetObjectFactory.freePointer(heldValue);
+    }) : null;
+    
+    return {
+    create(pointer: UniffiHandle): FleetLike {
+        const instance = Object.create(Fleet.prototype);
+        instance[pointerLiteralSymbol] = pointer;
+        instance[destructorGuardSymbol] = this.bless(pointer);
+        instance[uniffiTypeNameSymbol] = "Fleet";
+        return instance;
+    },
+
+    
+    bless(p: UniffiHandle): UniffiGcObject {
+        const ptr = {
+            p, // make sure this object doesn't get optimized away.
+            markDestroyed: () => undefined,
+        };
+        if (registry) {
+            registry.register(ptr, p, ptr);
+        }
+        return ptr;
+    },
+
+    unbless(ptr_: UniffiGcObject) {
+        if (registry) {
+            registry.unregister(ptr_);
+        }
+    },
+
+    pointer(obj_: FleetLike): UniffiHandle {
+        if ((obj_ as any)[destructorGuardSymbol] === undefined) {
+            throw new UniffiInternalError.UnexpectedNullPointer();
+        }
+        return (obj_ as any)[pointerLiteralSymbol];
+    },
+
+    clonePointer(obj_: FleetLike): UniffiHandle {
+        const pointer = this.pointer(obj_);
+        return uniffiCaller.rustCall(
+            /*caller:*/ (callStatus) => nativeModule().ubrn_uniffi_cua_sdk_fn_clone_fleet(pointer, callStatus),
+            /*liftString:*/ FfiConverterString.lift
+        );
+    },
+
+    freePointer(pointer: UniffiHandle): void {
+        uniffiCaller.rustCall(
+            /*caller:*/ (callStatus) => nativeModule().ubrn_uniffi_cua_sdk_fn_free_fleet(pointer, callStatus),
+            /*liftString:*/ FfiConverterString.lift
+        );
+    },
+
+    isConcreteType(obj_: any): obj_ is FleetLike {
+        return obj_[destructorGuardSymbol] && obj_[uniffiTypeNameSymbol] === "Fleet";
+    },
+}})();
+const FfiConverterTypeFleet = new FfiConverterObject(uniffiTypeFleetObjectFactory);
+
+/**
+ * cua-spacesd over gRPC-Web.
+ */
+export interface SpacesdClientLike {
+    
+/**
+ * Any unary `cua.env.v1` RPC with proto3-JSON bodies.
+ */
+    callJson(method: string, requestJson: string, asyncOpts_?: { signal: AbortSignal }) /*throws*/: Promise<string>;
+/**
+ * `GetCapabilities`.
+ */
+    capabilities(asyncOpts_?: { signal: AbortSignal }) /*throws*/: Promise<SpacesdCapabilities>;
+/**
+ * Left click.
+ */
+    click(x: number, y: number, asyncOpts_?: { signal: AbortSignal }) /*throws*/: Promise<void>;
+/**
+ * Pointer position.
+ */
+    cursorPosition(asyncOpts_?: { signal: AbortSignal }) /*throws*/: Promise<Point>;
+/**
+ * Clipboard text.
+ */
+    getClipboard(asyncOpts_?: { signal: AbortSignal }) /*throws*/: Promise<string | undefined>;
+/**
+ * `Health` as proto3 JSON.
+ */
+    health(asyncOpts_?: { signal: AbortSignal }) /*throws*/: Promise<string>;
+/**
+ * Presses a chord.
+ */
+    hotkey(keys: Array<string>, asyncOpts_?: { signal: AbortSignal }) /*throws*/: Promise<void>;
+/**
+ * Moves the pointer.
+ */
+    moveTo(x: number, y: number, asyncOpts_?: { signal: AbortSignal }) /*throws*/: Promise<void>;
+/**
+ * Presses one key.
+ */
+    press(keyName: string, asyncOpts_?: { signal: AbortSignal }) /*throws*/: Promise<void>;
+/**
+ * Runs a command to completion (at most 64 MiB of output).
+ */
+    run(command: SpacesdCommand, asyncOpts_?: { signal: AbortSignal }) /*throws*/: Promise<ProcessOutput>;
+/**
+ * Captures a display.
+ */
+    screenshot(options: ScreenshotOptions | undefined, asyncOpts_?: { signal: AbortSignal }) /*throws*/: Promise<Screenshot>;
+/**
+ * Scrolls by line deltas.
+ */
+    scroll(dx: number, dy: number, asyncOpts_?: { signal: AbortSignal }) /*throws*/: Promise<void>;
+/**
+ * Sets clipboard text.
+ */
+    setClipboard(text: string, asyncOpts_?: { signal: AbortSignal }) /*throws*/: Promise<bigint>;
+/**
+ * Runs `line` with `/bin/sh -c`.
+ */
+    sh(line: string, timeoutMs: number | undefined, asyncOpts_?: { signal: AbortSignal }) /*throws*/: Promise<ProcessOutput>;
+/**
+ * Types text.
+ */
+    typeText(text: string, asyncOpts_?: { signal: AbortSignal }) /*throws*/: Promise<void>;
+}
+/**
+ * @deprecated Use `SpacesdClientLike` instead.
+ */
+export type SpacesdClientInterface = SpacesdClientLike;
+
+
+/**
+ * cua-spacesd over gRPC-Web.
+ */
+export class SpacesdClient extends UniffiAbstractObject implements SpacesdClientLike {
+
+    readonly [uniffiTypeNameSymbol] = "SpacesdClient";
+    readonly [destructorGuardSymbol]: UniffiGcObject;
+    readonly [pointerLiteralSymbol]: UniffiHandle;
+    // No primary constructor declared for this class.
+private constructor(pointer: UniffiHandle) {
+    super();
+    this[pointerLiteralSymbol] = pointer;
+    this[destructorGuardSymbol] = uniffiTypeSpacesdClientObjectFactory.bless(pointer);
+}
+
+    
+
+    
+/**
+ * Any unary `cua.env.v1` RPC with proto3-JSON bodies.
+ */
+    async callJson(method: string, requestJson: string, asyncOpts_?: { signal: AbortSignal }): Promise<string> /*throws*/ {
+    return await uniffiRustCallAsync(
+            /*rustCaller:*/ uniffiCaller,
+            /*rustFutureFunc:*/ () => {
+                return nativeModule().ubrn_uniffi_cua_sdk_fn_method_spacesdclient_call_json(
+                    uniffiTypeSpacesdClientObjectFactory.clonePointer(this),FfiConverterString.lower(method, nativeModule().rustbuffer_alloc),FfiConverterString.lower(requestJson, nativeModule().rustbuffer_alloc)
+                );
+            },
+            /*pollFunc:*/ nativeModule().ubrn_ffi_cua_sdk_rust_future_poll_rust_buffer,
+            /*cancelFunc:*/ nativeModule().ubrn_ffi_cua_sdk_rust_future_cancel_rust_buffer,
+            /*completeFunc:*/ nativeModule().ubrn_ffi_cua_sdk_rust_future_complete_rust_buffer,
+            /*freeFunc:*/ nativeModule().ubrn_ffi_cua_sdk_rust_future_free_rust_buffer,
+            // Async returns always go through the JS-side converter: the
+            // FFI symbol returns the future handle (u64), and the user-level
+            // RustBuffer comes back via the shared `rust_future_complete_*`
+            // export. The bytes the runtime hands back must be deserialized
+            // here using the per-callable return-type converter.
+            /*liftFunc:*/ FfiConverterString.lift.bind(FfiConverterString),
+            /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString),
+            /*asyncOpts:*/ asyncOpts_,
+            /*errorHandler:*/ FfiConverterTypeCuaError.lift.bind(FfiConverterTypeCuaError)
+        );
+    }
+    
+/**
+ * `GetCapabilities`.
+ */
+    async capabilities(asyncOpts_?: { signal: AbortSignal }): Promise<SpacesdCapabilities> /*throws*/ {
+    return await uniffiRustCallAsync(
+            /*rustCaller:*/ uniffiCaller,
+            /*rustFutureFunc:*/ () => {
+                return nativeModule().ubrn_uniffi_cua_sdk_fn_method_spacesdclient_capabilities(
+                    uniffiTypeSpacesdClientObjectFactory.clonePointer(this)
+                );
+            },
+            /*pollFunc:*/ nativeModule().ubrn_ffi_cua_sdk_rust_future_poll_rust_buffer,
+            /*cancelFunc:*/ nativeModule().ubrn_ffi_cua_sdk_rust_future_cancel_rust_buffer,
+            /*completeFunc:*/ nativeModule().ubrn_ffi_cua_sdk_rust_future_complete_rust_buffer,
+            /*freeFunc:*/ nativeModule().ubrn_ffi_cua_sdk_rust_future_free_rust_buffer,
+            // Async returns always go through the JS-side converter: the
+            // FFI symbol returns the future handle (u64), and the user-level
+            // RustBuffer comes back via the shared `rust_future_complete_*`
+            // export. The bytes the runtime hands back must be deserialized
+            // here using the per-callable return-type converter.
+            /*liftFunc:*/ FfiConverterTypeSpacesdCapabilities.lift.bind(FfiConverterTypeSpacesdCapabilities),
+            /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString),
+            /*asyncOpts:*/ asyncOpts_,
+            /*errorHandler:*/ FfiConverterTypeCuaError.lift.bind(FfiConverterTypeCuaError)
+        );
+    }
+    
+/**
+ * Left click.
+ */
+    async click(x: number, y: number, asyncOpts_?: { signal: AbortSignal }): Promise<void> /*throws*/ {
+    return await uniffiRustCallAsync(
+            /*rustCaller:*/ uniffiCaller,
+            /*rustFutureFunc:*/ () => {
+                return nativeModule().ubrn_uniffi_cua_sdk_fn_method_spacesdclient_click(
+                    uniffiTypeSpacesdClientObjectFactory.clonePointer(this),FfiConverterFloat64.lower(x, nativeModule().rustbuffer_alloc),FfiConverterFloat64.lower(y, nativeModule().rustbuffer_alloc)
+                );
+            },
+            /*pollFunc:*/ nativeModule().ubrn_ffi_cua_sdk_rust_future_poll_void,
+            /*cancelFunc:*/ nativeModule().ubrn_ffi_cua_sdk_rust_future_cancel_void,
+            /*completeFunc:*/ nativeModule().ubrn_ffi_cua_sdk_rust_future_complete_void,
+            /*freeFunc:*/ nativeModule().ubrn_ffi_cua_sdk_rust_future_free_void,
+            /*liftFunc:*/ (_v) => {},
+            /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString),
+            /*asyncOpts:*/ asyncOpts_,
+            /*errorHandler:*/ FfiConverterTypeCuaError.lift.bind(FfiConverterTypeCuaError)
+        );
+    }
+    
+/**
+ * Pointer position.
+ */
+    async cursorPosition(asyncOpts_?: { signal: AbortSignal }): Promise<Point> /*throws*/ {
+    return await uniffiRustCallAsync(
+            /*rustCaller:*/ uniffiCaller,
+            /*rustFutureFunc:*/ () => {
+                return nativeModule().ubrn_uniffi_cua_sdk_fn_method_spacesdclient_cursor_position(
+                    uniffiTypeSpacesdClientObjectFactory.clonePointer(this)
+                );
+            },
+            /*pollFunc:*/ nativeModule().ubrn_ffi_cua_sdk_rust_future_poll_rust_buffer,
+            /*cancelFunc:*/ nativeModule().ubrn_ffi_cua_sdk_rust_future_cancel_rust_buffer,
+            /*completeFunc:*/ nativeModule().ubrn_ffi_cua_sdk_rust_future_complete_rust_buffer,
+            /*freeFunc:*/ nativeModule().ubrn_ffi_cua_sdk_rust_future_free_rust_buffer,
+            // Async returns always go through the JS-side converter: the
+            // FFI symbol returns the future handle (u64), and the user-level
+            // RustBuffer comes back via the shared `rust_future_complete_*`
+            // export. The bytes the runtime hands back must be deserialized
+            // here using the per-callable return-type converter.
+            /*liftFunc:*/ FfiConverterTypePoint.lift.bind(FfiConverterTypePoint),
+            /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString),
+            /*asyncOpts:*/ asyncOpts_,
+            /*errorHandler:*/ FfiConverterTypeCuaError.lift.bind(FfiConverterTypeCuaError)
+        );
+    }
+    
+/**
+ * Clipboard text.
+ */
+    async getClipboard(asyncOpts_?: { signal: AbortSignal }): Promise<string | undefined> /*throws*/ {
+    return await uniffiRustCallAsync(
+            /*rustCaller:*/ uniffiCaller,
+            /*rustFutureFunc:*/ () => {
+                return nativeModule().ubrn_uniffi_cua_sdk_fn_method_spacesdclient_get_clipboard(
+                    uniffiTypeSpacesdClientObjectFactory.clonePointer(this)
+                );
+            },
+            /*pollFunc:*/ nativeModule().ubrn_ffi_cua_sdk_rust_future_poll_rust_buffer,
+            /*cancelFunc:*/ nativeModule().ubrn_ffi_cua_sdk_rust_future_cancel_rust_buffer,
+            /*completeFunc:*/ nativeModule().ubrn_ffi_cua_sdk_rust_future_complete_rust_buffer,
+            /*freeFunc:*/ nativeModule().ubrn_ffi_cua_sdk_rust_future_free_rust_buffer,
+            // Async returns always go through the JS-side converter: the
+            // FFI symbol returns the future handle (u64), and the user-level
+            // RustBuffer comes back via the shared `rust_future_complete_*`
+            // export. The bytes the runtime hands back must be deserialized
+            // here using the per-callable return-type converter.
+            /*liftFunc:*/ FfiConverterOptionalString.lift.bind(FfiConverterOptionalString),
+            /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString),
+            /*asyncOpts:*/ asyncOpts_,
+            /*errorHandler:*/ FfiConverterTypeCuaError.lift.bind(FfiConverterTypeCuaError)
+        );
+    }
+    
+/**
+ * `Health` as proto3 JSON.
+ */
+    async health(asyncOpts_?: { signal: AbortSignal }): Promise<string> /*throws*/ {
+    return await uniffiRustCallAsync(
+            /*rustCaller:*/ uniffiCaller,
+            /*rustFutureFunc:*/ () => {
+                return nativeModule().ubrn_uniffi_cua_sdk_fn_method_spacesdclient_health(
+                    uniffiTypeSpacesdClientObjectFactory.clonePointer(this)
+                );
+            },
+            /*pollFunc:*/ nativeModule().ubrn_ffi_cua_sdk_rust_future_poll_rust_buffer,
+            /*cancelFunc:*/ nativeModule().ubrn_ffi_cua_sdk_rust_future_cancel_rust_buffer,
+            /*completeFunc:*/ nativeModule().ubrn_ffi_cua_sdk_rust_future_complete_rust_buffer,
+            /*freeFunc:*/ nativeModule().ubrn_ffi_cua_sdk_rust_future_free_rust_buffer,
+            // Async returns always go through the JS-side converter: the
+            // FFI symbol returns the future handle (u64), and the user-level
+            // RustBuffer comes back via the shared `rust_future_complete_*`
+            // export. The bytes the runtime hands back must be deserialized
+            // here using the per-callable return-type converter.
+            /*liftFunc:*/ FfiConverterString.lift.bind(FfiConverterString),
+            /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString),
+            /*asyncOpts:*/ asyncOpts_,
+            /*errorHandler:*/ FfiConverterTypeCuaError.lift.bind(FfiConverterTypeCuaError)
+        );
+    }
+    
+/**
+ * Presses a chord.
+ */
+    async hotkey(keys: Array<string>, asyncOpts_?: { signal: AbortSignal }): Promise<void> /*throws*/ {
+    return await uniffiRustCallAsync(
+            /*rustCaller:*/ uniffiCaller,
+            /*rustFutureFunc:*/ () => {
+                return nativeModule().ubrn_uniffi_cua_sdk_fn_method_spacesdclient_hotkey(
+                    uniffiTypeSpacesdClientObjectFactory.clonePointer(this),FfiConverterSequenceString.lower(keys, nativeModule().rustbuffer_alloc)
+                );
+            },
+            /*pollFunc:*/ nativeModule().ubrn_ffi_cua_sdk_rust_future_poll_void,
+            /*cancelFunc:*/ nativeModule().ubrn_ffi_cua_sdk_rust_future_cancel_void,
+            /*completeFunc:*/ nativeModule().ubrn_ffi_cua_sdk_rust_future_complete_void,
+            /*freeFunc:*/ nativeModule().ubrn_ffi_cua_sdk_rust_future_free_void,
+            /*liftFunc:*/ (_v) => {},
+            /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString),
+            /*asyncOpts:*/ asyncOpts_,
+            /*errorHandler:*/ FfiConverterTypeCuaError.lift.bind(FfiConverterTypeCuaError)
+        );
+    }
+    
+/**
+ * Moves the pointer.
+ */
+    async moveTo(x: number, y: number, asyncOpts_?: { signal: AbortSignal }): Promise<void> /*throws*/ {
+    return await uniffiRustCallAsync(
+            /*rustCaller:*/ uniffiCaller,
+            /*rustFutureFunc:*/ () => {
+                return nativeModule().ubrn_uniffi_cua_sdk_fn_method_spacesdclient_move_to(
+                    uniffiTypeSpacesdClientObjectFactory.clonePointer(this),FfiConverterFloat64.lower(x, nativeModule().rustbuffer_alloc),FfiConverterFloat64.lower(y, nativeModule().rustbuffer_alloc)
+                );
+            },
+            /*pollFunc:*/ nativeModule().ubrn_ffi_cua_sdk_rust_future_poll_void,
+            /*cancelFunc:*/ nativeModule().ubrn_ffi_cua_sdk_rust_future_cancel_void,
+            /*completeFunc:*/ nativeModule().ubrn_ffi_cua_sdk_rust_future_complete_void,
+            /*freeFunc:*/ nativeModule().ubrn_ffi_cua_sdk_rust_future_free_void,
+            /*liftFunc:*/ (_v) => {},
+            /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString),
+            /*asyncOpts:*/ asyncOpts_,
+            /*errorHandler:*/ FfiConverterTypeCuaError.lift.bind(FfiConverterTypeCuaError)
+        );
+    }
+    
+/**
+ * Presses one key.
+ */
+    async press(keyName: string, asyncOpts_?: { signal: AbortSignal }): Promise<void> /*throws*/ {
+    return await uniffiRustCallAsync(
+            /*rustCaller:*/ uniffiCaller,
+            /*rustFutureFunc:*/ () => {
+                return nativeModule().ubrn_uniffi_cua_sdk_fn_method_spacesdclient_press(
+                    uniffiTypeSpacesdClientObjectFactory.clonePointer(this),FfiConverterString.lower(keyName, nativeModule().rustbuffer_alloc)
+                );
+            },
+            /*pollFunc:*/ nativeModule().ubrn_ffi_cua_sdk_rust_future_poll_void,
+            /*cancelFunc:*/ nativeModule().ubrn_ffi_cua_sdk_rust_future_cancel_void,
+            /*completeFunc:*/ nativeModule().ubrn_ffi_cua_sdk_rust_future_complete_void,
+            /*freeFunc:*/ nativeModule().ubrn_ffi_cua_sdk_rust_future_free_void,
+            /*liftFunc:*/ (_v) => {},
+            /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString),
+            /*asyncOpts:*/ asyncOpts_,
+            /*errorHandler:*/ FfiConverterTypeCuaError.lift.bind(FfiConverterTypeCuaError)
+        );
+    }
+    
+/**
+ * Runs a command to completion (at most 64 MiB of output).
+ */
+    async run(command: SpacesdCommand, asyncOpts_?: { signal: AbortSignal }): Promise<ProcessOutput> /*throws*/ {
+    return await uniffiRustCallAsync(
+            /*rustCaller:*/ uniffiCaller,
+            /*rustFutureFunc:*/ () => {
+                return nativeModule().ubrn_uniffi_cua_sdk_fn_method_spacesdclient_run(
+                    uniffiTypeSpacesdClientObjectFactory.clonePointer(this),FfiConverterTypeSpacesdCommand.lower(command, nativeModule().rustbuffer_alloc)
+                );
+            },
+            /*pollFunc:*/ nativeModule().ubrn_ffi_cua_sdk_rust_future_poll_rust_buffer,
+            /*cancelFunc:*/ nativeModule().ubrn_ffi_cua_sdk_rust_future_cancel_rust_buffer,
+            /*completeFunc:*/ nativeModule().ubrn_ffi_cua_sdk_rust_future_complete_rust_buffer,
+            /*freeFunc:*/ nativeModule().ubrn_ffi_cua_sdk_rust_future_free_rust_buffer,
+            // Async returns always go through the JS-side converter: the
+            // FFI symbol returns the future handle (u64), and the user-level
+            // RustBuffer comes back via the shared `rust_future_complete_*`
+            // export. The bytes the runtime hands back must be deserialized
+            // here using the per-callable return-type converter.
+            /*liftFunc:*/ FfiConverterTypeProcessOutput.lift.bind(FfiConverterTypeProcessOutput),
+            /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString),
+            /*asyncOpts:*/ asyncOpts_,
+            /*errorHandler:*/ FfiConverterTypeCuaError.lift.bind(FfiConverterTypeCuaError)
+        );
+    }
+    
+/**
+ * Captures a display.
+ */
+    async screenshot(options: ScreenshotOptions | undefined, asyncOpts_?: { signal: AbortSignal }): Promise<Screenshot> /*throws*/ {
+    return await uniffiRustCallAsync(
+            /*rustCaller:*/ uniffiCaller,
+            /*rustFutureFunc:*/ () => {
+                return nativeModule().ubrn_uniffi_cua_sdk_fn_method_spacesdclient_screenshot(
+                    uniffiTypeSpacesdClientObjectFactory.clonePointer(this),FfiConverterOptionalTypeScreenshotOptions.lower(options, nativeModule().rustbuffer_alloc)
+                );
+            },
+            /*pollFunc:*/ nativeModule().ubrn_ffi_cua_sdk_rust_future_poll_rust_buffer,
+            /*cancelFunc:*/ nativeModule().ubrn_ffi_cua_sdk_rust_future_cancel_rust_buffer,
+            /*completeFunc:*/ nativeModule().ubrn_ffi_cua_sdk_rust_future_complete_rust_buffer,
+            /*freeFunc:*/ nativeModule().ubrn_ffi_cua_sdk_rust_future_free_rust_buffer,
+            // Async returns always go through the JS-side converter: the
+            // FFI symbol returns the future handle (u64), and the user-level
+            // RustBuffer comes back via the shared `rust_future_complete_*`
+            // export. The bytes the runtime hands back must be deserialized
+            // here using the per-callable return-type converter.
+            /*liftFunc:*/ FfiConverterTypeScreenshot.lift.bind(FfiConverterTypeScreenshot),
+            /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString),
+            /*asyncOpts:*/ asyncOpts_,
+            /*errorHandler:*/ FfiConverterTypeCuaError.lift.bind(FfiConverterTypeCuaError)
+        );
+    }
+    
+/**
+ * Scrolls by line deltas.
+ */
+    async scroll(dx: number, dy: number, asyncOpts_?: { signal: AbortSignal }): Promise<void> /*throws*/ {
+    return await uniffiRustCallAsync(
+            /*rustCaller:*/ uniffiCaller,
+            /*rustFutureFunc:*/ () => {
+                return nativeModule().ubrn_uniffi_cua_sdk_fn_method_spacesdclient_scroll(
+                    uniffiTypeSpacesdClientObjectFactory.clonePointer(this),FfiConverterFloat64.lower(dx, nativeModule().rustbuffer_alloc),FfiConverterFloat64.lower(dy, nativeModule().rustbuffer_alloc)
+                );
+            },
+            /*pollFunc:*/ nativeModule().ubrn_ffi_cua_sdk_rust_future_poll_void,
+            /*cancelFunc:*/ nativeModule().ubrn_ffi_cua_sdk_rust_future_cancel_void,
+            /*completeFunc:*/ nativeModule().ubrn_ffi_cua_sdk_rust_future_complete_void,
+            /*freeFunc:*/ nativeModule().ubrn_ffi_cua_sdk_rust_future_free_void,
+            /*liftFunc:*/ (_v) => {},
+            /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString),
+            /*asyncOpts:*/ asyncOpts_,
+            /*errorHandler:*/ FfiConverterTypeCuaError.lift.bind(FfiConverterTypeCuaError)
+        );
+    }
+    
+/**
+ * Sets clipboard text.
+ */
+    async setClipboard(text: string, asyncOpts_?: { signal: AbortSignal }): Promise<bigint> /*throws*/ {
+    return await uniffiRustCallAsync(
+            /*rustCaller:*/ uniffiCaller,
+            /*rustFutureFunc:*/ () => {
+                return nativeModule().ubrn_uniffi_cua_sdk_fn_method_spacesdclient_set_clipboard(
+                    uniffiTypeSpacesdClientObjectFactory.clonePointer(this),FfiConverterString.lower(text, nativeModule().rustbuffer_alloc)
+                );
+            },
+            /*pollFunc:*/ nativeModule().ubrn_ffi_cua_sdk_rust_future_poll_u64,
+            /*cancelFunc:*/ nativeModule().ubrn_ffi_cua_sdk_rust_future_cancel_u64,
+            /*completeFunc:*/ nativeModule().ubrn_ffi_cua_sdk_rust_future_complete_u64,
+            /*freeFunc:*/ nativeModule().ubrn_ffi_cua_sdk_rust_future_free_u64,
+            // Async returns always go through the JS-side converter: the
+            // FFI symbol returns the future handle (u64), and the user-level
+            // RustBuffer comes back via the shared `rust_future_complete_*`
+            // export. The bytes the runtime hands back must be deserialized
+            // here using the per-callable return-type converter.
+            /*liftFunc:*/ FfiConverterUInt64.lift.bind(FfiConverterUInt64),
+            /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString),
+            /*asyncOpts:*/ asyncOpts_,
+            /*errorHandler:*/ FfiConverterTypeCuaError.lift.bind(FfiConverterTypeCuaError)
+        );
+    }
+    
+/**
+ * Runs `line` with `/bin/sh -c`.
+ */
+    async sh(line: string, timeoutMs: number | undefined, asyncOpts_?: { signal: AbortSignal }): Promise<ProcessOutput> /*throws*/ {
+    return await uniffiRustCallAsync(
+            /*rustCaller:*/ uniffiCaller,
+            /*rustFutureFunc:*/ () => {
+                return nativeModule().ubrn_uniffi_cua_sdk_fn_method_spacesdclient_sh(
+                    uniffiTypeSpacesdClientObjectFactory.clonePointer(this),FfiConverterString.lower(line, nativeModule().rustbuffer_alloc),FfiConverterOptionalUInt32.lower(timeoutMs, nativeModule().rustbuffer_alloc)
+                );
+            },
+            /*pollFunc:*/ nativeModule().ubrn_ffi_cua_sdk_rust_future_poll_rust_buffer,
+            /*cancelFunc:*/ nativeModule().ubrn_ffi_cua_sdk_rust_future_cancel_rust_buffer,
+            /*completeFunc:*/ nativeModule().ubrn_ffi_cua_sdk_rust_future_complete_rust_buffer,
+            /*freeFunc:*/ nativeModule().ubrn_ffi_cua_sdk_rust_future_free_rust_buffer,
+            // Async returns always go through the JS-side converter: the
+            // FFI symbol returns the future handle (u64), and the user-level
+            // RustBuffer comes back via the shared `rust_future_complete_*`
+            // export. The bytes the runtime hands back must be deserialized
+            // here using the per-callable return-type converter.
+            /*liftFunc:*/ FfiConverterTypeProcessOutput.lift.bind(FfiConverterTypeProcessOutput),
+            /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString),
+            /*asyncOpts:*/ asyncOpts_,
+            /*errorHandler:*/ FfiConverterTypeCuaError.lift.bind(FfiConverterTypeCuaError)
+        );
+    }
+    
+/**
+ * Types text.
+ */
+    async typeText(text: string, asyncOpts_?: { signal: AbortSignal }): Promise<void> /*throws*/ {
+    return await uniffiRustCallAsync(
+            /*rustCaller:*/ uniffiCaller,
+            /*rustFutureFunc:*/ () => {
+                return nativeModule().ubrn_uniffi_cua_sdk_fn_method_spacesdclient_type_text(
+                    uniffiTypeSpacesdClientObjectFactory.clonePointer(this),FfiConverterString.lower(text, nativeModule().rustbuffer_alloc)
+                );
+            },
+            /*pollFunc:*/ nativeModule().ubrn_ffi_cua_sdk_rust_future_poll_void,
+            /*cancelFunc:*/ nativeModule().ubrn_ffi_cua_sdk_rust_future_cancel_void,
+            /*completeFunc:*/ nativeModule().ubrn_ffi_cua_sdk_rust_future_complete_void,
+            /*freeFunc:*/ nativeModule().ubrn_ffi_cua_sdk_rust_future_free_void,
+            /*liftFunc:*/ (_v) => {},
+            /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString),
+            /*asyncOpts:*/ asyncOpts_,
+            /*errorHandler:*/ FfiConverterTypeCuaError.lift.bind(FfiConverterTypeCuaError)
+        );
+    }
+    
+
+    uniffiDestroy(): void {
+        const ptr = (this as any)[destructorGuardSymbol];
+        if (ptr !== undefined) {
+            const pointer = uniffiTypeSpacesdClientObjectFactory.pointer(this);
+            uniffiTypeSpacesdClientObjectFactory.freePointer(pointer);
+            uniffiTypeSpacesdClientObjectFactory.unbless(ptr);
+            delete (this as any)[destructorGuardSymbol];
+        }
+    }
+
+    static instanceOf(obj_: any): obj_ is SpacesdClient {
+        return uniffiTypeSpacesdClientObjectFactory.isConcreteType(obj_);
+    }
+
+    
+}
+
+const uniffiTypeSpacesdClientObjectFactory: UniffiObjectFactory<SpacesdClientLike> = (() => {
+    
+    /// <reference lib="es2021" />
+    const registry = typeof FinalizationRegistry !== 'undefined' ? new FinalizationRegistry<UniffiHandle>((heldValue: UniffiHandle) => {
+        uniffiTypeSpacesdClientObjectFactory.freePointer(heldValue);
+    }) : null;
+    
+    return {
+    create(pointer: UniffiHandle): SpacesdClientLike {
+        const instance = Object.create(SpacesdClient.prototype);
+        instance[pointerLiteralSymbol] = pointer;
+        instance[destructorGuardSymbol] = this.bless(pointer);
+        instance[uniffiTypeNameSymbol] = "SpacesdClient";
+        return instance;
+    },
+
+    
+    bless(p: UniffiHandle): UniffiGcObject {
+        const ptr = {
+            p, // make sure this object doesn't get optimized away.
+            markDestroyed: () => undefined,
+        };
+        if (registry) {
+            registry.register(ptr, p, ptr);
+        }
+        return ptr;
+    },
+
+    unbless(ptr_: UniffiGcObject) {
+        if (registry) {
+            registry.unregister(ptr_);
+        }
+    },
+
+    pointer(obj_: SpacesdClientLike): UniffiHandle {
+        if ((obj_ as any)[destructorGuardSymbol] === undefined) {
+            throw new UniffiInternalError.UnexpectedNullPointer();
+        }
+        return (obj_ as any)[pointerLiteralSymbol];
+    },
+
+    clonePointer(obj_: SpacesdClientLike): UniffiHandle {
+        const pointer = this.pointer(obj_);
+        return uniffiCaller.rustCall(
+            /*caller:*/ (callStatus) => nativeModule().ubrn_uniffi_cua_sdk_fn_clone_spacesdclient(pointer, callStatus),
+            /*liftString:*/ FfiConverterString.lift
+        );
+    },
+
+    freePointer(pointer: UniffiHandle): void {
+        uniffiCaller.rustCall(
+            /*caller:*/ (callStatus) => nativeModule().ubrn_uniffi_cua_sdk_fn_free_spacesdclient(pointer, callStatus),
+            /*liftString:*/ FfiConverterString.lift
+        );
+    },
+
+    isConcreteType(obj_: any): obj_ is SpacesdClientLike {
+        return obj_[destructorGuardSymbol] && obj_[uniffiTypeNameSymbol] === "SpacesdClient";
+    },
+}})();
+const FfiConverterTypeSpacesdClient = new FfiConverterObject(uniffiTypeSpacesdClientObjectFactory);
+
+/**
+ * The cua SDK (browser build).
+ */
+export interface CuaLike {
+    
+/**
+ * Fleet control plane.
+ */
+    fleet() /*throws*/: FleetLike;
+/**
+ * Connects to cua-spacesd at `url` over gRPC-Web.
+ */
+    spacesd(url: string, token: string | undefined, asyncOpts_?: { signal: AbortSignal }) /*throws*/: Promise<SpacesdClientLike>;
+}
+/**
+ * @deprecated Use `CuaLike` instead.
+ */
+export type CuaInterface = CuaLike;
+
+
+/**
+ * The cua SDK (browser build).
+ */
+export class Cua extends UniffiAbstractObject implements CuaLike {
+
+    readonly [uniffiTypeNameSymbol] = "Cua";
+    readonly [destructorGuardSymbol]: UniffiGcObject;
+    readonly [pointerLiteralSymbol]: UniffiHandle;
+    // No primary constructor declared for this class.
+private constructor(pointer: UniffiHandle) {
+    super();
+    this[pointerLiteralSymbol] = pointer;
+    this[destructorGuardSymbol] = uniffiTypeCuaObjectFactory.bless(pointer);
+}
+
+    
+/**
+ * The browser runtime.
+ */
+    static embedded(config: CuaConfig): CuaLike {
+    return FfiConverterTypeCua.lift(uniffiCaller.rustCall(
+            /*caller:*/ (callStatus) => {
+                return nativeModule().ubrn_uniffi_cua_sdk_fn_constructor_cua_embedded(
+        FfiConverterTypeCuaConfig.lower(config, nativeModule().rustbuffer_alloc),
+                callStatus);
+            },
+            /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString),
+    ));
+    }
+    
+
+    
+/**
+ * Fleet control plane.
+ */
+    fleet(): FleetLike /*throws*/ {
+    return FfiConverterTypeFleet.lift(uniffiCaller.rustCallWithError(
+            /*liftError:*/ FfiConverterTypeCuaError.lift.bind(FfiConverterTypeCuaError),
+            /*caller:*/ (callStatus) => {
+                return nativeModule().ubrn_uniffi_cua_sdk_fn_method_cua_fleet(
+                uniffiTypeCuaObjectFactory.clonePointer(this),
+                callStatus);
+            },
+            /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString),
+    ));
+    }
+    
+/**
+ * Connects to cua-spacesd at `url` over gRPC-Web.
+ */
+    async spacesd(url: string, token: string | undefined, asyncOpts_?: { signal: AbortSignal }): Promise<SpacesdClientLike> /*throws*/ {
+    return await uniffiRustCallAsync(
+            /*rustCaller:*/ uniffiCaller,
+            /*rustFutureFunc:*/ () => {
+                return nativeModule().ubrn_uniffi_cua_sdk_fn_method_cua_spacesd(
+                    uniffiTypeCuaObjectFactory.clonePointer(this),FfiConverterString.lower(url, nativeModule().rustbuffer_alloc),FfiConverterOptionalString.lower(token, nativeModule().rustbuffer_alloc)
+                );
+            },
+            /*pollFunc:*/ nativeModule().ubrn_ffi_cua_sdk_rust_future_poll_u64,
+            /*cancelFunc:*/ nativeModule().ubrn_ffi_cua_sdk_rust_future_cancel_u64,
+            /*completeFunc:*/ nativeModule().ubrn_ffi_cua_sdk_rust_future_complete_u64,
+            /*freeFunc:*/ nativeModule().ubrn_ffi_cua_sdk_rust_future_free_u64,
+            // Async returns always go through the JS-side converter: the
+            // FFI symbol returns the future handle (u64), and the user-level
+            // RustBuffer comes back via the shared `rust_future_complete_*`
+            // export. The bytes the runtime hands back must be deserialized
+            // here using the per-callable return-type converter.
+            /*liftFunc:*/ FfiConverterTypeSpacesdClient.lift.bind(FfiConverterTypeSpacesdClient),
+            /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString),
+            /*asyncOpts:*/ asyncOpts_,
+            /*errorHandler:*/ FfiConverterTypeCuaError.lift.bind(FfiConverterTypeCuaError)
+        );
+    }
+    
+
+    uniffiDestroy(): void {
+        const ptr = (this as any)[destructorGuardSymbol];
+        if (ptr !== undefined) {
+            const pointer = uniffiTypeCuaObjectFactory.pointer(this);
+            uniffiTypeCuaObjectFactory.freePointer(pointer);
+            uniffiTypeCuaObjectFactory.unbless(ptr);
+            delete (this as any)[destructorGuardSymbol];
+        }
+    }
+
+    static instanceOf(obj_: any): obj_ is Cua {
+        return uniffiTypeCuaObjectFactory.isConcreteType(obj_);
+    }
+
+    
+}
+
+const uniffiTypeCuaObjectFactory: UniffiObjectFactory<CuaLike> = (() => {
+    
+    /// <reference lib="es2021" />
+    const registry = typeof FinalizationRegistry !== 'undefined' ? new FinalizationRegistry<UniffiHandle>((heldValue: UniffiHandle) => {
+        uniffiTypeCuaObjectFactory.freePointer(heldValue);
+    }) : null;
+    
+    return {
+    create(pointer: UniffiHandle): CuaLike {
+        const instance = Object.create(Cua.prototype);
+        instance[pointerLiteralSymbol] = pointer;
+        instance[destructorGuardSymbol] = this.bless(pointer);
+        instance[uniffiTypeNameSymbol] = "Cua";
+        return instance;
+    },
+
+    
+    bless(p: UniffiHandle): UniffiGcObject {
+        const ptr = {
+            p, // make sure this object doesn't get optimized away.
+            markDestroyed: () => undefined,
+        };
+        if (registry) {
+            registry.register(ptr, p, ptr);
+        }
+        return ptr;
+    },
+
+    unbless(ptr_: UniffiGcObject) {
+        if (registry) {
+            registry.unregister(ptr_);
+        }
+    },
+
+    pointer(obj_: CuaLike): UniffiHandle {
+        if ((obj_ as any)[destructorGuardSymbol] === undefined) {
+            throw new UniffiInternalError.UnexpectedNullPointer();
+        }
+        return (obj_ as any)[pointerLiteralSymbol];
+    },
+
+    clonePointer(obj_: CuaLike): UniffiHandle {
+        const pointer = this.pointer(obj_);
+        return uniffiCaller.rustCall(
+            /*caller:*/ (callStatus) => nativeModule().ubrn_uniffi_cua_sdk_fn_clone_cua(pointer, callStatus),
+            /*liftString:*/ FfiConverterString.lift
+        );
+    },
+
+    freePointer(pointer: UniffiHandle): void {
+        uniffiCaller.rustCall(
+            /*caller:*/ (callStatus) => nativeModule().ubrn_uniffi_cua_sdk_fn_free_cua(pointer, callStatus),
+            /*liftString:*/ FfiConverterString.lift
+        );
+    },
+
+    isConcreteType(obj_: any): obj_ is CuaLike {
+        return obj_[destructorGuardSymbol] && obj_[uniffiTypeNameSymbol] === "Cua";
+    },
+}})();
+const FfiConverterTypeCua = new FfiConverterObject(uniffiTypeCuaObjectFactory);
+
+// FfiConverter for string | undefined
+const FfiConverterOptionalString = new FfiConverterOptional(FfiConverterString);
+
+// FfiConverter for FleetSettings | undefined
+const FfiConverterOptionalTypeFleetSettings = new FfiConverterOptional(FfiConverterTypeFleetSettings);
+
+// FfiConverter for number | undefined
+const FfiConverterOptionalInt32 = new FfiConverterOptional(FfiConverterInt32);
+
+// FfiConverter for bigint | undefined
+const FfiConverterOptionalInt64 = new FfiConverterOptional(FfiConverterInt64);
+
+// FfiConverter for Array<string>
+const FfiConverterSequenceString = new FfiConverterArray(FfiConverterString);
+
+// FfiConverter for ExitInfo | undefined
+const FfiConverterOptionalTypeExitInfo = new FfiConverterOptional(FfiConverterTypeExitInfo);
+
+// FfiConverter for ImageFormat | undefined
+const FfiConverterOptionalTypeImageFormat = new FfiConverterOptional(FfiConverterTypeImageFormat);
+
+// FfiConverter for number | undefined
+const FfiConverterOptionalUInt32 = new FfiConverterOptional(FfiConverterUInt32);
+
+// FfiConverter for Map<string, string>
+const FfiConverterMapStringString = new FfiConverterMap(FfiConverterString, FfiConverterString);
+
+// FfiConverter for Array<SpacesdFeature>
+const FfiConverterSequenceTypeSpacesdFeature = new FfiConverterArray(FfiConverterTypeSpacesdFeature);
+
+// FfiConverter for PtySize | undefined
+const FfiConverterOptionalTypePtySize = new FfiConverterOptional(FfiConverterTypePtySize);
+
+// FfiConverter for ScreenshotOptions | undefined
+const FfiConverterOptionalTypeScreenshotOptions = new FfiConverterOptional(FfiConverterTypeScreenshotOptions);
+
+
+/**
+ * This should be called before anything else.
+ *
+ * It is likely that this is being done for you by the library's `index.ts`.
+ *
+ * It checks versions of uniffi between when the Rust scaffolding was generated
+ * and when the bindings were generated.
+ *
+ * It also initializes the machinery to enable Rust to talk back to Javascript.
+ */
+function uniffiEnsureInitialized() {
+    // Get the bindings contract version from our ComponentInterface
+    const bindingsContractVersion = 30;
+    // Get the scaffolding contract version by calling the into the dylib
+    const scaffoldingContractVersion = nativeModule().ubrn_ffi_cua_sdk_uniffi_contract_version();
+    if (bindingsContractVersion !== scaffoldingContractVersion) {
+        throw new UniffiInternalError.ContractVersionMismatch(scaffoldingContractVersion, bindingsContractVersion);
+    }
+    if (nativeModule().ubrn_uniffi_cua_sdk_checksum_func_cua_sdk_version() !== 62700) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cua_sdk_checksum_func_cua_sdk_version");
+    }
+    if (nativeModule().ubrn_uniffi_cua_sdk_checksum_func_error_doc_url() !== 10839) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cua_sdk_checksum_func_error_doc_url");
+    }
+    if (nativeModule().ubrn_uniffi_cua_sdk_checksum_constructor_cua_embedded() !== 45489) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cua_sdk_checksum_constructor_cua_embedded");
+    }
+    if (nativeModule().ubrn_uniffi_cua_sdk_checksum_method_cua_fleet() !== 47468) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cua_sdk_checksum_method_cua_fleet");
+    }
+    if (nativeModule().ubrn_uniffi_cua_sdk_checksum_method_cua_spacesd() !== 55115) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cua_sdk_checksum_method_cua_spacesd");
+    }
+    if (nativeModule().ubrn_uniffi_cua_sdk_checksum_method_fleet_acquire() !== 37737) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cua_sdk_checksum_method_fleet_acquire");
+    }
+    if (nativeModule().ubrn_uniffi_cua_sdk_checksum_method_fleet_list_claims() !== 29250) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cua_sdk_checksum_method_fleet_list_claims");
+    }
+    if (nativeModule().ubrn_uniffi_cua_sdk_checksum_method_fleet_list_pools() !== 64386) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cua_sdk_checksum_method_fleet_list_pools");
+    }
+    if (nativeModule().ubrn_uniffi_cua_sdk_checksum_method_fleet_release() !== 61023) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cua_sdk_checksum_method_fleet_release");
+    }
+    if (nativeModule().ubrn_uniffi_cua_sdk_checksum_method_spacesdclient_call_json() !== 32221) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cua_sdk_checksum_method_spacesdclient_call_json");
+    }
+    if (nativeModule().ubrn_uniffi_cua_sdk_checksum_method_spacesdclient_capabilities() !== 52681) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cua_sdk_checksum_method_spacesdclient_capabilities");
+    }
+    if (nativeModule().ubrn_uniffi_cua_sdk_checksum_method_spacesdclient_click() !== 34615) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cua_sdk_checksum_method_spacesdclient_click");
+    }
+    if (nativeModule().ubrn_uniffi_cua_sdk_checksum_method_spacesdclient_cursor_position() !== 32994) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cua_sdk_checksum_method_spacesdclient_cursor_position");
+    }
+    if (nativeModule().ubrn_uniffi_cua_sdk_checksum_method_spacesdclient_get_clipboard() !== 29593) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cua_sdk_checksum_method_spacesdclient_get_clipboard");
+    }
+    if (nativeModule().ubrn_uniffi_cua_sdk_checksum_method_spacesdclient_health() !== 58046) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cua_sdk_checksum_method_spacesdclient_health");
+    }
+    if (nativeModule().ubrn_uniffi_cua_sdk_checksum_method_spacesdclient_hotkey() !== 26513) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cua_sdk_checksum_method_spacesdclient_hotkey");
+    }
+    if (nativeModule().ubrn_uniffi_cua_sdk_checksum_method_spacesdclient_move_to() !== 8497) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cua_sdk_checksum_method_spacesdclient_move_to");
+    }
+    if (nativeModule().ubrn_uniffi_cua_sdk_checksum_method_spacesdclient_press() !== 48859) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cua_sdk_checksum_method_spacesdclient_press");
+    }
+    if (nativeModule().ubrn_uniffi_cua_sdk_checksum_method_spacesdclient_run() !== 60712) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cua_sdk_checksum_method_spacesdclient_run");
+    }
+    if (nativeModule().ubrn_uniffi_cua_sdk_checksum_method_spacesdclient_screenshot() !== 23114) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cua_sdk_checksum_method_spacesdclient_screenshot");
+    }
+    if (nativeModule().ubrn_uniffi_cua_sdk_checksum_method_spacesdclient_scroll() !== 18534) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cua_sdk_checksum_method_spacesdclient_scroll");
+    }
+    if (nativeModule().ubrn_uniffi_cua_sdk_checksum_method_spacesdclient_set_clipboard() !== 37414) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cua_sdk_checksum_method_spacesdclient_set_clipboard");
+    }
+    if (nativeModule().ubrn_uniffi_cua_sdk_checksum_method_spacesdclient_sh() !== 11145) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cua_sdk_checksum_method_spacesdclient_sh");
+    }
+    if (nativeModule().ubrn_uniffi_cua_sdk_checksum_method_spacesdclient_type_text() !== 18745) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cua_sdk_checksum_method_spacesdclient_type_text");
+    }
+
+    }
+
+export default Object.freeze({
+  initialize: uniffiEnsureInitialized,
+  converters: {
+    FfiConverterTypeCua,
+    FfiConverterTypeCuaConfig,
+    FfiConverterTypeCuaError,
+    FfiConverterTypeExitInfo,
+    FfiConverterTypeFileEntry,
+    FfiConverterTypeFleet,
+    FfiConverterTypeFleetSandbox,
+    FfiConverterTypeFleetSettings,
+    FfiConverterTypeImageFormat,
+    FfiConverterTypeMediaOpenOptions,
+    FfiConverterTypePoint,
+    FfiConverterTypeProcessEvent,
+    FfiConverterTypeProcessEventKind,
+    FfiConverterTypeProcessOutput,
+    FfiConverterTypePtySize,
+    FfiConverterTypeScreenshot,
+    FfiConverterTypeScreenshotOptions,
+    FfiConverterTypeSpacesdCapabilities,
+    FfiConverterTypeSpacesdClient,
+    FfiConverterTypeSpacesdCommand,
+    FfiConverterTypeSpacesdFeature,
+    FfiConverterTypeTransferResult,
+    FfiConverterTypeUploadOptions,
+  }
+});