@trycua/cua-driver 0.28.2 → 0.28.3

package/dist/native/cua_driver_contract.js

@@ -80,6 +80,55 @@ const FfiConverterTypeActionDelivery = (() => {
     ;
     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 ActionError} record objects.
+ */
+export const ActionError = (() => {
+    const defaults = () => ({});
+    const create = (() => {
+        return uniffiCreateRecord(defaults);
+    })();
+    return Object.freeze({
+        create,
+        new: create,
+        defaults: () => Object.freeze(defaults()),
+    });
+})();
+const FfiConverterTypeActionError = (() => {
+    class FFIConverter extends AbstractFfiConverterByteArray {
+        read(from) {
+            return {
+                code: FfiConverterString.read(from),
+                hint: FfiConverterOptionalString.read(from)
+            };
+        }
+        write(value, into) {
+            FfiConverterString.write(value.code, into);
+            FfiConverterOptionalString.write(value.hint, into);
+        }
+        allocationSize(value) {
+            return FfiConverterString.allocationSize(value.code) +
+                FfiConverterOptionalString.allocationSize(value.hint);
+        }
+    }
+    ;
+    return new FFIConverter();
+})();
 export var ActionEscalationTarget;
 (function (ActionEscalationTarget) {
     ActionEscalationTarget[ActionEscalationTarget["Pixel"] = 0] = "Pixel";
@@ -228,14 +277,17 @@ const FfiConverterTypeActionEvidence = (() => {
     class FFIConverter extends AbstractFfiConverterByteArray {
         read(from) {
             return {
-                kind: FfiConverterTypeActionEvidenceKind.read(from)
+                kind: FfiConverterTypeActionEvidenceKind.read(from),
+                detail: FfiConverterOptionalString.read(from)
             };
         }
         write(value, into) {
             FfiConverterTypeActionEvidenceKind.write(value.kind, into);
+            FfiConverterOptionalString.write(value.detail, into);
         }
         allocationSize(value) {
-            return FfiConverterTypeActionEvidenceKind.allocationSize(value.kind);
+            return FfiConverterTypeActionEvidenceKind.allocationSize(value.kind) +
+                FfiConverterOptionalString.allocationSize(value.detail);
         }
     }
     ;
@@ -338,7 +390,9 @@ const FfiConverterTypeActionResult = (() => {
                 route: FfiConverterTypeActionRoute.read(from),
                 delivery: FfiConverterOptionalTypeActionDelivery.read(from),
                 evidence: FfiConverterOptionalSequenceTypeActionEvidence.read(from),
-                escalation: FfiConverterOptionalTypeActionEscalation.read(from)
+                escalation: FfiConverterOptionalTypeActionEscalation.read(from),
+                summary: FfiConverterOptionalString.read(from),
+                error: FfiConverterOptionalTypeActionError.read(from)
             };
         }
         write(value, into) {
@@ -347,33 +401,22 @@ const FfiConverterTypeActionResult = (() => {
             FfiConverterOptionalTypeActionDelivery.write(value.delivery, into);
             FfiConverterOptionalSequenceTypeActionEvidence.write(value.evidence, into);
             FfiConverterOptionalTypeActionEscalation.write(value.escalation, into);
+            FfiConverterOptionalString.write(value.summary, into);
+            FfiConverterOptionalTypeActionError.write(value.error, into);
         }
         allocationSize(value) {
             return FfiConverterTypeActionEffect.allocationSize(value.effect) +
                 FfiConverterTypeActionRoute.allocationSize(value.route) +
                 FfiConverterOptionalTypeActionDelivery.allocationSize(value.delivery) +
                 FfiConverterOptionalSequenceTypeActionEvidence.allocationSize(value.evidence) +
-                FfiConverterOptionalTypeActionEscalation.allocationSize(value.escalation);
+                FfiConverterOptionalTypeActionEscalation.allocationSize(value.escalation) +
+                FfiConverterOptionalString.allocationSize(value.summary) +
+                FfiConverterOptionalTypeActionError.allocationSize(value.error);
         }
     }
     ;
     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 AppInfo} record objects.
  */
@@ -587,6 +630,7 @@ export var ClickPosition_Tags;
 (function (ClickPosition_Tags) {
     ClickPosition_Tags["Coordinates"] = "Coordinates";
     ClickPosition_Tags["Element"] = "Element";
+    ClickPosition_Tags["CapturedCoordinates"] = "CapturedCoordinates";
 })(ClickPosition_Tags || (ClickPosition_Tags = {}));
 export const ClickPosition = (() => {
     class Coordinates_ extends UniffiEnum {
@@ -627,13 +671,33 @@ export const ClickPosition = (() => {
             return obj.tag === ClickPosition_Tags.Element;
         }
     }
+    class CapturedCoordinates_ extends UniffiEnum {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        [uniffiTypeNameSymbol] = "ClickPosition";
+        tag = ClickPosition_Tags.CapturedCoordinates;
+        inner;
+        constructor(inner) {
+            super("ClickPosition", "CapturedCoordinates");
+            this.inner = Object.freeze(inner);
+        }
+        static new(inner) {
+            return new CapturedCoordinates_(inner);
+        }
+        static instanceOf(obj) {
+            return obj.tag === ClickPosition_Tags.CapturedCoordinates;
+        }
+    }
     function instanceOf(obj) {
         return obj[uniffiTypeNameSymbol] === "ClickPosition";
     }
     return Object.freeze({
         instanceOf,
         Coordinates: Coordinates_,
-        Element: Element_
+        Element: Element_,
+        CapturedCoordinates: CapturedCoordinates_
     });
 })();
 // FfiConverter for enum ClickPosition
@@ -644,6 +708,7 @@ const FfiConverterTypeClickPosition = (() => {
             switch (ordinalConverter.read(from)) {
                 case 1: return new ClickPosition.Coordinates({ x: FfiConverterFloat64.read(from), y: FfiConverterFloat64.read(from) });
                 case 2: return new ClickPosition.Element({ elementToken: FfiConverterString.read(from) });
+                case 3: return new ClickPosition.CapturedCoordinates({ x: FfiConverterFloat64.read(from), y: FfiConverterFloat64.read(from), captureId: FfiConverterString.read(from) });
                 default: throw new UniffiInternalError.UnexpectedEnumCase();
             }
         }
@@ -662,6 +727,14 @@ const FfiConverterTypeClickPosition = (() => {
                     FfiConverterString.write(inner.elementToken, into);
                     return;
                 }
+                case ClickPosition_Tags.CapturedCoordinates: {
+                    ordinalConverter.write(3, into);
+                    const inner = value.inner;
+                    FfiConverterFloat64.write(inner.x, into);
+                    FfiConverterFloat64.write(inner.y, into);
+                    FfiConverterString.write(inner.captureId, into);
+                    return;
+                }
                 default:
                     // Throwing from here means that ClickPosition_Tags hasn't matched an ordinal.
                     throw new UniffiInternalError.UnexpectedEnumCase();
@@ -682,6 +755,14 @@ const FfiConverterTypeClickPosition = (() => {
                     size += FfiConverterString.allocationSize(inner.elementToken);
                     return size;
                 }
+                case ClickPosition_Tags.CapturedCoordinates: {
+                    const inner = value.inner;
+                    let size = ordinalConverter.allocationSize(3);
+                    size += FfiConverterFloat64.allocationSize(inner.x);
+                    size += FfiConverterFloat64.allocationSize(inner.y);
+                    size += FfiConverterString.allocationSize(inner.captureId);
+                    return size;
+                }
                 default: throw new UniffiInternalError.UnexpectedEnumCase();
             }
         }
@@ -1702,7 +1783,9 @@ const FfiConverterTypeGetCursorPositionInput = (() => {
  * Generated factory for {@link GetDesktopStateInput} record objects.
  */
 export const GetDesktopStateInput = (() => {
-    const defaults = () => ({});
+    const defaults = () => ({
+        maxImageDimension: undefined
+    });
     const create = (() => {
         return uniffiCreateRecord(defaults);
     })();
@@ -1717,16 +1800,19 @@ const FfiConverterTypeGetDesktopStateInput = (() => {
         read(from) {
             return {
                 session: FfiConverterOptionalString.read(from),
-                screenshotOutFile: FfiConverterOptionalString.read(from)
+                screenshotOutFile: FfiConverterOptionalString.read(from),
+                maxImageDimension: FfiConverterOptionalUInt32.read(from)
             };
         }
         write(value, into) {
             FfiConverterOptionalString.write(value.session, into);
             FfiConverterOptionalString.write(value.screenshotOutFile, into);
+            FfiConverterOptionalUInt32.write(value.maxImageDimension, into);
         }
         allocationSize(value) {
             return FfiConverterOptionalString.allocationSize(value.session) +
-                FfiConverterOptionalString.allocationSize(value.screenshotOutFile);
+                FfiConverterOptionalString.allocationSize(value.screenshotOutFile) +
+                FfiConverterOptionalUInt32.allocationSize(value.maxImageDimension);
         }
     }
     ;
@@ -1829,7 +1915,9 @@ const FfiConverterTypeGetSessionStateInput = (() => {
  * Generated factory for {@link GetWindowStateInput} record objects.
  */
 export const GetWindowStateInput = (() => {
-    const defaults = () => ({});
+    const defaults = () => ({
+        timeoutMs: undefined
+    });
     const create = (() => {
         return uniffiCreateRecord(defaults);
     })();
@@ -1852,7 +1940,9 @@ const FfiConverterTypeGetWindowStateInput = (() => {
                 screenshotOutFile: FfiConverterOptionalString.read(from),
                 maxElements: FfiConverterOptionalUInt32.read(from),
                 maxDepth: FfiConverterOptionalUInt32.read(from),
-                maxDimension: FfiConverterOptionalUInt32.read(from)
+                maxDimension: FfiConverterOptionalUInt32.read(from),
+                maxImageDimension: FfiConverterOptionalUInt32.read(from),
+                timeoutMs: FfiConverterOptionalUInt32.read(from)
             };
         }
         write(value, into) {
@@ -1866,6 +1956,8 @@ const FfiConverterTypeGetWindowStateInput = (() => {
             FfiConverterOptionalUInt32.write(value.maxElements, into);
             FfiConverterOptionalUInt32.write(value.maxDepth, into);
             FfiConverterOptionalUInt32.write(value.maxDimension, into);
+            FfiConverterOptionalUInt32.write(value.maxImageDimension, into);
+            FfiConverterOptionalUInt32.write(value.timeoutMs, into);
         }
         allocationSize(value) {
             return FfiConverterUInt32.allocationSize(value.pid) +
@@ -1877,7 +1969,9 @@ const FfiConverterTypeGetWindowStateInput = (() => {
                 FfiConverterOptionalString.allocationSize(value.screenshotOutFile) +
                 FfiConverterOptionalUInt32.allocationSize(value.maxElements) +
                 FfiConverterOptionalUInt32.allocationSize(value.maxDepth) +
-                FfiConverterOptionalUInt32.allocationSize(value.maxDimension);
+                FfiConverterOptionalUInt32.allocationSize(value.maxDimension) +
+                FfiConverterOptionalUInt32.allocationSize(value.maxImageDimension) +
+                FfiConverterOptionalUInt32.allocationSize(value.timeoutMs);
         }
     }
     ;
@@ -2456,70 +2550,25 @@ const FfiConverterTypeMoveCursorInput = (() => {
     ;
     return new FFIConverter();
 })();
-export var VerificationStatus;
-(function (VerificationStatus) {
-    VerificationStatus[VerificationStatus["Satisfied"] = 0] = "Satisfied";
-    VerificationStatus[VerificationStatus["Unsatisfied"] = 1] = "Unsatisfied";
-    VerificationStatus[VerificationStatus["Unknown"] = 2] = "Unknown";
-})(VerificationStatus || (VerificationStatus = {}));
-const FfiConverterTypeVerificationStatus = (() => {
-    const ordinalConverter = FfiConverterInt32;
-    class FFIConverter extends AbstractFfiConverterByteArray {
-        read(from) {
-            switch (ordinalConverter.read(from)) {
-                case 1: return VerificationStatus.Satisfied;
-                case 2: return VerificationStatus.Unsatisfied;
-                case 3: return VerificationStatus.Unknown;
-                default: throw new UniffiInternalError.UnexpectedEnumCase();
-            }
-        }
-        write(value, into) {
-            switch (value) {
-                case VerificationStatus.Satisfied: return ordinalConverter.write(1, into);
-                case VerificationStatus.Unsatisfied: return ordinalConverter.write(2, into);
-                case VerificationStatus.Unknown: return ordinalConverter.write(3, into);
-            }
-        }
-        allocationSize(value) {
-            return ordinalConverter.allocationSize(0);
-        }
-    }
-    return new FFIConverter();
-})();
-export var UnknownReason;
-(function (UnknownReason) {
-    UnknownReason[UnknownReason["InvalidPredicate"] = 0] = "InvalidPredicate";
-    UnknownReason[UnknownReason["UnsupportedPredicate"] = 1] = "UnsupportedPredicate";
-    UnknownReason[UnknownReason["UntrustedSource"] = 2] = "UntrustedSource";
-    UnknownReason[UnknownReason["MultiMatch"] = 3] = "MultiMatch";
-    UnknownReason[UnknownReason["TargetMissing"] = 4] = "TargetMissing";
-    UnknownReason[UnknownReason["ObservationUnavailable"] = 5] = "ObservationUnavailable";
-    UnknownReason[UnknownReason["StabilityUnproven"] = 6] = "StabilityUnproven";
-})(UnknownReason || (UnknownReason = {}));
-const FfiConverterTypeUnknownReason = (() => {
+export var VisualRegionKind;
+(function (VisualRegionKind) {
+    VisualRegionKind[VisualRegionKind["Text"] = 0] = "Text";
+    VisualRegionKind[VisualRegionKind["Icon"] = 1] = "Icon";
+})(VisualRegionKind || (VisualRegionKind = {}));
+const FfiConverterTypeVisualRegionKind = (() => {
     const ordinalConverter = FfiConverterInt32;
     class FFIConverter extends AbstractFfiConverterByteArray {
         read(from) {
             switch (ordinalConverter.read(from)) {
-                case 1: return UnknownReason.InvalidPredicate;
-                case 2: return UnknownReason.UnsupportedPredicate;
-                case 3: return UnknownReason.UntrustedSource;
-                case 4: return UnknownReason.MultiMatch;
-                case 5: return UnknownReason.TargetMissing;
-                case 6: return UnknownReason.ObservationUnavailable;
-                case 7: return UnknownReason.StabilityUnproven;
+                case 1: return VisualRegionKind.Text;
+                case 2: return VisualRegionKind.Icon;
                 default: throw new UniffiInternalError.UnexpectedEnumCase();
             }
         }
         write(value, into) {
             switch (value) {
-                case UnknownReason.InvalidPredicate: return ordinalConverter.write(1, into);
-                case UnknownReason.UnsupportedPredicate: return ordinalConverter.write(2, into);
-                case UnknownReason.UntrustedSource: return ordinalConverter.write(3, into);
-                case UnknownReason.MultiMatch: return ordinalConverter.write(4, into);
-                case UnknownReason.TargetMissing: return ordinalConverter.write(5, into);
-                case UnknownReason.ObservationUnavailable: return ordinalConverter.write(6, into);
-                case UnknownReason.StabilityUnproven: return ordinalConverter.write(7, into);
+                case VisualRegionKind.Text: return ordinalConverter.write(1, into);
+                case VisualRegionKind.Icon: return ordinalConverter.write(2, into);
             }
         }
         allocationSize(value) {
@@ -2529,9 +2578,9 @@ const FfiConverterTypeUnknownReason = (() => {
     return new FFIConverter();
 })();
 /**
- * Generated factory for {@link PredicateOutcome} record objects.
+ * Generated factory for {@link ParseVisualRegionsOptions} record objects.
  */
-export const PredicateOutcome = (() => {
+export const ParseVisualRegionsOptions = (() => {
     const defaults = () => ({});
     const create = (() => {
         return uniffiCreateRecord(defaults);
@@ -2542,36 +2591,33 @@ export const PredicateOutcome = (() => {
         defaults: () => Object.freeze(defaults()),
     });
 })();
-const FfiConverterTypePredicateOutcome = (() => {
+const FfiConverterTypeParseVisualRegionsOptions = (() => {
     class FFIConverter extends AbstractFfiConverterByteArray {
         read(from) {
             return {
-                index: FfiConverterUInt64.read(from),
-                status: FfiConverterTypeVerificationStatus.read(from),
-                unknownReason: FfiConverterOptionalTypeUnknownReason.read(from),
-                observedJson: FfiConverterOptionalString.read(from)
+                kinds: FfiConverterOptionalSequenceTypeVisualRegionKind.read(from),
+                minConfidence: FfiConverterOptionalFloat64.read(from),
+                maxRegions: FfiConverterOptionalUInt32.read(from)
             };
         }
         write(value, into) {
-            FfiConverterUInt64.write(value.index, into);
-            FfiConverterTypeVerificationStatus.write(value.status, into);
-            FfiConverterOptionalTypeUnknownReason.write(value.unknownReason, into);
-            FfiConverterOptionalString.write(value.observedJson, into);
+            FfiConverterOptionalSequenceTypeVisualRegionKind.write(value.kinds, into);
+            FfiConverterOptionalFloat64.write(value.minConfidence, into);
+            FfiConverterOptionalUInt32.write(value.maxRegions, into);
         }
         allocationSize(value) {
-            return FfiConverterUInt64.allocationSize(value.index) +
-                FfiConverterTypeVerificationStatus.allocationSize(value.status) +
-                FfiConverterOptionalTypeUnknownReason.allocationSize(value.unknownReason) +
-                FfiConverterOptionalString.allocationSize(value.observedJson);
+            return FfiConverterOptionalSequenceTypeVisualRegionKind.allocationSize(value.kinds) +
+                FfiConverterOptionalFloat64.allocationSize(value.minConfidence) +
+                FfiConverterOptionalUInt32.allocationSize(value.maxRegions);
         }
     }
     ;
     return new FFIConverter();
 })();
 /**
- * Generated factory for {@link PressKeyInput} record objects.
+ * Generated factory for {@link ParseVisualRegionsInput} record objects.
  */
-export const PressKeyInput = (() => {
+export const ParseVisualRegionsInput = (() => {
     const defaults = () => ({});
     const create = (() => {
         return uniffiCreateRecord(defaults);
@@ -2582,96 +2628,843 @@ export const PressKeyInput = (() => {
         defaults: () => Object.freeze(defaults()),
     });
 })();
-const FfiConverterTypePressKeyInput = (() => {
+const FfiConverterTypeParseVisualRegionsInput = (() => {
     class FFIConverter extends AbstractFfiConverterByteArray {
         read(from) {
             return {
-                key: FfiConverterString.read(from),
-                target: FfiConverterOptionalTypeActionTarget.read(from),
-                scope: FfiConverterOptionalTypeDesktopScope.read(from),
-                session: FfiConverterOptionalString.read(from),
-                modifiers: FfiConverterOptionalSequenceString.read(from)
+                captureId: FfiConverterString.read(from),
+                options: FfiConverterTypeParseVisualRegionsOptions.read(from)
             };
         }
         write(value, into) {
-            FfiConverterString.write(value.key, into);
-            FfiConverterOptionalTypeActionTarget.write(value.target, into);
-            FfiConverterOptionalTypeDesktopScope.write(value.scope, into);
-            FfiConverterOptionalString.write(value.session, into);
-            FfiConverterOptionalSequenceString.write(value.modifiers, into);
+            FfiConverterString.write(value.captureId, into);
+            FfiConverterTypeParseVisualRegionsOptions.write(value.options, into);
         }
         allocationSize(value) {
-            return FfiConverterString.allocationSize(value.key) +
-                FfiConverterOptionalTypeActionTarget.allocationSize(value.target) +
-                FfiConverterOptionalTypeDesktopScope.allocationSize(value.scope) +
-                FfiConverterOptionalString.allocationSize(value.session) +
-                FfiConverterOptionalSequenceString.allocationSize(value.modifiers);
+            return FfiConverterString.allocationSize(value.captureId) +
+                FfiConverterTypeParseVisualRegionsOptions.allocationSize(value.options);
         }
     }
     ;
     return new FFIConverter();
 })();
-export var ScrollDirection;
-(function (ScrollDirection) {
-    ScrollDirection[ScrollDirection["Up"] = 0] = "Up";
-    ScrollDirection[ScrollDirection["Down"] = 1] = "Down";
-    ScrollDirection[ScrollDirection["Left"] = 2] = "Left";
-    ScrollDirection[ScrollDirection["Right"] = 3] = "Right";
-})(ScrollDirection || (ScrollDirection = {}));
-const FfiConverterTypeScrollDirection = (() => {
-    const ordinalConverter = FfiConverterInt32;
-    class FFIConverter extends AbstractFfiConverterByteArray {
-        read(from) {
-            switch (ordinalConverter.read(from)) {
-                case 1: return ScrollDirection.Up;
-                case 2: return ScrollDirection.Down;
-                case 3: return ScrollDirection.Left;
-                case 4: return ScrollDirection.Right;
-                default: throw new UniffiInternalError.UnexpectedEnumCase();
-            }
+// Enum: VisualCaptureSource
+export var VisualCaptureSource_Tags;
+(function (VisualCaptureSource_Tags) {
+    VisualCaptureSource_Tags["Window"] = "Window";
+    VisualCaptureSource_Tags["PrimaryDesktop"] = "PrimaryDesktop";
+})(VisualCaptureSource_Tags || (VisualCaptureSource_Tags = {}));
+/**
+ * Exact screen content that produced the immutable capture.
+ */
+export const VisualCaptureSource = (() => {
+    class Window_ extends UniffiEnum {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        [uniffiTypeNameSymbol] = "VisualCaptureSource";
+        tag = VisualCaptureSource_Tags.Window;
+        inner;
+        constructor(inner) {
+            super("VisualCaptureSource", "Window");
+            this.inner = Object.freeze(inner);
         }
-        write(value, into) {
-            switch (value) {
-                case ScrollDirection.Up: return ordinalConverter.write(1, into);
-                case ScrollDirection.Down: return ordinalConverter.write(2, into);
-                case ScrollDirection.Left: return ordinalConverter.write(3, into);
-                case ScrollDirection.Right: return ordinalConverter.write(4, into);
-            }
+        static new(inner) {
+            return new Window_(inner);
         }
-        allocationSize(value) {
-            return ordinalConverter.allocationSize(0);
+        static instanceOf(obj) {
+            return obj.tag === VisualCaptureSource_Tags.Window;
         }
     }
-    return new FFIConverter();
+    class PrimaryDesktop_ extends UniffiEnum {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        [uniffiTypeNameSymbol] = "VisualCaptureSource";
+        tag = VisualCaptureSource_Tags.PrimaryDesktop;
+        inner;
+        constructor(inner) {
+            super("VisualCaptureSource", "PrimaryDesktop");
+            this.inner = Object.freeze(inner);
+        }
+        static new(inner) {
+            return new PrimaryDesktop_(inner);
+        }
+        static instanceOf(obj) {
+            return obj.tag === VisualCaptureSource_Tags.PrimaryDesktop;
+        }
+    }
+    function instanceOf(obj) {
+        return obj[uniffiTypeNameSymbol] === "VisualCaptureSource";
+    }
+    return Object.freeze({
+        instanceOf,
+        Window: Window_,
+        PrimaryDesktop: PrimaryDesktop_
+    });
 })();
-export var ScrollBy;
-(function (ScrollBy) {
-    ScrollBy[ScrollBy["Line"] = 0] = "Line";
-    ScrollBy[ScrollBy["Page"] = 1] = "Page";
-})(ScrollBy || (ScrollBy = {}));
-const FfiConverterTypeScrollBy = (() => {
+// FfiConverter for enum VisualCaptureSource
+const FfiConverterTypeVisualCaptureSource = (() => {
     const ordinalConverter = FfiConverterInt32;
     class FFIConverter extends AbstractFfiConverterByteArray {
         read(from) {
             switch (ordinalConverter.read(from)) {
-                case 1: return ScrollBy.Line;
-                case 2: return ScrollBy.Page;
+                case 1: return new VisualCaptureSource.Window({ pid: FfiConverterUInt32.read(from), windowId: FfiConverterUInt64.read(from) });
+                case 2: return new VisualCaptureSource.PrimaryDesktop({ displayId: FfiConverterString.read(from) });
                 default: throw new UniffiInternalError.UnexpectedEnumCase();
             }
         }
         write(value, into) {
-            switch (value) {
-                case ScrollBy.Line: return ordinalConverter.write(1, into);
-                case ScrollBy.Page: return ordinalConverter.write(2, into);
-            }
-        }
-        allocationSize(value) {
-            return ordinalConverter.allocationSize(0);
-        }
-    }
-    return new FFIConverter();
-})();
-/**
+            switch (value.tag) {
+                case VisualCaptureSource_Tags.Window: {
+                    ordinalConverter.write(1, into);
+                    const inner = value.inner;
+                    FfiConverterUInt32.write(inner.pid, into);
+                    FfiConverterUInt64.write(inner.windowId, into);
+                    return;
+                }
+                case VisualCaptureSource_Tags.PrimaryDesktop: {
+                    ordinalConverter.write(2, into);
+                    const inner = value.inner;
+                    FfiConverterString.write(inner.displayId, into);
+                    return;
+                }
+                default:
+                    // Throwing from here means that VisualCaptureSource_Tags hasn't matched an ordinal.
+                    throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+        allocationSize(value) {
+            switch (value.tag) {
+                case VisualCaptureSource_Tags.Window: {
+                    const inner = value.inner;
+                    let size = ordinalConverter.allocationSize(1);
+                    size += FfiConverterUInt32.allocationSize(inner.pid);
+                    size += FfiConverterUInt64.allocationSize(inner.windowId);
+                    return size;
+                }
+                case VisualCaptureSource_Tags.PrimaryDesktop: {
+                    const inner = value.inner;
+                    let size = ordinalConverter.allocationSize(2);
+                    size += FfiConverterString.allocationSize(inner.displayId);
+                    return size;
+                }
+                default: throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+    }
+    return new FFIConverter();
+})();
+/**
+ * Generated factory for {@link VisualScreenshotReference} record objects.
+ */
+export const VisualScreenshotReference = (() => {
+    const defaults = () => ({});
+    const create = (() => {
+        return uniffiCreateRecord(defaults);
+    })();
+    return Object.freeze({
+        create,
+        new: create,
+        defaults: () => Object.freeze(defaults()),
+    });
+})();
+const FfiConverterTypeVisualScreenshotReference = (() => {
+    class FFIConverter extends AbstractFfiConverterByteArray {
+        read(from) {
+            return {
+                reference: FfiConverterString.read(from),
+                width: FfiConverterUInt32.read(from),
+                height: FfiConverterUInt32.read(from),
+                mimeType: FfiConverterString.read(from),
+                sha256: FfiConverterOptionalString.read(from)
+            };
+        }
+        write(value, into) {
+            FfiConverterString.write(value.reference, into);
+            FfiConverterUInt32.write(value.width, into);
+            FfiConverterUInt32.write(value.height, into);
+            FfiConverterString.write(value.mimeType, into);
+            FfiConverterOptionalString.write(value.sha256, into);
+        }
+        allocationSize(value) {
+            return FfiConverterString.allocationSize(value.reference) +
+                FfiConverterUInt32.allocationSize(value.width) +
+                FfiConverterUInt32.allocationSize(value.height) +
+                FfiConverterString.allocationSize(value.mimeType) +
+                FfiConverterOptionalString.allocationSize(value.sha256);
+        }
+    }
+    ;
+    return new FFIConverter();
+})();
+// Enum: VisualActionCoordinateSpace
+export var VisualActionCoordinateSpace_Tags;
+(function (VisualActionCoordinateSpace_Tags) {
+    VisualActionCoordinateSpace_Tags["ScreenshotPixels"] = "ScreenshotPixels";
+    VisualActionCoordinateSpace_Tags["Affine"] = "Affine";
+})(VisualActionCoordinateSpace_Tags || (VisualActionCoordinateSpace_Tags = {}));
+/**
+ * Normative mapping from source screenshot pixels to Driver action coordinates.
+ *
+ * Screenshot coordinates always originate at the encoded PNG's top-left; X
+ * increases right and Y increases down. The affine form maps a source point
+ * `(px, py)` exactly as:
+ *
+ * `action_x = m11 * px + m12 * py + tx`
+ *
+ * `action_y = m21 * px + m22 * py + ty`
+ */
+export const VisualActionCoordinateSpace = (() => {
+    /**
+     * Action coordinates are the same physical pixel coordinates as the PNG.
+     */
+    class ScreenshotPixels_ extends UniffiEnum {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        [uniffiTypeNameSymbol] = "VisualActionCoordinateSpace";
+        tag = VisualActionCoordinateSpace_Tags.ScreenshotPixels;
+        constructor() {
+            super("VisualActionCoordinateSpace", "ScreenshotPixels");
+        }
+        static new() {
+            return new ScreenshotPixels_();
+        }
+        static instanceOf(obj) {
+            return obj.tag === VisualActionCoordinateSpace_Tags.ScreenshotPixels;
+        }
+    }
+    /**
+     * Lossless six-coefficient affine transform retained by the capture registry.
+     */
+    class Affine_ extends UniffiEnum {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        [uniffiTypeNameSymbol] = "VisualActionCoordinateSpace";
+        tag = VisualActionCoordinateSpace_Tags.Affine;
+        inner;
+        constructor(inner) {
+            super("VisualActionCoordinateSpace", "Affine");
+            this.inner = Object.freeze(inner);
+        }
+        static new(inner) {
+            return new Affine_(inner);
+        }
+        static instanceOf(obj) {
+            return obj.tag === VisualActionCoordinateSpace_Tags.Affine;
+        }
+    }
+    function instanceOf(obj) {
+        return obj[uniffiTypeNameSymbol] === "VisualActionCoordinateSpace";
+    }
+    return Object.freeze({
+        instanceOf,
+        ScreenshotPixels: ScreenshotPixels_,
+        Affine: Affine_
+    });
+})();
+// FfiConverter for enum VisualActionCoordinateSpace
+const FfiConverterTypeVisualActionCoordinateSpace = (() => {
+    const ordinalConverter = FfiConverterInt32;
+    class FFIConverter extends AbstractFfiConverterByteArray {
+        read(from) {
+            switch (ordinalConverter.read(from)) {
+                case 1: return new VisualActionCoordinateSpace.ScreenshotPixels();
+                case 2: return new VisualActionCoordinateSpace.Affine({ m11: FfiConverterFloat64.read(from), m12: FfiConverterFloat64.read(from), m21: FfiConverterFloat64.read(from), m22: FfiConverterFloat64.read(from), tx: FfiConverterFloat64.read(from), ty: FfiConverterFloat64.read(from) });
+                default: throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+        write(value, into) {
+            switch (value.tag) {
+                case VisualActionCoordinateSpace_Tags.ScreenshotPixels: {
+                    ordinalConverter.write(1, into);
+                    return;
+                }
+                case VisualActionCoordinateSpace_Tags.Affine: {
+                    ordinalConverter.write(2, into);
+                    const inner = value.inner;
+                    FfiConverterFloat64.write(inner.m11, into);
+                    FfiConverterFloat64.write(inner.m12, into);
+                    FfiConverterFloat64.write(inner.m21, into);
+                    FfiConverterFloat64.write(inner.m22, into);
+                    FfiConverterFloat64.write(inner.tx, into);
+                    FfiConverterFloat64.write(inner.ty, into);
+                    return;
+                }
+                default:
+                    // Throwing from here means that VisualActionCoordinateSpace_Tags hasn't matched an ordinal.
+                    throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+        allocationSize(value) {
+            switch (value.tag) {
+                case VisualActionCoordinateSpace_Tags.ScreenshotPixels: {
+                    return ordinalConverter.allocationSize(1);
+                }
+                case VisualActionCoordinateSpace_Tags.Affine: {
+                    const inner = value.inner;
+                    let size = ordinalConverter.allocationSize(2);
+                    size += FfiConverterFloat64.allocationSize(inner.m11);
+                    size += FfiConverterFloat64.allocationSize(inner.m12);
+                    size += FfiConverterFloat64.allocationSize(inner.m21);
+                    size += FfiConverterFloat64.allocationSize(inner.m22);
+                    size += FfiConverterFloat64.allocationSize(inner.tx);
+                    size += FfiConverterFloat64.allocationSize(inner.ty);
+                    return size;
+                }
+                default: throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+    }
+    return new FFIConverter();
+})();
+/**
+ * Generated factory for {@link VisualCaptureProvenance} record objects.
+ */
+export const VisualCaptureProvenance = (() => {
+    const defaults = () => ({});
+    const create = (() => {
+        return uniffiCreateRecord(defaults);
+    })();
+    return Object.freeze({
+        create,
+        new: create,
+        defaults: () => Object.freeze(defaults()),
+    });
+})();
+const FfiConverterTypeVisualCaptureProvenance = (() => {
+    class FFIConverter extends AbstractFfiConverterByteArray {
+        read(from) {
+            return {
+                captureId: FfiConverterString.read(from),
+                source: FfiConverterTypeVisualCaptureSource.read(from),
+                screenshot: FfiConverterTypeVisualScreenshotReference.read(from),
+                actionCoordinateSpace: FfiConverterTypeVisualActionCoordinateSpace.read(from),
+                capturedAt: FfiConverterOptionalString.read(from)
+            };
+        }
+        write(value, into) {
+            FfiConverterString.write(value.captureId, into);
+            FfiConverterTypeVisualCaptureSource.write(value.source, into);
+            FfiConverterTypeVisualScreenshotReference.write(value.screenshot, into);
+            FfiConverterTypeVisualActionCoordinateSpace.write(value.actionCoordinateSpace, into);
+            FfiConverterOptionalString.write(value.capturedAt, into);
+        }
+        allocationSize(value) {
+            return FfiConverterString.allocationSize(value.captureId) +
+                FfiConverterTypeVisualCaptureSource.allocationSize(value.source) +
+                FfiConverterTypeVisualScreenshotReference.allocationSize(value.screenshot) +
+                FfiConverterTypeVisualActionCoordinateSpace.allocationSize(value.actionCoordinateSpace) +
+                FfiConverterOptionalString.allocationSize(value.capturedAt);
+        }
+    }
+    ;
+    return new FFIConverter();
+})();
+/**
+ * Generated factory for {@link VisualParserMetadata} record objects.
+ */
+export const VisualParserMetadata = (() => {
+    const defaults = () => ({});
+    const create = (() => {
+        return uniffiCreateRecord(defaults);
+    })();
+    return Object.freeze({
+        create,
+        new: create,
+        defaults: () => Object.freeze(defaults()),
+    });
+})();
+const FfiConverterTypeVisualParserMetadata = (() => {
+    class FFIConverter extends AbstractFfiConverterByteArray {
+        read(from) {
+            return {
+                extensionId: FfiConverterString.read(from),
+                extensionVersion: FfiConverterString.read(from),
+                modelId: FfiConverterString.read(from),
+                modelVersion: FfiConverterString.read(from),
+                runtime: FfiConverterOptionalString.read(from),
+                backend: FfiConverterOptionalString.read(from),
+                modelSourceRevision: FfiConverterOptionalString.read(from),
+                modelManifestSha256: FfiConverterOptionalString.read(from),
+                onnxRuntimeVersion: FfiConverterOptionalString.read(from),
+                onnxRuntimeLibrarySha256: FfiConverterOptionalString.read(from),
+                fixtureSha256: FfiConverterOptionalString.read(from)
+            };
+        }
+        write(value, into) {
+            FfiConverterString.write(value.extensionId, into);
+            FfiConverterString.write(value.extensionVersion, into);
+            FfiConverterString.write(value.modelId, into);
+            FfiConverterString.write(value.modelVersion, into);
+            FfiConverterOptionalString.write(value.runtime, into);
+            FfiConverterOptionalString.write(value.backend, into);
+            FfiConverterOptionalString.write(value.modelSourceRevision, into);
+            FfiConverterOptionalString.write(value.modelManifestSha256, into);
+            FfiConverterOptionalString.write(value.onnxRuntimeVersion, into);
+            FfiConverterOptionalString.write(value.onnxRuntimeLibrarySha256, into);
+            FfiConverterOptionalString.write(value.fixtureSha256, into);
+        }
+        allocationSize(value) {
+            return FfiConverterString.allocationSize(value.extensionId) +
+                FfiConverterString.allocationSize(value.extensionVersion) +
+                FfiConverterString.allocationSize(value.modelId) +
+                FfiConverterString.allocationSize(value.modelVersion) +
+                FfiConverterOptionalString.allocationSize(value.runtime) +
+                FfiConverterOptionalString.allocationSize(value.backend) +
+                FfiConverterOptionalString.allocationSize(value.modelSourceRevision) +
+                FfiConverterOptionalString.allocationSize(value.modelManifestSha256) +
+                FfiConverterOptionalString.allocationSize(value.onnxRuntimeVersion) +
+                FfiConverterOptionalString.allocationSize(value.onnxRuntimeLibrarySha256) +
+                FfiConverterOptionalString.allocationSize(value.fixtureSha256);
+        }
+    }
+    ;
+    return new FFIConverter();
+})();
+/**
+ * Generated factory for {@link VisualRegionBounds} record objects.
+ */
+export const VisualRegionBounds = (() => {
+    const defaults = () => ({});
+    const create = (() => {
+        return uniffiCreateRecord(defaults);
+    })();
+    return Object.freeze({
+        create,
+        new: create,
+        defaults: () => Object.freeze(defaults()),
+    });
+})();
+const FfiConverterTypeVisualRegionBounds = (() => {
+    class FFIConverter extends AbstractFfiConverterByteArray {
+        read(from) {
+            return {
+                x: FfiConverterUInt32.read(from),
+                y: FfiConverterUInt32.read(from),
+                width: FfiConverterUInt32.read(from),
+                height: FfiConverterUInt32.read(from)
+            };
+        }
+        write(value, into) {
+            FfiConverterUInt32.write(value.x, into);
+            FfiConverterUInt32.write(value.y, into);
+            FfiConverterUInt32.write(value.width, into);
+            FfiConverterUInt32.write(value.height, into);
+        }
+        allocationSize(value) {
+            return FfiConverterUInt32.allocationSize(value.x) +
+                FfiConverterUInt32.allocationSize(value.y) +
+                FfiConverterUInt32.allocationSize(value.width) +
+                FfiConverterUInt32.allocationSize(value.height);
+        }
+    }
+    ;
+    return new FFIConverter();
+})();
+/**
+ * Generated factory for {@link VisualRegion} record objects.
+ */
+export const VisualRegion = (() => {
+    const defaults = () => ({});
+    const create = (() => {
+        return uniffiCreateRecord(defaults);
+    })();
+    return Object.freeze({
+        create,
+        new: create,
+        defaults: () => Object.freeze(defaults()),
+    });
+})();
+const FfiConverterTypeVisualRegion = (() => {
+    class FFIConverter extends AbstractFfiConverterByteArray {
+        read(from) {
+            return {
+                id: FfiConverterString.read(from),
+                kind: FfiConverterTypeVisualRegionKind.read(from),
+                bounds: FfiConverterTypeVisualRegionBounds.read(from),
+                text: FfiConverterOptionalString.read(from),
+                label: FfiConverterOptionalString.read(from),
+                confidence: FfiConverterFloat64.read(from),
+                interactive: FfiConverterBool.read(from),
+                parentId: FfiConverterOptionalString.read(from),
+                groupId: FfiConverterOptionalString.read(from),
+                readingOrder: FfiConverterOptionalUInt32.read(from)
+            };
+        }
+        write(value, into) {
+            FfiConverterString.write(value.id, into);
+            FfiConverterTypeVisualRegionKind.write(value.kind, into);
+            FfiConverterTypeVisualRegionBounds.write(value.bounds, into);
+            FfiConverterOptionalString.write(value.text, into);
+            FfiConverterOptionalString.write(value.label, into);
+            FfiConverterFloat64.write(value.confidence, into);
+            FfiConverterBool.write(value.interactive, into);
+            FfiConverterOptionalString.write(value.parentId, into);
+            FfiConverterOptionalString.write(value.groupId, into);
+            FfiConverterOptionalUInt32.write(value.readingOrder, into);
+        }
+        allocationSize(value) {
+            return FfiConverterString.allocationSize(value.id) +
+                FfiConverterTypeVisualRegionKind.allocationSize(value.kind) +
+                FfiConverterTypeVisualRegionBounds.allocationSize(value.bounds) +
+                FfiConverterOptionalString.allocationSize(value.text) +
+                FfiConverterOptionalString.allocationSize(value.label) +
+                FfiConverterFloat64.allocationSize(value.confidence) +
+                FfiConverterBool.allocationSize(value.interactive) +
+                FfiConverterOptionalString.allocationSize(value.parentId) +
+                FfiConverterOptionalString.allocationSize(value.groupId) +
+                FfiConverterOptionalUInt32.allocationSize(value.readingOrder);
+        }
+    }
+    ;
+    return new FFIConverter();
+})();
+/**
+ * Generated factory for {@link VisualParseWarning} record objects.
+ */
+export const VisualParseWarning = (() => {
+    const defaults = () => ({});
+    const create = (() => {
+        return uniffiCreateRecord(defaults);
+    })();
+    return Object.freeze({
+        create,
+        new: create,
+        defaults: () => Object.freeze(defaults()),
+    });
+})();
+const FfiConverterTypeVisualParseWarning = (() => {
+    class FFIConverter extends AbstractFfiConverterByteArray {
+        read(from) {
+            return {
+                code: FfiConverterString.read(from),
+                message: FfiConverterString.read(from),
+                detail: FfiConverterOptionalString.read(from)
+            };
+        }
+        write(value, into) {
+            FfiConverterString.write(value.code, into);
+            FfiConverterString.write(value.message, into);
+            FfiConverterOptionalString.write(value.detail, into);
+        }
+        allocationSize(value) {
+            return FfiConverterString.allocationSize(value.code) +
+                FfiConverterString.allocationSize(value.message) +
+                FfiConverterOptionalString.allocationSize(value.detail);
+        }
+    }
+    ;
+    return new FFIConverter();
+})();
+/**
+ * Generated factory for {@link VisualParseTiming} record objects.
+ */
+export const VisualParseTiming = (() => {
+    const defaults = () => ({});
+    const create = (() => {
+        return uniffiCreateRecord(defaults);
+    })();
+    return Object.freeze({
+        create,
+        new: create,
+        defaults: () => Object.freeze(defaults()),
+    });
+})();
+const FfiConverterTypeVisualParseTiming = (() => {
+    class FFIConverter extends AbstractFfiConverterByteArray {
+        read(from) {
+            return {
+                durationMs: FfiConverterUInt64.read(from),
+                preprocessMs: FfiConverterOptionalUInt64.read(from),
+                inferenceMs: FfiConverterOptionalUInt64.read(from)
+            };
+        }
+        write(value, into) {
+            FfiConverterUInt64.write(value.durationMs, into);
+            FfiConverterOptionalUInt64.write(value.preprocessMs, into);
+            FfiConverterOptionalUInt64.write(value.inferenceMs, into);
+        }
+        allocationSize(value) {
+            return FfiConverterUInt64.allocationSize(value.durationMs) +
+                FfiConverterOptionalUInt64.allocationSize(value.preprocessMs) +
+                FfiConverterOptionalUInt64.allocationSize(value.inferenceMs);
+        }
+    }
+    ;
+    return new FFIConverter();
+})();
+/**
+ * Generated factory for {@link ParseVisualRegionsOutput} record objects.
+ */
+export const ParseVisualRegionsOutput = (() => {
+    const defaults = () => ({});
+    const create = (() => {
+        return uniffiCreateRecord(defaults);
+    })();
+    return Object.freeze({
+        create,
+        new: create,
+        defaults: () => Object.freeze(defaults()),
+    });
+})();
+const FfiConverterTypeParseVisualRegionsOutput = (() => {
+    class FFIConverter extends AbstractFfiConverterByteArray {
+        read(from) {
+            return {
+                schema: FfiConverterString.read(from),
+                capture: FfiConverterTypeVisualCaptureProvenance.read(from),
+                parser: FfiConverterTypeVisualParserMetadata.read(from),
+                regions: FfiConverterSequenceTypeVisualRegion.read(from),
+                warnings: FfiConverterSequenceTypeVisualParseWarning.read(from),
+                timing: FfiConverterTypeVisualParseTiming.read(from),
+                requestId: FfiConverterOptionalString.read(from)
+            };
+        }
+        write(value, into) {
+            FfiConverterString.write(value.schema, into);
+            FfiConverterTypeVisualCaptureProvenance.write(value.capture, into);
+            FfiConverterTypeVisualParserMetadata.write(value.parser, into);
+            FfiConverterSequenceTypeVisualRegion.write(value.regions, into);
+            FfiConverterSequenceTypeVisualParseWarning.write(value.warnings, into);
+            FfiConverterTypeVisualParseTiming.write(value.timing, into);
+            FfiConverterOptionalString.write(value.requestId, into);
+        }
+        allocationSize(value) {
+            return FfiConverterString.allocationSize(value.schema) +
+                FfiConverterTypeVisualCaptureProvenance.allocationSize(value.capture) +
+                FfiConverterTypeVisualParserMetadata.allocationSize(value.parser) +
+                FfiConverterSequenceTypeVisualRegion.allocationSize(value.regions) +
+                FfiConverterSequenceTypeVisualParseWarning.allocationSize(value.warnings) +
+                FfiConverterTypeVisualParseTiming.allocationSize(value.timing) +
+                FfiConverterOptionalString.allocationSize(value.requestId);
+        }
+    }
+    ;
+    return new FFIConverter();
+})();
+export var VerificationStatus;
+(function (VerificationStatus) {
+    VerificationStatus[VerificationStatus["Satisfied"] = 0] = "Satisfied";
+    VerificationStatus[VerificationStatus["Unsatisfied"] = 1] = "Unsatisfied";
+    VerificationStatus[VerificationStatus["Unknown"] = 2] = "Unknown";
+})(VerificationStatus || (VerificationStatus = {}));
+const FfiConverterTypeVerificationStatus = (() => {
+    const ordinalConverter = FfiConverterInt32;
+    class FFIConverter extends AbstractFfiConverterByteArray {
+        read(from) {
+            switch (ordinalConverter.read(from)) {
+                case 1: return VerificationStatus.Satisfied;
+                case 2: return VerificationStatus.Unsatisfied;
+                case 3: return VerificationStatus.Unknown;
+                default: throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+        write(value, into) {
+            switch (value) {
+                case VerificationStatus.Satisfied: return ordinalConverter.write(1, into);
+                case VerificationStatus.Unsatisfied: return ordinalConverter.write(2, into);
+                case VerificationStatus.Unknown: return ordinalConverter.write(3, into);
+            }
+        }
+        allocationSize(value) {
+            return ordinalConverter.allocationSize(0);
+        }
+    }
+    return new FFIConverter();
+})();
+export var UnknownReason;
+(function (UnknownReason) {
+    UnknownReason[UnknownReason["InvalidPredicate"] = 0] = "InvalidPredicate";
+    UnknownReason[UnknownReason["UnsupportedPredicate"] = 1] = "UnsupportedPredicate";
+    UnknownReason[UnknownReason["UntrustedSource"] = 2] = "UntrustedSource";
+    UnknownReason[UnknownReason["MultiMatch"] = 3] = "MultiMatch";
+    UnknownReason[UnknownReason["TargetMissing"] = 4] = "TargetMissing";
+    UnknownReason[UnknownReason["ObservationUnavailable"] = 5] = "ObservationUnavailable";
+    UnknownReason[UnknownReason["StabilityUnproven"] = 6] = "StabilityUnproven";
+})(UnknownReason || (UnknownReason = {}));
+const FfiConverterTypeUnknownReason = (() => {
+    const ordinalConverter = FfiConverterInt32;
+    class FFIConverter extends AbstractFfiConverterByteArray {
+        read(from) {
+            switch (ordinalConverter.read(from)) {
+                case 1: return UnknownReason.InvalidPredicate;
+                case 2: return UnknownReason.UnsupportedPredicate;
+                case 3: return UnknownReason.UntrustedSource;
+                case 4: return UnknownReason.MultiMatch;
+                case 5: return UnknownReason.TargetMissing;
+                case 6: return UnknownReason.ObservationUnavailable;
+                case 7: return UnknownReason.StabilityUnproven;
+                default: throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+        write(value, into) {
+            switch (value) {
+                case UnknownReason.InvalidPredicate: return ordinalConverter.write(1, into);
+                case UnknownReason.UnsupportedPredicate: return ordinalConverter.write(2, into);
+                case UnknownReason.UntrustedSource: return ordinalConverter.write(3, into);
+                case UnknownReason.MultiMatch: return ordinalConverter.write(4, into);
+                case UnknownReason.TargetMissing: return ordinalConverter.write(5, into);
+                case UnknownReason.ObservationUnavailable: return ordinalConverter.write(6, into);
+                case UnknownReason.StabilityUnproven: return ordinalConverter.write(7, into);
+            }
+        }
+        allocationSize(value) {
+            return ordinalConverter.allocationSize(0);
+        }
+    }
+    return new FFIConverter();
+})();
+/**
+ * Generated factory for {@link PredicateOutcome} record objects.
+ */
+export const PredicateOutcome = (() => {
+    const defaults = () => ({});
+    const create = (() => {
+        return uniffiCreateRecord(defaults);
+    })();
+    return Object.freeze({
+        create,
+        new: create,
+        defaults: () => Object.freeze(defaults()),
+    });
+})();
+const FfiConverterTypePredicateOutcome = (() => {
+    class FFIConverter extends AbstractFfiConverterByteArray {
+        read(from) {
+            return {
+                index: FfiConverterUInt64.read(from),
+                status: FfiConverterTypeVerificationStatus.read(from),
+                unknownReason: FfiConverterOptionalTypeUnknownReason.read(from),
+                observedJson: FfiConverterOptionalString.read(from)
+            };
+        }
+        write(value, into) {
+            FfiConverterUInt64.write(value.index, into);
+            FfiConverterTypeVerificationStatus.write(value.status, into);
+            FfiConverterOptionalTypeUnknownReason.write(value.unknownReason, into);
+            FfiConverterOptionalString.write(value.observedJson, into);
+        }
+        allocationSize(value) {
+            return FfiConverterUInt64.allocationSize(value.index) +
+                FfiConverterTypeVerificationStatus.allocationSize(value.status) +
+                FfiConverterOptionalTypeUnknownReason.allocationSize(value.unknownReason) +
+                FfiConverterOptionalString.allocationSize(value.observedJson);
+        }
+    }
+    ;
+    return new FFIConverter();
+})();
+/**
+ * Generated factory for {@link PressKeyInput} record objects.
+ */
+export const PressKeyInput = (() => {
+    const defaults = () => ({});
+    const create = (() => {
+        return uniffiCreateRecord(defaults);
+    })();
+    return Object.freeze({
+        create,
+        new: create,
+        defaults: () => Object.freeze(defaults()),
+    });
+})();
+const FfiConverterTypePressKeyInput = (() => {
+    class FFIConverter extends AbstractFfiConverterByteArray {
+        read(from) {
+            return {
+                key: FfiConverterString.read(from),
+                target: FfiConverterOptionalTypeActionTarget.read(from),
+                scope: FfiConverterOptionalTypeDesktopScope.read(from),
+                session: FfiConverterOptionalString.read(from),
+                modifiers: FfiConverterOptionalSequenceString.read(from)
+            };
+        }
+        write(value, into) {
+            FfiConverterString.write(value.key, into);
+            FfiConverterOptionalTypeActionTarget.write(value.target, into);
+            FfiConverterOptionalTypeDesktopScope.write(value.scope, into);
+            FfiConverterOptionalString.write(value.session, into);
+            FfiConverterOptionalSequenceString.write(value.modifiers, into);
+        }
+        allocationSize(value) {
+            return FfiConverterString.allocationSize(value.key) +
+                FfiConverterOptionalTypeActionTarget.allocationSize(value.target) +
+                FfiConverterOptionalTypeDesktopScope.allocationSize(value.scope) +
+                FfiConverterOptionalString.allocationSize(value.session) +
+                FfiConverterOptionalSequenceString.allocationSize(value.modifiers);
+        }
+    }
+    ;
+    return new FFIConverter();
+})();
+export var ScrollDirection;
+(function (ScrollDirection) {
+    ScrollDirection[ScrollDirection["Up"] = 0] = "Up";
+    ScrollDirection[ScrollDirection["Down"] = 1] = "Down";
+    ScrollDirection[ScrollDirection["Left"] = 2] = "Left";
+    ScrollDirection[ScrollDirection["Right"] = 3] = "Right";
+})(ScrollDirection || (ScrollDirection = {}));
+const FfiConverterTypeScrollDirection = (() => {
+    const ordinalConverter = FfiConverterInt32;
+    class FFIConverter extends AbstractFfiConverterByteArray {
+        read(from) {
+            switch (ordinalConverter.read(from)) {
+                case 1: return ScrollDirection.Up;
+                case 2: return ScrollDirection.Down;
+                case 3: return ScrollDirection.Left;
+                case 4: return ScrollDirection.Right;
+                default: throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+        write(value, into) {
+            switch (value) {
+                case ScrollDirection.Up: return ordinalConverter.write(1, into);
+                case ScrollDirection.Down: return ordinalConverter.write(2, into);
+                case ScrollDirection.Left: return ordinalConverter.write(3, into);
+                case ScrollDirection.Right: return ordinalConverter.write(4, into);
+            }
+        }
+        allocationSize(value) {
+            return ordinalConverter.allocationSize(0);
+        }
+    }
+    return new FFIConverter();
+})();
+export var ScrollBy;
+(function (ScrollBy) {
+    ScrollBy[ScrollBy["Line"] = 0] = "Line";
+    ScrollBy[ScrollBy["Page"] = 1] = "Page";
+})(ScrollBy || (ScrollBy = {}));
+const FfiConverterTypeScrollBy = (() => {
+    const ordinalConverter = FfiConverterInt32;
+    class FFIConverter extends AbstractFfiConverterByteArray {
+        read(from) {
+            switch (ordinalConverter.read(from)) {
+                case 1: return ScrollBy.Line;
+                case 2: return ScrollBy.Page;
+                default: throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+        write(value, into) {
+            switch (value) {
+                case ScrollBy.Line: return ordinalConverter.write(1, into);
+                case ScrollBy.Page: return ordinalConverter.write(2, into);
+            }
+        }
+        allocationSize(value) {
+            return ordinalConverter.allocationSize(0);
+        }
+    }
+    return new FFIConverter();
+})();
+/**
  * Generated factory for {@link ScrollInput} record objects.
  */
 export const ScrollInput = (() => {
@@ -3417,6 +4210,118 @@ const FfiConverterTypeVerifyStateOutput = (() => {
     ;
     return new FFIConverter();
 })();
+/**
+ * Stable machine-readable failures for capture lookup and visual parsing.
+ */
+export var VisualParseErrorCode;
+(function (VisualParseErrorCode) {
+    VisualParseErrorCode[VisualParseErrorCode["NotInstalled"] = 0] = "NotInstalled";
+    VisualParseErrorCode[VisualParseErrorCode["CaptureNotFound"] = 1] = "CaptureNotFound";
+    VisualParseErrorCode[VisualParseErrorCode["CaptureExpired"] = 2] = "CaptureExpired";
+    VisualParseErrorCode[VisualParseErrorCode["CaptureStale"] = 3] = "CaptureStale";
+    VisualParseErrorCode[VisualParseErrorCode["CaptureGenerationMismatch"] = 4] = "CaptureGenerationMismatch";
+    VisualParseErrorCode[VisualParseErrorCode["UnsupportedTarget"] = 5] = "UnsupportedTarget";
+    VisualParseErrorCode[VisualParseErrorCode["UnsupportedPlatform"] = 6] = "UnsupportedPlatform";
+    VisualParseErrorCode[VisualParseErrorCode["IncompatibleProtocol"] = 7] = "IncompatibleProtocol";
+    VisualParseErrorCode[VisualParseErrorCode["InvalidFrame"] = 8] = "InvalidFrame";
+    VisualParseErrorCode[VisualParseErrorCode["WorkerLaunchFailed"] = 9] = "WorkerLaunchFailed";
+    VisualParseErrorCode[VisualParseErrorCode["WorkerCrashed"] = 10] = "WorkerCrashed";
+    VisualParseErrorCode[VisualParseErrorCode["WorkerCancelled"] = 11] = "WorkerCancelled";
+    VisualParseErrorCode[VisualParseErrorCode["Timeout"] = 12] = "Timeout";
+    VisualParseErrorCode[VisualParseErrorCode["ResourceLimitExceeded"] = 13] = "ResourceLimitExceeded";
+    VisualParseErrorCode[VisualParseErrorCode["ArtifactInvalid"] = 14] = "ArtifactInvalid";
+    VisualParseErrorCode[VisualParseErrorCode["InferenceFailed"] = 15] = "InferenceFailed";
+})(VisualParseErrorCode || (VisualParseErrorCode = {}));
+const FfiConverterTypeVisualParseErrorCode = (() => {
+    const ordinalConverter = FfiConverterInt32;
+    class FFIConverter extends AbstractFfiConverterByteArray {
+        read(from) {
+            switch (ordinalConverter.read(from)) {
+                case 1: return VisualParseErrorCode.NotInstalled;
+                case 2: return VisualParseErrorCode.CaptureNotFound;
+                case 3: return VisualParseErrorCode.CaptureExpired;
+                case 4: return VisualParseErrorCode.CaptureStale;
+                case 5: return VisualParseErrorCode.CaptureGenerationMismatch;
+                case 6: return VisualParseErrorCode.UnsupportedTarget;
+                case 7: return VisualParseErrorCode.UnsupportedPlatform;
+                case 8: return VisualParseErrorCode.IncompatibleProtocol;
+                case 9: return VisualParseErrorCode.InvalidFrame;
+                case 10: return VisualParseErrorCode.WorkerLaunchFailed;
+                case 11: return VisualParseErrorCode.WorkerCrashed;
+                case 12: return VisualParseErrorCode.WorkerCancelled;
+                case 13: return VisualParseErrorCode.Timeout;
+                case 14: return VisualParseErrorCode.ResourceLimitExceeded;
+                case 15: return VisualParseErrorCode.ArtifactInvalid;
+                case 16: return VisualParseErrorCode.InferenceFailed;
+                default: throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+        write(value, into) {
+            switch (value) {
+                case VisualParseErrorCode.NotInstalled: return ordinalConverter.write(1, into);
+                case VisualParseErrorCode.CaptureNotFound: return ordinalConverter.write(2, into);
+                case VisualParseErrorCode.CaptureExpired: return ordinalConverter.write(3, into);
+                case VisualParseErrorCode.CaptureStale: return ordinalConverter.write(4, into);
+                case VisualParseErrorCode.CaptureGenerationMismatch: return ordinalConverter.write(5, into);
+                case VisualParseErrorCode.UnsupportedTarget: return ordinalConverter.write(6, into);
+                case VisualParseErrorCode.UnsupportedPlatform: return ordinalConverter.write(7, into);
+                case VisualParseErrorCode.IncompatibleProtocol: return ordinalConverter.write(8, into);
+                case VisualParseErrorCode.InvalidFrame: return ordinalConverter.write(9, into);
+                case VisualParseErrorCode.WorkerLaunchFailed: return ordinalConverter.write(10, into);
+                case VisualParseErrorCode.WorkerCrashed: return ordinalConverter.write(11, into);
+                case VisualParseErrorCode.WorkerCancelled: return ordinalConverter.write(12, into);
+                case VisualParseErrorCode.Timeout: return ordinalConverter.write(13, into);
+                case VisualParseErrorCode.ResourceLimitExceeded: return ordinalConverter.write(14, into);
+                case VisualParseErrorCode.ArtifactInvalid: return ordinalConverter.write(15, into);
+                case VisualParseErrorCode.InferenceFailed: return ordinalConverter.write(16, into);
+            }
+        }
+        allocationSize(value) {
+            return ordinalConverter.allocationSize(0);
+        }
+    }
+    return new FFIConverter();
+})();
+/**
+ * Generated factory for {@link VisualParseError} record objects.
+ */
+export const VisualParseError = (() => {
+    const defaults = () => ({});
+    const create = (() => {
+        return uniffiCreateRecord(defaults);
+    })();
+    return Object.freeze({
+        create,
+        new: create,
+        defaults: () => Object.freeze(defaults()),
+    });
+})();
+const FfiConverterTypeVisualParseError = (() => {
+    class FFIConverter extends AbstractFfiConverterByteArray {
+        read(from) {
+            return {
+                code: FfiConverterTypeVisualParseErrorCode.read(from),
+                message: FfiConverterString.read(from),
+                retryable: FfiConverterBool.read(from),
+                detail: FfiConverterOptionalString.read(from)
+            };
+        }
+        write(value, into) {
+            FfiConverterTypeVisualParseErrorCode.write(value.code, into);
+            FfiConverterString.write(value.message, into);
+            FfiConverterBool.write(value.retryable, into);
+            FfiConverterOptionalString.write(value.detail, into);
+        }
+        allocationSize(value) {
+            return FfiConverterTypeVisualParseErrorCode.allocationSize(value.code) +
+                FfiConverterString.allocationSize(value.message) +
+                FfiConverterBool.allocationSize(value.retryable) +
+                FfiConverterOptionalString.allocationSize(value.detail);
+        }
+    }
+    ;
+    return new FFIConverter();
+})();
 /**
  * Generated factory for {@link WindowElement} record objects.
  */
@@ -3622,6 +4527,8 @@ const FfiConverterTypePlatform = (() => {
 })();
 // FfiConverter for number | undefined
 const FfiConverterOptionalUInt32 = new FfiConverterOptional(FfiConverterUInt32);
+// FfiConverter for string | undefined
+const FfiConverterOptionalString = new FfiConverterOptional(FfiConverterString);
 // FfiConverter for ActionDelivery | undefined
 const FfiConverterOptionalTypeActionDelivery = new FfiConverterOptional(FfiConverterTypeActionDelivery);
 // FfiConverter for Array<ActionEvidence>
@@ -3630,8 +4537,8 @@ const FfiConverterSequenceTypeActionEvidence = new FfiConverterArray(FfiConverte
 const FfiConverterOptionalSequenceTypeActionEvidence = new FfiConverterOptional(FfiConverterSequenceTypeActionEvidence);
 // FfiConverter for ActionEscalation | undefined
 const FfiConverterOptionalTypeActionEscalation = new FfiConverterOptional(FfiConverterTypeActionEscalation);
-// FfiConverter for string | undefined
-const FfiConverterOptionalString = new FfiConverterOptional(FfiConverterString);
+// FfiConverter for ActionError | undefined
+const FfiConverterOptionalTypeActionError = new FfiConverterOptional(FfiConverterTypeActionError);
 // FfiConverter for number | undefined
 const FfiConverterOptionalFloat64 = new FfiConverterOptional(FfiConverterFloat64);
 // FfiConverter for ClickButton | undefined
@@ -3664,6 +4571,14 @@ const FfiConverterSequenceUInt64 = new FfiConverterArray(FfiConverterUInt64);
 const FfiConverterOptionalSequenceUInt64 = new FfiConverterOptional(FfiConverterSequenceUInt64);
 // FfiConverter for Array<WindowInfo>
 const FfiConverterSequenceTypeWindowInfo = new FfiConverterArray(FfiConverterTypeWindowInfo);
+// FfiConverter for Array<VisualRegionKind>
+const FfiConverterSequenceTypeVisualRegionKind = new FfiConverterArray(FfiConverterTypeVisualRegionKind);
+// FfiConverter for Array<VisualRegionKind> | undefined
+const FfiConverterOptionalSequenceTypeVisualRegionKind = new FfiConverterOptional(FfiConverterSequenceTypeVisualRegionKind);
+// FfiConverter for Array<VisualRegion>
+const FfiConverterSequenceTypeVisualRegion = new FfiConverterArray(FfiConverterTypeVisualRegion);
+// FfiConverter for Array<VisualParseWarning>
+const FfiConverterSequenceTypeVisualParseWarning = new FfiConverterArray(FfiConverterTypeVisualParseWarning);
 // FfiConverter for UnknownReason | undefined
 const FfiConverterOptionalTypeUnknownReason = new FfiConverterOptional(FfiConverterTypeUnknownReason);
 // FfiConverter for ScrollBy | undefined
@@ -3719,6 +4634,7 @@ export default Object.freeze({
         FfiConverterTypeActionDelivery,
         FfiConverterTypeActionDeliveryMode,
         FfiConverterTypeActionEffect,
+        FfiConverterTypeActionError,
         FfiConverterTypeActionEscalation,
         FfiConverterTypeActionEscalationReason,
         FfiConverterTypeActionEscalationTarget,
@@ -3772,6 +4688,9 @@ export default Object.freeze({
         FfiConverterTypeListWindowsInput,
         FfiConverterTypeListWindowsOutput,
         FfiConverterTypeMoveCursorInput,
+        FfiConverterTypeParseVisualRegionsInput,
+        FfiConverterTypeParseVisualRegionsOptions,
+        FfiConverterTypeParseVisualRegionsOutput,
         FfiConverterTypePlatform,
         FfiConverterTypePredicateOutcome,
         FfiConverterTypePressKeyInput,
@@ -3799,6 +4718,18 @@ export default Object.freeze({
         FfiConverterTypeVerificationStatus,
         FfiConverterTypeVerifyStateInput,
         FfiConverterTypeVerifyStateOutput,
+        FfiConverterTypeVisualActionCoordinateSpace,
+        FfiConverterTypeVisualCaptureProvenance,
+        FfiConverterTypeVisualCaptureSource,
+        FfiConverterTypeVisualParseError,
+        FfiConverterTypeVisualParseErrorCode,
+        FfiConverterTypeVisualParseTiming,
+        FfiConverterTypeVisualParseWarning,
+        FfiConverterTypeVisualParserMetadata,
+        FfiConverterTypeVisualRegion,
+        FfiConverterTypeVisualRegionBounds,
+        FfiConverterTypeVisualRegionKind,
+        FfiConverterTypeVisualScreenshotReference,
         FfiConverterTypeWindowBounds,
         FfiConverterTypeWindowElement,
         FfiConverterTypeWindowInfo,