@trycua/cua 0.2.0

package/browser/cua_sdk.js

@@ -0,0 +1,2607 @@
+// 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 { AbstractFfiConverterByteArray, FfiConverterArray, FfiConverterArrayBuffer, FfiConverterBool, FfiConverterFloat64, FfiConverterInt32, FfiConverterInt64, FfiConverterMap, FfiConverterObject, FfiConverterOptional, FfiConverterUInt32, FfiConverterUInt64, UniffiAbstractObject, 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) => new Uint8Array(n),
+    rustbuffer_free: (_) => { },
+});
+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() {
+    return ((__rb) => {
+        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) {
+    return ((__rb) => {
+        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) => encoder.encode(s),
+        bytesToString: (ab) => decoder.decode(ab),
+        stringByteLength: (s) => encoder.encode(s).byteLength,
+        writeStringIntoBuffer: (s, buf, offset) => {
+            const view = new Uint8Array(buf.arrayBuffer, offset, buf.arrayBuffer.byteLength - offset);
+            return encoder.encodeInto(s, view).written;
+        },
+        readStringFromBuffer: (buf, offset, length) => decoder.decode(new Uint8Array(buf.arrayBuffer, offset, length)),
+    };
+})();
+const FfiConverterString = uniffiCreateFfiConverterString(stringConverter);
+/**
+ * Generated factory for {@link FleetSettings} record objects.
+ */
+export const FleetSettings = (() => {
+    const defaults = () => ({
+        baseUrl: undefined,
+        token: undefined
+    });
+    const create = (() => {
+        return uniffiCreateRecord(defaults);
+    })();
+    return Object.freeze({
+        create,
+        new: create,
+        defaults: () => Object.freeze(defaults()),
+    });
+})();
+const FfiConverterTypeFleetSettings = (() => {
+    class FFIConverter extends AbstractFfiConverterByteArray {
+        read(from) {
+            return {
+                baseUrl: FfiConverterOptionalString.read(from),
+                token: FfiConverterOptionalString.read(from)
+            };
+        }
+        write(value, into) {
+            FfiConverterOptionalString.write(value.baseUrl, into);
+            FfiConverterOptionalString.write(value.token, into);
+        }
+        allocationSize(value) {
+            return FfiConverterOptionalString.allocationSize(value.baseUrl) +
+                FfiConverterOptionalString.allocationSize(value.token);
+        }
+    }
+    ;
+    return new FFIConverter();
+})();
+/**
+ * Generated factory for {@link CuaConfig} record objects.
+ */
+export const CuaConfig = (() => {
+    const defaults = () => ({
+        fleet: undefined
+    });
+    const create = (() => {
+        return uniffiCreateRecord(defaults);
+    })();
+    return Object.freeze({
+        create,
+        new: create,
+        defaults: () => Object.freeze(defaults()),
+    });
+})();
+const FfiConverterTypeCuaConfig = (() => {
+    class FFIConverter extends AbstractFfiConverterByteArray {
+        read(from) {
+            return {
+                fleet: FfiConverterOptionalTypeFleetSettings.read(from)
+            };
+        }
+        write(value, into) {
+            FfiConverterOptionalTypeFleetSettings.write(value.fleet, into);
+        }
+        allocationSize(value) {
+            return FfiConverterOptionalTypeFleetSettings.allocationSize(value.fleet);
+        }
+    }
+    ;
+    return new FFIConverter();
+})();
+/**
+ * Generated factory for {@link ExitInfo} record objects.
+ */
+export const ExitInfo = (() => {
+    const defaults = () => ({});
+    const create = (() => {
+        return uniffiCreateRecord(defaults);
+    })();
+    return Object.freeze({
+        create,
+        new: create,
+        defaults: () => Object.freeze(defaults()),
+    });
+})();
+const FfiConverterTypeExitInfo = (() => {
+    class FFIConverter extends AbstractFfiConverterByteArray {
+        read(from) {
+            return {
+                code: FfiConverterOptionalInt32.read(from),
+                signal: FfiConverterOptionalString.read(from),
+                timedOut: FfiConverterBool.read(from),
+                error: FfiConverterOptionalString.read(from),
+                success: FfiConverterBool.read(from)
+            };
+        }
+        write(value, into) {
+            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) {
+            return FfiConverterOptionalInt32.allocationSize(value.code) +
+                FfiConverterOptionalString.allocationSize(value.signal) +
+                FfiConverterBool.allocationSize(value.timedOut) +
+                FfiConverterOptionalString.allocationSize(value.error) +
+                FfiConverterBool.allocationSize(value.success);
+        }
+    }
+    ;
+    return new FFIConverter();
+})();
+/**
+ * Generated factory for {@link FileEntry} record objects.
+ */
+export const FileEntry = (() => {
+    const defaults = () => ({});
+    const create = (() => {
+        return uniffiCreateRecord(defaults);
+    })();
+    return Object.freeze({
+        create,
+        new: create,
+        defaults: () => Object.freeze(defaults()),
+    });
+})();
+const FfiConverterTypeFileEntry = (() => {
+    class FFIConverter extends AbstractFfiConverterByteArray {
+        read(from) {
+            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, into) {
+            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) {
+            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();
+})();
+/**
+ * Generated factory for {@link FleetSandbox} record objects.
+ */
+export const FleetSandbox = (() => {
+    const defaults = () => ({});
+    const create = (() => {
+        return uniffiCreateRecord(defaults);
+    })();
+    return Object.freeze({
+        create,
+        new: create,
+        defaults: () => Object.freeze(defaults()),
+    });
+})();
+const FfiConverterTypeFleetSandbox = (() => {
+    class FFIConverter extends AbstractFfiConverterByteArray {
+        read(from) {
+            return {
+                name: FfiConverterString.read(from),
+                namespace: FfiConverterString.read(from),
+                claim: FfiConverterString.read(from),
+                services: FfiConverterSequenceString.read(from)
+            };
+        }
+        write(value, into) {
+            FfiConverterString.write(value.name, into);
+            FfiConverterString.write(value.namespace, into);
+            FfiConverterString.write(value.claim, into);
+            FfiConverterSequenceString.write(value.services, into);
+        }
+        allocationSize(value) {
+            return FfiConverterString.allocationSize(value.name) +
+                FfiConverterString.allocationSize(value.namespace) +
+                FfiConverterString.allocationSize(value.claim) +
+                FfiConverterSequenceString.allocationSize(value.services);
+        }
+    }
+    ;
+    return new FFIConverter();
+})();
+/**
+ * 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(defaults);
+    })();
+    return Object.freeze({
+        create,
+        new: create,
+        defaults: () => Object.freeze(defaults()),
+    });
+})();
+const FfiConverterTypeMediaOpenOptions = (() => {
+    class FFIConverter extends AbstractFfiConverterByteArray {
+        read(from) {
+            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, into) {
+            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) {
+            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();
+})();
+/**
+ * Generated factory for {@link Point} record objects.
+ */
+export const Point = (() => {
+    const defaults = () => ({});
+    const create = (() => {
+        return uniffiCreateRecord(defaults);
+    })();
+    return Object.freeze({
+        create,
+        new: create,
+        defaults: () => Object.freeze(defaults()),
+    });
+})();
+const FfiConverterTypePoint = (() => {
+    class FFIConverter extends AbstractFfiConverterByteArray {
+        read(from) {
+            return {
+                x: FfiConverterFloat64.read(from),
+                y: FfiConverterFloat64.read(from)
+            };
+        }
+        write(value, into) {
+            FfiConverterFloat64.write(value.x, into);
+            FfiConverterFloat64.write(value.y, into);
+        }
+        allocationSize(value) {
+            return FfiConverterFloat64.allocationSize(value.x) +
+                FfiConverterFloat64.allocationSize(value.y);
+        }
+    }
+    ;
+    return new FFIConverter();
+})();
+/**
+ * Kind of a process event.
+ */
+export var ProcessEventKind;
+(function (ProcessEventKind) {
+    /**
+     * stdout bytes.
+     */
+    ProcessEventKind[ProcessEventKind["Stdout"] = 0] = "Stdout";
+    /**
+     * stderr bytes.
+     */
+    ProcessEventKind[ProcessEventKind["Stderr"] = 1] = "Stderr";
+    /**
+     * PTY bytes.
+     */
+    ProcessEventKind[ProcessEventKind["Pty"] = 2] = "Pty";
+    /**
+     * The process ended (always last).
+     */
+    ProcessEventKind[ProcessEventKind["Exit"] = 3] = "Exit";
+})(ProcessEventKind || (ProcessEventKind = {}));
+const FfiConverterTypeProcessEventKind = (() => {
+    const ordinalConverter = FfiConverterInt32;
+    class FFIConverter extends AbstractFfiConverterByteArray {
+        read(from) {
+            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, into) {
+            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) {
+            return ordinalConverter.allocationSize(0);
+        }
+    }
+    return new FFIConverter();
+})();
+/**
+ * Generated factory for {@link ProcessEvent} record objects.
+ */
+export const ProcessEvent = (() => {
+    const defaults = () => ({});
+    const create = (() => {
+        return uniffiCreateRecord(defaults);
+    })();
+    return Object.freeze({
+        create,
+        new: create,
+        defaults: () => Object.freeze(defaults()),
+    });
+})();
+const FfiConverterTypeProcessEvent = (() => {
+    class FFIConverter extends AbstractFfiConverterByteArray {
+        read(from) {
+            return {
+                kind: FfiConverterTypeProcessEventKind.read(from),
+                offset: FfiConverterUInt64.read(from),
+                data: FfiConverterArrayBuffer.read(from),
+                exit: FfiConverterOptionalTypeExitInfo.read(from)
+            };
+        }
+        write(value, into) {
+            FfiConverterTypeProcessEventKind.write(value.kind, into);
+            FfiConverterUInt64.write(value.offset, into);
+            FfiConverterArrayBuffer.write(value.data, into);
+            FfiConverterOptionalTypeExitInfo.write(value.exit, into);
+        }
+        allocationSize(value) {
+            return FfiConverterTypeProcessEventKind.allocationSize(value.kind) +
+                FfiConverterUInt64.allocationSize(value.offset) +
+                FfiConverterArrayBuffer.allocationSize(value.data) +
+                FfiConverterOptionalTypeExitInfo.allocationSize(value.exit);
+        }
+    }
+    ;
+    return new FFIConverter();
+})();
+/**
+ * Generated factory for {@link ProcessOutput} record objects.
+ */
+export const ProcessOutput = (() => {
+    const defaults = () => ({});
+    const create = (() => {
+        return uniffiCreateRecord(defaults);
+    })();
+    return Object.freeze({
+        create,
+        new: create,
+        defaults: () => Object.freeze(defaults()),
+    });
+})();
+const FfiConverterTypeProcessOutput = (() => {
+    class FFIConverter extends AbstractFfiConverterByteArray {
+        read(from) {
+            return {
+                exit: FfiConverterTypeExitInfo.read(from),
+                stdout: FfiConverterArrayBuffer.read(from),
+                stderr: FfiConverterArrayBuffer.read(from),
+                pty: FfiConverterArrayBuffer.read(from)
+            };
+        }
+        write(value, into) {
+            FfiConverterTypeExitInfo.write(value.exit, into);
+            FfiConverterArrayBuffer.write(value.stdout, into);
+            FfiConverterArrayBuffer.write(value.stderr, into);
+            FfiConverterArrayBuffer.write(value.pty, into);
+        }
+        allocationSize(value) {
+            return FfiConverterTypeExitInfo.allocationSize(value.exit) +
+                FfiConverterArrayBuffer.allocationSize(value.stdout) +
+                FfiConverterArrayBuffer.allocationSize(value.stderr) +
+                FfiConverterArrayBuffer.allocationSize(value.pty);
+        }
+    }
+    ;
+    return new FFIConverter();
+})();
+/**
+ * Generated factory for {@link PtySize} record objects.
+ */
+export const PtySize = (() => {
+    const defaults = () => ({});
+    const create = (() => {
+        return uniffiCreateRecord(defaults);
+    })();
+    return Object.freeze({
+        create,
+        new: create,
+        defaults: () => Object.freeze(defaults()),
+    });
+})();
+const FfiConverterTypePtySize = (() => {
+    class FFIConverter extends AbstractFfiConverterByteArray {
+        read(from) {
+            return {
+                cols: FfiConverterUInt32.read(from),
+                rows: FfiConverterUInt32.read(from)
+            };
+        }
+        write(value, into) {
+            FfiConverterUInt32.write(value.cols, into);
+            FfiConverterUInt32.write(value.rows, into);
+        }
+        allocationSize(value) {
+            return FfiConverterUInt32.allocationSize(value.cols) +
+                FfiConverterUInt32.allocationSize(value.rows);
+        }
+    }
+    ;
+    return new FFIConverter();
+})();
+/**
+ * Screenshot encoding.
+ */
+export var ImageFormat;
+(function (ImageFormat) {
+    /**
+     * PNG.
+     */
+    ImageFormat[ImageFormat["Png"] = 0] = "Png";
+    /**
+     * JPEG.
+     */
+    ImageFormat[ImageFormat["Jpeg"] = 1] = "Jpeg";
+    /**
+     * WebP.
+     */
+    ImageFormat[ImageFormat["Webp"] = 2] = "Webp";
+})(ImageFormat || (ImageFormat = {}));
+const FfiConverterTypeImageFormat = (() => {
+    const ordinalConverter = FfiConverterInt32;
+    class FFIConverter extends AbstractFfiConverterByteArray {
+        read(from) {
+            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, into) {
+            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) {
+            return ordinalConverter.allocationSize(0);
+        }
+    }
+    return new FFIConverter();
+})();
+/**
+ * Generated factory for {@link Screenshot} record objects.
+ */
+export const Screenshot = (() => {
+    const defaults = () => ({});
+    const create = (() => {
+        return uniffiCreateRecord(defaults);
+    })();
+    return Object.freeze({
+        create,
+        new: create,
+        defaults: () => Object.freeze(defaults()),
+    });
+})();
+const FfiConverterTypeScreenshot = (() => {
+    class FFIConverter extends AbstractFfiConverterByteArray {
+        read(from) {
+            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, into) {
+            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) {
+            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();
+})();
+/**
+ * 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(defaults);
+    })();
+    return Object.freeze({
+        create,
+        new: create,
+        defaults: () => Object.freeze(defaults()),
+    });
+})();
+const FfiConverterTypeScreenshotOptions = (() => {
+    class FFIConverter extends AbstractFfiConverterByteArray {
+        read(from) {
+            return {
+                display: FfiConverterOptionalString.read(from),
+                format: FfiConverterOptionalTypeImageFormat.read(from),
+                quality: FfiConverterOptionalUInt32.read(from),
+                maxDimension: FfiConverterOptionalUInt32.read(from),
+                includeCursor: FfiConverterBool.read(from)
+            };
+        }
+        write(value, into) {
+            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) {
+            return FfiConverterOptionalString.allocationSize(value.display) +
+                FfiConverterOptionalTypeImageFormat.allocationSize(value.format) +
+                FfiConverterOptionalUInt32.allocationSize(value.quality) +
+                FfiConverterOptionalUInt32.allocationSize(value.maxDimension) +
+                FfiConverterBool.allocationSize(value.includeCursor);
+        }
+    }
+    ;
+    return new FFIConverter();
+})();
+/**
+ * Generated factory for {@link SpacesdFeature} record objects.
+ */
+export const SpacesdFeature = (() => {
+    const defaults = () => ({});
+    const create = (() => {
+        return uniffiCreateRecord(defaults);
+    })();
+    return Object.freeze({
+        create,
+        new: create,
+        defaults: () => Object.freeze(defaults()),
+    });
+})();
+const FfiConverterTypeSpacesdFeature = (() => {
+    class FFIConverter extends AbstractFfiConverterByteArray {
+        read(from) {
+            return {
+                name: FfiConverterString.read(from),
+                supported: FfiConverterBool.read(from),
+                limitation: FfiConverterOptionalString.read(from),
+                attributes: FfiConverterMapStringString.read(from)
+            };
+        }
+        write(value, into) {
+            FfiConverterString.write(value.name, into);
+            FfiConverterBool.write(value.supported, into);
+            FfiConverterOptionalString.write(value.limitation, into);
+            FfiConverterMapStringString.write(value.attributes, into);
+        }
+        allocationSize(value) {
+            return FfiConverterString.allocationSize(value.name) +
+                FfiConverterBool.allocationSize(value.supported) +
+                FfiConverterOptionalString.allocationSize(value.limitation) +
+                FfiConverterMapStringString.allocationSize(value.attributes);
+        }
+    }
+    ;
+    return new FFIConverter();
+})();
+/**
+ * Generated factory for {@link SpacesdCapabilities} record objects.
+ */
+export const SpacesdCapabilities = (() => {
+    const defaults = () => ({});
+    const create = (() => {
+        return uniffiCreateRecord(defaults);
+    })();
+    return Object.freeze({
+        create,
+        new: create,
+        defaults: () => Object.freeze(defaults()),
+    });
+})();
+const FfiConverterTypeSpacesdCapabilities = (() => {
+    class FFIConverter extends AbstractFfiConverterByteArray {
+        read(from) {
+            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, into) {
+            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) {
+            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();
+})();
+/**
+ * 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(defaults);
+    })();
+    return Object.freeze({
+        create,
+        new: create,
+        defaults: () => Object.freeze(defaults()),
+    });
+})();
+const FfiConverterTypeSpacesdCommand = (() => {
+    class FFIConverter extends AbstractFfiConverterByteArray {
+        read(from) {
+            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, into) {
+            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) {
+            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();
+})();
+/**
+ * Generated factory for {@link TransferResult} record objects.
+ */
+export const TransferResult = (() => {
+    const defaults = () => ({});
+    const create = (() => {
+        return uniffiCreateRecord(defaults);
+    })();
+    return Object.freeze({
+        create,
+        new: create,
+        defaults: () => Object.freeze(defaults()),
+    });
+})();
+const FfiConverterTypeTransferResult = (() => {
+    class FFIConverter extends AbstractFfiConverterByteArray {
+        read(from) {
+            return {
+                size: FfiConverterUInt64.read(from),
+                sha256: FfiConverterString.read(from),
+                resumes: FfiConverterUInt32.read(from)
+            };
+        }
+        write(value, into) {
+            FfiConverterUInt64.write(value.size, into);
+            FfiConverterString.write(value.sha256, into);
+            FfiConverterUInt32.write(value.resumes, into);
+        }
+        allocationSize(value) {
+            return FfiConverterUInt64.allocationSize(value.size) +
+                FfiConverterString.allocationSize(value.sha256) +
+                FfiConverterUInt32.allocationSize(value.resumes);
+        }
+    }
+    ;
+    return new FFIConverter();
+})();
+/**
+ * Generated factory for {@link UploadOptions} record objects.
+ */
+export const UploadOptions = (() => {
+    const defaults = () => ({
+        createNew: false,
+        append: false,
+        permissions: 0,
+        createParents: true
+    });
+    const create = (() => {
+        return uniffiCreateRecord(defaults);
+    })();
+    return Object.freeze({
+        create,
+        new: create,
+        defaults: () => Object.freeze(defaults()),
+    });
+})();
+const FfiConverterTypeUploadOptions = (() => {
+    class FFIConverter extends AbstractFfiConverterByteArray {
+        read(from) {
+            return {
+                createNew: FfiConverterBool.read(from),
+                append: FfiConverterBool.read(from),
+                permissions: FfiConverterUInt32.read(from),
+                createParents: FfiConverterBool.read(from)
+            };
+        }
+        write(value, into) {
+            FfiConverterBool.write(value.createNew, into);
+            FfiConverterBool.write(value.append, into);
+            FfiConverterUInt32.write(value.permissions, into);
+            FfiConverterBool.write(value.createParents, into);
+        }
+        allocationSize(value) {
+            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 var CuaError_Tags;
+(function (CuaError_Tags) {
+    CuaError_Tags["InvalidArgument"] = "InvalidArgument";
+    CuaError_Tags["InvalidPlacement"] = "InvalidPlacement";
+    CuaError_Tags["NotFound"] = "NotFound";
+    CuaError_Tags["ProviderNotConfigured"] = "ProviderNotConfigured";
+    CuaError_Tags["Unsupported"] = "Unsupported";
+    CuaError_Tags["SpacesdNotAvailable"] = "SpacesdNotAvailable";
+    CuaError_Tags["Timeout"] = "Timeout";
+    CuaError_Tags["Fleet"] = "Fleet";
+    CuaError_Tags["FleetAdmissionDenied"] = "FleetAdmissionDenied";
+    CuaError_Tags["CloudCreditExhausted"] = "CloudCreditExhausted";
+    CuaError_Tags["Runtime"] = "Runtime";
+    CuaError_Tags["Env"] = "Env";
+    CuaError_Tags["Http"] = "Http";
+    CuaError_Tags["Unauthenticated"] = "Unauthenticated";
+    CuaError_Tags["PermissionDenied"] = "PermissionDenied";
+    CuaError_Tags["Transport"] = "Transport";
+    CuaError_Tags["DaemonNotRunning"] = "DaemonNotRunning";
+    CuaError_Tags["Closed"] = "Closed";
+    CuaError_Tags["CapabilityMissing"] = "CapabilityMissing";
+    CuaError_Tags["HostCapabilityMissing"] = "HostCapabilityMissing";
+    CuaError_Tags["TeleportRefused"] = "TeleportRefused";
+    CuaError_Tags["PoolSpecMismatch"] = "PoolSpecMismatch";
+    CuaError_Tags["ClaimSecretsNotDelivered"] = "ClaimSecretsNotDelivered";
+    CuaError_Tags["Internal"] = "Internal";
+    CuaError_Tags["AmbiguousSandbox"] = "AmbiguousSandbox";
+    CuaError_Tags["InsufficientDisk"] = "InsufficientDisk";
+    CuaError_Tags["ImageNotPublished"] = "ImageNotPublished";
+    CuaError_Tags["Cancelled"] = "Cancelled";
+    CuaError_Tags["Cloud"] = "Cloud";
+})(CuaError_Tags || (CuaError_Tags = {}));
+/**
+ * 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.
+         */
+        [uniffiTypeNameSymbol] = "CuaError";
+        /**
+         * @private
+         * This field is private and should not be used.
+         */
+        [variantOrdinalSymbol] = 1;
+        tag = CuaError_Tags.InvalidArgument;
+        constructor(message) {
+            super("CuaError", "InvalidArgument", message);
+        }
+        static instanceOf(e) {
+            return (instanceOf(e) && e[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.
+         */
+        [uniffiTypeNameSymbol] = "CuaError";
+        /**
+         * @private
+         * This field is private and should not be used.
+         */
+        [variantOrdinalSymbol] = 2;
+        tag = CuaError_Tags.InvalidPlacement;
+        constructor(message) {
+            super("CuaError", "InvalidPlacement", message);
+        }
+        static instanceOf(e) {
+            return (instanceOf(e) && e[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.
+         */
+        [uniffiTypeNameSymbol] = "CuaError";
+        /**
+         * @private
+         * This field is private and should not be used.
+         */
+        [variantOrdinalSymbol] = 3;
+        tag = CuaError_Tags.NotFound;
+        constructor(message) {
+            super("CuaError", "NotFound", message);
+        }
+        static instanceOf(e) {
+            return (instanceOf(e) && e[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.
+         */
+        [uniffiTypeNameSymbol] = "CuaError";
+        /**
+         * @private
+         * This field is private and should not be used.
+         */
+        [variantOrdinalSymbol] = 4;
+        tag = CuaError_Tags.ProviderNotConfigured;
+        constructor(message) {
+            super("CuaError", "ProviderNotConfigured", message);
+        }
+        static instanceOf(e) {
+            return (instanceOf(e) && e[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.
+         */
+        [uniffiTypeNameSymbol] = "CuaError";
+        /**
+         * @private
+         * This field is private and should not be used.
+         */
+        [variantOrdinalSymbol] = 5;
+        tag = CuaError_Tags.Unsupported;
+        constructor(message) {
+            super("CuaError", "Unsupported", message);
+        }
+        static instanceOf(e) {
+            return (instanceOf(e) && e[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.
+         */
+        [uniffiTypeNameSymbol] = "CuaError";
+        /**
+         * @private
+         * This field is private and should not be used.
+         */
+        [variantOrdinalSymbol] = 6;
+        tag = CuaError_Tags.SpacesdNotAvailable;
+        constructor(message) {
+            super("CuaError", "SpacesdNotAvailable", message);
+        }
+        static instanceOf(e) {
+            return (instanceOf(e) && e[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.
+         */
+        [uniffiTypeNameSymbol] = "CuaError";
+        /**
+         * @private
+         * This field is private and should not be used.
+         */
+        [variantOrdinalSymbol] = 7;
+        tag = CuaError_Tags.Timeout;
+        constructor(message) {
+            super("CuaError", "Timeout", message);
+        }
+        static instanceOf(e) {
+            return (instanceOf(e) && e[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.
+         */
+        [uniffiTypeNameSymbol] = "CuaError";
+        /**
+         * @private
+         * This field is private and should not be used.
+         */
+        [variantOrdinalSymbol] = 8;
+        tag = CuaError_Tags.Fleet;
+        constructor(message) {
+            super("CuaError", "Fleet", message);
+        }
+        static instanceOf(e) {
+            return (instanceOf(e) && e[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.
+         */
+        [uniffiTypeNameSymbol] = "CuaError";
+        /**
+         * @private
+         * This field is private and should not be used.
+         */
+        [variantOrdinalSymbol] = 9;
+        tag = CuaError_Tags.FleetAdmissionDenied;
+        constructor(message) {
+            super("CuaError", "FleetAdmissionDenied", message);
+        }
+        static instanceOf(e) {
+            return (instanceOf(e) && e[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.
+         */
+        [uniffiTypeNameSymbol] = "CuaError";
+        /**
+         * @private
+         * This field is private and should not be used.
+         */
+        [variantOrdinalSymbol] = 10;
+        tag = CuaError_Tags.CloudCreditExhausted;
+        constructor(message) {
+            super("CuaError", "CloudCreditExhausted", message);
+        }
+        static instanceOf(e) {
+            return (instanceOf(e) && e[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.
+         */
+        [uniffiTypeNameSymbol] = "CuaError";
+        /**
+         * @private
+         * This field is private and should not be used.
+         */
+        [variantOrdinalSymbol] = 11;
+        tag = CuaError_Tags.Runtime;
+        constructor(message) {
+            super("CuaError", "Runtime", message);
+        }
+        static instanceOf(e) {
+            return (instanceOf(e) && e[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.
+         */
+        [uniffiTypeNameSymbol] = "CuaError";
+        /**
+         * @private
+         * This field is private and should not be used.
+         */
+        [variantOrdinalSymbol] = 12;
+        tag = CuaError_Tags.Env;
+        constructor(message) {
+            super("CuaError", "Env", message);
+        }
+        static instanceOf(e) {
+            return (instanceOf(e) && e[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.
+         */
+        [uniffiTypeNameSymbol] = "CuaError";
+        /**
+         * @private
+         * This field is private and should not be used.
+         */
+        [variantOrdinalSymbol] = 13;
+        tag = CuaError_Tags.Http;
+        constructor(message) {
+            super("CuaError", "Http", message);
+        }
+        static instanceOf(e) {
+            return (instanceOf(e) && e[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.
+         */
+        [uniffiTypeNameSymbol] = "CuaError";
+        /**
+         * @private
+         * This field is private and should not be used.
+         */
+        [variantOrdinalSymbol] = 14;
+        tag = CuaError_Tags.Unauthenticated;
+        constructor(message) {
+            super("CuaError", "Unauthenticated", message);
+        }
+        static instanceOf(e) {
+            return (instanceOf(e) && e[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.
+         */
+        [uniffiTypeNameSymbol] = "CuaError";
+        /**
+         * @private
+         * This field is private and should not be used.
+         */
+        [variantOrdinalSymbol] = 15;
+        tag = CuaError_Tags.PermissionDenied;
+        constructor(message) {
+            super("CuaError", "PermissionDenied", message);
+        }
+        static instanceOf(e) {
+            return (instanceOf(e) && e[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.
+         */
+        [uniffiTypeNameSymbol] = "CuaError";
+        /**
+         * @private
+         * This field is private and should not be used.
+         */
+        [variantOrdinalSymbol] = 16;
+        tag = CuaError_Tags.Transport;
+        constructor(message) {
+            super("CuaError", "Transport", message);
+        }
+        static instanceOf(e) {
+            return (instanceOf(e) && e[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.
+         */
+        [uniffiTypeNameSymbol] = "CuaError";
+        /**
+         * @private
+         * This field is private and should not be used.
+         */
+        [variantOrdinalSymbol] = 17;
+        tag = CuaError_Tags.DaemonNotRunning;
+        constructor(message) {
+            super("CuaError", "DaemonNotRunning", message);
+        }
+        static instanceOf(e) {
+            return (instanceOf(e) && e[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.
+         */
+        [uniffiTypeNameSymbol] = "CuaError";
+        /**
+         * @private
+         * This field is private and should not be used.
+         */
+        [variantOrdinalSymbol] = 18;
+        tag = CuaError_Tags.Closed;
+        constructor(message) {
+            super("CuaError", "Closed", message);
+        }
+        static instanceOf(e) {
+            return (instanceOf(e) && e[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.
+         */
+        [uniffiTypeNameSymbol] = "CuaError";
+        /**
+         * @private
+         * This field is private and should not be used.
+         */
+        [variantOrdinalSymbol] = 19;
+        tag = CuaError_Tags.CapabilityMissing;
+        constructor(message) {
+            super("CuaError", "CapabilityMissing", message);
+        }
+        static instanceOf(e) {
+            return (instanceOf(e) && e[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.
+         */
+        [uniffiTypeNameSymbol] = "CuaError";
+        /**
+         * @private
+         * This field is private and should not be used.
+         */
+        [variantOrdinalSymbol] = 20;
+        tag = CuaError_Tags.HostCapabilityMissing;
+        constructor(message) {
+            super("CuaError", "HostCapabilityMissing", message);
+        }
+        static instanceOf(e) {
+            return (instanceOf(e) && e[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.
+         */
+        [uniffiTypeNameSymbol] = "CuaError";
+        /**
+         * @private
+         * This field is private and should not be used.
+         */
+        [variantOrdinalSymbol] = 21;
+        tag = CuaError_Tags.TeleportRefused;
+        constructor(message) {
+            super("CuaError", "TeleportRefused", message);
+        }
+        static instanceOf(e) {
+            return (instanceOf(e) && e[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.
+         */
+        [uniffiTypeNameSymbol] = "CuaError";
+        /**
+         * @private
+         * This field is private and should not be used.
+         */
+        [variantOrdinalSymbol] = 22;
+        tag = CuaError_Tags.PoolSpecMismatch;
+        constructor(message) {
+            super("CuaError", "PoolSpecMismatch", message);
+        }
+        static instanceOf(e) {
+            return (instanceOf(e) && e[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.
+         */
+        [uniffiTypeNameSymbol] = "CuaError";
+        /**
+         * @private
+         * This field is private and should not be used.
+         */
+        [variantOrdinalSymbol] = 23;
+        tag = CuaError_Tags.ClaimSecretsNotDelivered;
+        constructor(message) {
+            super("CuaError", "ClaimSecretsNotDelivered", message);
+        }
+        static instanceOf(e) {
+            return (instanceOf(e) && e[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.
+         */
+        [uniffiTypeNameSymbol] = "CuaError";
+        /**
+         * @private
+         * This field is private and should not be used.
+         */
+        [variantOrdinalSymbol] = 24;
+        tag = CuaError_Tags.Internal;
+        constructor(message) {
+            super("CuaError", "Internal", message);
+        }
+        static instanceOf(e) {
+            return (instanceOf(e) && e[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.
+         */
+        [uniffiTypeNameSymbol] = "CuaError";
+        /**
+         * @private
+         * This field is private and should not be used.
+         */
+        [variantOrdinalSymbol] = 25;
+        tag = CuaError_Tags.AmbiguousSandbox;
+        constructor(message) {
+            super("CuaError", "AmbiguousSandbox", message);
+        }
+        static instanceOf(e) {
+            return (instanceOf(e) && e[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.
+         */
+        [uniffiTypeNameSymbol] = "CuaError";
+        /**
+         * @private
+         * This field is private and should not be used.
+         */
+        [variantOrdinalSymbol] = 26;
+        tag = CuaError_Tags.InsufficientDisk;
+        constructor(message) {
+            super("CuaError", "InsufficientDisk", message);
+        }
+        static instanceOf(e) {
+            return (instanceOf(e) && e[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.
+         */
+        [uniffiTypeNameSymbol] = "CuaError";
+        /**
+         * @private
+         * This field is private and should not be used.
+         */
+        [variantOrdinalSymbol] = 27;
+        tag = CuaError_Tags.ImageNotPublished;
+        constructor(message) {
+            super("CuaError", "ImageNotPublished", message);
+        }
+        static instanceOf(e) {
+            return (instanceOf(e) && e[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.
+         */
+        [uniffiTypeNameSymbol] = "CuaError";
+        /**
+         * @private
+         * This field is private and should not be used.
+         */
+        [variantOrdinalSymbol] = 28;
+        tag = CuaError_Tags.Cancelled;
+        constructor(message) {
+            super("CuaError", "Cancelled", message);
+        }
+        static instanceOf(e) {
+            return (instanceOf(e) && e[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.
+         */
+        [uniffiTypeNameSymbol] = "CuaError";
+        /**
+         * @private
+         * This field is private and should not be used.
+         */
+        [variantOrdinalSymbol] = 29;
+        tag = CuaError_Tags.Cloud;
+        constructor(message) {
+            super("CuaError", "Cloud", message);
+        }
+        static instanceOf(e) {
+            return (instanceOf(e) && e[variantOrdinalSymbol] === 29);
+        }
+    }
+    // Utility function which does not rely on instanceof.
+    function instanceOf(e) {
+        return e[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,
+    };
+})();
+const FfiConverterTypeCuaError = (() => {
+    const intConverter = FfiConverterInt32;
+    class FfiConverter extends AbstractFfiConverterByteArray {
+        read(from) {
+            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, into) {
+            const obj = value;
+            const index = obj[variantOrdinalSymbol];
+            intConverter.write(index, into);
+        }
+        allocationSize(value) {
+            return intConverter.allocationSize(0);
+        }
+    }
+    return new FfiConverter();
+})();
+/**
+ * Fleet control plane (browser transport).
+ */
+export class Fleet extends UniffiAbstractObject {
+    [uniffiTypeNameSymbol] = "Fleet";
+    [destructorGuardSymbol];
+    [pointerLiteralSymbol];
+    // No primary constructor declared for this class.
+    constructor(pointer) {
+        super();
+        this[pointerLiteralSymbol] = pointer;
+        this[destructorGuardSymbol] = uniffiTypeFleetObjectFactory.bless(pointer);
+    }
+    /**
+     * Claims a sandbox from `pool` and waits for it to bind.
+     */
+    async acquire(pool, name, asyncOpts_) {
+        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, asyncOpts_) {
+        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, asyncOpts_) {
+        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, asyncOpts_) {
+        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() {
+        const ptr = this[destructorGuardSymbol];
+        if (ptr !== undefined) {
+            const pointer = uniffiTypeFleetObjectFactory.pointer(this);
+            uniffiTypeFleetObjectFactory.freePointer(pointer);
+            uniffiTypeFleetObjectFactory.unbless(ptr);
+            delete this[destructorGuardSymbol];
+        }
+    }
+    static instanceOf(obj_) {
+        return uniffiTypeFleetObjectFactory.isConcreteType(obj_);
+    }
+}
+const uniffiTypeFleetObjectFactory = (() => {
+    /// <reference lib="es2021" />
+    const registry = typeof FinalizationRegistry !== 'undefined' ? new FinalizationRegistry((heldValue) => {
+        uniffiTypeFleetObjectFactory.freePointer(heldValue);
+    }) : null;
+    return {
+        create(pointer) {
+            const instance = Object.create(Fleet.prototype);
+            instance[pointerLiteralSymbol] = pointer;
+            instance[destructorGuardSymbol] = this.bless(pointer);
+            instance[uniffiTypeNameSymbol] = "Fleet";
+            return instance;
+        },
+        bless(p) {
+            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_) {
+            if (registry) {
+                registry.unregister(ptr_);
+            }
+        },
+        pointer(obj_) {
+            if (obj_[destructorGuardSymbol] === undefined) {
+                throw new UniffiInternalError.UnexpectedNullPointer();
+            }
+            return obj_[pointerLiteralSymbol];
+        },
+        clonePointer(obj_) {
+            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) {
+            uniffiCaller.rustCall(
+            /*caller:*/ (callStatus) => nativeModule().ubrn_uniffi_cua_sdk_fn_free_fleet(pointer, callStatus), 
+            /*liftString:*/ FfiConverterString.lift);
+        },
+        isConcreteType(obj_) {
+            return obj_[destructorGuardSymbol] && obj_[uniffiTypeNameSymbol] === "Fleet";
+        },
+    };
+})();
+const FfiConverterTypeFleet = new FfiConverterObject(uniffiTypeFleetObjectFactory);
+/**
+ * cua-spacesd over gRPC-Web.
+ */
+export class SpacesdClient extends UniffiAbstractObject {
+    [uniffiTypeNameSymbol] = "SpacesdClient";
+    [destructorGuardSymbol];
+    [pointerLiteralSymbol];
+    // No primary constructor declared for this class.
+    constructor(pointer) {
+        super();
+        this[pointerLiteralSymbol] = pointer;
+        this[destructorGuardSymbol] = uniffiTypeSpacesdClientObjectFactory.bless(pointer);
+    }
+    /**
+     * Any unary `cua.env.v1` RPC with proto3-JSON bodies.
+     */
+    async callJson(method, requestJson, asyncOpts_) {
+        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_) {
+        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, y, asyncOpts_) {
+        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_) {
+        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_) {
+        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_) {
+        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, asyncOpts_) {
+        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, y, asyncOpts_) {
+        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, asyncOpts_) {
+        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, asyncOpts_) {
+        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, asyncOpts_) {
+        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, dy, asyncOpts_) {
+        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, asyncOpts_) {
+        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, timeoutMs, asyncOpts_) {
+        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, asyncOpts_) {
+        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() {
+        const ptr = this[destructorGuardSymbol];
+        if (ptr !== undefined) {
+            const pointer = uniffiTypeSpacesdClientObjectFactory.pointer(this);
+            uniffiTypeSpacesdClientObjectFactory.freePointer(pointer);
+            uniffiTypeSpacesdClientObjectFactory.unbless(ptr);
+            delete this[destructorGuardSymbol];
+        }
+    }
+    static instanceOf(obj_) {
+        return uniffiTypeSpacesdClientObjectFactory.isConcreteType(obj_);
+    }
+}
+const uniffiTypeSpacesdClientObjectFactory = (() => {
+    /// <reference lib="es2021" />
+    const registry = typeof FinalizationRegistry !== 'undefined' ? new FinalizationRegistry((heldValue) => {
+        uniffiTypeSpacesdClientObjectFactory.freePointer(heldValue);
+    }) : null;
+    return {
+        create(pointer) {
+            const instance = Object.create(SpacesdClient.prototype);
+            instance[pointerLiteralSymbol] = pointer;
+            instance[destructorGuardSymbol] = this.bless(pointer);
+            instance[uniffiTypeNameSymbol] = "SpacesdClient";
+            return instance;
+        },
+        bless(p) {
+            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_) {
+            if (registry) {
+                registry.unregister(ptr_);
+            }
+        },
+        pointer(obj_) {
+            if (obj_[destructorGuardSymbol] === undefined) {
+                throw new UniffiInternalError.UnexpectedNullPointer();
+            }
+            return obj_[pointerLiteralSymbol];
+        },
+        clonePointer(obj_) {
+            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) {
+            uniffiCaller.rustCall(
+            /*caller:*/ (callStatus) => nativeModule().ubrn_uniffi_cua_sdk_fn_free_spacesdclient(pointer, callStatus), 
+            /*liftString:*/ FfiConverterString.lift);
+        },
+        isConcreteType(obj_) {
+            return obj_[destructorGuardSymbol] && obj_[uniffiTypeNameSymbol] === "SpacesdClient";
+        },
+    };
+})();
+const FfiConverterTypeSpacesdClient = new FfiConverterObject(uniffiTypeSpacesdClientObjectFactory);
+/**
+ * The cua SDK (browser build).
+ */
+export class Cua extends UniffiAbstractObject {
+    [uniffiTypeNameSymbol] = "Cua";
+    [destructorGuardSymbol];
+    [pointerLiteralSymbol];
+    // No primary constructor declared for this class.
+    constructor(pointer) {
+        super();
+        this[pointerLiteralSymbol] = pointer;
+        this[destructorGuardSymbol] = uniffiTypeCuaObjectFactory.bless(pointer);
+    }
+    /**
+     * The browser runtime.
+     */
+    static embedded(config) {
+        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() {
+        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, token, asyncOpts_) {
+        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() {
+        const ptr = this[destructorGuardSymbol];
+        if (ptr !== undefined) {
+            const pointer = uniffiTypeCuaObjectFactory.pointer(this);
+            uniffiTypeCuaObjectFactory.freePointer(pointer);
+            uniffiTypeCuaObjectFactory.unbless(ptr);
+            delete this[destructorGuardSymbol];
+        }
+    }
+    static instanceOf(obj_) {
+        return uniffiTypeCuaObjectFactory.isConcreteType(obj_);
+    }
+}
+const uniffiTypeCuaObjectFactory = (() => {
+    /// <reference lib="es2021" />
+    const registry = typeof FinalizationRegistry !== 'undefined' ? new FinalizationRegistry((heldValue) => {
+        uniffiTypeCuaObjectFactory.freePointer(heldValue);
+    }) : null;
+    return {
+        create(pointer) {
+            const instance = Object.create(Cua.prototype);
+            instance[pointerLiteralSymbol] = pointer;
+            instance[destructorGuardSymbol] = this.bless(pointer);
+            instance[uniffiTypeNameSymbol] = "Cua";
+            return instance;
+        },
+        bless(p) {
+            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_) {
+            if (registry) {
+                registry.unregister(ptr_);
+            }
+        },
+        pointer(obj_) {
+            if (obj_[destructorGuardSymbol] === undefined) {
+                throw new UniffiInternalError.UnexpectedNullPointer();
+            }
+            return obj_[pointerLiteralSymbol];
+        },
+        clonePointer(obj_) {
+            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) {
+            uniffiCaller.rustCall(
+            /*caller:*/ (callStatus) => nativeModule().ubrn_uniffi_cua_sdk_fn_free_cua(pointer, callStatus), 
+            /*liftString:*/ FfiConverterString.lift);
+        },
+        isConcreteType(obj_) {
+            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,
+    }
+});