@trycua/cua-driver 0.12.5 → 0.14.0

package/dist/native/cua_driver_sdk.d.ts

@@ -1,8 +1,145 @@
-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";
+import { type ClickInput, type DragInput, type EndSessionInput, type EndSessionOutput, type EscalateSessionInput, type GetAgentCursorStateInput, type GetCursorPositionInput, type GetDesktopStateInput, type GetScreenSizeInput, type GetSessionStateInput, type HotkeyInput, type MoveCursorInput, type PressKeyInput, type ScrollInput, type SessionStateOutput, type SetAgentCursorEnabledInput, type SetAgentCursorMotionInput, type SetAgentCursorThemeInput, type StartSessionInput, type StartSessionOutput, type TypeTextInput } from "./cua_driver_contract.js";
+import { type UniffiByteArray, type UniffiGcObject, type UniffiHandle, FfiConverterObject, FfiConverterObjectWithCallbacks, RustBuffer, UniffiAbstractObject, destructorGuardSymbol, pointerLiteralSymbol, uniffiTypeNameSymbol } from "@ubjs/core";
+/**
+ * Generated-language host factory for a session-bound action surface.
+ *
+ * This remains a separate top-level capability instead of adding a required
+ * method to the released `CuaDriverProtocol` / `CuaDriverLike` structural
+ * interfaces.
+ */
+export declare function createTrustedSession(driver: CuaDriverLike, options: TrustedSessionOptions): CuaDriverSessionLike;
 export declare function currentMacOsPermissionStatus(): MacOsPermissionStatus;
 export declare function openMacOsScreenRecordingSettings(): void;
 export declare function requestMacOsPermissions(): MacOsPermissionStatus;
+/**
+ * Permission mode chosen by trusted host code for a runtime or session.
+ */
+export declare enum SessionPermissionMode {
+    Standard = 0,
+    Bounded = 1,
+    Unrestricted = 2
+}
+/**
+ * Immutable authorization ceiling supplied before a runtime accepts actions.
+ */
+export type RuntimeAuthorizationOptions = {
+    allowedModes: Array<SessionPermissionMode>;
+    /**
+     * Mode inherited by calls made through the released `CuaDriver` object
+     * rather than a trusted session-bound action surface.
+     */
+    compatibilityMode: SessionPermissionMode;
+    /**
+     * Required only when `compatibility_mode` is bounded.
+     */
+    compatibilityBoundedManifestPath?: string;
+    unrestrictedAcknowledged: boolean;
+    maxSessionTtlSeconds: bigint;
+    maxIdleTtlSeconds: bigint;
+};
+/**
+ * Generated factory for {@link RuntimeAuthorizationOptions} record objects.
+ */
+export declare const RuntimeAuthorizationOptions: Readonly<{
+    create: (partial: Partial<RuntimeAuthorizationOptions> & Required<Omit<RuntimeAuthorizationOptions, "compatibilityBoundedManifestPath">>) => RuntimeAuthorizationOptions;
+    new: (partial: Partial<RuntimeAuthorizationOptions> & Required<Omit<RuntimeAuthorizationOptions, "compatibilityBoundedManifestPath">>) => RuntimeAuthorizationOptions;
+    defaults: () => Partial<RuntimeAuthorizationOptions>;
+}>;
+/**
+ * Additive configured-runtime constructor options. Existing callers continue
+ * to use [`DriverOptions`] and inherit the compatibility session.
+ */
+export type ConfiguredDriverOptions = {
+    claudeCodeCompatibility: boolean;
+    authorization: RuntimeAuthorizationOptions;
+};
+/**
+ * Generated factory for {@link ConfiguredDriverOptions} record objects.
+ */
+export declare const ConfiguredDriverOptions: Readonly<{
+    create: (partial: Partial<ConfiguredDriverOptions> & Required<Omit<ConfiguredDriverOptions, never>>) => ConfiguredDriverOptions;
+    new: (partial: Partial<ConfiguredDriverOptions> & Required<Omit<ConfiguredDriverOptions, never>>) => ConfiguredDriverOptions;
+    defaults: () => Partial<ConfiguredDriverOptions>;
+}>;
+export declare enum DriverActivityKind {
+    AuthorizedAction = 0,
+    AuthorizationRefused = 1,
+    ActionFailed = 2,
+    GrantIssued = 3,
+    GrantRevoked = 4,
+    SessionStarted = 5,
+    SessionEnded = 6
+}
+/**
+ * A content-free lifecycle event emitted after native authorization decides
+ * a call. It never carries arguments, page text, paths, typed input, images,
+ * or raw resource identities.
+ */
+export type DriverActivityEvent = {
+    kind: DriverActivityKind;
+    unixMs: bigint;
+    toolName: string;
+    adapterIds: Array<string>;
+    riskClass: string;
+    publicSession?: string;
+    refusalCode?: string;
+};
+/**
+ * Generated factory for {@link DriverActivityEvent} record objects.
+ */
+export declare const DriverActivityEvent: Readonly<{
+    create: (partial: Partial<DriverActivityEvent> & Required<Omit<DriverActivityEvent, "publicSession" | "refusalCode">>) => DriverActivityEvent;
+    new: (partial: Partial<DriverActivityEvent> & Required<Omit<DriverActivityEvent, "publicSession" | "refusalCode">>) => DriverActivityEvent;
+    defaults: () => Partial<DriverActivityEvent>;
+}>;
+export declare enum DriverAuthorizationAction {
+    Allow = 0,
+    Deny = 1,
+    Cancel = 2
+}
+export type DriverAuthorizationDecision = {
+    action: DriverAuthorizationAction;
+    requestDigest: string;
+};
+/**
+ * Generated factory for {@link DriverAuthorizationDecision} record objects.
+ */
+export declare const DriverAuthorizationDecision: Readonly<{
+    create: (partial: Partial<DriverAuthorizationDecision> & Required<Omit<DriverAuthorizationDecision, never>>) => DriverAuthorizationDecision;
+    new: (partial: Partial<DriverAuthorizationDecision> & Required<Omit<DriverAuthorizationDecision, never>>) => DriverAuthorizationDecision;
+    defaults: () => Partial<DriverAuthorizationDecision>;
+}>;
+/**
+ * Content-bounded request delivered only to trusted host code.
+ *
+ * `resource_json` contains an attested resource identity. Hosts must avoid
+ * logging it or forwarding it to a model.
+ */
+export type DriverAuthorizationRequest = {
+    schema: string;
+    nonce: string;
+    generation: bigint;
+    daemonInstance: string;
+    permissionMode: string;
+    managedPolicySha256?: string;
+    userPolicySha256?: string;
+    adapterId: string;
+    riskClass: string;
+    publicSession: string;
+    transportSession: string;
+    resourceJson: string;
+    humanSummary: string;
+    expiresUnixMs: bigint;
+    requestDigest: string;
+};
+/**
+ * Generated factory for {@link DriverAuthorizationRequest} record objects.
+ */
+export declare const DriverAuthorizationRequest: Readonly<{
+    create: (partial: Partial<DriverAuthorizationRequest> & Required<Omit<DriverAuthorizationRequest, "managedPolicySha256" | "userPolicySha256">>) => DriverAuthorizationRequest;
+    new: (partial: Partial<DriverAuthorizationRequest> & Required<Omit<DriverAuthorizationRequest, "managedPolicySha256" | "userPolicySha256">>) => DriverAuthorizationRequest;
+    defaults: () => Partial<DriverAuthorizationRequest>;
+}>;
 /**
  * Transport-independent daemon identity used to prove that standalone and
  * embedded SDK/MCP routes reached a compatible Rust implementation.
@@ -120,8 +257,8 @@ export type EmbeddedDriverHostOptions = {
  * 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;
+    create: (partial: Partial<EmbeddedDriverHostOptions> & Required<Omit<EmbeddedDriverHostOptions, "socketPath" | "permissionMode" | "startupTimeoutMs" | "shutdownTimeoutMs" | "sessionPolicyPath">>) => EmbeddedDriverHostOptions;
+    new: (partial: Partial<EmbeddedDriverHostOptions> & Required<Omit<EmbeddedDriverHostOptions, "socketPath" | "permissionMode" | "startupTimeoutMs" | "shutdownTimeoutMs" | "sessionPolicyPath">>) => EmbeddedDriverHostOptions;
     defaults: () => Partial<EmbeddedDriverHostOptions>;
 }>;
 export type ImageContent = {
@@ -153,6 +290,29 @@ export declare const MacOsPermissionStatus: Readonly<{
     new: (partial: Partial<MacOsPermissionStatus> & Required<Omit<MacOsPermissionStatus, never>>) => MacOsPermissionStatus;
     defaults: () => Partial<MacOsPermissionStatus>;
 }>;
+/**
+ * Options for a directly supervised process-isolated runtime.
+ *
+ * The child receives configuration and actions only over inherited stdio. It
+ * exposes no socket and cannot be reconnected after the host channel closes.
+ */
+export type PrivateWorkerOptions = {
+    binaryPath: string;
+    hostBundleId: string;
+    startupTimeoutMs?: bigint;
+    shutdownTimeoutMs?: bigint;
+    configuredDriver: ConfiguredDriverOptions;
+    environment: Array<EmbeddedEnvironmentVariable>;
+    inheritStderr: boolean;
+};
+/**
+ * Generated factory for {@link PrivateWorkerOptions} record objects.
+ */
+export declare const PrivateWorkerOptions: Readonly<{
+    create: (partial: Partial<PrivateWorkerOptions> & Required<Omit<PrivateWorkerOptions, "startupTimeoutMs" | "shutdownTimeoutMs">>) => PrivateWorkerOptions;
+    new: (partial: Partial<PrivateWorkerOptions> & Required<Omit<PrivateWorkerOptions, "startupTimeoutMs" | "shutdownTimeoutMs">>) => PrivateWorkerOptions;
+    defaults: () => Partial<PrivateWorkerOptions>;
+}>;
 /**
  * Transport-neutral result envelope used for open-ended tool calls and
  * desktop tools whose platform extensions are intentionally preserved as JSON.
@@ -175,13 +335,133 @@ export declare const ToolResult: Readonly<{
     new: (partial: Partial<ToolResult> & Required<Omit<ToolResult, "errorCode" | "structuredJson" | "verified">>) => ToolResult;
     defaults: () => Partial<ToolResult>;
 }>;
+/**
+ * Trusted host request for one immutable, connection-bound action surface.
+ */
+export type TrustedSessionOptions = {
+    publicSession: string;
+    mode: SessionPermissionMode;
+    ttlSeconds: bigint;
+    idleTtlSeconds: bigint;
+    boundedManifestPath?: string;
+};
+/**
+ * Generated factory for {@link TrustedSessionOptions} record objects.
+ */
+export declare const TrustedSessionOptions: Readonly<{
+    create: (partial: Partial<TrustedSessionOptions> & Required<Omit<TrustedSessionOptions, "boundedManifestPath">>) => TrustedSessionOptions;
+    new: (partial: Partial<TrustedSessionOptions> & Required<Omit<TrustedSessionOptions, "boundedManifestPath">>) => TrustedSessionOptions;
+    defaults: () => Partial<TrustedSessionOptions>;
+}>;
+export declare enum ActionCompletion {
+    NotStarted = 0,
+    Completed = 1,
+    Unknown = 2
+}
+export declare enum DriverAuthorizationHostError_Tags {
+    Failed = "Failed"
+}
+export declare const DriverAuthorizationHostError: Readonly<{
+    instanceOf: (obj: any) => obj is DriverAuthorizationHostError;
+    Failed: {
+        new (inner: {
+            reason: string;
+        }): {
+            readonly tag: DriverAuthorizationHostError_Tags.Failed;
+            readonly inner: Readonly<{
+                reason: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "DriverAuthorizationHostError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        "new"(inner: {
+            reason: string;
+        }): {
+            readonly tag: DriverAuthorizationHostError_Tags.Failed;
+            readonly inner: Readonly<{
+                reason: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "DriverAuthorizationHostError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        instanceOf(obj: any): obj is {
+            readonly tag: DriverAuthorizationHostError_Tags.Failed;
+            readonly inner: Readonly<{
+                reason: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "DriverAuthorizationHostError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        hasInner(obj: any): obj is {
+            readonly tag: DriverAuthorizationHostError_Tags.Failed;
+            readonly inner: Readonly<{
+                reason: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "DriverAuthorizationHostError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        getInner(obj: {
+            readonly tag: DriverAuthorizationHostError_Tags.Failed;
+            readonly inner: Readonly<{
+                reason: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "DriverAuthorizationHostError";
+            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 DriverAuthorizationHostError = InstanceType<typeof DriverAuthorizationHostError['Failed']>;
 export declare enum DriverError_Tags {
     Configuration = "Configuration",
     InvalidArguments = "InvalidArguments",
     Transport = "Transport",
     Protocol = "Protocol",
     Tool = "Tool",
-    Shutdown = "Shutdown"
+    Shutdown = "Shutdown",
+    RuntimeAlreadyExists = "RuntimeAlreadyExists",
+    Worker = "Worker",
+    Remote = "Remote",
+    ActionInterrupted = "ActionInterrupted"
 }
 export declare const DriverError: Readonly<{
     instanceOf: (obj: any) => obj is DriverError;
@@ -574,9 +854,295 @@ export declare const DriverError: Readonly<{
         }): {
             readonly tag: DriverError_Tags.Tool;
             readonly inner: Readonly<{
-                tool: string;
-                message: string;
-                errorCode: string;
+                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;
+    };
+    Shutdown: {
+        new (): {
+            readonly tag: DriverError_Tags.Shutdown;
+            /**
+             * @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"(): {
+            readonly tag: DriverError_Tags.Shutdown;
+            /**
+             * @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.Shutdown;
+            /**
+             * @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.Shutdown;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "DriverError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+        prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+        stackTraceLimit: number;
+    };
+    RuntimeAlreadyExists: {
+        new (): {
+            readonly tag: DriverError_Tags.RuntimeAlreadyExists;
+            /**
+             * @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"(): {
+            readonly tag: DriverError_Tags.RuntimeAlreadyExists;
+            /**
+             * @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.RuntimeAlreadyExists;
+            /**
+             * @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.RuntimeAlreadyExists;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "DriverError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+        prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+        stackTraceLimit: number;
+    };
+    Worker: {
+        new (inner: {
+            reason: string;
+        }): {
+            readonly tag: DriverError_Tags.Worker;
+            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.Worker;
+            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.Worker;
+            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.Worker;
+            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.Worker;
+            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;
+    };
+    Remote: {
+        new (inner: {
+            reason: string;
+        }): {
+            readonly tag: DriverError_Tags.Remote;
+            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.Remote;
+            readonly inner: Readonly<{
+                reason: string;
             }>;
             /**
              * @private
@@ -589,11 +1155,9 @@ export declare const DriverError: Readonly<{
             cause?: unknown;
         };
         instanceOf(obj: any): obj is {
-            readonly tag: DriverError_Tags.Tool;
+            readonly tag: DriverError_Tags.Remote;
             readonly inner: Readonly<{
-                tool: string;
-                message: string;
-                errorCode: string;
+                reason: string;
             }>;
             /**
              * @private
@@ -606,11 +1170,9 @@ export declare const DriverError: Readonly<{
             cause?: unknown;
         };
         hasInner(obj: any): obj is {
-            readonly tag: DriverError_Tags.Tool;
+            readonly tag: DriverError_Tags.Remote;
             readonly inner: Readonly<{
-                tool: string;
-                message: string;
-                errorCode: string;
+                reason: string;
             }>;
             /**
              * @private
@@ -623,11 +1185,9 @@ export declare const DriverError: Readonly<{
             cause?: unknown;
         };
         getInner(obj: {
-            readonly tag: DriverError_Tags.Tool;
+            readonly tag: DriverError_Tags.Remote;
             readonly inner: Readonly<{
-                tool: string;
-                message: string;
-                errorCode: string;
+                reason: string;
             }>;
             /**
              * @private
@@ -639,17 +1199,22 @@ export declare const DriverError: Readonly<{
             stack?: string;
             cause?: unknown;
         }): Readonly<{
-            tool: string;
-            message: string;
-            errorCode: string;
+            reason: string;
         }>;
         captureStackTrace(targetObject: object, constructorOpt?: Function): void;
         prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
         stackTraceLimit: number;
     };
-    Shutdown: {
-        new (): {
-            readonly tag: DriverError_Tags.Shutdown;
+    ActionInterrupted: {
+        new (inner: {
+            completion: ActionCompletion;
+            reason: string;
+        }): {
+            readonly tag: DriverError_Tags.ActionInterrupted;
+            readonly inner: Readonly<{
+                completion: ActionCompletion;
+                reason: string;
+            }>;
             /**
              * @private
              * This field is private and should not be used, use `tag` instead.
@@ -660,8 +1225,15 @@ export declare const DriverError: Readonly<{
             stack?: string;
             cause?: unknown;
         };
-        "new"(): {
-            readonly tag: DriverError_Tags.Shutdown;
+        "new"(inner: {
+            completion: ActionCompletion;
+            reason: string;
+        }): {
+            readonly tag: DriverError_Tags.ActionInterrupted;
+            readonly inner: Readonly<{
+                completion: ActionCompletion;
+                reason: string;
+            }>;
             /**
              * @private
              * This field is private and should not be used, use `tag` instead.
@@ -673,7 +1245,11 @@ export declare const DriverError: Readonly<{
             cause?: unknown;
         };
         instanceOf(obj: any): obj is {
-            readonly tag: DriverError_Tags.Shutdown;
+            readonly tag: DriverError_Tags.ActionInterrupted;
+            readonly inner: Readonly<{
+                completion: ActionCompletion;
+                reason: string;
+            }>;
             /**
              * @private
              * This field is private and should not be used, use `tag` instead.
@@ -685,7 +1261,11 @@ export declare const DriverError: Readonly<{
             cause?: unknown;
         };
         hasInner(obj: any): obj is {
-            readonly tag: DriverError_Tags.Shutdown;
+            readonly tag: DriverError_Tags.ActionInterrupted;
+            readonly inner: Readonly<{
+                completion: ActionCompletion;
+                reason: string;
+            }>;
             /**
              * @private
              * This field is private and should not be used, use `tag` instead.
@@ -696,18 +1276,39 @@ export declare const DriverError: Readonly<{
             stack?: string;
             cause?: unknown;
         };
+        getInner(obj: {
+            readonly tag: DriverError_Tags.ActionInterrupted;
+            readonly inner: Readonly<{
+                completion: ActionCompletion;
+                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<{
+            completion: ActionCompletion;
+            reason: 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' | 'Shutdown']>;
+export type DriverError = InstanceType<typeof DriverError['Configuration' | 'InvalidArguments' | 'Transport' | 'Protocol' | 'Tool' | 'Shutdown' | 'RuntimeAlreadyExists' | 'Worker' | 'Remote' | 'ActionInterrupted']>;
 /**
  * Process topology used by this SDK object.
  */
 export declare enum DriverExecutionMode {
     Embedded = 0,
-    Daemon = 1
+    Daemon = 1,
+    PrivateWorker = 2,
+    Remote = 3
 }
 export declare enum EmbeddedDriverError_Tags {
     Configuration = "Configuration",
@@ -1431,6 +2032,9 @@ export interface CuaDriverLike {
         signal: AbortSignal;
     }): Promise<SessionStateOutput>;
     executionMode(): DriverExecutionMode;
+    getAgentCursorState(input: GetAgentCursorStateInput, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<ToolResult>;
     getCursorPosition(input: GetCursorPositionInput, asyncOpts_?: {
         signal: AbortSignal;
     }): Promise<ToolResult>;
@@ -1462,9 +2066,19 @@ export interface CuaDriverLike {
     pressKey(input: PressKeyInput, asyncOpts_?: {
         signal: AbortSignal;
     }): Promise<ToolResult>;
+    runtimeScopePrefix(): string | undefined;
     scroll(input: ScrollInput, asyncOpts_?: {
         signal: AbortSignal;
     }): Promise<ToolResult>;
+    setAgentCursorEnabled(input: SetAgentCursorEnabledInput, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<ToolResult>;
+    setAgentCursorMotion(input: SetAgentCursorMotionInput, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<ToolResult>;
+    setAgentCursorTheme(input: SetAgentCursorThemeInput, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<ToolResult>;
     /**
      * Stop accepting new embedded operations. Repeated calls are harmless;
      * daemon compatibility clients do not own the daemon and therefore no-op.
@@ -1508,6 +2122,60 @@ export declare class CuaDriver extends UniffiAbstractObject implements CuaDriver
      * `cua-driver` and never opens daemon IPC.
      */
     static create(options: DriverOptions | undefined): CuaDriverLike;
+    /**
+     * Create a same-process runtime with an explicit immutable authorization
+     * ceiling. This is a trusted host constructor and is not exposed as an
+     * agent tool. Existing `create()` callers remain unchanged.
+     */
+    static createConfigured(options: ConfiguredDriverOptions): CuaDriverLike;
+    /**
+     * Create a configured same-process runtime with a content-free activity
+     * observer supplied by trusted embedding-host code.
+     */
+    static createConfiguredWithActivityObserver(options: ConfiguredDriverOptions, observer: DriverActivityObserver): CuaDriverLike;
+    /**
+     * Language-package entry point for a configured activity-observer runtime.
+     */
+    static createConfiguredWithActivityObserverAndClientKind(options: ConfiguredDriverOptions, observer: DriverActivityObserver, clientKind: SdkClientKind): CuaDriverLike;
+    /**
+     * Create a configured same-process runtime with an optional residual
+     * authorization callback supplied by trusted embedding-host code.
+     *
+     * The callback object is immutable runtime configuration. Applications
+     * must not expose it to an agent or implement it using ordinary MCP
+     * elicitation, model-visible stdio, or an auto-accepting callback.
+     */
+    static createConfiguredWithAuthorizationHost(options: ConfiguredDriverOptions, host: DriverAuthorizationHost): CuaDriverLike;
+    /**
+     * Language-package entry point for a configured protected-host runtime.
+     */
+    static createConfiguredWithAuthorizationHostAndClientKind(options: ConfiguredDriverOptions, host: DriverAuthorizationHost, clientKind: SdkClientKind): CuaDriverLike;
+    /**
+     * Language-package entry point for an explicitly configured runtime.
+     */
+    static createConfiguredWithClientKind(options: ConfiguredDriverOptions, clientKind: SdkClientKind): CuaDriverLike;
+    /**
+     * Create a configured same-process runtime with both residual
+     * authorization and content-free activity callbacks.
+     */
+    static createConfiguredWithHostIntegrations(options: ConfiguredDriverOptions, host: DriverAuthorizationHost, observer: DriverActivityObserver): CuaDriverLike;
+    /**
+     * Language-package entry point for both trusted host callbacks.
+     */
+    static createConfiguredWithHostIntegrationsAndClientKind(options: ConfiguredDriverOptions, host: DriverAuthorizationHost, observer: DriverActivityObserver, clientKind: SdkClientKind): CuaDriverLike;
+    /**
+     * Create a process-isolated runtime owned by this SDK object.
+     *
+     * This constructor directly spawns the supplied Cua Driver binary and
+     * communicates only over inherited stdio. No daemon or reusable endpoint
+     * is created.
+     */
+    static createPrivateWorker(options: PrivateWorkerOptions): CuaDriverLike;
+    /**
+     * Language-package entry point that preserves the worker constructor
+     * while attaching the importing SDK runtime category.
+     */
+    static createPrivateWorkerWithClientKind(options: PrivateWorkerOptions, clientKind: SdkClientKind): CuaDriverLike;
     /**
      * Language-package entry point for the same-process runtime. The wrapper
      * at each package root selects the client kind automatically.
@@ -1534,6 +2202,9 @@ export declare class CuaDriver extends UniffiAbstractObject implements CuaDriver
         signal: AbortSignal;
     }): Promise<SessionStateOutput>;
     executionMode(): DriverExecutionMode;
+    getAgentCursorState(input: GetAgentCursorStateInput, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<ToolResult>;
     getCursorPosition(input: GetCursorPositionInput, asyncOpts_?: {
         signal: AbortSignal;
     }): Promise<ToolResult>;
@@ -1565,9 +2236,19 @@ export declare class CuaDriver extends UniffiAbstractObject implements CuaDriver
     pressKey(input: PressKeyInput, asyncOpts_?: {
         signal: AbortSignal;
     }): Promise<ToolResult>;
+    runtimeScopePrefix(): string | undefined;
     scroll(input: ScrollInput, asyncOpts_?: {
         signal: AbortSignal;
     }): Promise<ToolResult>;
+    setAgentCursorEnabled(input: SetAgentCursorEnabledInput, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<ToolResult>;
+    setAgentCursorMotion(input: SetAgentCursorMotionInput, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<ToolResult>;
+    setAgentCursorTheme(input: SetAgentCursorThemeInput, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<ToolResult>;
     /**
      * Stop accepting new embedded operations. Repeated calls are harmless;
      * daemon compatibility clients do not own the daemon and therefore no-op.
@@ -1589,6 +2270,202 @@ export declare class CuaDriver extends UniffiAbstractObject implements CuaDriver
     uniffiDestroy(): void;
     static instanceOf(obj_: any): obj_ is CuaDriver;
 }
+export interface CuaDriverSessionLike {
+    callTool(name: string, argumentsJson: string, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<ToolResult>;
+    click(input: ClickInput, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<ToolResult>;
+    /**
+     * Revoke the session-bound authority and release its native handle.
+     *
+     * This operation is idempotent. Dropping the object performs the same
+     * cleanup, but trusted hosts should call it at their lifecycle boundary.
+     */
+    close(): void;
+    drag(input: DragInput, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<ToolResult>;
+    endSession(input: EndSessionInput, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<EndSessionOutput>;
+    escalateSession(input: EscalateSessionInput, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<SessionStateOutput>;
+    getAgentCursorState(input: GetAgentCursorStateInput, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<ToolResult>;
+    getCursorPosition(input: GetCursorPositionInput, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<ToolResult>;
+    getDesktopState(input: GetDesktopStateInput, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<ToolResult>;
+    getScreenSize(input: GetScreenSizeInput, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<ToolResult>;
+    getSessionState(input: GetSessionStateInput, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<SessionStateOutput>;
+    hotkey(input: HotkeyInput, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<ToolResult>;
+    moveCursor(input: MoveCursorInput, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<ToolResult>;
+    pressKey(input: PressKeyInput, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<ToolResult>;
+    scroll(input: ScrollInput, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<ToolResult>;
+    setAgentCursorEnabled(input: SetAgentCursorEnabledInput, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<ToolResult>;
+    setAgentCursorMotion(input: SetAgentCursorMotionInput, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<ToolResult>;
+    setAgentCursorTheme(input: SetAgentCursorThemeInput, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<ToolResult>;
+    startSession(input: StartSessionInput, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<StartSessionOutput>;
+    typeText(input: TypeTextInput, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<ToolResult>;
+}
+/**
+ * @deprecated Use `CuaDriverSessionLike` instead.
+ */
+export type CuaDriverSessionInterface = CuaDriverSessionLike;
+export declare class CuaDriverSession extends UniffiAbstractObject implements CuaDriverSessionLike {
+    readonly [uniffiTypeNameSymbol] = "CuaDriverSession";
+    readonly [destructorGuardSymbol]: UniffiGcObject;
+    readonly [pointerLiteralSymbol]: UniffiHandle;
+    private constructor();
+    callTool(name: string, argumentsJson: string, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<ToolResult>;
+    click(input: ClickInput, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<ToolResult>;
+    /**
+     * Revoke the session-bound authority and release its native handle.
+     *
+     * This operation is idempotent. Dropping the object performs the same
+     * cleanup, but trusted hosts should call it at their lifecycle boundary.
+     */
+    close(): void;
+    drag(input: DragInput, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<ToolResult>;
+    endSession(input: EndSessionInput, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<EndSessionOutput>;
+    escalateSession(input: EscalateSessionInput, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<SessionStateOutput>;
+    getAgentCursorState(input: GetAgentCursorStateInput, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<ToolResult>;
+    getCursorPosition(input: GetCursorPositionInput, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<ToolResult>;
+    getDesktopState(input: GetDesktopStateInput, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<ToolResult>;
+    getScreenSize(input: GetScreenSizeInput, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<ToolResult>;
+    getSessionState(input: GetSessionStateInput, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<SessionStateOutput>;
+    hotkey(input: HotkeyInput, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<ToolResult>;
+    moveCursor(input: MoveCursorInput, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<ToolResult>;
+    pressKey(input: PressKeyInput, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<ToolResult>;
+    scroll(input: ScrollInput, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<ToolResult>;
+    setAgentCursorEnabled(input: SetAgentCursorEnabledInput, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<ToolResult>;
+    setAgentCursorMotion(input: SetAgentCursorMotionInput, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<ToolResult>;
+    setAgentCursorTheme(input: SetAgentCursorThemeInput, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<ToolResult>;
+    startSession(input: StartSessionInput, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<StartSessionOutput>;
+    typeText(input: TypeTextInput, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<ToolResult>;
+    uniffiDestroy(): void;
+    static instanceOf(obj_: any): obj_ is CuaDriverSession;
+}
+/**
+ * Optional observer implemented by trusted embedding-host code.
+ *
+ * Observations are informational and cannot grant authority or change a tool
+ * result. Implementations should return quickly and hand off expensive work.
+ */
+export interface DriverActivityObserver {
+    onActivity(event: DriverActivityEvent): void;
+}
+/**
+ * Optional observer implemented by trusted embedding-host code.
+ *
+ * Observations are informational and cannot grant authority or change a tool
+ * result. Implementations should return quickly and hand off expensive work.
+ */
+export declare class DriverActivityObserverImpl extends UniffiAbstractObject implements DriverActivityObserver {
+    readonly [uniffiTypeNameSymbol] = "DriverActivityObserverImpl";
+    readonly [destructorGuardSymbol]: UniffiGcObject;
+    readonly [pointerLiteralSymbol]: UniffiHandle;
+    private constructor();
+    onActivity(event: DriverActivityEvent): void;
+    uniffiDestroy(): void;
+    static instanceOf(obj_: any): obj_ is DriverActivityObserverImpl;
+}
+/**
+ * Optional callback implemented by a trusted embedding application.
+ *
+ * Cua invokes this only for a residual boundary whose active permission mode
+ * requires a host grant. Routine standard-mode automation and every
+ * in-manifest bounded operation bypass it.
+ */
+export interface DriverAuthorizationHost {
+    authorize(request: DriverAuthorizationRequest, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<DriverAuthorizationDecision>;
+}
+/**
+ * Optional callback implemented by a trusted embedding application.
+ *
+ * Cua invokes this only for a residual boundary whose active permission mode
+ * requires a host grant. Routine standard-mode automation and every
+ * in-manifest bounded operation bypass it.
+ */
+export declare class DriverAuthorizationHostImpl extends UniffiAbstractObject implements DriverAuthorizationHost {
+    readonly [uniffiTypeNameSymbol] = "DriverAuthorizationHostImpl";
+    readonly [destructorGuardSymbol]: UniffiGcObject;
+    readonly [pointerLiteralSymbol]: UniffiHandle;
+    private constructor();
+    authorize(request: DriverAuthorizationRequest, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<DriverAuthorizationDecision>;
+    uniffiDestroy(): void;
+    static instanceOf(obj_: any): obj_ is DriverAuthorizationHostImpl;
+}
 export interface EmbeddedCuaDriverHostLike {
     connection(): EmbeddedDriverConnection | undefined;
     restart(asyncOpts_?: {
@@ -1646,7 +2523,136 @@ declare function uniffiEnsureInitialized(): void;
 declare const _default: Readonly<{
     initialize: typeof uniffiEnsureInitialized;
     converters: {
+        FfiConverterTypeActionCompletion: {
+            read(from: RustBuffer): ActionCompletion;
+            write(value: ActionCompletion, into: RustBuffer): void;
+            allocationSize(value: ActionCompletion): number;
+            lift(value: UniffiByteArray): ActionCompletion;
+            lower(value: ActionCompletion, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
+        };
+        FfiConverterTypeConfiguredDriverOptions: {
+            read(from: RustBuffer): ConfiguredDriverOptions;
+            write(value: ConfiguredDriverOptions, into: RustBuffer): void;
+            allocationSize(value: ConfiguredDriverOptions): number;
+            lift(value: UniffiByteArray): ConfiguredDriverOptions;
+            lower(value: ConfiguredDriverOptions, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
+        };
         FfiConverterTypeCuaDriver: FfiConverterObject<CuaDriverLike>;
+        FfiConverterTypeCuaDriverSession: FfiConverterObject<CuaDriverSessionLike>;
+        FfiConverterTypeDriverActivityEvent: {
+            read(from: RustBuffer): DriverActivityEvent;
+            write(value: DriverActivityEvent, into: RustBuffer): void;
+            allocationSize(value: DriverActivityEvent): number;
+            lift(value: UniffiByteArray): DriverActivityEvent;
+            lower(value: DriverActivityEvent, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
+        };
+        FfiConverterTypeDriverActivityKind: {
+            read(from: RustBuffer): DriverActivityKind;
+            write(value: DriverActivityKind, into: RustBuffer): void;
+            allocationSize(value: DriverActivityKind): number;
+            lift(value: UniffiByteArray): DriverActivityKind;
+            lower(value: DriverActivityKind, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
+        };
+        FfiConverterTypeDriverActivityObserver: FfiConverterObjectWithCallbacks<DriverActivityObserver>;
+        FfiConverterTypeDriverAuthorizationAction: {
+            read(from: RustBuffer): DriverAuthorizationAction;
+            write(value: DriverAuthorizationAction, into: RustBuffer): void;
+            allocationSize(value: DriverAuthorizationAction): number;
+            lift(value: UniffiByteArray): DriverAuthorizationAction;
+            lower(value: DriverAuthorizationAction, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
+        };
+        FfiConverterTypeDriverAuthorizationDecision: {
+            read(from: RustBuffer): DriverAuthorizationDecision;
+            write(value: DriverAuthorizationDecision, into: RustBuffer): void;
+            allocationSize(value: DriverAuthorizationDecision): number;
+            lift(value: UniffiByteArray): DriverAuthorizationDecision;
+            lower(value: DriverAuthorizationDecision, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
+        };
+        FfiConverterTypeDriverAuthorizationHost: FfiConverterObjectWithCallbacks<DriverAuthorizationHost>;
+        FfiConverterTypeDriverAuthorizationHostError: {
+            read(from: RustBuffer): {
+                readonly tag: DriverAuthorizationHostError_Tags.Failed;
+                readonly inner: Readonly<{
+                    reason: string;
+                }>;
+                /**
+                 * @private
+                 * This field is private and should not be used, use `tag` instead.
+                 */
+                readonly [uniffiTypeNameSymbol]: "DriverAuthorizationHostError";
+                name: string;
+                message: string;
+                stack?: string;
+                cause?: unknown;
+            };
+            write(value: {
+                readonly tag: DriverAuthorizationHostError_Tags.Failed;
+                readonly inner: Readonly<{
+                    reason: string;
+                }>;
+                /**
+                 * @private
+                 * This field is private and should not be used, use `tag` instead.
+                 */
+                readonly [uniffiTypeNameSymbol]: "DriverAuthorizationHostError";
+                name: string;
+                message: string;
+                stack?: string;
+                cause?: unknown;
+            }, into: RustBuffer): void;
+            allocationSize(value: {
+                readonly tag: DriverAuthorizationHostError_Tags.Failed;
+                readonly inner: Readonly<{
+                    reason: string;
+                }>;
+                /**
+                 * @private
+                 * This field is private and should not be used, use `tag` instead.
+                 */
+                readonly [uniffiTypeNameSymbol]: "DriverAuthorizationHostError";
+                name: string;
+                message: string;
+                stack?: string;
+                cause?: unknown;
+            }): number;
+            lift(value: UniffiByteArray): {
+                readonly tag: DriverAuthorizationHostError_Tags.Failed;
+                readonly inner: Readonly<{
+                    reason: string;
+                }>;
+                /**
+                 * @private
+                 * This field is private and should not be used, use `tag` instead.
+                 */
+                readonly [uniffiTypeNameSymbol]: "DriverAuthorizationHostError";
+                name: string;
+                message: string;
+                stack?: string;
+                cause?: unknown;
+            };
+            lower(value: {
+                readonly tag: DriverAuthorizationHostError_Tags.Failed;
+                readonly inner: Readonly<{
+                    reason: string;
+                }>;
+                /**
+                 * @private
+                 * This field is private and should not be used, use `tag` instead.
+                 */
+                readonly [uniffiTypeNameSymbol]: "DriverAuthorizationHostError";
+                name: string;
+                message: string;
+                stack?: string;
+                cause?: unknown;
+            }, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
+        };
+        FfiConverterTypeDriverAuthorizationRequest: {
+            read(from: RustBuffer): DriverAuthorizationRequest;
+            write(value: DriverAuthorizationRequest, into: RustBuffer): void;
+            allocationSize(value: DriverAuthorizationRequest): number;
+            lift(value: UniffiByteArray): DriverAuthorizationRequest;
+            lower(value: DriverAuthorizationRequest, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
+        };
         FfiConverterTypeDriverError: {
             read(from: RustBuffer): DriverError;
             write(value: DriverError, into: RustBuffer): void;
@@ -1746,6 +2752,20 @@ declare const _default: Readonly<{
             lift(value: UniffiByteArray): MacOsPermissionStatus;
             lower(value: MacOsPermissionStatus, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
         };
+        FfiConverterTypePrivateWorkerOptions: {
+            read(from: RustBuffer): PrivateWorkerOptions;
+            write(value: PrivateWorkerOptions, into: RustBuffer): void;
+            allocationSize(value: PrivateWorkerOptions): number;
+            lift(value: UniffiByteArray): PrivateWorkerOptions;
+            lower(value: PrivateWorkerOptions, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
+        };
+        FfiConverterTypeRuntimeAuthorizationOptions: {
+            read(from: RustBuffer): RuntimeAuthorizationOptions;
+            write(value: RuntimeAuthorizationOptions, into: RustBuffer): void;
+            allocationSize(value: RuntimeAuthorizationOptions): number;
+            lift(value: UniffiByteArray): RuntimeAuthorizationOptions;
+            lower(value: RuntimeAuthorizationOptions, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
+        };
         FfiConverterTypeSdkClientKind: {
             read(from: RustBuffer): SdkClientKind;
             write(value: SdkClientKind, into: RustBuffer): void;
@@ -1753,6 +2773,13 @@ declare const _default: Readonly<{
             lift(value: UniffiByteArray): SdkClientKind;
             lower(value: SdkClientKind, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
         };
+        FfiConverterTypeSessionPermissionMode: {
+            read(from: RustBuffer): SessionPermissionMode;
+            write(value: SessionPermissionMode, into: RustBuffer): void;
+            allocationSize(value: SessionPermissionMode): number;
+            lift(value: UniffiByteArray): SessionPermissionMode;
+            lower(value: SessionPermissionMode, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
+        };
         FfiConverterTypeToolResult: {
             read(from: RustBuffer): ToolResult;
             write(value: ToolResult, into: RustBuffer): void;
@@ -1760,6 +2787,13 @@ declare const _default: Readonly<{
             lift(value: UniffiByteArray): ToolResult;
             lower(value: ToolResult, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
         };
+        FfiConverterTypeTrustedSessionOptions: {
+            read(from: RustBuffer): TrustedSessionOptions;
+            write(value: TrustedSessionOptions, into: RustBuffer): void;
+            allocationSize(value: TrustedSessionOptions): number;
+            lift(value: UniffiByteArray): TrustedSessionOptions;
+            lower(value: TrustedSessionOptions, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
+        };
     };
 }>;
 export default _default;