@trycua/cua-driver 0.11.0

package/dist/native/cua_driver_sdk.d.ts

@@ -0,0 +1,1541 @@
+import { type ClickInput, type DragInput, type EndSessionInput, type EndSessionOutput, type EscalateSessionInput, type GetCursorPositionInput, type GetDesktopStateInput, type GetScreenSizeInput, type GetSessionStateInput, type HotkeyInput, type MoveCursorInput, type PressKeyInput, type ScrollInput, type SessionStateOutput, type StartSessionInput, type StartSessionOutput, type TypeTextInput } from "./cua_driver_contract.js";
+import { type UniffiByteArray, type UniffiGcObject, type UniffiHandle, FfiConverterObject, RustBuffer, UniffiAbstractObject, destructorGuardSymbol, pointerLiteralSymbol, uniffiTypeNameSymbol } from "@ubjs/core";
+export declare function currentMacOsPermissionStatus(): MacOsPermissionStatus;
+export declare function openMacOsScreenRecordingSettings(): void;
+export declare function requestMacOsPermissions(): MacOsPermissionStatus;
+/**
+ * Transport-independent daemon identity used to prove that standalone and
+ * embedded SDK/MCP routes reached a compatible Rust implementation.
+ */
+export type DriverMetadata = {
+    driverVersion: string;
+    contractVersion: string;
+    toolsListSchemaVersion: string;
+    capabilityVersion: string;
+    mcpProtocolVersion: string;
+    pid: number;
+    embedded: boolean;
+    hostBundleId?: string;
+};
+/**
+ * Generated factory for {@link DriverMetadata} record objects.
+ */
+export declare const DriverMetadata: Readonly<{
+    create: (partial: Partial<DriverMetadata> & Required<Omit<DriverMetadata, "hostBundleId">>) => DriverMetadata;
+    new: (partial: Partial<DriverMetadata> & Required<Omit<DriverMetadata, "hostBundleId">>) => DriverMetadata;
+    defaults: () => Partial<DriverMetadata>;
+}>;
+export type EmbeddedEnvironmentVariable = {
+    name: string;
+    value: string;
+};
+/**
+ * Generated factory for {@link EmbeddedEnvironmentVariable} record objects.
+ */
+export declare const EmbeddedEnvironmentVariable: Readonly<{
+    create: (partial: Partial<EmbeddedEnvironmentVariable> & Required<Omit<EmbeddedEnvironmentVariable, never>>) => EmbeddedEnvironmentVariable;
+    new: (partial: Partial<EmbeddedEnvironmentVariable> & Required<Omit<EmbeddedEnvironmentVariable, never>>) => EmbeddedEnvironmentVariable;
+    defaults: () => Partial<EmbeddedEnvironmentVariable>;
+}>;
+export type EmbeddedMcpConfiguration = {
+    command: string;
+    args: Array<string>;
+    environment: Array<EmbeddedEnvironmentVariable>;
+};
+/**
+ * Generated factory for {@link EmbeddedMcpConfiguration} record objects.
+ */
+export declare const EmbeddedMcpConfiguration: Readonly<{
+    create: (partial: Partial<EmbeddedMcpConfiguration> & Required<Omit<EmbeddedMcpConfiguration, never>>) => EmbeddedMcpConfiguration;
+    new: (partial: Partial<EmbeddedMcpConfiguration> & Required<Omit<EmbeddedMcpConfiguration, never>>) => EmbeddedMcpConfiguration;
+    defaults: () => Partial<EmbeddedMcpConfiguration>;
+}>;
+export type EmbeddedDriverConnection = {
+    socketPath: string;
+    pid: number;
+    generation: string;
+    driverVersion: string;
+    contractVersion: string;
+    mcpProtocolVersion: string;
+    mcp: EmbeddedMcpConfiguration;
+};
+/**
+ * Generated factory for {@link EmbeddedDriverConnection} record objects.
+ */
+export declare const EmbeddedDriverConnection: Readonly<{
+    create: (partial: Partial<EmbeddedDriverConnection> & Required<Omit<EmbeddedDriverConnection, never>>) => EmbeddedDriverConnection;
+    new: (partial: Partial<EmbeddedDriverConnection> & Required<Omit<EmbeddedDriverConnection, never>>) => EmbeddedDriverConnection;
+    defaults: () => Partial<EmbeddedDriverConnection>;
+}>;
+export type EmbeddedDriverExit = {
+    generation: string;
+    code?: number;
+    success: boolean;
+};
+/**
+ * Generated factory for {@link EmbeddedDriverExit} record objects.
+ */
+export declare const EmbeddedDriverExit: Readonly<{
+    create: (partial: Partial<EmbeddedDriverExit> & Required<Omit<EmbeddedDriverExit, "code">>) => EmbeddedDriverExit;
+    new: (partial: Partial<EmbeddedDriverExit> & Required<Omit<EmbeddedDriverExit, "code">>) => EmbeddedDriverExit;
+    defaults: () => Partial<EmbeddedDriverExit>;
+}>;
+export declare enum EmbeddedPermissionMode {
+    Standard = 0,
+    Bounded = 1,
+    Unrestricted = 2
+}
+export type EmbeddedDriverHostOptions = {
+    binaryPath: string;
+    hostBundleId: string;
+    socketPath?: string;
+    startupTimeoutMs?: bigint;
+    shutdownTimeoutMs?: bigint;
+    permissionMode?: EmbeddedPermissionMode;
+    sessionPolicyPath?: string;
+    approveSessionPolicy: boolean;
+    dangerouslyBypassApprovals: boolean;
+    environment: Array<EmbeddedEnvironmentVariable>;
+    inheritStderr: boolean;
+};
+/**
+ * Generated factory for {@link EmbeddedDriverHostOptions} record objects.
+ */
+export declare const EmbeddedDriverHostOptions: Readonly<{
+    create: (partial: Partial<EmbeddedDriverHostOptions> & Required<Omit<EmbeddedDriverHostOptions, "socketPath" | "startupTimeoutMs" | "shutdownTimeoutMs" | "permissionMode" | "sessionPolicyPath">>) => EmbeddedDriverHostOptions;
+    new: (partial: Partial<EmbeddedDriverHostOptions> & Required<Omit<EmbeddedDriverHostOptions, "socketPath" | "startupTimeoutMs" | "shutdownTimeoutMs" | "permissionMode" | "sessionPolicyPath">>) => EmbeddedDriverHostOptions;
+    defaults: () => Partial<EmbeddedDriverHostOptions>;
+}>;
+export type ImageContent = {
+    mimeType: string;
+    dataBase64: string;
+};
+/**
+ * Generated factory for {@link ImageContent} record objects.
+ */
+export declare const ImageContent: Readonly<{
+    create: (partial: Partial<ImageContent> & Required<Omit<ImageContent, never>>) => ImageContent;
+    new: (partial: Partial<ImageContent> & Required<Omit<ImageContent, never>>) => ImageContent;
+    defaults: () => Partial<ImageContent>;
+}>;
+/**
+ * The TCC grants required by a macOS host application before it starts an
+ * embedded driver. These probes execute in the importing SDK process so the
+ * operating system attributes the request to the host application.
+ */
+export type MacOsPermissionStatus = {
+    accessibility: boolean;
+    screenRecording: boolean;
+};
+/**
+ * Generated factory for {@link MacOsPermissionStatus} record objects.
+ */
+export declare const MacOsPermissionStatus: Readonly<{
+    create: (partial: Partial<MacOsPermissionStatus> & Required<Omit<MacOsPermissionStatus, never>>) => MacOsPermissionStatus;
+    new: (partial: Partial<MacOsPermissionStatus> & Required<Omit<MacOsPermissionStatus, never>>) => MacOsPermissionStatus;
+    defaults: () => Partial<MacOsPermissionStatus>;
+}>;
+/**
+ * Transport-neutral result envelope used for open-ended tool calls and
+ * desktop tools whose platform extensions are intentionally preserved as JSON.
+ */
+export type ToolResult = {
+    text: string;
+    images: Array<ImageContent>;
+    structuredJson?: string;
+    isError: boolean;
+    errorCode?: string;
+    verified?: boolean;
+    degraded: boolean;
+    rawJson: string;
+};
+/**
+ * Generated factory for {@link ToolResult} record objects.
+ */
+export declare const ToolResult: Readonly<{
+    create: (partial: Partial<ToolResult> & Required<Omit<ToolResult, "errorCode" | "structuredJson" | "verified">>) => ToolResult;
+    new: (partial: Partial<ToolResult> & Required<Omit<ToolResult, "errorCode" | "structuredJson" | "verified">>) => ToolResult;
+    defaults: () => Partial<ToolResult>;
+}>;
+export declare enum DriverError_Tags {
+    Configuration = "Configuration",
+    InvalidArguments = "InvalidArguments",
+    Transport = "Transport",
+    Protocol = "Protocol",
+    Tool = "Tool"
+}
+export declare const DriverError: Readonly<{
+    instanceOf: (obj: any) => obj is DriverError;
+    Configuration: {
+        new (inner: {
+            reason: string;
+        }): {
+            readonly tag: DriverError_Tags.Configuration;
+            readonly inner: Readonly<{
+                reason: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "DriverError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        "new"(inner: {
+            reason: string;
+        }): {
+            readonly tag: DriverError_Tags.Configuration;
+            readonly inner: Readonly<{
+                reason: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "DriverError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        instanceOf(obj: any): obj is {
+            readonly tag: DriverError_Tags.Configuration;
+            readonly inner: Readonly<{
+                reason: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "DriverError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        hasInner(obj: any): obj is {
+            readonly tag: DriverError_Tags.Configuration;
+            readonly inner: Readonly<{
+                reason: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "DriverError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        getInner(obj: {
+            readonly tag: DriverError_Tags.Configuration;
+            readonly inner: Readonly<{
+                reason: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "DriverError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        }): Readonly<{
+            reason: string;
+        }>;
+        captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+        prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+        stackTraceLimit: number;
+    };
+    InvalidArguments: {
+        new (inner: {
+            tool: string;
+            reason: string;
+        }): {
+            readonly tag: DriverError_Tags.InvalidArguments;
+            readonly inner: Readonly<{
+                tool: string;
+                reason: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "DriverError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        "new"(inner: {
+            tool: string;
+            reason: string;
+        }): {
+            readonly tag: DriverError_Tags.InvalidArguments;
+            readonly inner: Readonly<{
+                tool: string;
+                reason: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "DriverError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        instanceOf(obj: any): obj is {
+            readonly tag: DriverError_Tags.InvalidArguments;
+            readonly inner: Readonly<{
+                tool: string;
+                reason: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "DriverError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        hasInner(obj: any): obj is {
+            readonly tag: DriverError_Tags.InvalidArguments;
+            readonly inner: Readonly<{
+                tool: string;
+                reason: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "DriverError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        getInner(obj: {
+            readonly tag: DriverError_Tags.InvalidArguments;
+            readonly inner: Readonly<{
+                tool: string;
+                reason: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "DriverError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        }): Readonly<{
+            tool: string;
+            reason: string;
+        }>;
+        captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+        prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+        stackTraceLimit: number;
+    };
+    Transport: {
+        new (inner: {
+            socketPath: string;
+            reason: string;
+        }): {
+            readonly tag: DriverError_Tags.Transport;
+            readonly inner: Readonly<{
+                socketPath: string;
+                reason: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "DriverError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        "new"(inner: {
+            socketPath: string;
+            reason: string;
+        }): {
+            readonly tag: DriverError_Tags.Transport;
+            readonly inner: Readonly<{
+                socketPath: string;
+                reason: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "DriverError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        instanceOf(obj: any): obj is {
+            readonly tag: DriverError_Tags.Transport;
+            readonly inner: Readonly<{
+                socketPath: string;
+                reason: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "DriverError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        hasInner(obj: any): obj is {
+            readonly tag: DriverError_Tags.Transport;
+            readonly inner: Readonly<{
+                socketPath: string;
+                reason: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "DriverError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        getInner(obj: {
+            readonly tag: DriverError_Tags.Transport;
+            readonly inner: Readonly<{
+                socketPath: string;
+                reason: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "DriverError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        }): Readonly<{
+            socketPath: string;
+            reason: string;
+        }>;
+        captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+        prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+        stackTraceLimit: number;
+    };
+    Protocol: {
+        new (inner: {
+            reason: string;
+        }): {
+            readonly tag: DriverError_Tags.Protocol;
+            readonly inner: Readonly<{
+                reason: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "DriverError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        "new"(inner: {
+            reason: string;
+        }): {
+            readonly tag: DriverError_Tags.Protocol;
+            readonly inner: Readonly<{
+                reason: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "DriverError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        instanceOf(obj: any): obj is {
+            readonly tag: DriverError_Tags.Protocol;
+            readonly inner: Readonly<{
+                reason: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "DriverError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        hasInner(obj: any): obj is {
+            readonly tag: DriverError_Tags.Protocol;
+            readonly inner: Readonly<{
+                reason: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "DriverError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        getInner(obj: {
+            readonly tag: DriverError_Tags.Protocol;
+            readonly inner: Readonly<{
+                reason: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "DriverError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        }): Readonly<{
+            reason: string;
+        }>;
+        captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+        prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+        stackTraceLimit: number;
+    };
+    Tool: {
+        new (inner: {
+            tool: string;
+            message: string;
+            errorCode: string;
+        }): {
+            readonly tag: DriverError_Tags.Tool;
+            readonly inner: Readonly<{
+                tool: string;
+                message: string;
+                errorCode: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "DriverError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        "new"(inner: {
+            tool: string;
+            message: string;
+            errorCode: string;
+        }): {
+            readonly tag: DriverError_Tags.Tool;
+            readonly inner: Readonly<{
+                tool: string;
+                message: string;
+                errorCode: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "DriverError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        instanceOf(obj: any): obj is {
+            readonly tag: DriverError_Tags.Tool;
+            readonly inner: Readonly<{
+                tool: string;
+                message: string;
+                errorCode: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "DriverError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        hasInner(obj: any): obj is {
+            readonly tag: DriverError_Tags.Tool;
+            readonly inner: Readonly<{
+                tool: string;
+                message: string;
+                errorCode: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "DriverError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        getInner(obj: {
+            readonly tag: DriverError_Tags.Tool;
+            readonly inner: Readonly<{
+                tool: string;
+                message: string;
+                errorCode: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "DriverError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        }): Readonly<{
+            tool: string;
+            message: string;
+            errorCode: string;
+        }>;
+        captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+        prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+        stackTraceLimit: number;
+    };
+}>;
+export type DriverError = InstanceType<typeof DriverError['Configuration' | 'InvalidArguments' | 'Transport' | 'Protocol' | 'Tool']>;
+export declare enum EmbeddedDriverError_Tags {
+    Configuration = "Configuration",
+    EndpointConflict = "EndpointConflict",
+    Spawn = "Spawn",
+    StartupCancelled = "StartupCancelled",
+    StartupTimeout = "StartupTimeout",
+    ExitedBeforeReady = "ExitedBeforeReady",
+    IncompatibleDaemon = "IncompatibleDaemon",
+    Lifecycle = "Lifecycle"
+}
+export declare const EmbeddedDriverError: Readonly<{
+    instanceOf: (obj: any) => obj is EmbeddedDriverError;
+    Configuration: {
+        new (inner: {
+            reason: string;
+        }): {
+            readonly tag: EmbeddedDriverError_Tags.Configuration;
+            readonly inner: Readonly<{
+                reason: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "EmbeddedDriverError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        "new"(inner: {
+            reason: string;
+        }): {
+            readonly tag: EmbeddedDriverError_Tags.Configuration;
+            readonly inner: Readonly<{
+                reason: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "EmbeddedDriverError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        instanceOf(obj: any): obj is {
+            readonly tag: EmbeddedDriverError_Tags.Configuration;
+            readonly inner: Readonly<{
+                reason: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "EmbeddedDriverError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        hasInner(obj: any): obj is {
+            readonly tag: EmbeddedDriverError_Tags.Configuration;
+            readonly inner: Readonly<{
+                reason: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "EmbeddedDriverError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        getInner(obj: {
+            readonly tag: EmbeddedDriverError_Tags.Configuration;
+            readonly inner: Readonly<{
+                reason: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "EmbeddedDriverError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        }): Readonly<{
+            reason: string;
+        }>;
+        captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+        prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+        stackTraceLimit: number;
+    };
+    EndpointConflict: {
+        new (inner: {
+            path: string;
+            reason: string;
+        }): {
+            readonly tag: EmbeddedDriverError_Tags.EndpointConflict;
+            readonly inner: Readonly<{
+                path: string;
+                reason: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "EmbeddedDriverError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        "new"(inner: {
+            path: string;
+            reason: string;
+        }): {
+            readonly tag: EmbeddedDriverError_Tags.EndpointConflict;
+            readonly inner: Readonly<{
+                path: string;
+                reason: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "EmbeddedDriverError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        instanceOf(obj: any): obj is {
+            readonly tag: EmbeddedDriverError_Tags.EndpointConflict;
+            readonly inner: Readonly<{
+                path: string;
+                reason: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "EmbeddedDriverError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        hasInner(obj: any): obj is {
+            readonly tag: EmbeddedDriverError_Tags.EndpointConflict;
+            readonly inner: Readonly<{
+                path: string;
+                reason: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "EmbeddedDriverError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        getInner(obj: {
+            readonly tag: EmbeddedDriverError_Tags.EndpointConflict;
+            readonly inner: Readonly<{
+                path: string;
+                reason: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "EmbeddedDriverError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        }): Readonly<{
+            path: string;
+            reason: string;
+        }>;
+        captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+        prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+        stackTraceLimit: number;
+    };
+    Spawn: {
+        new (inner: {
+            binaryPath: string;
+            reason: string;
+        }): {
+            readonly tag: EmbeddedDriverError_Tags.Spawn;
+            readonly inner: Readonly<{
+                binaryPath: string;
+                reason: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "EmbeddedDriverError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        "new"(inner: {
+            binaryPath: string;
+            reason: string;
+        }): {
+            readonly tag: EmbeddedDriverError_Tags.Spawn;
+            readonly inner: Readonly<{
+                binaryPath: string;
+                reason: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "EmbeddedDriverError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        instanceOf(obj: any): obj is {
+            readonly tag: EmbeddedDriverError_Tags.Spawn;
+            readonly inner: Readonly<{
+                binaryPath: string;
+                reason: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "EmbeddedDriverError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        hasInner(obj: any): obj is {
+            readonly tag: EmbeddedDriverError_Tags.Spawn;
+            readonly inner: Readonly<{
+                binaryPath: string;
+                reason: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "EmbeddedDriverError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        getInner(obj: {
+            readonly tag: EmbeddedDriverError_Tags.Spawn;
+            readonly inner: Readonly<{
+                binaryPath: string;
+                reason: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "EmbeddedDriverError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        }): Readonly<{
+            binaryPath: string;
+            reason: string;
+        }>;
+        captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+        prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+        stackTraceLimit: number;
+    };
+    StartupCancelled: {
+        new (): {
+            readonly tag: EmbeddedDriverError_Tags.StartupCancelled;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "EmbeddedDriverError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        "new"(): {
+            readonly tag: EmbeddedDriverError_Tags.StartupCancelled;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "EmbeddedDriverError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        instanceOf(obj: any): obj is {
+            readonly tag: EmbeddedDriverError_Tags.StartupCancelled;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "EmbeddedDriverError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        hasInner(obj: any): obj is {
+            readonly tag: EmbeddedDriverError_Tags.StartupCancelled;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "EmbeddedDriverError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+        prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+        stackTraceLimit: number;
+    };
+    StartupTimeout: {
+        new (inner: {
+            timeoutMs: bigint;
+        }): {
+            readonly tag: EmbeddedDriverError_Tags.StartupTimeout;
+            readonly inner: Readonly<{
+                timeoutMs: bigint;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "EmbeddedDriverError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        "new"(inner: {
+            timeoutMs: bigint;
+        }): {
+            readonly tag: EmbeddedDriverError_Tags.StartupTimeout;
+            readonly inner: Readonly<{
+                timeoutMs: bigint;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "EmbeddedDriverError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        instanceOf(obj: any): obj is {
+            readonly tag: EmbeddedDriverError_Tags.StartupTimeout;
+            readonly inner: Readonly<{
+                timeoutMs: bigint;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "EmbeddedDriverError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        hasInner(obj: any): obj is {
+            readonly tag: EmbeddedDriverError_Tags.StartupTimeout;
+            readonly inner: Readonly<{
+                timeoutMs: bigint;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "EmbeddedDriverError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        getInner(obj: {
+            readonly tag: EmbeddedDriverError_Tags.StartupTimeout;
+            readonly inner: Readonly<{
+                timeoutMs: bigint;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "EmbeddedDriverError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        }): Readonly<{
+            timeoutMs: bigint;
+        }>;
+        captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+        prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+        stackTraceLimit: number;
+    };
+    ExitedBeforeReady: {
+        new (inner: {
+            code?: number;
+        }): {
+            readonly tag: EmbeddedDriverError_Tags.ExitedBeforeReady;
+            readonly inner: Readonly<{
+                code?: number;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "EmbeddedDriverError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        "new"(inner: {
+            code?: number;
+        }): {
+            readonly tag: EmbeddedDriverError_Tags.ExitedBeforeReady;
+            readonly inner: Readonly<{
+                code?: number;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "EmbeddedDriverError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        instanceOf(obj: any): obj is {
+            readonly tag: EmbeddedDriverError_Tags.ExitedBeforeReady;
+            readonly inner: Readonly<{
+                code?: number;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "EmbeddedDriverError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        hasInner(obj: any): obj is {
+            readonly tag: EmbeddedDriverError_Tags.ExitedBeforeReady;
+            readonly inner: Readonly<{
+                code?: number;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "EmbeddedDriverError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        getInner(obj: {
+            readonly tag: EmbeddedDriverError_Tags.ExitedBeforeReady;
+            readonly inner: Readonly<{
+                code?: number;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "EmbeddedDriverError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        }): Readonly<{
+            code?: number;
+        }>;
+        captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+        prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+        stackTraceLimit: number;
+    };
+    IncompatibleDaemon: {
+        new (inner: {
+            reason: string;
+        }): {
+            readonly tag: EmbeddedDriverError_Tags.IncompatibleDaemon;
+            readonly inner: Readonly<{
+                reason: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "EmbeddedDriverError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        "new"(inner: {
+            reason: string;
+        }): {
+            readonly tag: EmbeddedDriverError_Tags.IncompatibleDaemon;
+            readonly inner: Readonly<{
+                reason: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "EmbeddedDriverError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        instanceOf(obj: any): obj is {
+            readonly tag: EmbeddedDriverError_Tags.IncompatibleDaemon;
+            readonly inner: Readonly<{
+                reason: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "EmbeddedDriverError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        hasInner(obj: any): obj is {
+            readonly tag: EmbeddedDriverError_Tags.IncompatibleDaemon;
+            readonly inner: Readonly<{
+                reason: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "EmbeddedDriverError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        getInner(obj: {
+            readonly tag: EmbeddedDriverError_Tags.IncompatibleDaemon;
+            readonly inner: Readonly<{
+                reason: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "EmbeddedDriverError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        }): Readonly<{
+            reason: string;
+        }>;
+        captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+        prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+        stackTraceLimit: number;
+    };
+    Lifecycle: {
+        new (inner: {
+            reason: string;
+        }): {
+            readonly tag: EmbeddedDriverError_Tags.Lifecycle;
+            readonly inner: Readonly<{
+                reason: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "EmbeddedDriverError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        "new"(inner: {
+            reason: string;
+        }): {
+            readonly tag: EmbeddedDriverError_Tags.Lifecycle;
+            readonly inner: Readonly<{
+                reason: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "EmbeddedDriverError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        instanceOf(obj: any): obj is {
+            readonly tag: EmbeddedDriverError_Tags.Lifecycle;
+            readonly inner: Readonly<{
+                reason: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "EmbeddedDriverError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        hasInner(obj: any): obj is {
+            readonly tag: EmbeddedDriverError_Tags.Lifecycle;
+            readonly inner: Readonly<{
+                reason: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "EmbeddedDriverError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        getInner(obj: {
+            readonly tag: EmbeddedDriverError_Tags.Lifecycle;
+            readonly inner: Readonly<{
+                reason: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "EmbeddedDriverError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        }): Readonly<{
+            reason: string;
+        }>;
+        captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+        prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+        stackTraceLimit: number;
+    };
+}>;
+export type EmbeddedDriverError = InstanceType<typeof EmbeddedDriverError['Configuration' | 'EndpointConflict' | 'Spawn' | 'StartupCancelled' | 'StartupTimeout' | 'ExitedBeforeReady' | 'IncompatibleDaemon' | 'Lifecycle']>;
+export declare enum EmbeddedDriverHostState {
+    Stopped = 0,
+    Starting = 1,
+    Ready = 2,
+    Stopping = 3
+}
+export interface CuaDriverLike {
+    /**
+     * Escape hatch for forward-compatible tools and application-owned server
+     * adapters. Typed methods below serialize the same canonical Rust inputs.
+     */
+    callTool(name: string, argumentsJson: string): ToolResult;
+    click(input: ClickInput): ToolResult;
+    drag(input: DragInput): ToolResult;
+    endSession(input: EndSessionInput): EndSessionOutput;
+    escalateSession(input: EscalateSessionInput): SessionStateOutput;
+    getCursorPosition(input: GetCursorPositionInput): ToolResult;
+    getDesktopState(input: GetDesktopStateInput): ToolResult;
+    getScreenSize(input: GetScreenSizeInput): ToolResult;
+    getSessionState(input: GetSessionStateInput): SessionStateOutput;
+    hotkey(input: HotkeyInput): ToolResult;
+    isAvailable(): boolean;
+    listToolsJson(): string;
+    metadata(): DriverMetadata;
+    moveCursor(input: MoveCursorInput): ToolResult;
+    pressKey(input: PressKeyInput): ToolResult;
+    scroll(input: ScrollInput): ToolResult;
+    socketPath(): string;
+    startSession(input: StartSessionInput): StartSessionOutput;
+    typeText(input: TypeTextInput): ToolResult;
+}
+/**
+ * @deprecated Use `CuaDriverLike` instead.
+ */
+export type CuaDriverInterface = CuaDriverLike;
+export declare class CuaDriver extends UniffiAbstractObject implements CuaDriverLike {
+    readonly [uniffiTypeNameSymbol] = "CuaDriver";
+    readonly [destructorGuardSymbol]: UniffiGcObject;
+    readonly [pointerLiteralSymbol]: UniffiHandle;
+    private constructor();
+    /**
+     * Connect to the default installed daemon or an explicitly selected socket.
+     * Construction does not launch a process or perform I/O.
+     */
+    static connect(socketPath: string | undefined): CuaDriverLike;
+    /**
+     * Escape hatch for forward-compatible tools and application-owned server
+     * adapters. Typed methods below serialize the same canonical Rust inputs.
+     */
+    callTool(name: string, argumentsJson: string): ToolResult;
+    click(input: ClickInput): ToolResult;
+    drag(input: DragInput): ToolResult;
+    endSession(input: EndSessionInput): EndSessionOutput;
+    escalateSession(input: EscalateSessionInput): SessionStateOutput;
+    getCursorPosition(input: GetCursorPositionInput): ToolResult;
+    getDesktopState(input: GetDesktopStateInput): ToolResult;
+    getScreenSize(input: GetScreenSizeInput): ToolResult;
+    getSessionState(input: GetSessionStateInput): SessionStateOutput;
+    hotkey(input: HotkeyInput): ToolResult;
+    isAvailable(): boolean;
+    listToolsJson(): string;
+    metadata(): DriverMetadata;
+    moveCursor(input: MoveCursorInput): ToolResult;
+    pressKey(input: PressKeyInput): ToolResult;
+    scroll(input: ScrollInput): ToolResult;
+    socketPath(): string;
+    startSession(input: StartSessionInput): StartSessionOutput;
+    typeText(input: TypeTextInput): ToolResult;
+    uniffiDestroy(): void;
+    static instanceOf(obj_: any): obj_ is CuaDriver;
+}
+export interface EmbeddedCuaDriverHostLike {
+    connection(): EmbeddedDriverConnection | undefined;
+    restart(asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<EmbeddedDriverConnection>;
+    start(asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<EmbeddedDriverConnection>;
+    state(): EmbeddedDriverHostState;
+    stop(asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<void>;
+    waitForExit(generation: string, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<EmbeddedDriverExit>;
+}
+/**
+ * @deprecated Use `EmbeddedCuaDriverHostLike` instead.
+ */
+export type EmbeddedCuaDriverHostInterface = EmbeddedCuaDriverHostLike;
+export declare class EmbeddedCuaDriverHost extends UniffiAbstractObject implements EmbeddedCuaDriverHostLike {
+    readonly [uniffiTypeNameSymbol] = "EmbeddedCuaDriverHost";
+    readonly [destructorGuardSymbol]: UniffiGcObject;
+    readonly [pointerLiteralSymbol]: UniffiHandle;
+    constructor(binaryPath: string, hostBundleId: string);
+    static withOptions(options: EmbeddedDriverHostOptions): EmbeddedCuaDriverHostLike;
+    connection(): EmbeddedDriverConnection | undefined;
+    restart(asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<EmbeddedDriverConnection>;
+    start(asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<EmbeddedDriverConnection>;
+    state(): EmbeddedDriverHostState;
+    stop(asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<void>;
+    waitForExit(generation: string, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<EmbeddedDriverExit>;
+    uniffiDestroy(): void;
+    static instanceOf(obj_: any): obj_ is EmbeddedCuaDriverHost;
+}
+/**
+ * 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.
+ */
+declare function uniffiEnsureInitialized(): void;
+declare const _default: Readonly<{
+    initialize: typeof uniffiEnsureInitialized;
+    converters: {
+        FfiConverterTypeCuaDriver: FfiConverterObject<CuaDriverLike>;
+        FfiConverterTypeDriverError: {
+            read(from: RustBuffer): DriverError;
+            write(value: DriverError, into: RustBuffer): void;
+            allocationSize(value: DriverError): number;
+            lift(value: UniffiByteArray): DriverError;
+            lower(value: DriverError, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
+        };
+        FfiConverterTypeDriverMetadata: {
+            read(from: RustBuffer): DriverMetadata;
+            write(value: DriverMetadata, into: RustBuffer): void;
+            allocationSize(value: DriverMetadata): number;
+            lift(value: UniffiByteArray): DriverMetadata;
+            lower(value: DriverMetadata, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
+        };
+        FfiConverterTypeEmbeddedCuaDriverHost: FfiConverterObject<EmbeddedCuaDriverHostLike>;
+        FfiConverterTypeEmbeddedDriverConnection: {
+            read(from: RustBuffer): EmbeddedDriverConnection;
+            write(value: EmbeddedDriverConnection, into: RustBuffer): void;
+            allocationSize(value: EmbeddedDriverConnection): number;
+            lift(value: UniffiByteArray): EmbeddedDriverConnection;
+            lower(value: EmbeddedDriverConnection, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
+        };
+        FfiConverterTypeEmbeddedDriverError: {
+            read(from: RustBuffer): EmbeddedDriverError;
+            write(value: EmbeddedDriverError, into: RustBuffer): void;
+            allocationSize(value: EmbeddedDriverError): number;
+            lift(value: UniffiByteArray): EmbeddedDriverError;
+            lower(value: EmbeddedDriverError, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
+        };
+        FfiConverterTypeEmbeddedDriverExit: {
+            read(from: RustBuffer): EmbeddedDriverExit;
+            write(value: EmbeddedDriverExit, into: RustBuffer): void;
+            allocationSize(value: EmbeddedDriverExit): number;
+            lift(value: UniffiByteArray): EmbeddedDriverExit;
+            lower(value: EmbeddedDriverExit, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
+        };
+        FfiConverterTypeEmbeddedDriverHostOptions: {
+            read(from: RustBuffer): EmbeddedDriverHostOptions;
+            write(value: EmbeddedDriverHostOptions, into: RustBuffer): void;
+            allocationSize(value: EmbeddedDriverHostOptions): number;
+            lift(value: UniffiByteArray): EmbeddedDriverHostOptions;
+            lower(value: EmbeddedDriverHostOptions, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
+        };
+        FfiConverterTypeEmbeddedDriverHostState: {
+            read(from: RustBuffer): EmbeddedDriverHostState;
+            write(value: EmbeddedDriverHostState, into: RustBuffer): void;
+            allocationSize(value: EmbeddedDriverHostState): number;
+            lift(value: UniffiByteArray): EmbeddedDriverHostState;
+            lower(value: EmbeddedDriverHostState, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
+        };
+        FfiConverterTypeEmbeddedEnvironmentVariable: {
+            read(from: RustBuffer): EmbeddedEnvironmentVariable;
+            write(value: EmbeddedEnvironmentVariable, into: RustBuffer): void;
+            allocationSize(value: EmbeddedEnvironmentVariable): number;
+            lift(value: UniffiByteArray): EmbeddedEnvironmentVariable;
+            lower(value: EmbeddedEnvironmentVariable, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
+        };
+        FfiConverterTypeEmbeddedMcpConfiguration: {
+            read(from: RustBuffer): EmbeddedMcpConfiguration;
+            write(value: EmbeddedMcpConfiguration, into: RustBuffer): void;
+            allocationSize(value: EmbeddedMcpConfiguration): number;
+            lift(value: UniffiByteArray): EmbeddedMcpConfiguration;
+            lower(value: EmbeddedMcpConfiguration, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
+        };
+        FfiConverterTypeEmbeddedPermissionMode: {
+            read(from: RustBuffer): EmbeddedPermissionMode;
+            write(value: EmbeddedPermissionMode, into: RustBuffer): void;
+            allocationSize(value: EmbeddedPermissionMode): number;
+            lift(value: UniffiByteArray): EmbeddedPermissionMode;
+            lower(value: EmbeddedPermissionMode, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
+        };
+        FfiConverterTypeImageContent: {
+            read(from: RustBuffer): ImageContent;
+            write(value: ImageContent, into: RustBuffer): void;
+            allocationSize(value: ImageContent): number;
+            lift(value: UniffiByteArray): ImageContent;
+            lower(value: ImageContent, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
+        };
+        FfiConverterTypeMacOsPermissionStatus: {
+            read(from: RustBuffer): MacOsPermissionStatus;
+            write(value: MacOsPermissionStatus, into: RustBuffer): void;
+            allocationSize(value: MacOsPermissionStatus): number;
+            lift(value: UniffiByteArray): MacOsPermissionStatus;
+            lower(value: MacOsPermissionStatus, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
+        };
+        FfiConverterTypeToolResult: {
+            read(from: RustBuffer): ToolResult;
+            write(value: ToolResult, into: RustBuffer): void;
+            allocationSize(value: ToolResult): number;
+            lift(value: UniffiByteArray): ToolResult;
+            lower(value: ToolResult, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
+        };
+    };
+}>;
+export default _default;