@trycua/cua-driver 0.11.0

package/dist/native/cua_driver_sdk.js

@@ -0,0 +1,1857 @@
+// 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 nativeModule from "./cua_driver_sdk-ffi.js";
+import { AbstractFfiConverterByteArray, FfiConverterArray, FfiConverterBool, FfiConverterInt32, FfiConverterObject, FfiConverterOptional, FfiConverterUInt32, FfiConverterUInt64, UniffiAbstractObject, UniffiError, UniffiInternalError, UniffiRustCaller, destructorGuardSymbol, pointerLiteralSymbol, uniffiCreateFfiConverterString, uniffiCreateRecord, uniffiRustCallAsync, uniffiTypeNameSymbol, } from "@ubjs/core";
+import uniffiCuaDriverContractModule from "./cua_driver_contract.js";
+const { FfiConverterTypeClickInput, FfiConverterTypeDragInput, FfiConverterTypeEndSessionInput, FfiConverterTypeEndSessionOutput, FfiConverterTypeEscalateSessionInput, FfiConverterTypeGetCursorPositionInput, FfiConverterTypeGetDesktopStateInput, FfiConverterTypeGetScreenSizeInput, FfiConverterTypeGetSessionStateInput, FfiConverterTypeHotkeyInput, FfiConverterTypeMoveCursorInput, FfiConverterTypePressKeyInput, FfiConverterTypeScrollInput, FfiConverterTypeSessionStateOutput, FfiConverterTypeStartSessionInput, FfiConverterTypeStartSessionOutput, FfiConverterTypeTypeTextInput } = uniffiCuaDriverContractModule.converters;
+const uniffiCaller = new UniffiRustCaller(() => ({ code: 0 }));
+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.
+export function currentMacOsPermissionStatus() {
+    return ((__rb) => {
+        try {
+            return FfiConverterTypeMacOsPermissionStatus.lift(__rb);
+        }
+        finally {
+            nativeModule().rustbuffer_free(__rb);
+        }
+    })(uniffiCaller.rustCall(
+    /*caller:*/ (callStatus) => {
+        return nativeModule().uniffi_cua_driver_sdk_fn_func_current_mac_os_permission_status(callStatus);
+    }, 
+    /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)));
+}
+export function openMacOsScreenRecordingSettings() {
+    uniffiCaller.rustCallWithError(
+    /*liftError:*/ FfiConverterTypeDriverError.lift.bind(FfiConverterTypeDriverError), 
+    /*caller:*/ (callStatus) => {
+        nativeModule().uniffi_cua_driver_sdk_fn_func_open_mac_os_screen_recording_settings(callStatus);
+    }, 
+    /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString));
+}
+export function requestMacOsPermissions() {
+    return ((__rb) => {
+        try {
+            return FfiConverterTypeMacOsPermissionStatus.lift(__rb);
+        }
+        finally {
+            nativeModule().rustbuffer_free(__rb);
+        }
+    })(uniffiCaller.rustCall(
+    /*caller:*/ (callStatus) => {
+        return nativeModule().uniffi_cua_driver_sdk_fn_func_request_mac_os_permissions(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 DriverMetadata} record objects.
+ */
+export const DriverMetadata = (() => {
+    const defaults = () => ({});
+    const create = (() => {
+        return uniffiCreateRecord(defaults);
+    })();
+    return Object.freeze({
+        create,
+        new: create,
+        defaults: () => Object.freeze(defaults()),
+    });
+})();
+const FfiConverterTypeDriverMetadata = (() => {
+    class FFIConverter extends AbstractFfiConverterByteArray {
+        read(from) {
+            return {
+                driverVersion: FfiConverterString.read(from),
+                contractVersion: FfiConverterString.read(from),
+                toolsListSchemaVersion: FfiConverterString.read(from),
+                capabilityVersion: FfiConverterString.read(from),
+                mcpProtocolVersion: FfiConverterString.read(from),
+                pid: FfiConverterUInt32.read(from),
+                embedded: FfiConverterBool.read(from),
+                hostBundleId: FfiConverterOptionalString.read(from)
+            };
+        }
+        write(value, into) {
+            FfiConverterString.write(value.driverVersion, into);
+            FfiConverterString.write(value.contractVersion, into);
+            FfiConverterString.write(value.toolsListSchemaVersion, into);
+            FfiConverterString.write(value.capabilityVersion, into);
+            FfiConverterString.write(value.mcpProtocolVersion, into);
+            FfiConverterUInt32.write(value.pid, into);
+            FfiConverterBool.write(value.embedded, into);
+            FfiConverterOptionalString.write(value.hostBundleId, into);
+        }
+        allocationSize(value) {
+            return FfiConverterString.allocationSize(value.driverVersion) +
+                FfiConverterString.allocationSize(value.contractVersion) +
+                FfiConverterString.allocationSize(value.toolsListSchemaVersion) +
+                FfiConverterString.allocationSize(value.capabilityVersion) +
+                FfiConverterString.allocationSize(value.mcpProtocolVersion) +
+                FfiConverterUInt32.allocationSize(value.pid) +
+                FfiConverterBool.allocationSize(value.embedded) +
+                FfiConverterOptionalString.allocationSize(value.hostBundleId);
+        }
+    }
+    ;
+    return new FFIConverter();
+})();
+/**
+ * Generated factory for {@link EmbeddedEnvironmentVariable} record objects.
+ */
+export const EmbeddedEnvironmentVariable = (() => {
+    const defaults = () => ({});
+    const create = (() => {
+        return uniffiCreateRecord(defaults);
+    })();
+    return Object.freeze({
+        create,
+        new: create,
+        defaults: () => Object.freeze(defaults()),
+    });
+})();
+const FfiConverterTypeEmbeddedEnvironmentVariable = (() => {
+    class FFIConverter extends AbstractFfiConverterByteArray {
+        read(from) {
+            return {
+                name: FfiConverterString.read(from),
+                value: FfiConverterString.read(from)
+            };
+        }
+        write(value, into) {
+            FfiConverterString.write(value.name, into);
+            FfiConverterString.write(value.value, into);
+        }
+        allocationSize(value) {
+            return FfiConverterString.allocationSize(value.name) +
+                FfiConverterString.allocationSize(value.value);
+        }
+    }
+    ;
+    return new FFIConverter();
+})();
+/**
+ * Generated factory for {@link EmbeddedMcpConfiguration} record objects.
+ */
+export const EmbeddedMcpConfiguration = (() => {
+    const defaults = () => ({});
+    const create = (() => {
+        return uniffiCreateRecord(defaults);
+    })();
+    return Object.freeze({
+        create,
+        new: create,
+        defaults: () => Object.freeze(defaults()),
+    });
+})();
+const FfiConverterTypeEmbeddedMcpConfiguration = (() => {
+    class FFIConverter extends AbstractFfiConverterByteArray {
+        read(from) {
+            return {
+                command: FfiConverterString.read(from),
+                args: FfiConverterSequenceString.read(from),
+                environment: FfiConverterSequenceTypeEmbeddedEnvironmentVariable.read(from)
+            };
+        }
+        write(value, into) {
+            FfiConverterString.write(value.command, into);
+            FfiConverterSequenceString.write(value.args, into);
+            FfiConverterSequenceTypeEmbeddedEnvironmentVariable.write(value.environment, into);
+        }
+        allocationSize(value) {
+            return FfiConverterString.allocationSize(value.command) +
+                FfiConverterSequenceString.allocationSize(value.args) +
+                FfiConverterSequenceTypeEmbeddedEnvironmentVariable.allocationSize(value.environment);
+        }
+    }
+    ;
+    return new FFIConverter();
+})();
+/**
+ * Generated factory for {@link EmbeddedDriverConnection} record objects.
+ */
+export const EmbeddedDriverConnection = (() => {
+    const defaults = () => ({});
+    const create = (() => {
+        return uniffiCreateRecord(defaults);
+    })();
+    return Object.freeze({
+        create,
+        new: create,
+        defaults: () => Object.freeze(defaults()),
+    });
+})();
+const FfiConverterTypeEmbeddedDriverConnection = (() => {
+    class FFIConverter extends AbstractFfiConverterByteArray {
+        read(from) {
+            return {
+                socketPath: FfiConverterString.read(from),
+                pid: FfiConverterUInt32.read(from),
+                generation: FfiConverterString.read(from),
+                driverVersion: FfiConverterString.read(from),
+                contractVersion: FfiConverterString.read(from),
+                mcpProtocolVersion: FfiConverterString.read(from),
+                mcp: FfiConverterTypeEmbeddedMcpConfiguration.read(from)
+            };
+        }
+        write(value, into) {
+            FfiConverterString.write(value.socketPath, into);
+            FfiConverterUInt32.write(value.pid, into);
+            FfiConverterString.write(value.generation, into);
+            FfiConverterString.write(value.driverVersion, into);
+            FfiConverterString.write(value.contractVersion, into);
+            FfiConverterString.write(value.mcpProtocolVersion, into);
+            FfiConverterTypeEmbeddedMcpConfiguration.write(value.mcp, into);
+        }
+        allocationSize(value) {
+            return FfiConverterString.allocationSize(value.socketPath) +
+                FfiConverterUInt32.allocationSize(value.pid) +
+                FfiConverterString.allocationSize(value.generation) +
+                FfiConverterString.allocationSize(value.driverVersion) +
+                FfiConverterString.allocationSize(value.contractVersion) +
+                FfiConverterString.allocationSize(value.mcpProtocolVersion) +
+                FfiConverterTypeEmbeddedMcpConfiguration.allocationSize(value.mcp);
+        }
+    }
+    ;
+    return new FFIConverter();
+})();
+/**
+ * Generated factory for {@link EmbeddedDriverExit} record objects.
+ */
+export const EmbeddedDriverExit = (() => {
+    const defaults = () => ({});
+    const create = (() => {
+        return uniffiCreateRecord(defaults);
+    })();
+    return Object.freeze({
+        create,
+        new: create,
+        defaults: () => Object.freeze(defaults()),
+    });
+})();
+const FfiConverterTypeEmbeddedDriverExit = (() => {
+    class FFIConverter extends AbstractFfiConverterByteArray {
+        read(from) {
+            return {
+                generation: FfiConverterString.read(from),
+                code: FfiConverterOptionalInt32.read(from),
+                success: FfiConverterBool.read(from)
+            };
+        }
+        write(value, into) {
+            FfiConverterString.write(value.generation, into);
+            FfiConverterOptionalInt32.write(value.code, into);
+            FfiConverterBool.write(value.success, into);
+        }
+        allocationSize(value) {
+            return FfiConverterString.allocationSize(value.generation) +
+                FfiConverterOptionalInt32.allocationSize(value.code) +
+                FfiConverterBool.allocationSize(value.success);
+        }
+    }
+    ;
+    return new FFIConverter();
+})();
+export var EmbeddedPermissionMode;
+(function (EmbeddedPermissionMode) {
+    EmbeddedPermissionMode[EmbeddedPermissionMode["Standard"] = 0] = "Standard";
+    EmbeddedPermissionMode[EmbeddedPermissionMode["Bounded"] = 1] = "Bounded";
+    EmbeddedPermissionMode[EmbeddedPermissionMode["Unrestricted"] = 2] = "Unrestricted";
+})(EmbeddedPermissionMode || (EmbeddedPermissionMode = {}));
+const FfiConverterTypeEmbeddedPermissionMode = (() => {
+    const ordinalConverter = FfiConverterInt32;
+    class FFIConverter extends AbstractFfiConverterByteArray {
+        read(from) {
+            switch (ordinalConverter.read(from)) {
+                case 1: return EmbeddedPermissionMode.Standard;
+                case 2: return EmbeddedPermissionMode.Bounded;
+                case 3: return EmbeddedPermissionMode.Unrestricted;
+                default: throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+        write(value, into) {
+            switch (value) {
+                case EmbeddedPermissionMode.Standard: return ordinalConverter.write(1, into);
+                case EmbeddedPermissionMode.Bounded: return ordinalConverter.write(2, into);
+                case EmbeddedPermissionMode.Unrestricted: return ordinalConverter.write(3, into);
+            }
+        }
+        allocationSize(value) {
+            return ordinalConverter.allocationSize(0);
+        }
+    }
+    return new FFIConverter();
+})();
+/**
+ * Generated factory for {@link EmbeddedDriverHostOptions} record objects.
+ */
+export const EmbeddedDriverHostOptions = (() => {
+    const defaults = () => ({});
+    const create = (() => {
+        return uniffiCreateRecord(defaults);
+    })();
+    return Object.freeze({
+        create,
+        new: create,
+        defaults: () => Object.freeze(defaults()),
+    });
+})();
+const FfiConverterTypeEmbeddedDriverHostOptions = (() => {
+    class FFIConverter extends AbstractFfiConverterByteArray {
+        read(from) {
+            return {
+                binaryPath: FfiConverterString.read(from),
+                hostBundleId: FfiConverterString.read(from),
+                socketPath: FfiConverterOptionalString.read(from),
+                startupTimeoutMs: FfiConverterOptionalUInt64.read(from),
+                shutdownTimeoutMs: FfiConverterOptionalUInt64.read(from),
+                permissionMode: FfiConverterOptionalTypeEmbeddedPermissionMode.read(from),
+                sessionPolicyPath: FfiConverterOptionalString.read(from),
+                approveSessionPolicy: FfiConverterBool.read(from),
+                dangerouslyBypassApprovals: FfiConverterBool.read(from),
+                environment: FfiConverterSequenceTypeEmbeddedEnvironmentVariable.read(from),
+                inheritStderr: FfiConverterBool.read(from)
+            };
+        }
+        write(value, into) {
+            FfiConverterString.write(value.binaryPath, into);
+            FfiConverterString.write(value.hostBundleId, into);
+            FfiConverterOptionalString.write(value.socketPath, into);
+            FfiConverterOptionalUInt64.write(value.startupTimeoutMs, into);
+            FfiConverterOptionalUInt64.write(value.shutdownTimeoutMs, into);
+            FfiConverterOptionalTypeEmbeddedPermissionMode.write(value.permissionMode, into);
+            FfiConverterOptionalString.write(value.sessionPolicyPath, into);
+            FfiConverterBool.write(value.approveSessionPolicy, into);
+            FfiConverterBool.write(value.dangerouslyBypassApprovals, into);
+            FfiConverterSequenceTypeEmbeddedEnvironmentVariable.write(value.environment, into);
+            FfiConverterBool.write(value.inheritStderr, into);
+        }
+        allocationSize(value) {
+            return FfiConverterString.allocationSize(value.binaryPath) +
+                FfiConverterString.allocationSize(value.hostBundleId) +
+                FfiConverterOptionalString.allocationSize(value.socketPath) +
+                FfiConverterOptionalUInt64.allocationSize(value.startupTimeoutMs) +
+                FfiConverterOptionalUInt64.allocationSize(value.shutdownTimeoutMs) +
+                FfiConverterOptionalTypeEmbeddedPermissionMode.allocationSize(value.permissionMode) +
+                FfiConverterOptionalString.allocationSize(value.sessionPolicyPath) +
+                FfiConverterBool.allocationSize(value.approveSessionPolicy) +
+                FfiConverterBool.allocationSize(value.dangerouslyBypassApprovals) +
+                FfiConverterSequenceTypeEmbeddedEnvironmentVariable.allocationSize(value.environment) +
+                FfiConverterBool.allocationSize(value.inheritStderr);
+        }
+    }
+    ;
+    return new FFIConverter();
+})();
+/**
+ * Generated factory for {@link ImageContent} record objects.
+ */
+export const ImageContent = (() => {
+    const defaults = () => ({});
+    const create = (() => {
+        return uniffiCreateRecord(defaults);
+    })();
+    return Object.freeze({
+        create,
+        new: create,
+        defaults: () => Object.freeze(defaults()),
+    });
+})();
+const FfiConverterTypeImageContent = (() => {
+    class FFIConverter extends AbstractFfiConverterByteArray {
+        read(from) {
+            return {
+                mimeType: FfiConverterString.read(from),
+                dataBase64: FfiConverterString.read(from)
+            };
+        }
+        write(value, into) {
+            FfiConverterString.write(value.mimeType, into);
+            FfiConverterString.write(value.dataBase64, into);
+        }
+        allocationSize(value) {
+            return FfiConverterString.allocationSize(value.mimeType) +
+                FfiConverterString.allocationSize(value.dataBase64);
+        }
+    }
+    ;
+    return new FFIConverter();
+})();
+/**
+ * Generated factory for {@link MacOsPermissionStatus} record objects.
+ */
+export const MacOsPermissionStatus = (() => {
+    const defaults = () => ({});
+    const create = (() => {
+        return uniffiCreateRecord(defaults);
+    })();
+    return Object.freeze({
+        create,
+        new: create,
+        defaults: () => Object.freeze(defaults()),
+    });
+})();
+const FfiConverterTypeMacOsPermissionStatus = (() => {
+    class FFIConverter extends AbstractFfiConverterByteArray {
+        read(from) {
+            return {
+                accessibility: FfiConverterBool.read(from),
+                screenRecording: FfiConverterBool.read(from)
+            };
+        }
+        write(value, into) {
+            FfiConverterBool.write(value.accessibility, into);
+            FfiConverterBool.write(value.screenRecording, into);
+        }
+        allocationSize(value) {
+            return FfiConverterBool.allocationSize(value.accessibility) +
+                FfiConverterBool.allocationSize(value.screenRecording);
+        }
+    }
+    ;
+    return new FFIConverter();
+})();
+/**
+ * Generated factory for {@link ToolResult} record objects.
+ */
+export const ToolResult = (() => {
+    const defaults = () => ({});
+    const create = (() => {
+        return uniffiCreateRecord(defaults);
+    })();
+    return Object.freeze({
+        create,
+        new: create,
+        defaults: () => Object.freeze(defaults()),
+    });
+})();
+const FfiConverterTypeToolResult = (() => {
+    class FFIConverter extends AbstractFfiConverterByteArray {
+        read(from) {
+            return {
+                text: FfiConverterString.read(from),
+                images: FfiConverterSequenceTypeImageContent.read(from),
+                structuredJson: FfiConverterOptionalString.read(from),
+                isError: FfiConverterBool.read(from),
+                errorCode: FfiConverterOptionalString.read(from),
+                verified: FfiConverterOptionalBoolean.read(from),
+                degraded: FfiConverterBool.read(from),
+                rawJson: FfiConverterString.read(from)
+            };
+        }
+        write(value, into) {
+            FfiConverterString.write(value.text, into);
+            FfiConverterSequenceTypeImageContent.write(value.images, into);
+            FfiConverterOptionalString.write(value.structuredJson, into);
+            FfiConverterBool.write(value.isError, into);
+            FfiConverterOptionalString.write(value.errorCode, into);
+            FfiConverterOptionalBoolean.write(value.verified, into);
+            FfiConverterBool.write(value.degraded, into);
+            FfiConverterString.write(value.rawJson, into);
+        }
+        allocationSize(value) {
+            return FfiConverterString.allocationSize(value.text) +
+                FfiConverterSequenceTypeImageContent.allocationSize(value.images) +
+                FfiConverterOptionalString.allocationSize(value.structuredJson) +
+                FfiConverterBool.allocationSize(value.isError) +
+                FfiConverterOptionalString.allocationSize(value.errorCode) +
+                FfiConverterOptionalBoolean.allocationSize(value.verified) +
+                FfiConverterBool.allocationSize(value.degraded) +
+                FfiConverterString.allocationSize(value.rawJson);
+        }
+    }
+    ;
+    return new FFIConverter();
+})();
+// Error type: DriverError
+export var DriverError_Tags;
+(function (DriverError_Tags) {
+    DriverError_Tags["Configuration"] = "Configuration";
+    DriverError_Tags["InvalidArguments"] = "InvalidArguments";
+    DriverError_Tags["Transport"] = "Transport";
+    DriverError_Tags["Protocol"] = "Protocol";
+    DriverError_Tags["Tool"] = "Tool";
+})(DriverError_Tags || (DriverError_Tags = {}));
+export const DriverError = (() => {
+    class Configuration_ extends UniffiError {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        [uniffiTypeNameSymbol] = "DriverError";
+        tag = DriverError_Tags.Configuration;
+        inner;
+        constructor(inner) {
+            super("DriverError", "Configuration");
+            this.inner = Object.freeze(inner);
+        }
+        static new(inner) {
+            return new Configuration_(inner);
+        }
+        static instanceOf(obj) {
+            return obj.tag === DriverError_Tags.Configuration;
+        }
+        static hasInner(obj) {
+            return Configuration_.instanceOf(obj);
+        }
+        static getInner(obj) {
+            return obj.inner;
+        }
+    }
+    class InvalidArguments_ extends UniffiError {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        [uniffiTypeNameSymbol] = "DriverError";
+        tag = DriverError_Tags.InvalidArguments;
+        inner;
+        constructor(inner) {
+            super("DriverError", "InvalidArguments");
+            this.inner = Object.freeze(inner);
+        }
+        static new(inner) {
+            return new InvalidArguments_(inner);
+        }
+        static instanceOf(obj) {
+            return obj.tag === DriverError_Tags.InvalidArguments;
+        }
+        static hasInner(obj) {
+            return InvalidArguments_.instanceOf(obj);
+        }
+        static getInner(obj) {
+            return obj.inner;
+        }
+    }
+    class Transport_ extends UniffiError {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        [uniffiTypeNameSymbol] = "DriverError";
+        tag = DriverError_Tags.Transport;
+        inner;
+        constructor(inner) {
+            super("DriverError", "Transport");
+            this.inner = Object.freeze(inner);
+        }
+        static new(inner) {
+            return new Transport_(inner);
+        }
+        static instanceOf(obj) {
+            return obj.tag === DriverError_Tags.Transport;
+        }
+        static hasInner(obj) {
+            return Transport_.instanceOf(obj);
+        }
+        static getInner(obj) {
+            return obj.inner;
+        }
+    }
+    class Protocol_ extends UniffiError {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        [uniffiTypeNameSymbol] = "DriverError";
+        tag = DriverError_Tags.Protocol;
+        inner;
+        constructor(inner) {
+            super("DriverError", "Protocol");
+            this.inner = Object.freeze(inner);
+        }
+        static new(inner) {
+            return new Protocol_(inner);
+        }
+        static instanceOf(obj) {
+            return obj.tag === DriverError_Tags.Protocol;
+        }
+        static hasInner(obj) {
+            return Protocol_.instanceOf(obj);
+        }
+        static getInner(obj) {
+            return obj.inner;
+        }
+    }
+    class Tool_ extends UniffiError {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        [uniffiTypeNameSymbol] = "DriverError";
+        tag = DriverError_Tags.Tool;
+        inner;
+        constructor(inner) {
+            super("DriverError", "Tool");
+            this.inner = Object.freeze(inner);
+        }
+        static new(inner) {
+            return new Tool_(inner);
+        }
+        static instanceOf(obj) {
+            return obj.tag === DriverError_Tags.Tool;
+        }
+        static hasInner(obj) {
+            return Tool_.instanceOf(obj);
+        }
+        static getInner(obj) {
+            return obj.inner;
+        }
+    }
+    function instanceOf(obj) {
+        return obj[uniffiTypeNameSymbol] === "DriverError";
+    }
+    return Object.freeze({
+        instanceOf,
+        Configuration: Configuration_,
+        InvalidArguments: InvalidArguments_,
+        Transport: Transport_,
+        Protocol: Protocol_,
+        Tool: Tool_
+    });
+})();
+// FfiConverter for enum DriverError
+const FfiConverterTypeDriverError = (() => {
+    const ordinalConverter = FfiConverterInt32;
+    class FFIConverter extends AbstractFfiConverterByteArray {
+        read(from) {
+            switch (ordinalConverter.read(from)) {
+                case 1: return new DriverError.Configuration({ reason: FfiConverterString.read(from) });
+                case 2: return new DriverError.InvalidArguments({ tool: FfiConverterString.read(from), reason: FfiConverterString.read(from) });
+                case 3: return new DriverError.Transport({ socketPath: FfiConverterString.read(from), reason: FfiConverterString.read(from) });
+                case 4: return new DriverError.Protocol({ reason: FfiConverterString.read(from) });
+                case 5: return new DriverError.Tool({ tool: FfiConverterString.read(from), message: FfiConverterString.read(from), errorCode: FfiConverterString.read(from) });
+                default: throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+        write(value, into) {
+            switch (value.tag) {
+                case DriverError_Tags.Configuration: {
+                    ordinalConverter.write(1, into);
+                    const inner = value.inner;
+                    FfiConverterString.write(inner.reason, into);
+                    return;
+                }
+                case DriverError_Tags.InvalidArguments: {
+                    ordinalConverter.write(2, into);
+                    const inner = value.inner;
+                    FfiConverterString.write(inner.tool, into);
+                    FfiConverterString.write(inner.reason, into);
+                    return;
+                }
+                case DriverError_Tags.Transport: {
+                    ordinalConverter.write(3, into);
+                    const inner = value.inner;
+                    FfiConverterString.write(inner.socketPath, into);
+                    FfiConverterString.write(inner.reason, into);
+                    return;
+                }
+                case DriverError_Tags.Protocol: {
+                    ordinalConverter.write(4, into);
+                    const inner = value.inner;
+                    FfiConverterString.write(inner.reason, into);
+                    return;
+                }
+                case DriverError_Tags.Tool: {
+                    ordinalConverter.write(5, into);
+                    const inner = value.inner;
+                    FfiConverterString.write(inner.tool, into);
+                    FfiConverterString.write(inner.message, into);
+                    FfiConverterString.write(inner.errorCode, into);
+                    return;
+                }
+                default:
+                    // Throwing from here means that DriverError_Tags hasn't matched an ordinal.
+                    throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+        allocationSize(value) {
+            switch (value.tag) {
+                case DriverError_Tags.Configuration: {
+                    const inner = value.inner;
+                    let size = ordinalConverter.allocationSize(1);
+                    size += FfiConverterString.allocationSize(inner.reason);
+                    return size;
+                }
+                case DriverError_Tags.InvalidArguments: {
+                    const inner = value.inner;
+                    let size = ordinalConverter.allocationSize(2);
+                    size += FfiConverterString.allocationSize(inner.tool);
+                    size += FfiConverterString.allocationSize(inner.reason);
+                    return size;
+                }
+                case DriverError_Tags.Transport: {
+                    const inner = value.inner;
+                    let size = ordinalConverter.allocationSize(3);
+                    size += FfiConverterString.allocationSize(inner.socketPath);
+                    size += FfiConverterString.allocationSize(inner.reason);
+                    return size;
+                }
+                case DriverError_Tags.Protocol: {
+                    const inner = value.inner;
+                    let size = ordinalConverter.allocationSize(4);
+                    size += FfiConverterString.allocationSize(inner.reason);
+                    return size;
+                }
+                case DriverError_Tags.Tool: {
+                    const inner = value.inner;
+                    let size = ordinalConverter.allocationSize(5);
+                    size += FfiConverterString.allocationSize(inner.tool);
+                    size += FfiConverterString.allocationSize(inner.message);
+                    size += FfiConverterString.allocationSize(inner.errorCode);
+                    return size;
+                }
+                default: throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+    }
+    return new FFIConverter();
+})();
+// Error type: EmbeddedDriverError
+export var EmbeddedDriverError_Tags;
+(function (EmbeddedDriverError_Tags) {
+    EmbeddedDriverError_Tags["Configuration"] = "Configuration";
+    EmbeddedDriverError_Tags["EndpointConflict"] = "EndpointConflict";
+    EmbeddedDriverError_Tags["Spawn"] = "Spawn";
+    EmbeddedDriverError_Tags["StartupCancelled"] = "StartupCancelled";
+    EmbeddedDriverError_Tags["StartupTimeout"] = "StartupTimeout";
+    EmbeddedDriverError_Tags["ExitedBeforeReady"] = "ExitedBeforeReady";
+    EmbeddedDriverError_Tags["IncompatibleDaemon"] = "IncompatibleDaemon";
+    EmbeddedDriverError_Tags["Lifecycle"] = "Lifecycle";
+})(EmbeddedDriverError_Tags || (EmbeddedDriverError_Tags = {}));
+export const EmbeddedDriverError = (() => {
+    class Configuration_ extends UniffiError {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        [uniffiTypeNameSymbol] = "EmbeddedDriverError";
+        tag = EmbeddedDriverError_Tags.Configuration;
+        inner;
+        constructor(inner) {
+            super("EmbeddedDriverError", "Configuration");
+            this.inner = Object.freeze(inner);
+        }
+        static new(inner) {
+            return new Configuration_(inner);
+        }
+        static instanceOf(obj) {
+            return obj.tag === EmbeddedDriverError_Tags.Configuration;
+        }
+        static hasInner(obj) {
+            return Configuration_.instanceOf(obj);
+        }
+        static getInner(obj) {
+            return obj.inner;
+        }
+    }
+    class EndpointConflict_ extends UniffiError {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        [uniffiTypeNameSymbol] = "EmbeddedDriverError";
+        tag = EmbeddedDriverError_Tags.EndpointConflict;
+        inner;
+        constructor(inner) {
+            super("EmbeddedDriverError", "EndpointConflict");
+            this.inner = Object.freeze(inner);
+        }
+        static new(inner) {
+            return new EndpointConflict_(inner);
+        }
+        static instanceOf(obj) {
+            return obj.tag === EmbeddedDriverError_Tags.EndpointConflict;
+        }
+        static hasInner(obj) {
+            return EndpointConflict_.instanceOf(obj);
+        }
+        static getInner(obj) {
+            return obj.inner;
+        }
+    }
+    class Spawn_ extends UniffiError {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        [uniffiTypeNameSymbol] = "EmbeddedDriverError";
+        tag = EmbeddedDriverError_Tags.Spawn;
+        inner;
+        constructor(inner) {
+            super("EmbeddedDriverError", "Spawn");
+            this.inner = Object.freeze(inner);
+        }
+        static new(inner) {
+            return new Spawn_(inner);
+        }
+        static instanceOf(obj) {
+            return obj.tag === EmbeddedDriverError_Tags.Spawn;
+        }
+        static hasInner(obj) {
+            return Spawn_.instanceOf(obj);
+        }
+        static getInner(obj) {
+            return obj.inner;
+        }
+    }
+    class StartupCancelled_ extends UniffiError {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        [uniffiTypeNameSymbol] = "EmbeddedDriverError";
+        tag = EmbeddedDriverError_Tags.StartupCancelled;
+        constructor() {
+            super("EmbeddedDriverError", "StartupCancelled");
+        }
+        static new() {
+            return new StartupCancelled_();
+        }
+        static instanceOf(obj) {
+            return obj.tag === EmbeddedDriverError_Tags.StartupCancelled;
+        }
+        static hasInner(obj) {
+            return false;
+        }
+    }
+    class StartupTimeout_ extends UniffiError {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        [uniffiTypeNameSymbol] = "EmbeddedDriverError";
+        tag = EmbeddedDriverError_Tags.StartupTimeout;
+        inner;
+        constructor(inner) {
+            super("EmbeddedDriverError", "StartupTimeout");
+            this.inner = Object.freeze(inner);
+        }
+        static new(inner) {
+            return new StartupTimeout_(inner);
+        }
+        static instanceOf(obj) {
+            return obj.tag === EmbeddedDriverError_Tags.StartupTimeout;
+        }
+        static hasInner(obj) {
+            return StartupTimeout_.instanceOf(obj);
+        }
+        static getInner(obj) {
+            return obj.inner;
+        }
+    }
+    class ExitedBeforeReady_ extends UniffiError {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        [uniffiTypeNameSymbol] = "EmbeddedDriverError";
+        tag = EmbeddedDriverError_Tags.ExitedBeforeReady;
+        inner;
+        constructor(inner) {
+            super("EmbeddedDriverError", "ExitedBeforeReady");
+            this.inner = Object.freeze(inner);
+        }
+        static new(inner) {
+            return new ExitedBeforeReady_(inner);
+        }
+        static instanceOf(obj) {
+            return obj.tag === EmbeddedDriverError_Tags.ExitedBeforeReady;
+        }
+        static hasInner(obj) {
+            return ExitedBeforeReady_.instanceOf(obj);
+        }
+        static getInner(obj) {
+            return obj.inner;
+        }
+    }
+    class IncompatibleDaemon_ extends UniffiError {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        [uniffiTypeNameSymbol] = "EmbeddedDriverError";
+        tag = EmbeddedDriverError_Tags.IncompatibleDaemon;
+        inner;
+        constructor(inner) {
+            super("EmbeddedDriverError", "IncompatibleDaemon");
+            this.inner = Object.freeze(inner);
+        }
+        static new(inner) {
+            return new IncompatibleDaemon_(inner);
+        }
+        static instanceOf(obj) {
+            return obj.tag === EmbeddedDriverError_Tags.IncompatibleDaemon;
+        }
+        static hasInner(obj) {
+            return IncompatibleDaemon_.instanceOf(obj);
+        }
+        static getInner(obj) {
+            return obj.inner;
+        }
+    }
+    class Lifecycle_ extends UniffiError {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        [uniffiTypeNameSymbol] = "EmbeddedDriverError";
+        tag = EmbeddedDriverError_Tags.Lifecycle;
+        inner;
+        constructor(inner) {
+            super("EmbeddedDriverError", "Lifecycle");
+            this.inner = Object.freeze(inner);
+        }
+        static new(inner) {
+            return new Lifecycle_(inner);
+        }
+        static instanceOf(obj) {
+            return obj.tag === EmbeddedDriverError_Tags.Lifecycle;
+        }
+        static hasInner(obj) {
+            return Lifecycle_.instanceOf(obj);
+        }
+        static getInner(obj) {
+            return obj.inner;
+        }
+    }
+    function instanceOf(obj) {
+        return obj[uniffiTypeNameSymbol] === "EmbeddedDriverError";
+    }
+    return Object.freeze({
+        instanceOf,
+        Configuration: Configuration_,
+        EndpointConflict: EndpointConflict_,
+        Spawn: Spawn_,
+        StartupCancelled: StartupCancelled_,
+        StartupTimeout: StartupTimeout_,
+        ExitedBeforeReady: ExitedBeforeReady_,
+        IncompatibleDaemon: IncompatibleDaemon_,
+        Lifecycle: Lifecycle_
+    });
+})();
+// FfiConverter for enum EmbeddedDriverError
+const FfiConverterTypeEmbeddedDriverError = (() => {
+    const ordinalConverter = FfiConverterInt32;
+    class FFIConverter extends AbstractFfiConverterByteArray {
+        read(from) {
+            switch (ordinalConverter.read(from)) {
+                case 1: return new EmbeddedDriverError.Configuration({ reason: FfiConverterString.read(from) });
+                case 2: return new EmbeddedDriverError.EndpointConflict({ path: FfiConverterString.read(from), reason: FfiConverterString.read(from) });
+                case 3: return new EmbeddedDriverError.Spawn({ binaryPath: FfiConverterString.read(from), reason: FfiConverterString.read(from) });
+                case 4: return new EmbeddedDriverError.StartupCancelled();
+                case 5: return new EmbeddedDriverError.StartupTimeout({ timeoutMs: FfiConverterUInt64.read(from) });
+                case 6: return new EmbeddedDriverError.ExitedBeforeReady({ code: FfiConverterOptionalInt32.read(from) });
+                case 7: return new EmbeddedDriverError.IncompatibleDaemon({ reason: FfiConverterString.read(from) });
+                case 8: return new EmbeddedDriverError.Lifecycle({ reason: FfiConverterString.read(from) });
+                default: throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+        write(value, into) {
+            switch (value.tag) {
+                case EmbeddedDriverError_Tags.Configuration: {
+                    ordinalConverter.write(1, into);
+                    const inner = value.inner;
+                    FfiConverterString.write(inner.reason, into);
+                    return;
+                }
+                case EmbeddedDriverError_Tags.EndpointConflict: {
+                    ordinalConverter.write(2, into);
+                    const inner = value.inner;
+                    FfiConverterString.write(inner.path, into);
+                    FfiConverterString.write(inner.reason, into);
+                    return;
+                }
+                case EmbeddedDriverError_Tags.Spawn: {
+                    ordinalConverter.write(3, into);
+                    const inner = value.inner;
+                    FfiConverterString.write(inner.binaryPath, into);
+                    FfiConverterString.write(inner.reason, into);
+                    return;
+                }
+                case EmbeddedDriverError_Tags.StartupCancelled: {
+                    ordinalConverter.write(4, into);
+                    return;
+                }
+                case EmbeddedDriverError_Tags.StartupTimeout: {
+                    ordinalConverter.write(5, into);
+                    const inner = value.inner;
+                    FfiConverterUInt64.write(inner.timeoutMs, into);
+                    return;
+                }
+                case EmbeddedDriverError_Tags.ExitedBeforeReady: {
+                    ordinalConverter.write(6, into);
+                    const inner = value.inner;
+                    FfiConverterOptionalInt32.write(inner.code, into);
+                    return;
+                }
+                case EmbeddedDriverError_Tags.IncompatibleDaemon: {
+                    ordinalConverter.write(7, into);
+                    const inner = value.inner;
+                    FfiConverterString.write(inner.reason, into);
+                    return;
+                }
+                case EmbeddedDriverError_Tags.Lifecycle: {
+                    ordinalConverter.write(8, into);
+                    const inner = value.inner;
+                    FfiConverterString.write(inner.reason, into);
+                    return;
+                }
+                default:
+                    // Throwing from here means that EmbeddedDriverError_Tags hasn't matched an ordinal.
+                    throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+        allocationSize(value) {
+            switch (value.tag) {
+                case EmbeddedDriverError_Tags.Configuration: {
+                    const inner = value.inner;
+                    let size = ordinalConverter.allocationSize(1);
+                    size += FfiConverterString.allocationSize(inner.reason);
+                    return size;
+                }
+                case EmbeddedDriverError_Tags.EndpointConflict: {
+                    const inner = value.inner;
+                    let size = ordinalConverter.allocationSize(2);
+                    size += FfiConverterString.allocationSize(inner.path);
+                    size += FfiConverterString.allocationSize(inner.reason);
+                    return size;
+                }
+                case EmbeddedDriverError_Tags.Spawn: {
+                    const inner = value.inner;
+                    let size = ordinalConverter.allocationSize(3);
+                    size += FfiConverterString.allocationSize(inner.binaryPath);
+                    size += FfiConverterString.allocationSize(inner.reason);
+                    return size;
+                }
+                case EmbeddedDriverError_Tags.StartupCancelled: {
+                    return ordinalConverter.allocationSize(4);
+                }
+                case EmbeddedDriverError_Tags.StartupTimeout: {
+                    const inner = value.inner;
+                    let size = ordinalConverter.allocationSize(5);
+                    size += FfiConverterUInt64.allocationSize(inner.timeoutMs);
+                    return size;
+                }
+                case EmbeddedDriverError_Tags.ExitedBeforeReady: {
+                    const inner = value.inner;
+                    let size = ordinalConverter.allocationSize(6);
+                    size += FfiConverterOptionalInt32.allocationSize(inner.code);
+                    return size;
+                }
+                case EmbeddedDriverError_Tags.IncompatibleDaemon: {
+                    const inner = value.inner;
+                    let size = ordinalConverter.allocationSize(7);
+                    size += FfiConverterString.allocationSize(inner.reason);
+                    return size;
+                }
+                case EmbeddedDriverError_Tags.Lifecycle: {
+                    const inner = value.inner;
+                    let size = ordinalConverter.allocationSize(8);
+                    size += FfiConverterString.allocationSize(inner.reason);
+                    return size;
+                }
+                default: throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+    }
+    return new FFIConverter();
+})();
+export var EmbeddedDriverHostState;
+(function (EmbeddedDriverHostState) {
+    EmbeddedDriverHostState[EmbeddedDriverHostState["Stopped"] = 0] = "Stopped";
+    EmbeddedDriverHostState[EmbeddedDriverHostState["Starting"] = 1] = "Starting";
+    EmbeddedDriverHostState[EmbeddedDriverHostState["Ready"] = 2] = "Ready";
+    EmbeddedDriverHostState[EmbeddedDriverHostState["Stopping"] = 3] = "Stopping";
+})(EmbeddedDriverHostState || (EmbeddedDriverHostState = {}));
+const FfiConverterTypeEmbeddedDriverHostState = (() => {
+    const ordinalConverter = FfiConverterInt32;
+    class FFIConverter extends AbstractFfiConverterByteArray {
+        read(from) {
+            switch (ordinalConverter.read(from)) {
+                case 1: return EmbeddedDriverHostState.Stopped;
+                case 2: return EmbeddedDriverHostState.Starting;
+                case 3: return EmbeddedDriverHostState.Ready;
+                case 4: return EmbeddedDriverHostState.Stopping;
+                default: throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+        write(value, into) {
+            switch (value) {
+                case EmbeddedDriverHostState.Stopped: return ordinalConverter.write(1, into);
+                case EmbeddedDriverHostState.Starting: return ordinalConverter.write(2, into);
+                case EmbeddedDriverHostState.Ready: return ordinalConverter.write(3, into);
+                case EmbeddedDriverHostState.Stopping: return ordinalConverter.write(4, into);
+            }
+        }
+        allocationSize(value) {
+            return ordinalConverter.allocationSize(0);
+        }
+    }
+    return new FFIConverter();
+})();
+export class CuaDriver extends UniffiAbstractObject {
+    [uniffiTypeNameSymbol] = "CuaDriver";
+    [destructorGuardSymbol];
+    [pointerLiteralSymbol];
+    // No primary constructor declared for this class.
+    constructor(pointer) {
+        super();
+        this[pointerLiteralSymbol] = pointer;
+        this[destructorGuardSymbol] = uniffiTypeCuaDriverObjectFactory.bless(pointer);
+    }
+    /**
+     * Connect to the default installed daemon or an explicitly selected socket.
+     * Construction does not launch a process or perform I/O.
+     */
+    static connect(socketPath) {
+        return FfiConverterTypeCuaDriver.lift(uniffiCaller.rustCallWithError(
+        /*liftError:*/ FfiConverterTypeDriverError.lift.bind(FfiConverterTypeDriverError), 
+        /*caller:*/ (callStatus) => {
+            return nativeModule().uniffi_cua_driver_sdk_fn_constructor_cuadriver_connect(FfiConverterOptionalString.lower(socketPath, nativeModule().rustbuffer_alloc), callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)));
+    }
+    /**
+     * Escape hatch for forward-compatible tools and application-owned server
+     * adapters. Typed methods below serialize the same canonical Rust inputs.
+     */
+    callTool(name, argumentsJson) {
+        return ((__rb) => {
+            try {
+                return FfiConverterTypeToolResult.lift(__rb);
+            }
+            finally {
+                nativeModule().rustbuffer_free(__rb);
+            }
+        })(uniffiCaller.rustCallWithError(
+        /*liftError:*/ FfiConverterTypeDriverError.lift.bind(FfiConverterTypeDriverError), 
+        /*caller:*/ (callStatus) => {
+            return nativeModule().uniffi_cua_driver_sdk_fn_method_cuadriver_call_tool(uniffiTypeCuaDriverObjectFactory.clonePointer(this), FfiConverterString.lower(name, nativeModule().rustbuffer_alloc), FfiConverterString.lower(argumentsJson, nativeModule().rustbuffer_alloc), callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)));
+    }
+    click(input) {
+        return ((__rb) => {
+            try {
+                return FfiConverterTypeToolResult.lift(__rb);
+            }
+            finally {
+                nativeModule().rustbuffer_free(__rb);
+            }
+        })(uniffiCaller.rustCallWithError(
+        /*liftError:*/ FfiConverterTypeDriverError.lift.bind(FfiConverterTypeDriverError), 
+        /*caller:*/ (callStatus) => {
+            return nativeModule().uniffi_cua_driver_sdk_fn_method_cuadriver_click(uniffiTypeCuaDriverObjectFactory.clonePointer(this), FfiConverterTypeClickInput.lower(input, nativeModule().rustbuffer_alloc), callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)));
+    }
+    drag(input) {
+        return ((__rb) => {
+            try {
+                return FfiConverterTypeToolResult.lift(__rb);
+            }
+            finally {
+                nativeModule().rustbuffer_free(__rb);
+            }
+        })(uniffiCaller.rustCallWithError(
+        /*liftError:*/ FfiConverterTypeDriverError.lift.bind(FfiConverterTypeDriverError), 
+        /*caller:*/ (callStatus) => {
+            return nativeModule().uniffi_cua_driver_sdk_fn_method_cuadriver_drag(uniffiTypeCuaDriverObjectFactory.clonePointer(this), FfiConverterTypeDragInput.lower(input, nativeModule().rustbuffer_alloc), callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)));
+    }
+    endSession(input) {
+        return ((__rb) => {
+            try {
+                return FfiConverterTypeEndSessionOutput.lift(__rb);
+            }
+            finally {
+                nativeModule().rustbuffer_free(__rb);
+            }
+        })(uniffiCaller.rustCallWithError(
+        /*liftError:*/ FfiConverterTypeDriverError.lift.bind(FfiConverterTypeDriverError), 
+        /*caller:*/ (callStatus) => {
+            return nativeModule().uniffi_cua_driver_sdk_fn_method_cuadriver_end_session(uniffiTypeCuaDriverObjectFactory.clonePointer(this), FfiConverterTypeEndSessionInput.lower(input, nativeModule().rustbuffer_alloc), callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)));
+    }
+    escalateSession(input) {
+        return ((__rb) => {
+            try {
+                return FfiConverterTypeSessionStateOutput.lift(__rb);
+            }
+            finally {
+                nativeModule().rustbuffer_free(__rb);
+            }
+        })(uniffiCaller.rustCallWithError(
+        /*liftError:*/ FfiConverterTypeDriverError.lift.bind(FfiConverterTypeDriverError), 
+        /*caller:*/ (callStatus) => {
+            return nativeModule().uniffi_cua_driver_sdk_fn_method_cuadriver_escalate_session(uniffiTypeCuaDriverObjectFactory.clonePointer(this), FfiConverterTypeEscalateSessionInput.lower(input, nativeModule().rustbuffer_alloc), callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)));
+    }
+    getCursorPosition(input) {
+        return ((__rb) => {
+            try {
+                return FfiConverterTypeToolResult.lift(__rb);
+            }
+            finally {
+                nativeModule().rustbuffer_free(__rb);
+            }
+        })(uniffiCaller.rustCallWithError(
+        /*liftError:*/ FfiConverterTypeDriverError.lift.bind(FfiConverterTypeDriverError), 
+        /*caller:*/ (callStatus) => {
+            return nativeModule().uniffi_cua_driver_sdk_fn_method_cuadriver_get_cursor_position(uniffiTypeCuaDriverObjectFactory.clonePointer(this), FfiConverterTypeGetCursorPositionInput.lower(input, nativeModule().rustbuffer_alloc), callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)));
+    }
+    getDesktopState(input) {
+        return ((__rb) => {
+            try {
+                return FfiConverterTypeToolResult.lift(__rb);
+            }
+            finally {
+                nativeModule().rustbuffer_free(__rb);
+            }
+        })(uniffiCaller.rustCallWithError(
+        /*liftError:*/ FfiConverterTypeDriverError.lift.bind(FfiConverterTypeDriverError), 
+        /*caller:*/ (callStatus) => {
+            return nativeModule().uniffi_cua_driver_sdk_fn_method_cuadriver_get_desktop_state(uniffiTypeCuaDriverObjectFactory.clonePointer(this), FfiConverterTypeGetDesktopStateInput.lower(input, nativeModule().rustbuffer_alloc), callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)));
+    }
+    getScreenSize(input) {
+        return ((__rb) => {
+            try {
+                return FfiConverterTypeToolResult.lift(__rb);
+            }
+            finally {
+                nativeModule().rustbuffer_free(__rb);
+            }
+        })(uniffiCaller.rustCallWithError(
+        /*liftError:*/ FfiConverterTypeDriverError.lift.bind(FfiConverterTypeDriverError), 
+        /*caller:*/ (callStatus) => {
+            return nativeModule().uniffi_cua_driver_sdk_fn_method_cuadriver_get_screen_size(uniffiTypeCuaDriverObjectFactory.clonePointer(this), FfiConverterTypeGetScreenSizeInput.lower(input, nativeModule().rustbuffer_alloc), callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)));
+    }
+    getSessionState(input) {
+        return ((__rb) => {
+            try {
+                return FfiConverterTypeSessionStateOutput.lift(__rb);
+            }
+            finally {
+                nativeModule().rustbuffer_free(__rb);
+            }
+        })(uniffiCaller.rustCallWithError(
+        /*liftError:*/ FfiConverterTypeDriverError.lift.bind(FfiConverterTypeDriverError), 
+        /*caller:*/ (callStatus) => {
+            return nativeModule().uniffi_cua_driver_sdk_fn_method_cuadriver_get_session_state(uniffiTypeCuaDriverObjectFactory.clonePointer(this), FfiConverterTypeGetSessionStateInput.lower(input, nativeModule().rustbuffer_alloc), callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)));
+    }
+    hotkey(input) {
+        return ((__rb) => {
+            try {
+                return FfiConverterTypeToolResult.lift(__rb);
+            }
+            finally {
+                nativeModule().rustbuffer_free(__rb);
+            }
+        })(uniffiCaller.rustCallWithError(
+        /*liftError:*/ FfiConverterTypeDriverError.lift.bind(FfiConverterTypeDriverError), 
+        /*caller:*/ (callStatus) => {
+            return nativeModule().uniffi_cua_driver_sdk_fn_method_cuadriver_hotkey(uniffiTypeCuaDriverObjectFactory.clonePointer(this), FfiConverterTypeHotkeyInput.lower(input, nativeModule().rustbuffer_alloc), callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)));
+    }
+    isAvailable() {
+        return FfiConverterBool.lift(uniffiCaller.rustCall(
+        /*caller:*/ (callStatus) => {
+            return nativeModule().uniffi_cua_driver_sdk_fn_method_cuadriver_is_available(uniffiTypeCuaDriverObjectFactory.clonePointer(this), callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)));
+    }
+    listToolsJson() {
+        return ((__rb) => {
+            try {
+                return FfiConverterString.lift(__rb);
+            }
+            finally {
+                nativeModule().rustbuffer_free(__rb);
+            }
+        })(uniffiCaller.rustCallWithError(
+        /*liftError:*/ FfiConverterTypeDriverError.lift.bind(FfiConverterTypeDriverError), 
+        /*caller:*/ (callStatus) => {
+            return nativeModule().uniffi_cua_driver_sdk_fn_method_cuadriver_list_tools_json(uniffiTypeCuaDriverObjectFactory.clonePointer(this), callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)));
+    }
+    metadata() {
+        return ((__rb) => {
+            try {
+                return FfiConverterTypeDriverMetadata.lift(__rb);
+            }
+            finally {
+                nativeModule().rustbuffer_free(__rb);
+            }
+        })(uniffiCaller.rustCallWithError(
+        /*liftError:*/ FfiConverterTypeDriverError.lift.bind(FfiConverterTypeDriverError), 
+        /*caller:*/ (callStatus) => {
+            return nativeModule().uniffi_cua_driver_sdk_fn_method_cuadriver_metadata(uniffiTypeCuaDriverObjectFactory.clonePointer(this), callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)));
+    }
+    moveCursor(input) {
+        return ((__rb) => {
+            try {
+                return FfiConverterTypeToolResult.lift(__rb);
+            }
+            finally {
+                nativeModule().rustbuffer_free(__rb);
+            }
+        })(uniffiCaller.rustCallWithError(
+        /*liftError:*/ FfiConverterTypeDriverError.lift.bind(FfiConverterTypeDriverError), 
+        /*caller:*/ (callStatus) => {
+            return nativeModule().uniffi_cua_driver_sdk_fn_method_cuadriver_move_cursor(uniffiTypeCuaDriverObjectFactory.clonePointer(this), FfiConverterTypeMoveCursorInput.lower(input, nativeModule().rustbuffer_alloc), callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)));
+    }
+    pressKey(input) {
+        return ((__rb) => {
+            try {
+                return FfiConverterTypeToolResult.lift(__rb);
+            }
+            finally {
+                nativeModule().rustbuffer_free(__rb);
+            }
+        })(uniffiCaller.rustCallWithError(
+        /*liftError:*/ FfiConverterTypeDriverError.lift.bind(FfiConverterTypeDriverError), 
+        /*caller:*/ (callStatus) => {
+            return nativeModule().uniffi_cua_driver_sdk_fn_method_cuadriver_press_key(uniffiTypeCuaDriverObjectFactory.clonePointer(this), FfiConverterTypePressKeyInput.lower(input, nativeModule().rustbuffer_alloc), callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)));
+    }
+    scroll(input) {
+        return ((__rb) => {
+            try {
+                return FfiConverterTypeToolResult.lift(__rb);
+            }
+            finally {
+                nativeModule().rustbuffer_free(__rb);
+            }
+        })(uniffiCaller.rustCallWithError(
+        /*liftError:*/ FfiConverterTypeDriverError.lift.bind(FfiConverterTypeDriverError), 
+        /*caller:*/ (callStatus) => {
+            return nativeModule().uniffi_cua_driver_sdk_fn_method_cuadriver_scroll(uniffiTypeCuaDriverObjectFactory.clonePointer(this), FfiConverterTypeScrollInput.lower(input, nativeModule().rustbuffer_alloc), callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)));
+    }
+    socketPath() {
+        return ((__rb) => {
+            try {
+                return FfiConverterString.lift(__rb);
+            }
+            finally {
+                nativeModule().rustbuffer_free(__rb);
+            }
+        })(uniffiCaller.rustCall(
+        /*caller:*/ (callStatus) => {
+            return nativeModule().uniffi_cua_driver_sdk_fn_method_cuadriver_socket_path(uniffiTypeCuaDriverObjectFactory.clonePointer(this), callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)));
+    }
+    startSession(input) {
+        return ((__rb) => {
+            try {
+                return FfiConverterTypeStartSessionOutput.lift(__rb);
+            }
+            finally {
+                nativeModule().rustbuffer_free(__rb);
+            }
+        })(uniffiCaller.rustCallWithError(
+        /*liftError:*/ FfiConverterTypeDriverError.lift.bind(FfiConverterTypeDriverError), 
+        /*caller:*/ (callStatus) => {
+            return nativeModule().uniffi_cua_driver_sdk_fn_method_cuadriver_start_session(uniffiTypeCuaDriverObjectFactory.clonePointer(this), FfiConverterTypeStartSessionInput.lower(input, nativeModule().rustbuffer_alloc), callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)));
+    }
+    typeText(input) {
+        return ((__rb) => {
+            try {
+                return FfiConverterTypeToolResult.lift(__rb);
+            }
+            finally {
+                nativeModule().rustbuffer_free(__rb);
+            }
+        })(uniffiCaller.rustCallWithError(
+        /*liftError:*/ FfiConverterTypeDriverError.lift.bind(FfiConverterTypeDriverError), 
+        /*caller:*/ (callStatus) => {
+            return nativeModule().uniffi_cua_driver_sdk_fn_method_cuadriver_type_text(uniffiTypeCuaDriverObjectFactory.clonePointer(this), FfiConverterTypeTypeTextInput.lower(input, nativeModule().rustbuffer_alloc), callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)));
+    }
+    uniffiDestroy() {
+        const ptr = this[destructorGuardSymbol];
+        if (ptr !== undefined) {
+            const pointer = uniffiTypeCuaDriverObjectFactory.pointer(this);
+            uniffiTypeCuaDriverObjectFactory.freePointer(pointer);
+            uniffiTypeCuaDriverObjectFactory.unbless(ptr);
+            delete this[destructorGuardSymbol];
+        }
+    }
+    static instanceOf(obj_) {
+        return uniffiTypeCuaDriverObjectFactory.isConcreteType(obj_);
+    }
+}
+const uniffiTypeCuaDriverObjectFactory = (() => {
+    /// <reference lib="es2021" />
+    const registry = typeof FinalizationRegistry !== 'undefined' ? new FinalizationRegistry((heldValue) => {
+        uniffiTypeCuaDriverObjectFactory.freePointer(heldValue);
+    }) : null;
+    return {
+        create(pointer) {
+            const instance = Object.create(CuaDriver.prototype);
+            instance[pointerLiteralSymbol] = pointer;
+            instance[destructorGuardSymbol] = this.bless(pointer);
+            instance[uniffiTypeNameSymbol] = "CuaDriver";
+            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().uniffi_cua_driver_sdk_fn_clone_cuadriver(pointer, callStatus), 
+            /*liftString:*/ FfiConverterString.lift);
+        },
+        freePointer(pointer) {
+            uniffiCaller.rustCall(
+            /*caller:*/ (callStatus) => nativeModule().uniffi_cua_driver_sdk_fn_free_cuadriver(pointer, callStatus), 
+            /*liftString:*/ FfiConverterString.lift);
+        },
+        isConcreteType(obj_) {
+            return obj_[destructorGuardSymbol] && obj_[uniffiTypeNameSymbol] === "CuaDriver";
+        },
+    };
+})();
+const FfiConverterTypeCuaDriver = new FfiConverterObject(uniffiTypeCuaDriverObjectFactory);
+export class EmbeddedCuaDriverHost extends UniffiAbstractObject {
+    [uniffiTypeNameSymbol] = "EmbeddedCuaDriverHost";
+    [destructorGuardSymbol];
+    [pointerLiteralSymbol];
+    constructor(binaryPath, hostBundleId) {
+        super();
+        const pointer = uniffiCaller.rustCallWithError(
+        /*liftError:*/ FfiConverterTypeEmbeddedDriverError.lift.bind(FfiConverterTypeEmbeddedDriverError), 
+        /*caller:*/ (callStatus) => {
+            return nativeModule().uniffi_cua_driver_sdk_fn_constructor_embeddedcuadriverhost_new(FfiConverterString.lower(binaryPath, nativeModule().rustbuffer_alloc), FfiConverterString.lower(hostBundleId, nativeModule().rustbuffer_alloc), callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString));
+        this[pointerLiteralSymbol] = pointer;
+        this[destructorGuardSymbol] = uniffiTypeEmbeddedCuaDriverHostObjectFactory.bless(pointer);
+    }
+    static withOptions(options) {
+        return FfiConverterTypeEmbeddedCuaDriverHost.lift(uniffiCaller.rustCallWithError(
+        /*liftError:*/ FfiConverterTypeEmbeddedDriverError.lift.bind(FfiConverterTypeEmbeddedDriverError), 
+        /*caller:*/ (callStatus) => {
+            return nativeModule().uniffi_cua_driver_sdk_fn_constructor_embeddedcuadriverhost_with_options(FfiConverterTypeEmbeddedDriverHostOptions.lower(options, nativeModule().rustbuffer_alloc), callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)));
+    }
+    connection() {
+        return ((__rb) => {
+            try {
+                return FfiConverterOptionalTypeEmbeddedDriverConnection.lift(__rb);
+            }
+            finally {
+                nativeModule().rustbuffer_free(__rb);
+            }
+        })(uniffiCaller.rustCall(
+        /*caller:*/ (callStatus) => {
+            return nativeModule().uniffi_cua_driver_sdk_fn_method_embeddedcuadriverhost_connection(uniffiTypeEmbeddedCuaDriverHostObjectFactory.clonePointer(this), callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)));
+    }
+    async restart(asyncOpts_) {
+        const __stack = uniffiIsDebug ? new Error().stack : undefined;
+        try {
+            return await uniffiRustCallAsync(
+            /*rustCaller:*/ uniffiCaller, 
+            /*rustFutureFunc:*/ () => {
+                return nativeModule().uniffi_cua_driver_sdk_fn_method_embeddedcuadriverhost_restart(uniffiTypeEmbeddedCuaDriverHostObjectFactory.clonePointer(this));
+            }, 
+            /*pollFunc:*/ nativeModule().ffi_cua_driver_sdk_rust_future_poll_rust_buffer, 
+            /*cancelFunc:*/ nativeModule().ffi_cua_driver_sdk_rust_future_cancel_rust_buffer, 
+            /*completeFunc:*/ nativeModule().ffi_cua_driver_sdk_rust_future_complete_rust_buffer, 
+            /*freeFunc:*/ nativeModule().ffi_cua_driver_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:*/ FfiConverterTypeEmbeddedDriverConnection.lift.bind(FfiConverterTypeEmbeddedDriverConnection), 
+            /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString), 
+            /*asyncOpts:*/ asyncOpts_, 
+            /*errorHandler:*/ FfiConverterTypeEmbeddedDriverError.lift.bind(FfiConverterTypeEmbeddedDriverError));
+        }
+        catch (__error) {
+            if (uniffiIsDebug && __error instanceof Error) {
+                __error.stack = __stack;
+            }
+            throw __error;
+        }
+    }
+    async start(asyncOpts_) {
+        const __stack = uniffiIsDebug ? new Error().stack : undefined;
+        try {
+            return await uniffiRustCallAsync(
+            /*rustCaller:*/ uniffiCaller, 
+            /*rustFutureFunc:*/ () => {
+                return nativeModule().uniffi_cua_driver_sdk_fn_method_embeddedcuadriverhost_start(uniffiTypeEmbeddedCuaDriverHostObjectFactory.clonePointer(this));
+            }, 
+            /*pollFunc:*/ nativeModule().ffi_cua_driver_sdk_rust_future_poll_rust_buffer, 
+            /*cancelFunc:*/ nativeModule().ffi_cua_driver_sdk_rust_future_cancel_rust_buffer, 
+            /*completeFunc:*/ nativeModule().ffi_cua_driver_sdk_rust_future_complete_rust_buffer, 
+            /*freeFunc:*/ nativeModule().ffi_cua_driver_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:*/ FfiConverterTypeEmbeddedDriverConnection.lift.bind(FfiConverterTypeEmbeddedDriverConnection), 
+            /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString), 
+            /*asyncOpts:*/ asyncOpts_, 
+            /*errorHandler:*/ FfiConverterTypeEmbeddedDriverError.lift.bind(FfiConverterTypeEmbeddedDriverError));
+        }
+        catch (__error) {
+            if (uniffiIsDebug && __error instanceof Error) {
+                __error.stack = __stack;
+            }
+            throw __error;
+        }
+    }
+    state() {
+        return ((__rb) => {
+            try {
+                return FfiConverterTypeEmbeddedDriverHostState.lift(__rb);
+            }
+            finally {
+                nativeModule().rustbuffer_free(__rb);
+            }
+        })(uniffiCaller.rustCall(
+        /*caller:*/ (callStatus) => {
+            return nativeModule().uniffi_cua_driver_sdk_fn_method_embeddedcuadriverhost_state(uniffiTypeEmbeddedCuaDriverHostObjectFactory.clonePointer(this), callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)));
+    }
+    async stop(asyncOpts_) {
+        const __stack = uniffiIsDebug ? new Error().stack : undefined;
+        try {
+            return await uniffiRustCallAsync(
+            /*rustCaller:*/ uniffiCaller, 
+            /*rustFutureFunc:*/ () => {
+                return nativeModule().uniffi_cua_driver_sdk_fn_method_embeddedcuadriverhost_stop(uniffiTypeEmbeddedCuaDriverHostObjectFactory.clonePointer(this));
+            }, 
+            /*pollFunc:*/ nativeModule().ffi_cua_driver_sdk_rust_future_poll_void, 
+            /*cancelFunc:*/ nativeModule().ffi_cua_driver_sdk_rust_future_cancel_void, 
+            /*completeFunc:*/ nativeModule().ffi_cua_driver_sdk_rust_future_complete_void, 
+            /*freeFunc:*/ nativeModule().ffi_cua_driver_sdk_rust_future_free_void, 
+            /*liftFunc:*/ (_v) => { }, 
+            /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString), 
+            /*asyncOpts:*/ asyncOpts_, 
+            /*errorHandler:*/ FfiConverterTypeEmbeddedDriverError.lift.bind(FfiConverterTypeEmbeddedDriverError));
+        }
+        catch (__error) {
+            if (uniffiIsDebug && __error instanceof Error) {
+                __error.stack = __stack;
+            }
+            throw __error;
+        }
+    }
+    async waitForExit(generation, asyncOpts_) {
+        const __stack = uniffiIsDebug ? new Error().stack : undefined;
+        try {
+            return await uniffiRustCallAsync(
+            /*rustCaller:*/ uniffiCaller, 
+            /*rustFutureFunc:*/ () => {
+                return nativeModule().uniffi_cua_driver_sdk_fn_method_embeddedcuadriverhost_wait_for_exit(uniffiTypeEmbeddedCuaDriverHostObjectFactory.clonePointer(this), FfiConverterString.lower(generation, nativeModule().rustbuffer_alloc));
+            }, 
+            /*pollFunc:*/ nativeModule().ffi_cua_driver_sdk_rust_future_poll_rust_buffer, 
+            /*cancelFunc:*/ nativeModule().ffi_cua_driver_sdk_rust_future_cancel_rust_buffer, 
+            /*completeFunc:*/ nativeModule().ffi_cua_driver_sdk_rust_future_complete_rust_buffer, 
+            /*freeFunc:*/ nativeModule().ffi_cua_driver_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:*/ FfiConverterTypeEmbeddedDriverExit.lift.bind(FfiConverterTypeEmbeddedDriverExit), 
+            /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString), 
+            /*asyncOpts:*/ asyncOpts_, 
+            /*errorHandler:*/ FfiConverterTypeEmbeddedDriverError.lift.bind(FfiConverterTypeEmbeddedDriverError));
+        }
+        catch (__error) {
+            if (uniffiIsDebug && __error instanceof Error) {
+                __error.stack = __stack;
+            }
+            throw __error;
+        }
+    }
+    uniffiDestroy() {
+        const ptr = this[destructorGuardSymbol];
+        if (ptr !== undefined) {
+            const pointer = uniffiTypeEmbeddedCuaDriverHostObjectFactory.pointer(this);
+            uniffiTypeEmbeddedCuaDriverHostObjectFactory.freePointer(pointer);
+            uniffiTypeEmbeddedCuaDriverHostObjectFactory.unbless(ptr);
+            delete this[destructorGuardSymbol];
+        }
+    }
+    static instanceOf(obj_) {
+        return uniffiTypeEmbeddedCuaDriverHostObjectFactory.isConcreteType(obj_);
+    }
+}
+const uniffiTypeEmbeddedCuaDriverHostObjectFactory = (() => {
+    /// <reference lib="es2021" />
+    const registry = typeof FinalizationRegistry !== 'undefined' ? new FinalizationRegistry((heldValue) => {
+        uniffiTypeEmbeddedCuaDriverHostObjectFactory.freePointer(heldValue);
+    }) : null;
+    return {
+        create(pointer) {
+            const instance = Object.create(EmbeddedCuaDriverHost.prototype);
+            instance[pointerLiteralSymbol] = pointer;
+            instance[destructorGuardSymbol] = this.bless(pointer);
+            instance[uniffiTypeNameSymbol] = "EmbeddedCuaDriverHost";
+            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().uniffi_cua_driver_sdk_fn_clone_embeddedcuadriverhost(pointer, callStatus), 
+            /*liftString:*/ FfiConverterString.lift);
+        },
+        freePointer(pointer) {
+            uniffiCaller.rustCall(
+            /*caller:*/ (callStatus) => nativeModule().uniffi_cua_driver_sdk_fn_free_embeddedcuadriverhost(pointer, callStatus), 
+            /*liftString:*/ FfiConverterString.lift);
+        },
+        isConcreteType(obj_) {
+            return obj_[destructorGuardSymbol] && obj_[uniffiTypeNameSymbol] === "EmbeddedCuaDriverHost";
+        },
+    };
+})();
+const FfiConverterTypeEmbeddedCuaDriverHost = new FfiConverterObject(uniffiTypeEmbeddedCuaDriverHostObjectFactory);
+// FfiConverter for string | undefined
+const FfiConverterOptionalString = new FfiConverterOptional(FfiConverterString);
+// FfiConverter for Array<string>
+const FfiConverterSequenceString = new FfiConverterArray(FfiConverterString);
+// FfiConverter for Array<EmbeddedEnvironmentVariable>
+const FfiConverterSequenceTypeEmbeddedEnvironmentVariable = new FfiConverterArray(FfiConverterTypeEmbeddedEnvironmentVariable);
+// FfiConverter for number | undefined
+const FfiConverterOptionalInt32 = new FfiConverterOptional(FfiConverterInt32);
+// FfiConverter for bigint | undefined
+const FfiConverterOptionalUInt64 = new FfiConverterOptional(FfiConverterUInt64);
+// FfiConverter for EmbeddedPermissionMode | undefined
+const FfiConverterOptionalTypeEmbeddedPermissionMode = new FfiConverterOptional(FfiConverterTypeEmbeddedPermissionMode);
+// FfiConverter for Array<ImageContent>
+const FfiConverterSequenceTypeImageContent = new FfiConverterArray(FfiConverterTypeImageContent);
+// FfiConverter for boolean | undefined
+const FfiConverterOptionalBoolean = new FfiConverterOptional(FfiConverterBool);
+// FfiConverter for EmbeddedDriverConnection | undefined
+const FfiConverterOptionalTypeEmbeddedDriverConnection = new FfiConverterOptional(FfiConverterTypeEmbeddedDriverConnection);
+/**
+ * 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().ffi_cua_driver_sdk_uniffi_contract_version();
+    if (bindingsContractVersion !== scaffoldingContractVersion) {
+        throw new UniffiInternalError.ContractVersionMismatch(scaffoldingContractVersion, bindingsContractVersion);
+    }
+    if (nativeModule().uniffi_cua_driver_sdk_checksum_func_current_mac_os_permission_status() !== 22890) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cua_driver_sdk_checksum_func_current_mac_os_permission_status");
+    }
+    if (nativeModule().uniffi_cua_driver_sdk_checksum_func_open_mac_os_screen_recording_settings() !== 6663) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cua_driver_sdk_checksum_func_open_mac_os_screen_recording_settings");
+    }
+    if (nativeModule().uniffi_cua_driver_sdk_checksum_func_request_mac_os_permissions() !== 61823) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cua_driver_sdk_checksum_func_request_mac_os_permissions");
+    }
+    if (nativeModule().uniffi_cua_driver_sdk_checksum_constructor_cuadriver_connect() !== 42154) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cua_driver_sdk_checksum_constructor_cuadriver_connect");
+    }
+    if (nativeModule().uniffi_cua_driver_sdk_checksum_method_cuadriver_call_tool() !== 31445) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cua_driver_sdk_checksum_method_cuadriver_call_tool");
+    }
+    if (nativeModule().uniffi_cua_driver_sdk_checksum_method_cuadriver_click() !== 34118) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cua_driver_sdk_checksum_method_cuadriver_click");
+    }
+    if (nativeModule().uniffi_cua_driver_sdk_checksum_method_cuadriver_drag() !== 35252) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cua_driver_sdk_checksum_method_cuadriver_drag");
+    }
+    if (nativeModule().uniffi_cua_driver_sdk_checksum_method_cuadriver_end_session() !== 33990) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cua_driver_sdk_checksum_method_cuadriver_end_session");
+    }
+    if (nativeModule().uniffi_cua_driver_sdk_checksum_method_cuadriver_escalate_session() !== 37358) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cua_driver_sdk_checksum_method_cuadriver_escalate_session");
+    }
+    if (nativeModule().uniffi_cua_driver_sdk_checksum_method_cuadriver_get_cursor_position() !== 54043) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cua_driver_sdk_checksum_method_cuadriver_get_cursor_position");
+    }
+    if (nativeModule().uniffi_cua_driver_sdk_checksum_method_cuadriver_get_desktop_state() !== 32992) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cua_driver_sdk_checksum_method_cuadriver_get_desktop_state");
+    }
+    if (nativeModule().uniffi_cua_driver_sdk_checksum_method_cuadriver_get_screen_size() !== 15250) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cua_driver_sdk_checksum_method_cuadriver_get_screen_size");
+    }
+    if (nativeModule().uniffi_cua_driver_sdk_checksum_method_cuadriver_get_session_state() !== 51055) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cua_driver_sdk_checksum_method_cuadriver_get_session_state");
+    }
+    if (nativeModule().uniffi_cua_driver_sdk_checksum_method_cuadriver_hotkey() !== 3135) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cua_driver_sdk_checksum_method_cuadriver_hotkey");
+    }
+    if (nativeModule().uniffi_cua_driver_sdk_checksum_method_cuadriver_is_available() !== 42961) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cua_driver_sdk_checksum_method_cuadriver_is_available");
+    }
+    if (nativeModule().uniffi_cua_driver_sdk_checksum_method_cuadriver_list_tools_json() !== 43987) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cua_driver_sdk_checksum_method_cuadriver_list_tools_json");
+    }
+    if (nativeModule().uniffi_cua_driver_sdk_checksum_method_cuadriver_metadata() !== 50371) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cua_driver_sdk_checksum_method_cuadriver_metadata");
+    }
+    if (nativeModule().uniffi_cua_driver_sdk_checksum_method_cuadriver_move_cursor() !== 11209) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cua_driver_sdk_checksum_method_cuadriver_move_cursor");
+    }
+    if (nativeModule().uniffi_cua_driver_sdk_checksum_method_cuadriver_press_key() !== 17425) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cua_driver_sdk_checksum_method_cuadriver_press_key");
+    }
+    if (nativeModule().uniffi_cua_driver_sdk_checksum_method_cuadriver_scroll() !== 21614) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cua_driver_sdk_checksum_method_cuadriver_scroll");
+    }
+    if (nativeModule().uniffi_cua_driver_sdk_checksum_method_cuadriver_socket_path() !== 24461) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cua_driver_sdk_checksum_method_cuadriver_socket_path");
+    }
+    if (nativeModule().uniffi_cua_driver_sdk_checksum_method_cuadriver_start_session() !== 53509) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cua_driver_sdk_checksum_method_cuadriver_start_session");
+    }
+    if (nativeModule().uniffi_cua_driver_sdk_checksum_method_cuadriver_type_text() !== 19673) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cua_driver_sdk_checksum_method_cuadriver_type_text");
+    }
+    if (nativeModule().uniffi_cua_driver_sdk_checksum_constructor_embeddedcuadriverhost_new() !== 10108) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cua_driver_sdk_checksum_constructor_embeddedcuadriverhost_new");
+    }
+    if (nativeModule().uniffi_cua_driver_sdk_checksum_constructor_embeddedcuadriverhost_with_options() !== 41121) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cua_driver_sdk_checksum_constructor_embeddedcuadriverhost_with_options");
+    }
+    if (nativeModule().uniffi_cua_driver_sdk_checksum_method_embeddedcuadriverhost_connection() !== 44467) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cua_driver_sdk_checksum_method_embeddedcuadriverhost_connection");
+    }
+    if (nativeModule().uniffi_cua_driver_sdk_checksum_method_embeddedcuadriverhost_restart() !== 27248) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cua_driver_sdk_checksum_method_embeddedcuadriverhost_restart");
+    }
+    if (nativeModule().uniffi_cua_driver_sdk_checksum_method_embeddedcuadriverhost_start() !== 16011) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cua_driver_sdk_checksum_method_embeddedcuadriverhost_start");
+    }
+    if (nativeModule().uniffi_cua_driver_sdk_checksum_method_embeddedcuadriverhost_state() !== 42795) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cua_driver_sdk_checksum_method_embeddedcuadriverhost_state");
+    }
+    if (nativeModule().uniffi_cua_driver_sdk_checksum_method_embeddedcuadriverhost_stop() !== 28521) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cua_driver_sdk_checksum_method_embeddedcuadriverhost_stop");
+    }
+    if (nativeModule().uniffi_cua_driver_sdk_checksum_method_embeddedcuadriverhost_wait_for_exit() !== 21124) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cua_driver_sdk_checksum_method_embeddedcuadriverhost_wait_for_exit");
+    }
+}
+export default Object.freeze({
+    initialize: uniffiEnsureInitialized,
+    converters: {
+        FfiConverterTypeCuaDriver,
+        FfiConverterTypeDriverError,
+        FfiConverterTypeDriverMetadata,
+        FfiConverterTypeEmbeddedCuaDriverHost,
+        FfiConverterTypeEmbeddedDriverConnection,
+        FfiConverterTypeEmbeddedDriverError,
+        FfiConverterTypeEmbeddedDriverExit,
+        FfiConverterTypeEmbeddedDriverHostOptions,
+        FfiConverterTypeEmbeddedDriverHostState,
+        FfiConverterTypeEmbeddedEnvironmentVariable,
+        FfiConverterTypeEmbeddedMcpConfiguration,
+        FfiConverterTypeEmbeddedPermissionMode,
+        FfiConverterTypeImageContent,
+        FfiConverterTypeMacOsPermissionStatus,
+        FfiConverterTypeToolResult,
+    }
+});