@trycua/cua-driver 0.34.1 → 0.35.4

package/dist/native/cua_driver_sdk.js

@@ -4,9 +4,9 @@
 /* eslint-disable */
 // @ts-nocheck
 import nativeModule from "./cua_driver_sdk-ffi.js";
-import { AbstractFfiConverterByteArray, FfiConverterArray, FfiConverterArrayBuffer, FfiConverterBool, FfiConverterInt32, FfiConverterObject, FfiConverterObjectWithCallbacks, FfiConverterOptional, FfiConverterUInt16, FfiConverterUInt32, FfiConverterUInt64, UniffiAbstractObject, UniffiError, UniffiInternalError, UniffiResult, UniffiRustCaller, destructorGuardSymbol, pointerLiteralSymbol, uniffiCreateFfiConverterString, uniffiCreateRecord, uniffiRustCallAsync, uniffiTraitInterfaceCall, uniffiTraitInterfaceCallAsyncWithError, uniffiTraitInterfaceCallWithError, uniffiTypeNameSymbol, } from "@ubjs/core";
+import { AbstractFfiConverterByteArray, FfiConverterArray, FfiConverterArrayBuffer, FfiConverterBool, FfiConverterFloat64, FfiConverterInt32, FfiConverterObject, FfiConverterObjectWithCallbacks, FfiConverterOptional, FfiConverterUInt16, FfiConverterUInt32, FfiConverterUInt64, UniffiAbstractObject, UniffiEnum, UniffiError, UniffiInternalError, UniffiResult, UniffiRustCaller, destructorGuardSymbol, pointerLiteralSymbol, uniffiCreateFfiConverterString, uniffiCreateRecord, uniffiRustCallAsync, uniffiTraitInterfaceCall, uniffiTraitInterfaceCallAsyncWithError, uniffiTraitInterfaceCallWithError, uniffiTypeNameSymbol, } from "@ubjs/core";
 import uniffiCuaDriverContractModule from "./cua_driver_contract.js";
-const { FfiConverterTypeActionResult, FfiConverterTypeClickInput, FfiConverterTypeClipboardReadInput, FfiConverterTypeClipboardWriteInput, FfiConverterTypeDragInput, FfiConverterTypeEndSessionInput, FfiConverterTypeEndSessionOutput, FfiConverterTypeEscalateSessionInput, FfiConverterTypeGetAgentCursorStateInput, FfiConverterTypeGetCursorPositionInput, FfiConverterTypeGetDesktopStateInput, FfiConverterTypeGetScreenSizeInput, FfiConverterTypeGetSessionInput, FfiConverterTypeGetSessionStateInput, FfiConverterTypeGetWindowStateInput, FfiConverterTypeHotkeyInput, FfiConverterTypeInvokeMenuInput, FfiConverterTypeListAppsInput, FfiConverterTypeListAppsOutput, FfiConverterTypeListSessionsInput, FfiConverterTypeListSessionsOutput, FfiConverterTypeListWindowsInput, FfiConverterTypeListWindowsOutput, FfiConverterTypeMoveCursorInput, FfiConverterTypeParseVisualRegionsInput, FfiConverterTypePressKeyInput, FfiConverterTypeScrollInput, FfiConverterTypeSessionOutput, FfiConverterTypeSessionStateOutput, FfiConverterTypeSetAgentCursorEnabledInput, FfiConverterTypeSetAgentCursorMotionInput, FfiConverterTypeSetAgentCursorThemeInput, FfiConverterTypeSetWindowFrameInput, FfiConverterTypeStartSessionInput, FfiConverterTypeStartSessionOutput, FfiConverterTypeTypeTextInput, FfiConverterTypeVerifyStateInput, FfiConverterTypeVerifyStateOutput, FfiConverterTypeWindowStateOutput } = uniffiCuaDriverContractModule.converters;
+const { FfiConverterTypeActionResult, FfiConverterTypeClickInput, FfiConverterTypeClipboardReadInput, FfiConverterTypeClipboardWriteInput, FfiConverterTypeCursorMotionEffects, FfiConverterTypeCursorMotionEffectsOutput, FfiConverterTypeCursorMotionStyle, FfiConverterTypeCursorMotionTiming, FfiConverterTypeDragInput, FfiConverterTypeEndSessionInput, FfiConverterTypeEndSessionOutput, FfiConverterTypeEscalateSessionInput, FfiConverterTypeGetAgentCursorStateInput, FfiConverterTypeGetCursorPositionInput, FfiConverterTypeGetDesktopStateInput, FfiConverterTypeGetScreenSizeInput, FfiConverterTypeGetSessionInput, FfiConverterTypeGetSessionStateInput, FfiConverterTypeGetWindowStateInput, FfiConverterTypeHotkeyInput, FfiConverterTypeInvokeMenuInput, FfiConverterTypeListAppsInput, FfiConverterTypeListAppsOutput, FfiConverterTypeListSessionsInput, FfiConverterTypeListSessionsOutput, FfiConverterTypeListWindowsInput, FfiConverterTypeListWindowsOutput, FfiConverterTypeMoveCursorInput, FfiConverterTypeParseVisualRegionsInput, FfiConverterTypePressKeyInput, FfiConverterTypeScrollInput, FfiConverterTypeSessionOutput, FfiConverterTypeSessionStateOutput, FfiConverterTypeSetAgentCursorEnabledInput, FfiConverterTypeSetAgentCursorMotionInput, FfiConverterTypeSetAgentCursorThemeInput, FfiConverterTypeSetWindowFrameInput, FfiConverterTypeStartSessionInput, FfiConverterTypeStartSessionOutput, FfiConverterTypeTypeTextInput, FfiConverterTypeVerifyStateInput, FfiConverterTypeVerifyStateOutput, FfiConverterTypeWindowStateOutput } = uniffiCuaDriverContractModule.converters;
 const uniffiCaller = new UniffiRustCaller(() => ({ code: 0 }));
 const uniffiIsDebug = 
 // @ts-ignore -- The process global might not be defined
@@ -87,6 +87,58 @@ export function currentMacOsPermissionStatus() {
     }, 
     /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)));
 }
+/**
+ * Click effects (ripple, squish) `age` seconds after a click at `(x, y)`.
+ */
+export function cursorClickEffects(effects, age, x, y) {
+    return ((__rb) => {
+        try {
+            return FfiConverterTypeCursorEffectFrame.lift(__rb);
+        }
+        finally {
+            nativeModule().rustbuffer_free(__rb);
+        }
+    })(uniffiCaller.rustCall(
+    /*caller:*/ (callStatus) => {
+        return nativeModule().uniffi_cua_driver_sdk_fn_func_cursor_click_effects(FfiConverterTypeCursorMotionEffectsOutput.lower(effects, nativeModule().rustbuffer_alloc), FfiConverterFloat64.lower(age, nativeModule().rustbuffer_alloc), FfiConverterFloat64.lower(x, nativeModule().rustbuffer_alloc), FfiConverterFloat64.lower(y, nativeModule().rustbuffer_alloc), callStatus);
+    }, 
+    /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)));
+}
+/**
+ * The spec behind a built-in style (`signature_arc`, `spring_settle` and
+ * `comet_swoop`); `None` for the simulated styles.
+ */
+export function cursorMotionSpecForStyle(style, params) {
+    return ((__rb) => {
+        try {
+            return FfiConverterOptionalTypeCursorMotionSpec.lift(__rb);
+        }
+        finally {
+            nativeModule().rustbuffer_free(__rb);
+        }
+    })(uniffiCaller.rustCall(
+    /*caller:*/ (callStatus) => {
+        return nativeModule().uniffi_cua_driver_sdk_fn_func_cursor_motion_spec_for_style(FfiConverterTypeCursorMotionStyle.lower(style, nativeModule().rustbuffer_alloc), FfiConverterTypeCursorMotionParams.lower(params, nativeModule().rustbuffer_alloc), callStatus);
+    }, 
+    /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)));
+}
+/**
+ * Cua Driver's default motion knobs.
+ */
+export function defaultCursorMotionParams() {
+    return ((__rb) => {
+        try {
+            return FfiConverterTypeCursorMotionParams.lift(__rb);
+        }
+        finally {
+            nativeModule().rustbuffer_free(__rb);
+        }
+    })(uniffiCaller.rustCall(
+    /*caller:*/ (callStatus) => {
+        return nativeModule().uniffi_cua_driver_sdk_fn_func_default_cursor_motion_params(callStatus);
+    }, 
+    /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)));
+}
 export function openMacOsScreenRecordingSettings() {
     uniffiCaller.rustCallWithError(
     /*liftError:*/ FfiConverterTypeDriverError.lift.bind(FfiConverterTypeDriverError), 
@@ -106,6 +158,26 @@ export function openMcpDriverChannel(transport, authenticatedPrincipal) {
     }, 
     /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)));
 }
+/**
+ * Plan one move for a built-in style.
+ */
+export function planCursorMove(params, request) {
+    return FfiConverterTypeCursorTrajectory.lift(uniffiCaller.rustCall(
+    /*caller:*/ (callStatus) => {
+        return nativeModule().uniffi_cua_driver_sdk_fn_func_plan_cursor_move(FfiConverterTypeCursorMotionParams.lower(params, nativeModule().rustbuffer_alloc), FfiConverterTypeCursorMoveRequest.lower(request, nativeModule().rustbuffer_alloc), callStatus);
+    }, 
+    /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)));
+}
+/**
+ * Plan one move for a custom spec.
+ */
+export function planCursorSpec(spec, request) {
+    return FfiConverterTypeCursorTrajectory.lift(uniffiCaller.rustCall(
+    /*caller:*/ (callStatus) => {
+        return nativeModule().uniffi_cua_driver_sdk_fn_func_plan_cursor_spec(FfiConverterTypeCursorMotionSpec.lower(spec, nativeModule().rustbuffer_alloc), FfiConverterTypeCursorMoveRequest.lower(request, nativeModule().rustbuffer_alloc), callStatus);
+    }, 
+    /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)));
+}
 export function requestMacOsPermissions() {
     return ((__rb) => {
         try {
@@ -142,9 +214,1216 @@ const FfiConverterTypeSessionPermissionMode = (() => {
         }
         write(value, into) {
             switch (value) {
-                case SessionPermissionMode.Standard: return ordinalConverter.write(1, into);
-                case SessionPermissionMode.Bounded: return ordinalConverter.write(2, into);
-                case SessionPermissionMode.Unrestricted: return ordinalConverter.write(3, into);
+                case SessionPermissionMode.Standard: return ordinalConverter.write(1, into);
+                case SessionPermissionMode.Bounded: return ordinalConverter.write(2, into);
+                case SessionPermissionMode.Unrestricted: return ordinalConverter.write(3, into);
+            }
+        }
+        allocationSize(value) {
+            return ordinalConverter.allocationSize(0);
+        }
+    }
+    return new FFIConverter();
+})();
+const stringConverter = (() => {
+    const encoder = new TextEncoder();
+    const decoder = new TextDecoder();
+    return {
+        stringToBytes: (s) => encoder.encode(s),
+        bytesToString: (ab) => decoder.decode(ab),
+        stringByteLength: (s) => encoder.encode(s).byteLength,
+        writeStringIntoBuffer: (s, buf, offset) => {
+            const view = new Uint8Array(buf.arrayBuffer, offset, buf.arrayBuffer.byteLength - offset);
+            return encoder.encodeInto(s, view).written;
+        },
+        readStringFromBuffer: (buf, offset, length) => decoder.decode(new Uint8Array(buf.arrayBuffer, offset, length)),
+    };
+})();
+const FfiConverterString = uniffiCreateFfiConverterString(stringConverter);
+/**
+ * Generated factory for {@link RuntimeAuthorizationOptions} record objects.
+ */
+export const RuntimeAuthorizationOptions = (() => {
+    const defaults = () => ({
+        compatibilityCapabilityManifestPath: undefined,
+    });
+    const create = (() => {
+        return uniffiCreateRecord(defaults);
+    })();
+    return Object.freeze({
+        create,
+        new: create,
+        defaults: () => Object.freeze(defaults()),
+    });
+})();
+const FfiConverterTypeRuntimeAuthorizationOptions = (() => {
+    class FFIConverter extends AbstractFfiConverterByteArray {
+        read(from) {
+            return {
+                allowedModes: FfiConverterSequenceTypeSessionPermissionMode.read(from),
+                compatibilityMode: FfiConverterTypeSessionPermissionMode.read(from),
+                compatibilityCapabilityManifestPath: FfiConverterOptionalString.read(from),
+                compatibilityBoundedManifestPath: FfiConverterOptionalString.read(from),
+                unrestrictedAcknowledged: FfiConverterBool.read(from),
+                maxSessionTtlSeconds: FfiConverterUInt64.read(from),
+                maxIdleTtlSeconds: FfiConverterUInt64.read(from)
+            };
+        }
+        write(value, into) {
+            FfiConverterSequenceTypeSessionPermissionMode.write(value.allowedModes, into);
+            FfiConverterTypeSessionPermissionMode.write(value.compatibilityMode, into);
+            FfiConverterOptionalString.write(value.compatibilityCapabilityManifestPath, into);
+            FfiConverterOptionalString.write(value.compatibilityBoundedManifestPath, into);
+            FfiConverterBool.write(value.unrestrictedAcknowledged, into);
+            FfiConverterUInt64.write(value.maxSessionTtlSeconds, into);
+            FfiConverterUInt64.write(value.maxIdleTtlSeconds, into);
+        }
+        allocationSize(value) {
+            return FfiConverterSequenceTypeSessionPermissionMode.allocationSize(value.allowedModes) +
+                FfiConverterTypeSessionPermissionMode.allocationSize(value.compatibilityMode) +
+                FfiConverterOptionalString.allocationSize(value.compatibilityCapabilityManifestPath) +
+                FfiConverterOptionalString.allocationSize(value.compatibilityBoundedManifestPath) +
+                FfiConverterBool.allocationSize(value.unrestrictedAcknowledged) +
+                FfiConverterUInt64.allocationSize(value.maxSessionTtlSeconds) +
+                FfiConverterUInt64.allocationSize(value.maxIdleTtlSeconds);
+        }
+    }
+    ;
+    return new FFIConverter();
+})();
+/**
+ * Generated factory for {@link ConfiguredDriverOptions} record objects.
+ */
+export const ConfiguredDriverOptions = (() => {
+    const defaults = () => ({});
+    const create = (() => {
+        return uniffiCreateRecord(defaults);
+    })();
+    return Object.freeze({
+        create,
+        new: create,
+        defaults: () => Object.freeze(defaults()),
+    });
+})();
+const FfiConverterTypeConfiguredDriverOptions = (() => {
+    class FFIConverter extends AbstractFfiConverterByteArray {
+        read(from) {
+            return {
+                claudeCodeCompatibility: FfiConverterBool.read(from),
+                authorization: FfiConverterTypeRuntimeAuthorizationOptions.read(from)
+            };
+        }
+        write(value, into) {
+            FfiConverterBool.write(value.claudeCodeCompatibility, into);
+            FfiConverterTypeRuntimeAuthorizationOptions.write(value.authorization, into);
+        }
+        allocationSize(value) {
+            return FfiConverterBool.allocationSize(value.claudeCodeCompatibility) +
+                FfiConverterTypeRuntimeAuthorizationOptions.allocationSize(value.authorization);
+        }
+    }
+    ;
+    return new FFIConverter();
+})();
+/**
+ * Generated factory for {@link CursorGlow} record objects.
+ */
+export const CursorGlow = (() => {
+    const defaults = () => ({});
+    const create = (() => {
+        return uniffiCreateRecord(defaults);
+    })();
+    return Object.freeze({
+        create,
+        new: create,
+        defaults: () => Object.freeze(defaults()),
+    });
+})();
+const FfiConverterTypeCursorGlow = (() => {
+    class FFIConverter extends AbstractFfiConverterByteArray {
+        read(from) {
+            return {
+                x: FfiConverterFloat64.read(from),
+                y: FfiConverterFloat64.read(from),
+                r: FfiConverterFloat64.read(from),
+                alpha: FfiConverterFloat64.read(from)
+            };
+        }
+        write(value, into) {
+            FfiConverterFloat64.write(value.x, into);
+            FfiConverterFloat64.write(value.y, into);
+            FfiConverterFloat64.write(value.r, into);
+            FfiConverterFloat64.write(value.alpha, into);
+        }
+        allocationSize(value) {
+            return FfiConverterFloat64.allocationSize(value.x) +
+                FfiConverterFloat64.allocationSize(value.y) +
+                FfiConverterFloat64.allocationSize(value.r) +
+                FfiConverterFloat64.allocationSize(value.alpha);
+        }
+    }
+    ;
+    return new FFIConverter();
+})();
+/**
+ * Generated factory for {@link CursorTrailSegment} record objects.
+ */
+export const CursorTrailSegment = (() => {
+    const defaults = () => ({});
+    const create = (() => {
+        return uniffiCreateRecord(defaults);
+    })();
+    return Object.freeze({
+        create,
+        new: create,
+        defaults: () => Object.freeze(defaults()),
+    });
+})();
+const FfiConverterTypeCursorTrailSegment = (() => {
+    class FFIConverter extends AbstractFfiConverterByteArray {
+        read(from) {
+            return {
+                ax: FfiConverterFloat64.read(from),
+                ay: FfiConverterFloat64.read(from),
+                bx: FfiConverterFloat64.read(from),
+                by: FfiConverterFloat64.read(from),
+                width: FfiConverterFloat64.read(from),
+                alpha: FfiConverterFloat64.read(from)
+            };
+        }
+        write(value, into) {
+            FfiConverterFloat64.write(value.ax, into);
+            FfiConverterFloat64.write(value.ay, into);
+            FfiConverterFloat64.write(value.bx, into);
+            FfiConverterFloat64.write(value.by, into);
+            FfiConverterFloat64.write(value.width, into);
+            FfiConverterFloat64.write(value.alpha, into);
+        }
+        allocationSize(value) {
+            return FfiConverterFloat64.allocationSize(value.ax) +
+                FfiConverterFloat64.allocationSize(value.ay) +
+                FfiConverterFloat64.allocationSize(value.bx) +
+                FfiConverterFloat64.allocationSize(value.by) +
+                FfiConverterFloat64.allocationSize(value.width) +
+                FfiConverterFloat64.allocationSize(value.alpha);
+        }
+    }
+    ;
+    return new FFIConverter();
+})();
+/**
+ * Generated factory for {@link CursorMotionRect} record objects.
+ */
+export const CursorMotionRect = (() => {
+    const defaults = () => ({});
+    const create = (() => {
+        return uniffiCreateRecord(defaults);
+    })();
+    return Object.freeze({
+        create,
+        new: create,
+        defaults: () => Object.freeze(defaults()),
+    });
+})();
+const FfiConverterTypeCursorMotionRect = (() => {
+    class FFIConverter extends AbstractFfiConverterByteArray {
+        read(from) {
+            return {
+                x: FfiConverterFloat64.read(from),
+                y: FfiConverterFloat64.read(from),
+                width: FfiConverterFloat64.read(from),
+                height: FfiConverterFloat64.read(from)
+            };
+        }
+        write(value, into) {
+            FfiConverterFloat64.write(value.x, into);
+            FfiConverterFloat64.write(value.y, into);
+            FfiConverterFloat64.write(value.width, into);
+            FfiConverterFloat64.write(value.height, into);
+        }
+        allocationSize(value) {
+            return FfiConverterFloat64.allocationSize(value.x) +
+                FfiConverterFloat64.allocationSize(value.y) +
+                FfiConverterFloat64.allocationSize(value.width) +
+                FfiConverterFloat64.allocationSize(value.height);
+        }
+    }
+    ;
+    return new FFIConverter();
+})();
+/**
+ * Generated factory for {@link CursorMagnet} record objects.
+ */
+export const CursorMagnet = (() => {
+    const defaults = () => ({});
+    const create = (() => {
+        return uniffiCreateRecord(defaults);
+    })();
+    return Object.freeze({
+        create,
+        new: create,
+        defaults: () => Object.freeze(defaults()),
+    });
+})();
+const FfiConverterTypeCursorMagnet = (() => {
+    class FFIConverter extends AbstractFfiConverterByteArray {
+        read(from) {
+            return {
+                rect: FfiConverterTypeCursorMotionRect.read(from),
+                glow: FfiConverterFloat64.read(from)
+            };
+        }
+        write(value, into) {
+            FfiConverterTypeCursorMotionRect.write(value.rect, into);
+            FfiConverterFloat64.write(value.glow, into);
+        }
+        allocationSize(value) {
+            return FfiConverterTypeCursorMotionRect.allocationSize(value.rect) +
+                FfiConverterFloat64.allocationSize(value.glow);
+        }
+    }
+    ;
+    return new FFIConverter();
+})();
+/**
+ * Generated factory for {@link CursorRipple} record objects.
+ */
+export const CursorRipple = (() => {
+    const defaults = () => ({});
+    const create = (() => {
+        return uniffiCreateRecord(defaults);
+    })();
+    return Object.freeze({
+        create,
+        new: create,
+        defaults: () => Object.freeze(defaults()),
+    });
+})();
+const FfiConverterTypeCursorRipple = (() => {
+    class FFIConverter extends AbstractFfiConverterByteArray {
+        read(from) {
+            return {
+                x: FfiConverterFloat64.read(from),
+                y: FfiConverterFloat64.read(from),
+                r: FfiConverterFloat64.read(from),
+                width: FfiConverterFloat64.read(from),
+                alpha: FfiConverterFloat64.read(from)
+            };
+        }
+        write(value, into) {
+            FfiConverterFloat64.write(value.x, into);
+            FfiConverterFloat64.write(value.y, into);
+            FfiConverterFloat64.write(value.r, into);
+            FfiConverterFloat64.write(value.width, into);
+            FfiConverterFloat64.write(value.alpha, into);
+        }
+        allocationSize(value) {
+            return FfiConverterFloat64.allocationSize(value.x) +
+                FfiConverterFloat64.allocationSize(value.y) +
+                FfiConverterFloat64.allocationSize(value.r) +
+                FfiConverterFloat64.allocationSize(value.width) +
+                FfiConverterFloat64.allocationSize(value.alpha);
+        }
+    }
+    ;
+    return new FFIConverter();
+})();
+/**
+ * Generated factory for {@link CursorEffectFrame} record objects.
+ */
+export const CursorEffectFrame = (() => {
+    const defaults = () => ({});
+    const create = (() => {
+        return uniffiCreateRecord(defaults);
+    })();
+    return Object.freeze({
+        create,
+        new: create,
+        defaults: () => Object.freeze(defaults()),
+    });
+})();
+const FfiConverterTypeCursorEffectFrame = (() => {
+    class FFIConverter extends AbstractFfiConverterByteArray {
+        read(from) {
+            return {
+                glow: FfiConverterOptionalTypeCursorGlow.read(from),
+                trail: FfiConverterSequenceTypeCursorTrailSegment.read(from),
+                magnet: FfiConverterOptionalTypeCursorMagnet.read(from),
+                ripple: FfiConverterOptionalTypeCursorRipple.read(from),
+                squish: FfiConverterFloat64.read(from)
+            };
+        }
+        write(value, into) {
+            FfiConverterOptionalTypeCursorGlow.write(value.glow, into);
+            FfiConverterSequenceTypeCursorTrailSegment.write(value.trail, into);
+            FfiConverterOptionalTypeCursorMagnet.write(value.magnet, into);
+            FfiConverterOptionalTypeCursorRipple.write(value.ripple, into);
+            FfiConverterFloat64.write(value.squish, into);
+        }
+        allocationSize(value) {
+            return FfiConverterOptionalTypeCursorGlow.allocationSize(value.glow) +
+                FfiConverterSequenceTypeCursorTrailSegment.allocationSize(value.trail) +
+                FfiConverterOptionalTypeCursorMagnet.allocationSize(value.magnet) +
+                FfiConverterOptionalTypeCursorRipple.allocationSize(value.ripple) +
+                FfiConverterFloat64.allocationSize(value.squish);
+        }
+    }
+    ;
+    return new FFIConverter();
+})();
+/**
+ * Generated factory for {@link CursorMotionParams} record objects.
+ */
+export const CursorMotionParams = (() => {
+    const defaults = () => ({});
+    const create = (() => {
+        return uniffiCreateRecord(defaults);
+    })();
+    return Object.freeze({
+        create,
+        new: create,
+        defaults: () => Object.freeze(defaults()),
+    });
+})();
+const FfiConverterTypeCursorMotionParams = (() => {
+    class FFIConverter extends AbstractFfiConverterByteArray {
+        read(from) {
+            return {
+                style: FfiConverterTypeCursorMotionStyle.read(from),
+                timing: FfiConverterTypeCursorMotionTiming.read(from),
+                effects: FfiConverterTypeCursorMotionEffects.read(from),
+                startHandle: FfiConverterFloat64.read(from),
+                endHandle: FfiConverterFloat64.read(from),
+                arcSize: FfiConverterFloat64.read(from),
+                arcFlow: FfiConverterFloat64.read(from),
+                spring: FfiConverterFloat64.read(from),
+                glideDurationMs: FfiConverterFloat64.read(from),
+                peakSpeed: FfiConverterFloat64.read(from),
+                minStartSpeed: FfiConverterFloat64.read(from),
+                minEndSpeed: FfiConverterFloat64.read(from),
+                turnRadius: FfiConverterFloat64.read(from)
+            };
+        }
+        write(value, into) {
+            FfiConverterTypeCursorMotionStyle.write(value.style, into);
+            FfiConverterTypeCursorMotionTiming.write(value.timing, into);
+            FfiConverterTypeCursorMotionEffects.write(value.effects, into);
+            FfiConverterFloat64.write(value.startHandle, into);
+            FfiConverterFloat64.write(value.endHandle, into);
+            FfiConverterFloat64.write(value.arcSize, into);
+            FfiConverterFloat64.write(value.arcFlow, into);
+            FfiConverterFloat64.write(value.spring, into);
+            FfiConverterFloat64.write(value.glideDurationMs, into);
+            FfiConverterFloat64.write(value.peakSpeed, into);
+            FfiConverterFloat64.write(value.minStartSpeed, into);
+            FfiConverterFloat64.write(value.minEndSpeed, into);
+            FfiConverterFloat64.write(value.turnRadius, into);
+        }
+        allocationSize(value) {
+            return FfiConverterTypeCursorMotionStyle.allocationSize(value.style) +
+                FfiConverterTypeCursorMotionTiming.allocationSize(value.timing) +
+                FfiConverterTypeCursorMotionEffects.allocationSize(value.effects) +
+                FfiConverterFloat64.allocationSize(value.startHandle) +
+                FfiConverterFloat64.allocationSize(value.endHandle) +
+                FfiConverterFloat64.allocationSize(value.arcSize) +
+                FfiConverterFloat64.allocationSize(value.arcFlow) +
+                FfiConverterFloat64.allocationSize(value.spring) +
+                FfiConverterFloat64.allocationSize(value.glideDurationMs) +
+                FfiConverterFloat64.allocationSize(value.peakSpeed) +
+                FfiConverterFloat64.allocationSize(value.minStartSpeed) +
+                FfiConverterFloat64.allocationSize(value.minEndSpeed) +
+                FfiConverterFloat64.allocationSize(value.turnRadius);
+        }
+    }
+    ;
+    return new FFIConverter();
+})();
+/**
+ * Generated factory for {@link CursorMotionPoint} record objects.
+ */
+export const CursorMotionPoint = (() => {
+    const defaults = () => ({});
+    const create = (() => {
+        return uniffiCreateRecord(defaults);
+    })();
+    return Object.freeze({
+        create,
+        new: create,
+        defaults: () => Object.freeze(defaults()),
+    });
+})();
+const FfiConverterTypeCursorMotionPoint = (() => {
+    class FFIConverter extends AbstractFfiConverterByteArray {
+        read(from) {
+            return {
+                x: FfiConverterFloat64.read(from),
+                y: FfiConverterFloat64.read(from)
+            };
+        }
+        write(value, into) {
+            FfiConverterFloat64.write(value.x, into);
+            FfiConverterFloat64.write(value.y, into);
+        }
+        allocationSize(value) {
+            return FfiConverterFloat64.allocationSize(value.x) +
+                FfiConverterFloat64.allocationSize(value.y);
+        }
+    }
+    ;
+    return new FFIConverter();
+})();
+/**
+ * Generated factory for {@link CursorMotionSample} record objects.
+ */
+export const CursorMotionSample = (() => {
+    const defaults = () => ({});
+    const create = (() => {
+        return uniffiCreateRecord(defaults);
+    })();
+    return Object.freeze({
+        create,
+        new: create,
+        defaults: () => Object.freeze(defaults()),
+    });
+})();
+const FfiConverterTypeCursorMotionSample = (() => {
+    class FFIConverter extends AbstractFfiConverterByteArray {
+        read(from) {
+            return {
+                t: FfiConverterFloat64.read(from),
+                x: FfiConverterFloat64.read(from),
+                y: FfiConverterFloat64.read(from),
+                heading: FfiConverterFloat64.read(from)
+            };
+        }
+        write(value, into) {
+            FfiConverterFloat64.write(value.t, into);
+            FfiConverterFloat64.write(value.x, into);
+            FfiConverterFloat64.write(value.y, into);
+            FfiConverterFloat64.write(value.heading, into);
+        }
+        allocationSize(value) {
+            return FfiConverterFloat64.allocationSize(value.t) +
+                FfiConverterFloat64.allocationSize(value.x) +
+                FfiConverterFloat64.allocationSize(value.y) +
+                FfiConverterFloat64.allocationSize(value.heading);
+        }
+    }
+    ;
+    return new FFIConverter();
+})();
+// Enum: CursorPathShape
+export var CursorPathShape_Tags;
+(function (CursorPathShape_Tags) {
+    CursorPathShape_Tags["Straight"] = "Straight";
+    CursorPathShape_Tags["Arc"] = "Arc";
+    CursorPathShape_Tags["Bow"] = "Bow";
+})(CursorPathShape_Tags || (CursorPathShape_Tags = {}));
+/**
+ * Path shape of a custom motion.
+ */
+export const CursorPathShape = (() => {
+    class Straight_ extends UniffiEnum {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        [uniffiTypeNameSymbol] = "CursorPathShape";
+        tag = CursorPathShape_Tags.Straight;
+        constructor() {
+            super("CursorPathShape", "Straight");
+        }
+        static new() {
+            return new Straight_();
+        }
+        static instanceOf(obj) {
+            return obj.tag === CursorPathShape_Tags.Straight;
+        }
+    }
+    /**
+     * The Cua cubic bezier; a positive `arc_size` bends to the natural side.
+     */
+    class Arc_ extends UniffiEnum {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        [uniffiTypeNameSymbol] = "CursorPathShape";
+        tag = CursorPathShape_Tags.Arc;
+        inner;
+        constructor(inner) {
+            super("CursorPathShape", "Arc");
+            this.inner = Object.freeze(inner);
+        }
+        static new(inner) {
+            return new Arc_(inner);
+        }
+        static instanceOf(obj) {
+            return obj.tag === CursorPathShape_Tags.Arc;
+        }
+    }
+    /**
+     * A gentle quadratic bow.
+     */
+    class Bow_ extends UniffiEnum {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        [uniffiTypeNameSymbol] = "CursorPathShape";
+        tag = CursorPathShape_Tags.Bow;
+        inner;
+        constructor(inner) {
+            super("CursorPathShape", "Bow");
+            this.inner = Object.freeze(inner);
+        }
+        static new(inner) {
+            return new Bow_(inner);
+        }
+        static instanceOf(obj) {
+            return obj.tag === CursorPathShape_Tags.Bow;
+        }
+    }
+    function instanceOf(obj) {
+        return obj[uniffiTypeNameSymbol] === "CursorPathShape";
+    }
+    return Object.freeze({
+        instanceOf,
+        Straight: Straight_,
+        Arc: Arc_,
+        Bow: Bow_
+    });
+})();
+// FfiConverter for enum CursorPathShape
+const FfiConverterTypeCursorPathShape = (() => {
+    const ordinalConverter = FfiConverterInt32;
+    class FFIConverter extends AbstractFfiConverterByteArray {
+        read(from) {
+            switch (ordinalConverter.read(from)) {
+                case 1: return new CursorPathShape.Straight();
+                case 2: return new CursorPathShape.Arc({ startHandle: FfiConverterFloat64.read(from), endHandle: FfiConverterFloat64.read(from), arcSize: FfiConverterFloat64.read(from), arcFlow: FfiConverterFloat64.read(from) });
+                case 3: return new CursorPathShape.Bow({ amount: FfiConverterFloat64.read(from) });
+                default: throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+        write(value, into) {
+            switch (value.tag) {
+                case CursorPathShape_Tags.Straight: {
+                    ordinalConverter.write(1, into);
+                    return;
+                }
+                case CursorPathShape_Tags.Arc: {
+                    ordinalConverter.write(2, into);
+                    const inner = value.inner;
+                    FfiConverterFloat64.write(inner.startHandle, into);
+                    FfiConverterFloat64.write(inner.endHandle, into);
+                    FfiConverterFloat64.write(inner.arcSize, into);
+                    FfiConverterFloat64.write(inner.arcFlow, into);
+                    return;
+                }
+                case CursorPathShape_Tags.Bow: {
+                    ordinalConverter.write(3, into);
+                    const inner = value.inner;
+                    FfiConverterFloat64.write(inner.amount, into);
+                    return;
+                }
+                default:
+                    // Throwing from here means that CursorPathShape_Tags hasn't matched an ordinal.
+                    throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+        allocationSize(value) {
+            switch (value.tag) {
+                case CursorPathShape_Tags.Straight: {
+                    return ordinalConverter.allocationSize(1);
+                }
+                case CursorPathShape_Tags.Arc: {
+                    const inner = value.inner;
+                    let size = ordinalConverter.allocationSize(2);
+                    size += FfiConverterFloat64.allocationSize(inner.startHandle);
+                    size += FfiConverterFloat64.allocationSize(inner.endHandle);
+                    size += FfiConverterFloat64.allocationSize(inner.arcSize);
+                    size += FfiConverterFloat64.allocationSize(inner.arcFlow);
+                    return size;
+                }
+                case CursorPathShape_Tags.Bow: {
+                    const inner = value.inner;
+                    let size = ordinalConverter.allocationSize(3);
+                    size += FfiConverterFloat64.allocationSize(inner.amount);
+                    return size;
+                }
+                default: throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+    }
+    return new FFIConverter();
+})();
+// Enum: CursorEase
+export var CursorEase_Tags;
+(function (CursorEase_Tags) {
+    CursorEase_Tags["Linear"] = "Linear";
+    CursorEase_Tags["MinJerk"] = "MinJerk";
+    CursorEase_Tags["Smootherstep"] = "Smootherstep";
+    CursorEase_Tags["InOutCubic"] = "InOutCubic";
+    CursorEase_Tags["InOutSine"] = "InOutSine";
+    CursorEase_Tags["OutCubic"] = "OutCubic";
+    CursorEase_Tags["CubicBezier"] = "CubicBezier";
+})(CursorEase_Tags || (CursorEase_Tags = {}));
+/**
+ * Speed curve along the path.
+ */
+export const CursorEase = (() => {
+    class Linear_ extends UniffiEnum {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        [uniffiTypeNameSymbol] = "CursorEase";
+        tag = CursorEase_Tags.Linear;
+        constructor() {
+            super("CursorEase", "Linear");
+        }
+        static new() {
+            return new Linear_();
+        }
+        static instanceOf(obj) {
+            return obj.tag === CursorEase_Tags.Linear;
+        }
+    }
+    class MinJerk_ extends UniffiEnum {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        [uniffiTypeNameSymbol] = "CursorEase";
+        tag = CursorEase_Tags.MinJerk;
+        constructor() {
+            super("CursorEase", "MinJerk");
+        }
+        static new() {
+            return new MinJerk_();
+        }
+        static instanceOf(obj) {
+            return obj.tag === CursorEase_Tags.MinJerk;
+        }
+    }
+    class Smootherstep_ extends UniffiEnum {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        [uniffiTypeNameSymbol] = "CursorEase";
+        tag = CursorEase_Tags.Smootherstep;
+        constructor() {
+            super("CursorEase", "Smootherstep");
+        }
+        static new() {
+            return new Smootherstep_();
+        }
+        static instanceOf(obj) {
+            return obj.tag === CursorEase_Tags.Smootherstep;
+        }
+    }
+    class InOutCubic_ extends UniffiEnum {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        [uniffiTypeNameSymbol] = "CursorEase";
+        tag = CursorEase_Tags.InOutCubic;
+        constructor() {
+            super("CursorEase", "InOutCubic");
+        }
+        static new() {
+            return new InOutCubic_();
+        }
+        static instanceOf(obj) {
+            return obj.tag === CursorEase_Tags.InOutCubic;
+        }
+    }
+    class InOutSine_ extends UniffiEnum {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        [uniffiTypeNameSymbol] = "CursorEase";
+        tag = CursorEase_Tags.InOutSine;
+        constructor() {
+            super("CursorEase", "InOutSine");
+        }
+        static new() {
+            return new InOutSine_();
+        }
+        static instanceOf(obj) {
+            return obj.tag === CursorEase_Tags.InOutSine;
+        }
+    }
+    class OutCubic_ extends UniffiEnum {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        [uniffiTypeNameSymbol] = "CursorEase";
+        tag = CursorEase_Tags.OutCubic;
+        constructor() {
+            super("CursorEase", "OutCubic");
+        }
+        static new() {
+            return new OutCubic_();
+        }
+        static instanceOf(obj) {
+            return obj.tag === CursorEase_Tags.OutCubic;
+        }
+    }
+    class CubicBezier_ extends UniffiEnum {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        [uniffiTypeNameSymbol] = "CursorEase";
+        tag = CursorEase_Tags.CubicBezier;
+        inner;
+        constructor(inner) {
+            super("CursorEase", "CubicBezier");
+            this.inner = Object.freeze(inner);
+        }
+        static new(inner) {
+            return new CubicBezier_(inner);
+        }
+        static instanceOf(obj) {
+            return obj.tag === CursorEase_Tags.CubicBezier;
+        }
+    }
+    function instanceOf(obj) {
+        return obj[uniffiTypeNameSymbol] === "CursorEase";
+    }
+    return Object.freeze({
+        instanceOf,
+        Linear: Linear_,
+        MinJerk: MinJerk_,
+        Smootherstep: Smootherstep_,
+        InOutCubic: InOutCubic_,
+        InOutSine: InOutSine_,
+        OutCubic: OutCubic_,
+        CubicBezier: CubicBezier_
+    });
+})();
+// FfiConverter for enum CursorEase
+const FfiConverterTypeCursorEase = (() => {
+    const ordinalConverter = FfiConverterInt32;
+    class FFIConverter extends AbstractFfiConverterByteArray {
+        read(from) {
+            switch (ordinalConverter.read(from)) {
+                case 1: return new CursorEase.Linear();
+                case 2: return new CursorEase.MinJerk();
+                case 3: return new CursorEase.Smootherstep();
+                case 4: return new CursorEase.InOutCubic();
+                case 5: return new CursorEase.InOutSine();
+                case 6: return new CursorEase.OutCubic();
+                case 7: return new CursorEase.CubicBezier({ x1: FfiConverterFloat64.read(from), y1: FfiConverterFloat64.read(from), x2: FfiConverterFloat64.read(from), y2: FfiConverterFloat64.read(from) });
+                default: throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+        write(value, into) {
+            switch (value.tag) {
+                case CursorEase_Tags.Linear: {
+                    ordinalConverter.write(1, into);
+                    return;
+                }
+                case CursorEase_Tags.MinJerk: {
+                    ordinalConverter.write(2, into);
+                    return;
+                }
+                case CursorEase_Tags.Smootherstep: {
+                    ordinalConverter.write(3, into);
+                    return;
+                }
+                case CursorEase_Tags.InOutCubic: {
+                    ordinalConverter.write(4, into);
+                    return;
+                }
+                case CursorEase_Tags.InOutSine: {
+                    ordinalConverter.write(5, into);
+                    return;
+                }
+                case CursorEase_Tags.OutCubic: {
+                    ordinalConverter.write(6, into);
+                    return;
+                }
+                case CursorEase_Tags.CubicBezier: {
+                    ordinalConverter.write(7, into);
+                    const inner = value.inner;
+                    FfiConverterFloat64.write(inner.x1, into);
+                    FfiConverterFloat64.write(inner.y1, into);
+                    FfiConverterFloat64.write(inner.x2, into);
+                    FfiConverterFloat64.write(inner.y2, into);
+                    return;
+                }
+                default:
+                    // Throwing from here means that CursorEase_Tags hasn't matched an ordinal.
+                    throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+        allocationSize(value) {
+            switch (value.tag) {
+                case CursorEase_Tags.Linear: {
+                    return ordinalConverter.allocationSize(1);
+                }
+                case CursorEase_Tags.MinJerk: {
+                    return ordinalConverter.allocationSize(2);
+                }
+                case CursorEase_Tags.Smootherstep: {
+                    return ordinalConverter.allocationSize(3);
+                }
+                case CursorEase_Tags.InOutCubic: {
+                    return ordinalConverter.allocationSize(4);
+                }
+                case CursorEase_Tags.InOutSine: {
+                    return ordinalConverter.allocationSize(5);
+                }
+                case CursorEase_Tags.OutCubic: {
+                    return ordinalConverter.allocationSize(6);
+                }
+                case CursorEase_Tags.CubicBezier: {
+                    const inner = value.inner;
+                    let size = ordinalConverter.allocationSize(7);
+                    size += FfiConverterFloat64.allocationSize(inner.x1);
+                    size += FfiConverterFloat64.allocationSize(inner.y1);
+                    size += FfiConverterFloat64.allocationSize(inner.x2);
+                    size += FfiConverterFloat64.allocationSize(inner.y2);
+                    return size;
+                }
+                default: throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+    }
+    return new FFIConverter();
+})();
+// Enum: CursorSettle
+export var CursorSettle_Tags;
+(function (CursorSettle_Tags) {
+    CursorSettle_Tags["None"] = "None";
+    CursorSettle_Tags["FollowThrough"] = "FollowThrough";
+    CursorSettle_Tags["Spring"] = "Spring";
+})(CursorSettle_Tags || (CursorSettle_Tags = {}));
+/**
+ * Overshoot or settle at the end of the glide.
+ */
+export const CursorSettle = (() => {
+    class None_ extends UniffiEnum {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        [uniffiTypeNameSymbol] = "CursorSettle";
+        tag = CursorSettle_Tags.None;
+        constructor() {
+            super("CursorSettle", "None");
+        }
+        static new() {
+            return new None_();
+        }
+        static instanceOf(obj) {
+            return obj.tag === CursorSettle_Tags.None;
+        }
+    }
+    class FollowThrough_ extends UniffiEnum {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        [uniffiTypeNameSymbol] = "CursorSettle";
+        tag = CursorSettle_Tags.FollowThrough;
+        inner;
+        constructor(inner) {
+            super("CursorSettle", "FollowThrough");
+            this.inner = Object.freeze(inner);
+        }
+        static new(inner) {
+            return new FollowThrough_(inner);
+        }
+        static instanceOf(obj) {
+            return obj.tag === CursorSettle_Tags.FollowThrough;
+        }
+    }
+    class Spring_ extends UniffiEnum {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        [uniffiTypeNameSymbol] = "CursorSettle";
+        tag = CursorSettle_Tags.Spring;
+        inner;
+        constructor(inner) {
+            super("CursorSettle", "Spring");
+            this.inner = Object.freeze(inner);
+        }
+        static new(inner) {
+            return new Spring_(inner);
+        }
+        static instanceOf(obj) {
+            return obj.tag === CursorSettle_Tags.Spring;
+        }
+    }
+    function instanceOf(obj) {
+        return obj[uniffiTypeNameSymbol] === "CursorSettle";
+    }
+    return Object.freeze({
+        instanceOf,
+        None: None_,
+        FollowThrough: FollowThrough_,
+        Spring: Spring_
+    });
+})();
+// FfiConverter for enum CursorSettle
+const FfiConverterTypeCursorSettle = (() => {
+    const ordinalConverter = FfiConverterInt32;
+    class FFIConverter extends AbstractFfiConverterByteArray {
+        read(from) {
+            switch (ordinalConverter.read(from)) {
+                case 1: return new CursorSettle.None();
+                case 2: return new CursorSettle.FollowThrough({ amount: FfiConverterFloat64.read(from), maxPt: FfiConverterFloat64.read(from), at: FfiConverterFloat64.read(from) });
+                case 3: return new CursorSettle.Spring({ amount: FfiConverterFloat64.read(from), maxPt: FfiConverterFloat64.read(from), cycles: FfiConverterFloat64.read(from), decay: FfiConverterFloat64.read(from), start: FfiConverterFloat64.read(from), glideEnd: FfiConverterFloat64.read(from) });
+                default: throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+        write(value, into) {
+            switch (value.tag) {
+                case CursorSettle_Tags.None: {
+                    ordinalConverter.write(1, into);
+                    return;
+                }
+                case CursorSettle_Tags.FollowThrough: {
+                    ordinalConverter.write(2, into);
+                    const inner = value.inner;
+                    FfiConverterFloat64.write(inner.amount, into);
+                    FfiConverterFloat64.write(inner.maxPt, into);
+                    FfiConverterFloat64.write(inner.at, into);
+                    return;
+                }
+                case CursorSettle_Tags.Spring: {
+                    ordinalConverter.write(3, into);
+                    const inner = value.inner;
+                    FfiConverterFloat64.write(inner.amount, into);
+                    FfiConverterFloat64.write(inner.maxPt, into);
+                    FfiConverterFloat64.write(inner.cycles, into);
+                    FfiConverterFloat64.write(inner.decay, into);
+                    FfiConverterFloat64.write(inner.start, into);
+                    FfiConverterFloat64.write(inner.glideEnd, into);
+                    return;
+                }
+                default:
+                    // Throwing from here means that CursorSettle_Tags hasn't matched an ordinal.
+                    throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+        allocationSize(value) {
+            switch (value.tag) {
+                case CursorSettle_Tags.None: {
+                    return ordinalConverter.allocationSize(1);
+                }
+                case CursorSettle_Tags.FollowThrough: {
+                    const inner = value.inner;
+                    let size = ordinalConverter.allocationSize(2);
+                    size += FfiConverterFloat64.allocationSize(inner.amount);
+                    size += FfiConverterFloat64.allocationSize(inner.maxPt);
+                    size += FfiConverterFloat64.allocationSize(inner.at);
+                    return size;
+                }
+                case CursorSettle_Tags.Spring: {
+                    const inner = value.inner;
+                    let size = ordinalConverter.allocationSize(3);
+                    size += FfiConverterFloat64.allocationSize(inner.amount);
+                    size += FfiConverterFloat64.allocationSize(inner.maxPt);
+                    size += FfiConverterFloat64.allocationSize(inner.cycles);
+                    size += FfiConverterFloat64.allocationSize(inner.decay);
+                    size += FfiConverterFloat64.allocationSize(inner.start);
+                    size += FfiConverterFloat64.allocationSize(inner.glideEnd);
+                    return size;
+                }
+                default: throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+    }
+    return new FFIConverter();
+})();
+// Enum: CursorMotionDuration
+export var CursorMotionDuration_Tags;
+(function (CursorMotionDuration_Tags) {
+    CursorMotionDuration_Tags["Fixed"] = "Fixed";
+    CursorMotionDuration_Tags["Fitts"] = "Fitts";
+    CursorMotionDuration_Tags["Distance"] = "Distance";
+})(CursorMotionDuration_Tags || (CursorMotionDuration_Tags = {}));
+/**
+ * Duration model of a custom motion.
+ */
+export const CursorMotionDuration = (() => {
+    class Fixed_ extends UniffiEnum {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        [uniffiTypeNameSymbol] = "CursorMotionDuration";
+        tag = CursorMotionDuration_Tags.Fixed;
+        inner;
+        constructor(inner) {
+            super("CursorMotionDuration", "Fixed");
+            this.inner = Object.freeze(inner);
+        }
+        static new(inner) {
+            return new Fixed_(inner);
+        }
+        static instanceOf(obj) {
+            return obj.tag === CursorMotionDuration_Tags.Fixed;
+        }
+    }
+    class Fitts_ extends UniffiEnum {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        [uniffiTypeNameSymbol] = "CursorMotionDuration";
+        tag = CursorMotionDuration_Tags.Fitts;
+        inner;
+        constructor(inner) {
+            super("CursorMotionDuration", "Fitts");
+            this.inner = Object.freeze(inner);
+        }
+        static new(inner) {
+            return new Fitts_(inner);
+        }
+        static instanceOf(obj) {
+            return obj.tag === CursorMotionDuration_Tags.Fitts;
+        }
+    }
+    class Distance_ extends UniffiEnum {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        [uniffiTypeNameSymbol] = "CursorMotionDuration";
+        tag = CursorMotionDuration_Tags.Distance;
+        inner;
+        constructor(inner) {
+            super("CursorMotionDuration", "Distance");
+            this.inner = Object.freeze(inner);
+        }
+        static new(inner) {
+            return new Distance_(inner);
+        }
+        static instanceOf(obj) {
+            return obj.tag === CursorMotionDuration_Tags.Distance;
+        }
+    }
+    function instanceOf(obj) {
+        return obj[uniffiTypeNameSymbol] === "CursorMotionDuration";
+    }
+    return Object.freeze({
+        instanceOf,
+        Fixed: Fixed_,
+        Fitts: Fitts_,
+        Distance: Distance_
+    });
+})();
+// FfiConverter for enum CursorMotionDuration
+const FfiConverterTypeCursorMotionDuration = (() => {
+    const ordinalConverter = FfiConverterInt32;
+    class FFIConverter extends AbstractFfiConverterByteArray {
+        read(from) {
+            switch (ordinalConverter.read(from)) {
+                case 1: return new CursorMotionDuration.Fixed({ ms: FfiConverterFloat64.read(from) });
+                case 2: return new CursorMotionDuration.Fitts({ a: FfiConverterFloat64.read(from), b: FfiConverterFloat64.read(from), minMs: FfiConverterFloat64.read(from), maxMs: FfiConverterFloat64.read(from), scale: FfiConverterFloat64.read(from) });
+                case 3: return new CursorMotionDuration.Distance({ baseMs: FfiConverterFloat64.read(from), msPerPt: FfiConverterFloat64.read(from), minMs: FfiConverterFloat64.read(from), maxMs: FfiConverterFloat64.read(from) });
+                default: throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+        write(value, into) {
+            switch (value.tag) {
+                case CursorMotionDuration_Tags.Fixed: {
+                    ordinalConverter.write(1, into);
+                    const inner = value.inner;
+                    FfiConverterFloat64.write(inner.ms, into);
+                    return;
+                }
+                case CursorMotionDuration_Tags.Fitts: {
+                    ordinalConverter.write(2, into);
+                    const inner = value.inner;
+                    FfiConverterFloat64.write(inner.a, into);
+                    FfiConverterFloat64.write(inner.b, into);
+                    FfiConverterFloat64.write(inner.minMs, into);
+                    FfiConverterFloat64.write(inner.maxMs, into);
+                    FfiConverterFloat64.write(inner.scale, into);
+                    return;
+                }
+                case CursorMotionDuration_Tags.Distance: {
+                    ordinalConverter.write(3, into);
+                    const inner = value.inner;
+                    FfiConverterFloat64.write(inner.baseMs, into);
+                    FfiConverterFloat64.write(inner.msPerPt, into);
+                    FfiConverterFloat64.write(inner.minMs, into);
+                    FfiConverterFloat64.write(inner.maxMs, into);
+                    return;
+                }
+                default:
+                    // Throwing from here means that CursorMotionDuration_Tags hasn't matched an ordinal.
+                    throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+        allocationSize(value) {
+            switch (value.tag) {
+                case CursorMotionDuration_Tags.Fixed: {
+                    const inner = value.inner;
+                    let size = ordinalConverter.allocationSize(1);
+                    size += FfiConverterFloat64.allocationSize(inner.ms);
+                    return size;
+                }
+                case CursorMotionDuration_Tags.Fitts: {
+                    const inner = value.inner;
+                    let size = ordinalConverter.allocationSize(2);
+                    size += FfiConverterFloat64.allocationSize(inner.a);
+                    size += FfiConverterFloat64.allocationSize(inner.b);
+                    size += FfiConverterFloat64.allocationSize(inner.minMs);
+                    size += FfiConverterFloat64.allocationSize(inner.maxMs);
+                    size += FfiConverterFloat64.allocationSize(inner.scale);
+                    return size;
+                }
+                case CursorMotionDuration_Tags.Distance: {
+                    const inner = value.inner;
+                    let size = ordinalConverter.allocationSize(3);
+                    size += FfiConverterFloat64.allocationSize(inner.baseMs);
+                    size += FfiConverterFloat64.allocationSize(inner.msPerPt);
+                    size += FfiConverterFloat64.allocationSize(inner.minMs);
+                    size += FfiConverterFloat64.allocationSize(inner.maxMs);
+                    return size;
+                }
+                default: throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+    }
+    return new FFIConverter();
+})();
+/**
+ * `Tangent`: the tip leads the motion. `Fixed`: the rest pose.
+ */
+export var CursorHeading;
+(function (CursorHeading) {
+    CursorHeading[CursorHeading["Tangent"] = 0] = "Tangent";
+    CursorHeading[CursorHeading["Fixed"] = 1] = "Fixed";
+})(CursorHeading || (CursorHeading = {}));
+const FfiConverterTypeCursorHeading = (() => {
+    const ordinalConverter = FfiConverterInt32;
+    class FFIConverter extends AbstractFfiConverterByteArray {
+        read(from) {
+            switch (ordinalConverter.read(from)) {
+                case 1: return CursorHeading.Tangent;
+                case 2: return CursorHeading.Fixed;
+                default: throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+        write(value, into) {
+            switch (value) {
+                case CursorHeading.Tangent: return ordinalConverter.write(1, into);
+                case CursorHeading.Fixed: return ordinalConverter.write(2, into);
             }
         }
         allocationSize(value) {
@@ -153,28 +1432,60 @@ const FfiConverterTypeSessionPermissionMode = (() => {
     }
     return new FFIConverter();
 })();
-const stringConverter = (() => {
-    const encoder = new TextEncoder();
-    const decoder = new TextDecoder();
-    return {
-        stringToBytes: (s) => encoder.encode(s),
-        bytesToString: (ab) => decoder.decode(ab),
-        stringByteLength: (s) => encoder.encode(s).byteLength,
-        writeStringIntoBuffer: (s, buf, offset) => {
-            const view = new Uint8Array(buf.arrayBuffer, offset, buf.arrayBuffer.byteLength - offset);
-            return encoder.encodeInto(s, view).written;
-        },
-        readStringFromBuffer: (buf, offset, length) => decoder.decode(new Uint8Array(buf.arrayBuffer, offset, length)),
-    };
-})();
-const FfiConverterString = uniffiCreateFfiConverterString(stringConverter);
 /**
- * Generated factory for {@link RuntimeAuthorizationOptions} record objects.
+ * Generated factory for {@link CursorTrailSpec} record objects.
  */
-export const RuntimeAuthorizationOptions = (() => {
-    const defaults = () => ({
-        compatibilityCapabilityManifestPath: undefined,
+export const CursorTrailSpec = (() => {
+    const defaults = () => ({});
+    const create = (() => {
+        return uniffiCreateRecord(defaults);
+    })();
+    return Object.freeze({
+        create,
+        new: create,
+        defaults: () => Object.freeze(defaults()),
     });
+})();
+const FfiConverterTypeCursorTrailSpec = (() => {
+    class FFIConverter extends AbstractFfiConverterByteArray {
+        read(from) {
+            return {
+                secs: FfiConverterFloat64.read(from),
+                fadeLen: FfiConverterFloat64.read(from),
+                steps: FfiConverterUInt32.read(from),
+                tailWidth: FfiConverterFloat64.read(from),
+                headWidth: FfiConverterFloat64.read(from),
+                alpha: FfiConverterFloat64.read(from),
+                anchorOffset: FfiConverterFloat64.read(from)
+            };
+        }
+        write(value, into) {
+            FfiConverterFloat64.write(value.secs, into);
+            FfiConverterFloat64.write(value.fadeLen, into);
+            FfiConverterUInt32.write(value.steps, into);
+            FfiConverterFloat64.write(value.tailWidth, into);
+            FfiConverterFloat64.write(value.headWidth, into);
+            FfiConverterFloat64.write(value.alpha, into);
+            FfiConverterFloat64.write(value.anchorOffset, into);
+        }
+        allocationSize(value) {
+            return FfiConverterFloat64.allocationSize(value.secs) +
+                FfiConverterFloat64.allocationSize(value.fadeLen) +
+                FfiConverterUInt32.allocationSize(value.steps) +
+                FfiConverterFloat64.allocationSize(value.tailWidth) +
+                FfiConverterFloat64.allocationSize(value.headWidth) +
+                FfiConverterFloat64.allocationSize(value.alpha) +
+                FfiConverterFloat64.allocationSize(value.anchorOffset);
+        }
+    }
+    ;
+    return new FFIConverter();
+})();
+/**
+ * Generated factory for {@link CursorMotionSpec} record objects.
+ */
+export const CursorMotionSpec = (() => {
+    const defaults = () => ({});
     const create = (() => {
         return uniffiCreateRecord(defaults);
     })();
@@ -184,45 +1495,45 @@ export const RuntimeAuthorizationOptions = (() => {
         defaults: () => Object.freeze(defaults()),
     });
 })();
-const FfiConverterTypeRuntimeAuthorizationOptions = (() => {
+const FfiConverterTypeCursorMotionSpec = (() => {
     class FFIConverter extends AbstractFfiConverterByteArray {
         read(from) {
             return {
-                allowedModes: FfiConverterSequenceTypeSessionPermissionMode.read(from),
-                compatibilityMode: FfiConverterTypeSessionPermissionMode.read(from),
-                compatibilityCapabilityManifestPath: FfiConverterOptionalString.read(from),
-                compatibilityBoundedManifestPath: FfiConverterOptionalString.read(from),
-                unrestrictedAcknowledged: FfiConverterBool.read(from),
-                maxSessionTtlSeconds: FfiConverterUInt64.read(from),
-                maxIdleTtlSeconds: FfiConverterUInt64.read(from)
+                path: FfiConverterTypeCursorPathShape.read(from),
+                ease: FfiConverterTypeCursorEase.read(from),
+                settle: FfiConverterTypeCursorSettle.read(from),
+                duration: FfiConverterTypeCursorMotionDuration.read(from),
+                heading: FfiConverterTypeCursorHeading.read(from),
+                effects: FfiConverterTypeCursorMotionEffectsOutput.read(from),
+                trail: FfiConverterTypeCursorTrailSpec.read(from)
             };
         }
         write(value, into) {
-            FfiConverterSequenceTypeSessionPermissionMode.write(value.allowedModes, into);
-            FfiConverterTypeSessionPermissionMode.write(value.compatibilityMode, into);
-            FfiConverterOptionalString.write(value.compatibilityCapabilityManifestPath, into);
-            FfiConverterOptionalString.write(value.compatibilityBoundedManifestPath, into);
-            FfiConverterBool.write(value.unrestrictedAcknowledged, into);
-            FfiConverterUInt64.write(value.maxSessionTtlSeconds, into);
-            FfiConverterUInt64.write(value.maxIdleTtlSeconds, into);
+            FfiConverterTypeCursorPathShape.write(value.path, into);
+            FfiConverterTypeCursorEase.write(value.ease, into);
+            FfiConverterTypeCursorSettle.write(value.settle, into);
+            FfiConverterTypeCursorMotionDuration.write(value.duration, into);
+            FfiConverterTypeCursorHeading.write(value.heading, into);
+            FfiConverterTypeCursorMotionEffectsOutput.write(value.effects, into);
+            FfiConverterTypeCursorTrailSpec.write(value.trail, into);
         }
         allocationSize(value) {
-            return FfiConverterSequenceTypeSessionPermissionMode.allocationSize(value.allowedModes) +
-                FfiConverterTypeSessionPermissionMode.allocationSize(value.compatibilityMode) +
-                FfiConverterOptionalString.allocationSize(value.compatibilityCapabilityManifestPath) +
-                FfiConverterOptionalString.allocationSize(value.compatibilityBoundedManifestPath) +
-                FfiConverterBool.allocationSize(value.unrestrictedAcknowledged) +
-                FfiConverterUInt64.allocationSize(value.maxSessionTtlSeconds) +
-                FfiConverterUInt64.allocationSize(value.maxIdleTtlSeconds);
+            return FfiConverterTypeCursorPathShape.allocationSize(value.path) +
+                FfiConverterTypeCursorEase.allocationSize(value.ease) +
+                FfiConverterTypeCursorSettle.allocationSize(value.settle) +
+                FfiConverterTypeCursorMotionDuration.allocationSize(value.duration) +
+                FfiConverterTypeCursorHeading.allocationSize(value.heading) +
+                FfiConverterTypeCursorMotionEffectsOutput.allocationSize(value.effects) +
+                FfiConverterTypeCursorTrailSpec.allocationSize(value.trail);
         }
     }
     ;
     return new FFIConverter();
 })();
 /**
- * Generated factory for {@link ConfiguredDriverOptions} record objects.
+ * Generated factory for {@link CursorMoveRequest} record objects.
  */
-export const ConfiguredDriverOptions = (() => {
+export const CursorMoveRequest = (() => {
     const defaults = () => ({});
     const create = (() => {
         return uniffiCreateRecord(defaults);
@@ -233,21 +1544,36 @@ export const ConfiguredDriverOptions = (() => {
         defaults: () => Object.freeze(defaults()),
     });
 })();
-const FfiConverterTypeConfiguredDriverOptions = (() => {
+const FfiConverterTypeCursorMoveRequest = (() => {
     class FFIConverter extends AbstractFfiConverterByteArray {
         read(from) {
             return {
-                claudeCodeCompatibility: FfiConverterBool.read(from),
-                authorization: FfiConverterTypeRuntimeAuthorizationOptions.read(from)
+                fromPoint: FfiConverterTypeCursorMotionPoint.read(from),
+                toPoint: FfiConverterTypeCursorMotionPoint.read(from),
+                fromHeading: FfiConverterOptionalFloat64.read(from),
+                endHeading: FfiConverterOptionalFloat64.read(from),
+                target: FfiConverterOptionalTypeCursorMotionRect.read(from),
+                seed: FfiConverterString.read(from),
+                reducedMotion: FfiConverterBool.read(from)
             };
         }
         write(value, into) {
-            FfiConverterBool.write(value.claudeCodeCompatibility, into);
-            FfiConverterTypeRuntimeAuthorizationOptions.write(value.authorization, into);
+            FfiConverterTypeCursorMotionPoint.write(value.fromPoint, into);
+            FfiConverterTypeCursorMotionPoint.write(value.toPoint, into);
+            FfiConverterOptionalFloat64.write(value.fromHeading, into);
+            FfiConverterOptionalFloat64.write(value.endHeading, into);
+            FfiConverterOptionalTypeCursorMotionRect.write(value.target, into);
+            FfiConverterString.write(value.seed, into);
+            FfiConverterBool.write(value.reducedMotion, into);
         }
         allocationSize(value) {
-            return FfiConverterBool.allocationSize(value.claudeCodeCompatibility) +
-                FfiConverterTypeRuntimeAuthorizationOptions.allocationSize(value.authorization);
+            return FfiConverterTypeCursorMotionPoint.allocationSize(value.fromPoint) +
+                FfiConverterTypeCursorMotionPoint.allocationSize(value.toPoint) +
+                FfiConverterOptionalFloat64.allocationSize(value.fromHeading) +
+                FfiConverterOptionalFloat64.allocationSize(value.endHeading) +
+                FfiConverterOptionalTypeCursorMotionRect.allocationSize(value.target) +
+                FfiConverterString.allocationSize(value.seed) +
+                FfiConverterBool.allocationSize(value.reducedMotion);
         }
     }
     ;
@@ -5160,6 +6486,220 @@ const uniffiTypeCuaDriverSessionObjectFactory = (() => {
     };
 })();
 const FfiConverterTypeCuaDriverSession = new FfiConverterObject(uniffiTypeCuaDriverSessionObjectFactory);
+/**
+ * A planned move, played back by time.
+ */
+export class CursorTrajectory extends UniffiAbstractObject {
+    [uniffiTypeNameSymbol] = "CursorTrajectory";
+    [destructorGuardSymbol];
+    [pointerLiteralSymbol];
+    // No primary constructor declared for this class.
+    constructor(pointer) {
+        super();
+        this[pointerLiteralSymbol] = pointer;
+        this[destructorGuardSymbol] = uniffiTypeCursorTrajectoryObjectFactory.bless(pointer);
+    }
+    /**
+     * When the tip first reaches the target, seconds.
+     */
+    arrivalT() {
+        return FfiConverterFloat64.lift(uniffiCaller.rustCall(
+        /*caller:*/ (callStatus) => {
+            return nativeModule().uniffi_cua_driver_sdk_fn_method_cursortrajectory_arrival_t(uniffiTypeCursorTrajectoryObjectFactory.clonePointer(this), callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)));
+    }
+    /**
+     * Seconds until the last sample (any settle included).
+     */
+    duration() {
+        return FfiConverterFloat64.lift(uniffiCaller.rustCall(
+        /*caller:*/ (callStatus) => {
+            return nativeModule().uniffi_cua_driver_sdk_fn_method_cursortrajectory_duration(uniffiTypeCursorTrajectoryObjectFactory.clonePointer(this), callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)));
+    }
+    /**
+     * The move's effects (glow, trail, magnet) at `t`, around the arrow's
+     * body. `blend` is whether the surface can draw translucency.
+     */
+    effectFrame(t, blend) {
+        return ((__rb) => {
+            try {
+                return FfiConverterTypeCursorEffectFrame.lift(__rb);
+            }
+            finally {
+                nativeModule().rustbuffer_free(__rb);
+            }
+        })(uniffiCaller.rustCall(
+        /*caller:*/ (callStatus) => {
+            return nativeModule().uniffi_cua_driver_sdk_fn_method_cursortrajectory_effect_frame(uniffiTypeCursorTrajectoryObjectFactory.clonePointer(this), FfiConverterFloat64.lower(t, nativeModule().rustbuffer_alloc), FfiConverterBool.lower(blend, nativeModule().rustbuffer_alloc), callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)));
+    }
+    effects() {
+        return ((__rb) => {
+            try {
+                return FfiConverterTypeCursorMotionEffectsOutput.lift(__rb);
+            }
+            finally {
+                nativeModule().rustbuffer_free(__rb);
+            }
+        })(uniffiCaller.rustCall(
+        /*caller:*/ (callStatus) => {
+            return nativeModule().uniffi_cua_driver_sdk_fn_method_cursortrajectory_effects(uniffiTypeCursorTrajectoryObjectFactory.clonePointer(this), callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)));
+    }
+    /**
+     * When the move and its trail or magnet glow have finished, seconds.
+     */
+    linger() {
+        return FfiConverterFloat64.lift(uniffiCaller.rustCall(
+        /*caller:*/ (callStatus) => {
+            return nativeModule().uniffi_cua_driver_sdk_fn_method_cursortrajectory_linger(uniffiTypeCursorTrajectoryObjectFactory.clonePointer(this), callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)));
+    }
+    /**
+     * Interpolated sample at `t` seconds, clamped to the ends.
+     */
+    sampleAt(t) {
+        return ((__rb) => {
+            try {
+                return FfiConverterTypeCursorMotionSample.lift(__rb);
+            }
+            finally {
+                nativeModule().rustbuffer_free(__rb);
+            }
+        })(uniffiCaller.rustCall(
+        /*caller:*/ (callStatus) => {
+            return nativeModule().uniffi_cua_driver_sdk_fn_method_cursortrajectory_sample_at(uniffiTypeCursorTrajectoryObjectFactory.clonePointer(this), FfiConverterFloat64.lower(t, nativeModule().rustbuffer_alloc), callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)));
+    }
+    /**
+     * Every sample at 120 Hz. Read once; interpolate locally per frame.
+     */
+    samples() {
+        return ((__rb) => {
+            try {
+                return FfiConverterSequenceTypeCursorMotionSample.lift(__rb);
+            }
+            finally {
+                nativeModule().rustbuffer_free(__rb);
+            }
+        })(uniffiCaller.rustCall(
+        /*caller:*/ (callStatus) => {
+            return nativeModule().uniffi_cua_driver_sdk_fn_method_cursortrajectory_samples(uniffiTypeCursorTrajectoryObjectFactory.clonePointer(this), callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)));
+    }
+    /**
+     * Magnetic lock-on time, seconds.
+     */
+    snapT() {
+        return ((__rb) => {
+            try {
+                return FfiConverterOptionalFloat64.lift(__rb);
+            }
+            finally {
+                nativeModule().rustbuffer_free(__rb);
+            }
+        })(uniffiCaller.rustCall(
+        /*caller:*/ (callStatus) => {
+            return nativeModule().uniffi_cua_driver_sdk_fn_method_cursortrajectory_snap_t(uniffiTypeCursorTrajectoryObjectFactory.clonePointer(this), callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)));
+    }
+    /**
+     * The target used for timing (the request's, or a 24 pt box).
+     */
+    target() {
+        return ((__rb) => {
+            try {
+                return FfiConverterTypeCursorMotionRect.lift(__rb);
+            }
+            finally {
+                nativeModule().rustbuffer_free(__rb);
+            }
+        })(uniffiCaller.rustCall(
+        /*caller:*/ (callStatus) => {
+            return nativeModule().uniffi_cua_driver_sdk_fn_method_cursortrajectory_target(uniffiTypeCursorTrajectoryObjectFactory.clonePointer(this), callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)));
+    }
+    targetKnown() {
+        return FfiConverterBool.lift(uniffiCaller.rustCall(
+        /*caller:*/ (callStatus) => {
+            return nativeModule().uniffi_cua_driver_sdk_fn_method_cursortrajectory_target_known(uniffiTypeCursorTrajectoryObjectFactory.clonePointer(this), callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)));
+    }
+    uniffiDestroy() {
+        const ptr = this[destructorGuardSymbol];
+        if (ptr !== undefined) {
+            const pointer = uniffiTypeCursorTrajectoryObjectFactory.pointer(this);
+            uniffiTypeCursorTrajectoryObjectFactory.freePointer(pointer);
+            uniffiTypeCursorTrajectoryObjectFactory.unbless(ptr);
+            delete this[destructorGuardSymbol];
+        }
+    }
+    static instanceOf(obj_) {
+        return uniffiTypeCursorTrajectoryObjectFactory.isConcreteType(obj_);
+    }
+}
+const uniffiTypeCursorTrajectoryObjectFactory = (() => {
+    /// <reference lib="es2021" />
+    const registry = typeof FinalizationRegistry !== 'undefined' ? new FinalizationRegistry((heldValue) => {
+        uniffiTypeCursorTrajectoryObjectFactory.freePointer(heldValue);
+    }) : null;
+    return {
+        create(pointer) {
+            const instance = Object.create(CursorTrajectory.prototype);
+            instance[pointerLiteralSymbol] = pointer;
+            instance[destructorGuardSymbol] = this.bless(pointer);
+            instance[uniffiTypeNameSymbol] = "CursorTrajectory";
+            return instance;
+        },
+        bless(p) {
+            const ptr = {
+                p, // make sure this object doesn't get optimized away.
+                markDestroyed: () => undefined,
+            };
+            if (registry) {
+                registry.register(ptr, p, ptr);
+            }
+            return ptr;
+        },
+        unbless(ptr_) {
+            if (registry) {
+                registry.unregister(ptr_);
+            }
+        },
+        pointer(obj_) {
+            if (obj_[destructorGuardSymbol] === undefined) {
+                throw new UniffiInternalError.UnexpectedNullPointer();
+            }
+            return obj_[pointerLiteralSymbol];
+        },
+        clonePointer(obj_) {
+            const pointer = this.pointer(obj_);
+            return uniffiCaller.rustCall(
+            /*caller:*/ (callStatus) => nativeModule().uniffi_cua_driver_sdk_fn_clone_cursortrajectory(pointer, callStatus), 
+            /*liftString:*/ FfiConverterString.lift);
+        },
+        freePointer(pointer) {
+            uniffiCaller.rustCall(
+            /*caller:*/ (callStatus) => nativeModule().uniffi_cua_driver_sdk_fn_free_cursortrajectory(pointer, callStatus), 
+            /*liftString:*/ FfiConverterString.lift);
+        },
+        isConcreteType(obj_) {
+            return obj_[destructorGuardSymbol] && obj_[uniffiTypeNameSymbol] === "CursorTrajectory";
+        },
+    };
+})();
+const FfiConverterTypeCursorTrajectory = new FfiConverterObject(uniffiTypeCursorTrajectoryObjectFactory);
 /**
  * Optional observer implemented by trusted embedding-host code.
  *
@@ -5973,6 +7513,18 @@ const FfiConverterTypeMcpDriverChannel = new FfiConverterObject(uniffiTypeMcpDri
 const FfiConverterSequenceTypeSessionPermissionMode = new FfiConverterArray(FfiConverterTypeSessionPermissionMode);
 // FfiConverter for string | undefined
 const FfiConverterOptionalString = new FfiConverterOptional(FfiConverterString);
+// FfiConverter for CursorGlow | undefined
+const FfiConverterOptionalTypeCursorGlow = new FfiConverterOptional(FfiConverterTypeCursorGlow);
+// FfiConverter for Array<CursorTrailSegment>
+const FfiConverterSequenceTypeCursorTrailSegment = new FfiConverterArray(FfiConverterTypeCursorTrailSegment);
+// FfiConverter for CursorMagnet | undefined
+const FfiConverterOptionalTypeCursorMagnet = new FfiConverterOptional(FfiConverterTypeCursorMagnet);
+// FfiConverter for CursorRipple | undefined
+const FfiConverterOptionalTypeCursorRipple = new FfiConverterOptional(FfiConverterTypeCursorRipple);
+// FfiConverter for number | undefined
+const FfiConverterOptionalFloat64 = new FfiConverterOptional(FfiConverterFloat64);
+// FfiConverter for CursorMotionRect | undefined
+const FfiConverterOptionalTypeCursorMotionRect = new FfiConverterOptional(FfiConverterTypeCursorMotionRect);
 // FfiConverter for Array<string>
 const FfiConverterSequenceString = new FfiConverterArray(FfiConverterString);
 // FfiConverter for Array<DriverServiceHeader>
@@ -5991,8 +7543,12 @@ const FfiConverterSequenceTypeImageContent = new FfiConverterArray(FfiConverterT
 const FfiConverterOptionalTypeActionResult = new FfiConverterOptional(FfiConverterTypeActionResult);
 // FfiConverter for VerifyStateOutput | undefined
 const FfiConverterOptionalTypeVerifyStateOutput = new FfiConverterOptional(FfiConverterTypeVerifyStateOutput);
+// FfiConverter for Array<CursorMotionSample>
+const FfiConverterSequenceTypeCursorMotionSample = new FfiConverterArray(FfiConverterTypeCursorMotionSample);
 // FfiConverter for EmbeddedDriverConnection | undefined
 const FfiConverterOptionalTypeEmbeddedDriverConnection = new FfiConverterOptional(FfiConverterTypeEmbeddedDriverConnection);
+// FfiConverter for CursorMotionSpec | undefined
+const FfiConverterOptionalTypeCursorMotionSpec = new FfiConverterOptional(FfiConverterTypeCursorMotionSpec);
 // FfiConverter for DriverOptions | undefined
 const FfiConverterOptionalTypeDriverOptions = new FfiConverterOptional(FfiConverterTypeDriverOptions);
 /**
@@ -6025,12 +7581,27 @@ function uniffiEnsureInitialized() {
     if (nativeModule().uniffi_cua_driver_sdk_checksum_func_current_mac_os_permission_status() !== 22890) {
         throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cua_driver_sdk_checksum_func_current_mac_os_permission_status");
     }
+    if (nativeModule().uniffi_cua_driver_sdk_checksum_func_cursor_click_effects() !== 47083) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cua_driver_sdk_checksum_func_cursor_click_effects");
+    }
+    if (nativeModule().uniffi_cua_driver_sdk_checksum_func_cursor_motion_spec_for_style() !== 60220) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cua_driver_sdk_checksum_func_cursor_motion_spec_for_style");
+    }
+    if (nativeModule().uniffi_cua_driver_sdk_checksum_func_default_cursor_motion_params() !== 63994) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cua_driver_sdk_checksum_func_default_cursor_motion_params");
+    }
     if (nativeModule().uniffi_cua_driver_sdk_checksum_func_open_mac_os_screen_recording_settings() !== 6663) {
         throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cua_driver_sdk_checksum_func_open_mac_os_screen_recording_settings");
     }
     if (nativeModule().uniffi_cua_driver_sdk_checksum_func_open_mcp_driver_channel() !== 952) {
         throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cua_driver_sdk_checksum_func_open_mcp_driver_channel");
     }
+    if (nativeModule().uniffi_cua_driver_sdk_checksum_func_plan_cursor_move() !== 47047) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cua_driver_sdk_checksum_func_plan_cursor_move");
+    }
+    if (nativeModule().uniffi_cua_driver_sdk_checksum_func_plan_cursor_spec() !== 61096) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cua_driver_sdk_checksum_func_plan_cursor_spec");
+    }
     if (nativeModule().uniffi_cua_driver_sdk_checksum_func_request_mac_os_permissions() !== 61823) {
         throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cua_driver_sdk_checksum_func_request_mac_os_permissions");
     }
@@ -6283,6 +7854,36 @@ function uniffiEnsureInitialized() {
     if (nativeModule().uniffi_cua_driver_sdk_checksum_method_cuadriversession_verify_state() !== 36472) {
         throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cua_driver_sdk_checksum_method_cuadriversession_verify_state");
     }
+    if (nativeModule().uniffi_cua_driver_sdk_checksum_method_cursortrajectory_arrival_t() !== 18003) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cua_driver_sdk_checksum_method_cursortrajectory_arrival_t");
+    }
+    if (nativeModule().uniffi_cua_driver_sdk_checksum_method_cursortrajectory_duration() !== 45567) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cua_driver_sdk_checksum_method_cursortrajectory_duration");
+    }
+    if (nativeModule().uniffi_cua_driver_sdk_checksum_method_cursortrajectory_effect_frame() !== 63284) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cua_driver_sdk_checksum_method_cursortrajectory_effect_frame");
+    }
+    if (nativeModule().uniffi_cua_driver_sdk_checksum_method_cursortrajectory_effects() !== 30979) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cua_driver_sdk_checksum_method_cursortrajectory_effects");
+    }
+    if (nativeModule().uniffi_cua_driver_sdk_checksum_method_cursortrajectory_linger() !== 61008) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cua_driver_sdk_checksum_method_cursortrajectory_linger");
+    }
+    if (nativeModule().uniffi_cua_driver_sdk_checksum_method_cursortrajectory_sample_at() !== 63579) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cua_driver_sdk_checksum_method_cursortrajectory_sample_at");
+    }
+    if (nativeModule().uniffi_cua_driver_sdk_checksum_method_cursortrajectory_samples() !== 43656) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cua_driver_sdk_checksum_method_cursortrajectory_samples");
+    }
+    if (nativeModule().uniffi_cua_driver_sdk_checksum_method_cursortrajectory_snap_t() !== 61947) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cua_driver_sdk_checksum_method_cursortrajectory_snap_t");
+    }
+    if (nativeModule().uniffi_cua_driver_sdk_checksum_method_cursortrajectory_target() !== 1238) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cua_driver_sdk_checksum_method_cursortrajectory_target");
+    }
+    if (nativeModule().uniffi_cua_driver_sdk_checksum_method_cursortrajectory_target_known() !== 24778) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cua_driver_sdk_checksum_method_cursortrajectory_target_known");
+    }
     if (nativeModule().uniffi_cua_driver_sdk_checksum_method_driveractivityobserver_on_activity() !== 9786) {
         throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cua_driver_sdk_checksum_method_driveractivityobserver_on_activity");
     }
@@ -6358,6 +7959,24 @@ export default Object.freeze({
         FfiConverterTypeConfiguredDriverOptions,
         FfiConverterTypeCuaDriver,
         FfiConverterTypeCuaDriverSession,
+        FfiConverterTypeCursorEase,
+        FfiConverterTypeCursorEffectFrame,
+        FfiConverterTypeCursorGlow,
+        FfiConverterTypeCursorHeading,
+        FfiConverterTypeCursorMagnet,
+        FfiConverterTypeCursorMotionDuration,
+        FfiConverterTypeCursorMotionParams,
+        FfiConverterTypeCursorMotionPoint,
+        FfiConverterTypeCursorMotionRect,
+        FfiConverterTypeCursorMotionSample,
+        FfiConverterTypeCursorMotionSpec,
+        FfiConverterTypeCursorMoveRequest,
+        FfiConverterTypeCursorPathShape,
+        FfiConverterTypeCursorRipple,
+        FfiConverterTypeCursorSettle,
+        FfiConverterTypeCursorTrailSegment,
+        FfiConverterTypeCursorTrailSpec,
+        FfiConverterTypeCursorTrajectory,
         FfiConverterTypeDriverActivityEvent,
         FfiConverterTypeDriverActivityKind,
         FfiConverterTypeDriverActivityObserver,