@trycua/cua-driver 0.14.2 → 0.17.0

package/dist/native/cua_driver_contract.js

@@ -4,7 +4,7 @@
 /* eslint-disable */
 // @ts-nocheck
 import nativeModule from "./cua_driver_contract-ffi.js";
-import { AbstractFfiConverterByteArray, FfiConverterArray, FfiConverterBool, FfiConverterFloat64, FfiConverterInt32, FfiConverterOptional, FfiConverterUInt32, FfiConverterUInt64, UniffiInternalError, UniffiRustCaller, uniffiCreateFfiConverterString, uniffiCreateRecord, } from "@ubjs/core";
+import { AbstractFfiConverterByteArray, FfiConverterArray, FfiConverterBool, FfiConverterFloat64, FfiConverterInt32, FfiConverterInt64, FfiConverterOptional, FfiConverterUInt32, FfiConverterUInt64, UniffiInternalError, UniffiRustCaller, uniffiCreateFfiConverterString, uniffiCreateRecord, } from "@ubjs/core";
 const uniffiCaller = new UniffiRustCaller(() => ({ code: 0 }));
 const uniffiIsDebug = 
 // @ts-ignore -- The process global might not be defined
@@ -13,6 +13,395 @@ typeof process !== "object" ||
     process?.env?.NODE_ENV !== "production" ||
     false;
 // Public interface members begin here.
+export var ActionDeliveryMode;
+(function (ActionDeliveryMode) {
+    ActionDeliveryMode[ActionDeliveryMode["Background"] = 0] = "Background";
+    ActionDeliveryMode[ActionDeliveryMode["Foreground"] = 1] = "Foreground";
+    ActionDeliveryMode[ActionDeliveryMode["NotApplicable"] = 2] = "NotApplicable";
+    ActionDeliveryMode[ActionDeliveryMode["Unknown"] = 3] = "Unknown";
+})(ActionDeliveryMode || (ActionDeliveryMode = {}));
+const FfiConverterTypeActionDeliveryMode = (() => {
+    const ordinalConverter = FfiConverterInt32;
+    class FFIConverter extends AbstractFfiConverterByteArray {
+        read(from) {
+            switch (ordinalConverter.read(from)) {
+                case 1: return ActionDeliveryMode.Background;
+                case 2: return ActionDeliveryMode.Foreground;
+                case 3: return ActionDeliveryMode.NotApplicable;
+                case 4: return ActionDeliveryMode.Unknown;
+                default: throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+        write(value, into) {
+            switch (value) {
+                case ActionDeliveryMode.Background: return ordinalConverter.write(1, into);
+                case ActionDeliveryMode.Foreground: return ordinalConverter.write(2, into);
+                case ActionDeliveryMode.NotApplicable: return ordinalConverter.write(3, into);
+                case ActionDeliveryMode.Unknown: return ordinalConverter.write(4, into);
+            }
+        }
+        allocationSize(value) {
+            return ordinalConverter.allocationSize(0);
+        }
+    }
+    return new FFIConverter();
+})();
+/**
+ * Generated factory for {@link ActionDelivery} record objects.
+ */
+export const ActionDelivery = (() => {
+    const defaults = () => ({});
+    const create = (() => {
+        return uniffiCreateRecord(defaults);
+    })();
+    return Object.freeze({
+        create,
+        new: create,
+        defaults: () => Object.freeze(defaults()),
+    });
+})();
+const FfiConverterTypeActionDelivery = (() => {
+    class FFIConverter extends AbstractFfiConverterByteArray {
+        read(from) {
+            return {
+                mode: FfiConverterTypeActionDeliveryMode.read(from),
+                deliveredCount: FfiConverterOptionalUInt32.read(from)
+            };
+        }
+        write(value, into) {
+            FfiConverterTypeActionDeliveryMode.write(value.mode, into);
+            FfiConverterOptionalUInt32.write(value.deliveredCount, into);
+        }
+        allocationSize(value) {
+            return FfiConverterTypeActionDeliveryMode.allocationSize(value.mode) +
+                FfiConverterOptionalUInt32.allocationSize(value.deliveredCount);
+        }
+    }
+    ;
+    return new FFIConverter();
+})();
+export var ActionEscalationTarget;
+(function (ActionEscalationTarget) {
+    ActionEscalationTarget[ActionEscalationTarget["Pixel"] = 0] = "Pixel";
+    ActionEscalationTarget[ActionEscalationTarget["Foreground"] = 1] = "Foreground";
+    ActionEscalationTarget[ActionEscalationTarget["Page"] = 2] = "Page";
+    ActionEscalationTarget[ActionEscalationTarget["Session"] = 3] = "Session";
+})(ActionEscalationTarget || (ActionEscalationTarget = {}));
+const FfiConverterTypeActionEscalationTarget = (() => {
+    const ordinalConverter = FfiConverterInt32;
+    class FFIConverter extends AbstractFfiConverterByteArray {
+        read(from) {
+            switch (ordinalConverter.read(from)) {
+                case 1: return ActionEscalationTarget.Pixel;
+                case 2: return ActionEscalationTarget.Foreground;
+                case 3: return ActionEscalationTarget.Page;
+                case 4: return ActionEscalationTarget.Session;
+                default: throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+        write(value, into) {
+            switch (value) {
+                case ActionEscalationTarget.Pixel: return ordinalConverter.write(1, into);
+                case ActionEscalationTarget.Foreground: return ordinalConverter.write(2, into);
+                case ActionEscalationTarget.Page: return ordinalConverter.write(3, into);
+                case ActionEscalationTarget.Session: return ordinalConverter.write(4, into);
+            }
+        }
+        allocationSize(value) {
+            return ordinalConverter.allocationSize(0);
+        }
+    }
+    return new FFIConverter();
+})();
+export var ActionEscalationReason;
+(function (ActionEscalationReason) {
+    ActionEscalationReason[ActionEscalationReason["RouteUnavailable"] = 0] = "RouteUnavailable";
+    ActionEscalationReason[ActionEscalationReason["DeliveryFailed"] = 1] = "DeliveryFailed";
+    ActionEscalationReason[ActionEscalationReason["EffectUnconfirmed"] = 2] = "EffectUnconfirmed";
+    ActionEscalationReason[ActionEscalationReason["SuspectedNoop"] = 3] = "SuspectedNoop";
+    ActionEscalationReason[ActionEscalationReason["PermissionRequired"] = 4] = "PermissionRequired";
+})(ActionEscalationReason || (ActionEscalationReason = {}));
+const FfiConverterTypeActionEscalationReason = (() => {
+    const ordinalConverter = FfiConverterInt32;
+    class FFIConverter extends AbstractFfiConverterByteArray {
+        read(from) {
+            switch (ordinalConverter.read(from)) {
+                case 1: return ActionEscalationReason.RouteUnavailable;
+                case 2: return ActionEscalationReason.DeliveryFailed;
+                case 3: return ActionEscalationReason.EffectUnconfirmed;
+                case 4: return ActionEscalationReason.SuspectedNoop;
+                case 5: return ActionEscalationReason.PermissionRequired;
+                default: throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+        write(value, into) {
+            switch (value) {
+                case ActionEscalationReason.RouteUnavailable: return ordinalConverter.write(1, into);
+                case ActionEscalationReason.DeliveryFailed: return ordinalConverter.write(2, into);
+                case ActionEscalationReason.EffectUnconfirmed: return ordinalConverter.write(3, into);
+                case ActionEscalationReason.SuspectedNoop: return ordinalConverter.write(4, into);
+                case ActionEscalationReason.PermissionRequired: return ordinalConverter.write(5, into);
+            }
+        }
+        allocationSize(value) {
+            return ordinalConverter.allocationSize(0);
+        }
+    }
+    return new FFIConverter();
+})();
+/**
+ * Generated factory for {@link ActionEscalation} record objects.
+ */
+export const ActionEscalation = (() => {
+    const defaults = () => ({});
+    const create = (() => {
+        return uniffiCreateRecord(defaults);
+    })();
+    return Object.freeze({
+        create,
+        new: create,
+        defaults: () => Object.freeze(defaults()),
+    });
+})();
+const FfiConverterTypeActionEscalation = (() => {
+    class FFIConverter extends AbstractFfiConverterByteArray {
+        read(from) {
+            return {
+                target: FfiConverterTypeActionEscalationTarget.read(from),
+                reason: FfiConverterTypeActionEscalationReason.read(from)
+            };
+        }
+        write(value, into) {
+            FfiConverterTypeActionEscalationTarget.write(value.target, into);
+            FfiConverterTypeActionEscalationReason.write(value.reason, into);
+        }
+        allocationSize(value) {
+            return FfiConverterTypeActionEscalationTarget.allocationSize(value.target) +
+                FfiConverterTypeActionEscalationReason.allocationSize(value.reason);
+        }
+    }
+    ;
+    return new FFIConverter();
+})();
+export var ActionEvidenceKind;
+(function (ActionEvidenceKind) {
+    ActionEvidenceKind[ActionEvidenceKind["ValueReadback"] = 0] = "ValueReadback";
+    ActionEvidenceKind[ActionEvidenceKind["WindowChange"] = 1] = "WindowChange";
+})(ActionEvidenceKind || (ActionEvidenceKind = {}));
+const FfiConverterTypeActionEvidenceKind = (() => {
+    const ordinalConverter = FfiConverterInt32;
+    class FFIConverter extends AbstractFfiConverterByteArray {
+        read(from) {
+            switch (ordinalConverter.read(from)) {
+                case 1: return ActionEvidenceKind.ValueReadback;
+                case 2: return ActionEvidenceKind.WindowChange;
+                default: throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+        write(value, into) {
+            switch (value) {
+                case ActionEvidenceKind.ValueReadback: return ordinalConverter.write(1, into);
+                case ActionEvidenceKind.WindowChange: return ordinalConverter.write(2, into);
+            }
+        }
+        allocationSize(value) {
+            return ordinalConverter.allocationSize(0);
+        }
+    }
+    return new FFIConverter();
+})();
+/**
+ * Generated factory for {@link ActionEvidence} record objects.
+ */
+export const ActionEvidence = (() => {
+    const defaults = () => ({});
+    const create = (() => {
+        return uniffiCreateRecord(defaults);
+    })();
+    return Object.freeze({
+        create,
+        new: create,
+        defaults: () => Object.freeze(defaults()),
+    });
+})();
+const FfiConverterTypeActionEvidence = (() => {
+    class FFIConverter extends AbstractFfiConverterByteArray {
+        read(from) {
+            return {
+                kind: FfiConverterTypeActionEvidenceKind.read(from)
+            };
+        }
+        write(value, into) {
+            FfiConverterTypeActionEvidenceKind.write(value.kind, into);
+        }
+        allocationSize(value) {
+            return FfiConverterTypeActionEvidenceKind.allocationSize(value.kind);
+        }
+    }
+    ;
+    return new FFIConverter();
+})();
+export var ActionEffect;
+(function (ActionEffect) {
+    ActionEffect[ActionEffect["Confirmed"] = 0] = "Confirmed";
+    ActionEffect[ActionEffect["Partial"] = 1] = "Partial";
+    ActionEffect[ActionEffect["Unverifiable"] = 2] = "Unverifiable";
+    ActionEffect[ActionEffect["SuspectedNoop"] = 3] = "SuspectedNoop";
+    ActionEffect[ActionEffect["Refused"] = 4] = "Refused";
+})(ActionEffect || (ActionEffect = {}));
+const FfiConverterTypeActionEffect = (() => {
+    const ordinalConverter = FfiConverterInt32;
+    class FFIConverter extends AbstractFfiConverterByteArray {
+        read(from) {
+            switch (ordinalConverter.read(from)) {
+                case 1: return ActionEffect.Confirmed;
+                case 2: return ActionEffect.Partial;
+                case 3: return ActionEffect.Unverifiable;
+                case 4: return ActionEffect.SuspectedNoop;
+                case 5: return ActionEffect.Refused;
+                default: throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+        write(value, into) {
+            switch (value) {
+                case ActionEffect.Confirmed: return ordinalConverter.write(1, into);
+                case ActionEffect.Partial: return ordinalConverter.write(2, into);
+                case ActionEffect.Unverifiable: return ordinalConverter.write(3, into);
+                case ActionEffect.SuspectedNoop: return ordinalConverter.write(4, into);
+                case ActionEffect.Refused: return ordinalConverter.write(5, into);
+            }
+        }
+        allocationSize(value) {
+            return ordinalConverter.allocationSize(0);
+        }
+    }
+    return new FFIConverter();
+})();
+export var ActionRoute;
+(function (ActionRoute) {
+    ActionRoute[ActionRoute["Accessibility"] = 0] = "Accessibility";
+    ActionRoute[ActionRoute["SyntheticEvents"] = 1] = "SyntheticEvents";
+    ActionRoute[ActionRoute["GlobalInput"] = 2] = "GlobalInput";
+    ActionRoute[ActionRoute["SystemApi"] = 3] = "SystemApi";
+    ActionRoute[ActionRoute["Dom"] = 4] = "Dom";
+    ActionRoute[ActionRoute["TrustedInput"] = 5] = "TrustedInput";
+})(ActionRoute || (ActionRoute = {}));
+const FfiConverterTypeActionRoute = (() => {
+    const ordinalConverter = FfiConverterInt32;
+    class FFIConverter extends AbstractFfiConverterByteArray {
+        read(from) {
+            switch (ordinalConverter.read(from)) {
+                case 1: return ActionRoute.Accessibility;
+                case 2: return ActionRoute.SyntheticEvents;
+                case 3: return ActionRoute.GlobalInput;
+                case 4: return ActionRoute.SystemApi;
+                case 5: return ActionRoute.Dom;
+                case 6: return ActionRoute.TrustedInput;
+                default: throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+        write(value, into) {
+            switch (value) {
+                case ActionRoute.Accessibility: return ordinalConverter.write(1, into);
+                case ActionRoute.SyntheticEvents: return ordinalConverter.write(2, into);
+                case ActionRoute.GlobalInput: return ordinalConverter.write(3, into);
+                case ActionRoute.SystemApi: return ordinalConverter.write(4, into);
+                case ActionRoute.Dom: return ordinalConverter.write(5, into);
+                case ActionRoute.TrustedInput: return ordinalConverter.write(6, into);
+            }
+        }
+        allocationSize(value) {
+            return ordinalConverter.allocationSize(0);
+        }
+    }
+    return new FFIConverter();
+})();
+/**
+ * Generated factory for {@link ActionResult} record objects.
+ */
+export const ActionResult = (() => {
+    const defaults = () => ({});
+    const create = (() => {
+        return uniffiCreateRecord(defaults);
+    })();
+    return Object.freeze({
+        create,
+        new: create,
+        defaults: () => Object.freeze(defaults()),
+    });
+})();
+const FfiConverterTypeActionResult = (() => {
+    class FFIConverter extends AbstractFfiConverterByteArray {
+        read(from) {
+            return {
+                effect: FfiConverterTypeActionEffect.read(from),
+                route: FfiConverterTypeActionRoute.read(from),
+                delivery: FfiConverterOptionalTypeActionDelivery.read(from),
+                evidence: FfiConverterOptionalSequenceTypeActionEvidence.read(from),
+                escalation: FfiConverterOptionalTypeActionEscalation.read(from)
+            };
+        }
+        write(value, into) {
+            FfiConverterTypeActionEffect.write(value.effect, into);
+            FfiConverterTypeActionRoute.write(value.route, into);
+            FfiConverterOptionalTypeActionDelivery.write(value.delivery, into);
+            FfiConverterOptionalSequenceTypeActionEvidence.write(value.evidence, into);
+            FfiConverterOptionalTypeActionEscalation.write(value.escalation, into);
+        }
+        allocationSize(value) {
+            return FfiConverterTypeActionEffect.allocationSize(value.effect) +
+                FfiConverterTypeActionRoute.allocationSize(value.route) +
+                FfiConverterOptionalTypeActionDelivery.allocationSize(value.delivery) +
+                FfiConverterOptionalSequenceTypeActionEvidence.allocationSize(value.evidence) +
+                FfiConverterOptionalTypeActionEscalation.allocationSize(value.escalation);
+        }
+    }
+    ;
+    return new FFIConverter();
+})();
+/**
+ * Generated factory for {@link BoundsExpectation} record objects.
+ */
+export const BoundsExpectation = (() => {
+    const defaults = () => ({});
+    const create = (() => {
+        return uniffiCreateRecord(defaults);
+    })();
+    return Object.freeze({
+        create,
+        new: create,
+        defaults: () => Object.freeze(defaults()),
+    });
+})();
+const FfiConverterTypeBoundsExpectation = (() => {
+    class FFIConverter extends AbstractFfiConverterByteArray {
+        read(from) {
+            return {
+                x: FfiConverterFloat64.read(from),
+                y: FfiConverterFloat64.read(from),
+                width: FfiConverterFloat64.read(from),
+                height: FfiConverterFloat64.read(from),
+                tolerancePx: FfiConverterOptionalFloat64.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);
+            FfiConverterOptionalFloat64.write(value.tolerancePx, into);
+        }
+        allocationSize(value) {
+            return FfiConverterFloat64.allocationSize(value.x) +
+                FfiConverterFloat64.allocationSize(value.y) +
+                FfiConverterFloat64.allocationSize(value.width) +
+                FfiConverterFloat64.allocationSize(value.height) +
+                FfiConverterOptionalFloat64.allocationSize(value.tolerancePx);
+        }
+    }
+    ;
+    return new FFIConverter();
+})();
 export var DesktopScope;
 (function (DesktopScope) {
     DesktopScope[DesktopScope["Desktop"] = 0] = "Desktop";
@@ -128,6 +517,166 @@ const FfiConverterTypeClickInput = (() => {
     ;
     return new FFIConverter();
 })();
+/**
+ * Generated factory for {@link ClipboardReadInput} record objects.
+ */
+export const ClipboardReadInput = (() => {
+    const defaults = () => ({});
+    const create = (() => {
+        return uniffiCreateRecord(defaults);
+    })();
+    return Object.freeze({
+        create,
+        new: create,
+        defaults: () => Object.freeze(defaults()),
+    });
+})();
+const FfiConverterTypeClipboardReadInput = (() => {
+    class FFIConverter extends AbstractFfiConverterByteArray {
+        read(from) {
+            return {
+                includeText: FfiConverterBool.read(from),
+                session: FfiConverterOptionalString.read(from)
+            };
+        }
+        write(value, into) {
+            FfiConverterBool.write(value.includeText, into);
+            FfiConverterOptionalString.write(value.session, into);
+        }
+        allocationSize(value) {
+            return FfiConverterBool.allocationSize(value.includeText) +
+                FfiConverterOptionalString.allocationSize(value.session);
+        }
+    }
+    ;
+    return new FFIConverter();
+})();
+/**
+ * Generated factory for {@link ClipboardReadOutput} record objects.
+ */
+export const ClipboardReadOutput = (() => {
+    const defaults = () => ({});
+    const create = (() => {
+        return uniffiCreateRecord(defaults);
+    })();
+    return Object.freeze({
+        create,
+        new: create,
+        defaults: () => Object.freeze(defaults()),
+    });
+})();
+const FfiConverterTypeClipboardReadOutput = (() => {
+    class FFIConverter extends AbstractFfiConverterByteArray {
+        read(from) {
+            return {
+                supported: FfiConverterBool.read(from),
+                types: FfiConverterSequenceString.read(from),
+                text: FfiConverterOptionalString.read(from),
+                privacySensitive: FfiConverterBool.read(from),
+                contentRedactedFromTelemetry: FfiConverterBool.read(from)
+            };
+        }
+        write(value, into) {
+            FfiConverterBool.write(value.supported, into);
+            FfiConverterSequenceString.write(value.types, into);
+            FfiConverterOptionalString.write(value.text, into);
+            FfiConverterBool.write(value.privacySensitive, into);
+            FfiConverterBool.write(value.contentRedactedFromTelemetry, into);
+        }
+        allocationSize(value) {
+            return FfiConverterBool.allocationSize(value.supported) +
+                FfiConverterSequenceString.allocationSize(value.types) +
+                FfiConverterOptionalString.allocationSize(value.text) +
+                FfiConverterBool.allocationSize(value.privacySensitive) +
+                FfiConverterBool.allocationSize(value.contentRedactedFromTelemetry);
+        }
+    }
+    ;
+    return new FFIConverter();
+})();
+/**
+ * Generated factory for {@link ClipboardWriteInput} record objects.
+ */
+export const ClipboardWriteInput = (() => {
+    const defaults = () => ({});
+    const create = (() => {
+        return uniffiCreateRecord(defaults);
+    })();
+    return Object.freeze({
+        create,
+        new: create,
+        defaults: () => Object.freeze(defaults()),
+    });
+})();
+const FfiConverterTypeClipboardWriteInput = (() => {
+    class FFIConverter extends AbstractFfiConverterByteArray {
+        read(from) {
+            return {
+                text: FfiConverterOptionalString.read(from),
+                imagePath: FfiConverterOptionalString.read(from),
+                filePath: FfiConverterOptionalString.read(from),
+                session: FfiConverterOptionalString.read(from)
+            };
+        }
+        write(value, into) {
+            FfiConverterOptionalString.write(value.text, into);
+            FfiConverterOptionalString.write(value.imagePath, into);
+            FfiConverterOptionalString.write(value.filePath, into);
+            FfiConverterOptionalString.write(value.session, into);
+        }
+        allocationSize(value) {
+            return FfiConverterOptionalString.allocationSize(value.text) +
+                FfiConverterOptionalString.allocationSize(value.imagePath) +
+                FfiConverterOptionalString.allocationSize(value.filePath) +
+                FfiConverterOptionalString.allocationSize(value.session);
+        }
+    }
+    ;
+    return new FFIConverter();
+})();
+/**
+ * Generated factory for {@link ClipboardWriteOutput} record objects.
+ */
+export const ClipboardWriteOutput = (() => {
+    const defaults = () => ({});
+    const create = (() => {
+        return uniffiCreateRecord(defaults);
+    })();
+    return Object.freeze({
+        create,
+        new: create,
+        defaults: () => Object.freeze(defaults()),
+    });
+})();
+const FfiConverterTypeClipboardWriteOutput = (() => {
+    class FFIConverter extends AbstractFfiConverterByteArray {
+        read(from) {
+            return {
+                supported: FfiConverterBool.read(from),
+                writtenType: FfiConverterString.read(from),
+                types: FfiConverterSequenceString.read(from),
+                privacySensitive: FfiConverterBool.read(from),
+                contentRedactedFromTelemetry: FfiConverterBool.read(from)
+            };
+        }
+        write(value, into) {
+            FfiConverterBool.write(value.supported, into);
+            FfiConverterString.write(value.writtenType, into);
+            FfiConverterSequenceString.write(value.types, into);
+            FfiConverterBool.write(value.privacySensitive, into);
+            FfiConverterBool.write(value.contentRedactedFromTelemetry, into);
+        }
+        allocationSize(value) {
+            return FfiConverterBool.allocationSize(value.supported) +
+                FfiConverterString.allocationSize(value.writtenType) +
+                FfiConverterSequenceString.allocationSize(value.types) +
+                FfiConverterBool.allocationSize(value.privacySensitive) +
+                FfiConverterBool.allocationSize(value.contentRedactedFromTelemetry);
+        }
+    }
+    ;
+    return new FFIConverter();
+})();
 /**
  * Generated factory for {@link CursorMotionOutput} record objects.
  */
@@ -458,28 +1007,105 @@ const FfiConverterTypeDragInput = (() => {
             };
         }
         write(value, into) {
-            FfiConverterFloat64.write(value.fromX, into);
-            FfiConverterFloat64.write(value.fromY, into);
-            FfiConverterFloat64.write(value.toX, into);
-            FfiConverterFloat64.write(value.toY, into);
-            FfiConverterTypeDesktopScope.write(value.scope, into);
-            FfiConverterOptionalString.write(value.session, into);
-            FfiConverterOptionalUInt64.write(value.durationMs, into);
-            FfiConverterOptionalUInt64.write(value.steps, into);
-            FfiConverterOptionalTypeClickButton.write(value.button, into);
-            FfiConverterOptionalSequenceString.write(value.modifier, into);
+            FfiConverterFloat64.write(value.fromX, into);
+            FfiConverterFloat64.write(value.fromY, into);
+            FfiConverterFloat64.write(value.toX, into);
+            FfiConverterFloat64.write(value.toY, into);
+            FfiConverterTypeDesktopScope.write(value.scope, into);
+            FfiConverterOptionalString.write(value.session, into);
+            FfiConverterOptionalUInt64.write(value.durationMs, into);
+            FfiConverterOptionalUInt64.write(value.steps, into);
+            FfiConverterOptionalTypeClickButton.write(value.button, into);
+            FfiConverterOptionalSequenceString.write(value.modifier, into);
+        }
+        allocationSize(value) {
+            return FfiConverterFloat64.allocationSize(value.fromX) +
+                FfiConverterFloat64.allocationSize(value.fromY) +
+                FfiConverterFloat64.allocationSize(value.toX) +
+                FfiConverterFloat64.allocationSize(value.toY) +
+                FfiConverterTypeDesktopScope.allocationSize(value.scope) +
+                FfiConverterOptionalString.allocationSize(value.session) +
+                FfiConverterOptionalUInt64.allocationSize(value.durationMs) +
+                FfiConverterOptionalUInt64.allocationSize(value.steps) +
+                FfiConverterOptionalTypeClickButton.allocationSize(value.button) +
+                FfiConverterOptionalSequenceString.allocationSize(value.modifier);
+        }
+    }
+    ;
+    return new FFIConverter();
+})();
+/**
+ * Generated factory for {@link ElementSelector} record objects.
+ */
+export const ElementSelector = (() => {
+    const defaults = () => ({});
+    const create = (() => {
+        return uniffiCreateRecord(defaults);
+    })();
+    return Object.freeze({
+        create,
+        new: create,
+        defaults: () => Object.freeze(defaults()),
+    });
+})();
+const FfiConverterTypeElementSelector = (() => {
+    class FFIConverter extends AbstractFfiConverterByteArray {
+        read(from) {
+            return {
+                role: FfiConverterOptionalString.read(from),
+                labelContains: FfiConverterOptionalString.read(from)
+            };
+        }
+        write(value, into) {
+            FfiConverterOptionalString.write(value.role, into);
+            FfiConverterOptionalString.write(value.labelContains, into);
+        }
+        allocationSize(value) {
+            return FfiConverterOptionalString.allocationSize(value.role) +
+                FfiConverterOptionalString.allocationSize(value.labelContains);
+        }
+    }
+    ;
+    return new FFIConverter();
+})();
+/**
+ * Generated factory for {@link ElementPredicate} record objects.
+ */
+export const ElementPredicate = (() => {
+    const defaults = () => ({});
+    const create = (() => {
+        return uniffiCreateRecord(defaults);
+    })();
+    return Object.freeze({
+        create,
+        new: create,
+        defaults: () => Object.freeze(defaults()),
+    });
+})();
+const FfiConverterTypeElementPredicate = (() => {
+    class FFIConverter extends AbstractFfiConverterByteArray {
+        read(from) {
+            return {
+                selector: FfiConverterTypeElementSelector.read(from),
+                exists: FfiConverterOptionalBoolean.read(from),
+                valueEquals: FfiConverterOptionalString.read(from),
+                enabled: FfiConverterOptionalBoolean.read(from),
+                selected: FfiConverterOptionalBoolean.read(from)
+            };
+        }
+        write(value, into) {
+            FfiConverterTypeElementSelector.write(value.selector, into);
+            FfiConverterOptionalBoolean.write(value.exists, into);
+            FfiConverterOptionalString.write(value.valueEquals, into);
+            FfiConverterOptionalBoolean.write(value.enabled, into);
+            FfiConverterOptionalBoolean.write(value.selected, into);
         }
         allocationSize(value) {
-            return FfiConverterFloat64.allocationSize(value.fromX) +
-                FfiConverterFloat64.allocationSize(value.fromY) +
-                FfiConverterFloat64.allocationSize(value.toX) +
-                FfiConverterFloat64.allocationSize(value.toY) +
-                FfiConverterTypeDesktopScope.allocationSize(value.scope) +
-                FfiConverterOptionalString.allocationSize(value.session) +
-                FfiConverterOptionalUInt64.allocationSize(value.durationMs) +
-                FfiConverterOptionalUInt64.allocationSize(value.steps) +
-                FfiConverterOptionalTypeClickButton.allocationSize(value.button) +
-                FfiConverterOptionalSequenceString.allocationSize(value.modifier);
+            return FfiConverterTypeElementSelector.allocationSize(value.selector) +
+                FfiConverterOptionalBoolean.allocationSize(value.exists) +
+                FfiConverterOptionalString.allocationSize(value.valueEquals) +
+                FfiConverterOptionalBoolean.allocationSize(value.enabled) +
+                FfiConverterOptionalBoolean.allocationSize(value.selected);
         }
     }
     ;
@@ -864,6 +1490,46 @@ const FfiConverterTypeHotkeyInput = (() => {
     ;
     return new FFIConverter();
 })();
+/**
+ * Generated factory for {@link InvokeMenuInput} record objects.
+ */
+export const InvokeMenuInput = (() => {
+    const defaults = () => ({});
+    const create = (() => {
+        return uniffiCreateRecord(defaults);
+    })();
+    return Object.freeze({
+        create,
+        new: create,
+        defaults: () => Object.freeze(defaults()),
+    });
+})();
+const FfiConverterTypeInvokeMenuInput = (() => {
+    class FFIConverter extends AbstractFfiConverterByteArray {
+        read(from) {
+            return {
+                pid: FfiConverterUInt32.read(from),
+                windowId: FfiConverterUInt64.read(from),
+                path: FfiConverterSequenceString.read(from),
+                session: FfiConverterOptionalString.read(from)
+            };
+        }
+        write(value, into) {
+            FfiConverterUInt32.write(value.pid, into);
+            FfiConverterUInt64.write(value.windowId, into);
+            FfiConverterSequenceString.write(value.path, into);
+            FfiConverterOptionalString.write(value.session, into);
+        }
+        allocationSize(value) {
+            return FfiConverterUInt32.allocationSize(value.pid) +
+                FfiConverterUInt64.allocationSize(value.windowId) +
+                FfiConverterSequenceString.allocationSize(value.path) +
+                FfiConverterOptionalString.allocationSize(value.session);
+        }
+    }
+    ;
+    return new FFIConverter();
+})();
 /**
  * Generated factory for {@link MoveCursorInput} record objects.
  */
@@ -904,6 +1570,118 @@ 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 = (() => {
+    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.
  */
@@ -1387,6 +2165,55 @@ const FfiConverterTypeSetAgentCursorThemeOutput = (() => {
     ;
     return new FFIConverter();
 })();
+/**
+ * Generated factory for {@link SetWindowFrameInput} record objects.
+ */
+export const SetWindowFrameInput = (() => {
+    const defaults = () => ({});
+    const create = (() => {
+        return uniffiCreateRecord(defaults);
+    })();
+    return Object.freeze({
+        create,
+        new: create,
+        defaults: () => Object.freeze(defaults()),
+    });
+})();
+const FfiConverterTypeSetWindowFrameInput = (() => {
+    class FFIConverter extends AbstractFfiConverterByteArray {
+        read(from) {
+            return {
+                pid: FfiConverterUInt32.read(from),
+                windowId: FfiConverterUInt64.read(from),
+                x: FfiConverterFloat64.read(from),
+                y: FfiConverterFloat64.read(from),
+                width: FfiConverterFloat64.read(from),
+                height: FfiConverterFloat64.read(from),
+                session: FfiConverterOptionalString.read(from)
+            };
+        }
+        write(value, into) {
+            FfiConverterUInt32.write(value.pid, into);
+            FfiConverterUInt64.write(value.windowId, into);
+            FfiConverterFloat64.write(value.x, into);
+            FfiConverterFloat64.write(value.y, into);
+            FfiConverterFloat64.write(value.width, into);
+            FfiConverterFloat64.write(value.height, into);
+            FfiConverterOptionalString.write(value.session, into);
+        }
+        allocationSize(value) {
+            return FfiConverterUInt32.allocationSize(value.pid) +
+                FfiConverterUInt64.allocationSize(value.windowId) +
+                FfiConverterFloat64.allocationSize(value.x) +
+                FfiConverterFloat64.allocationSize(value.y) +
+                FfiConverterFloat64.allocationSize(value.width) +
+                FfiConverterFloat64.allocationSize(value.height) +
+                FfiConverterOptionalString.allocationSize(value.session);
+        }
+    }
+    ;
+    return new FFIConverter();
+})();
 /**
  * Generated factory for {@link StartSessionInput} record objects.
  */
@@ -1461,6 +2288,74 @@ const FfiConverterTypeStartSessionOutput = (() => {
     ;
     return new FFIConverter();
 })();
+/**
+ * Generated factory for {@link WindowPredicate} record objects.
+ */
+export const WindowPredicate = (() => {
+    const defaults = () => ({});
+    const create = (() => {
+        return uniffiCreateRecord(defaults);
+    })();
+    return Object.freeze({
+        create,
+        new: create,
+        defaults: () => Object.freeze(defaults()),
+    });
+})();
+const FfiConverterTypeWindowPredicate = (() => {
+    class FFIConverter extends AbstractFfiConverterByteArray {
+        read(from) {
+            return {
+                exists: FfiConverterOptionalBoolean.read(from),
+                bounds: FfiConverterOptionalTypeBoundsExpectation.read(from)
+            };
+        }
+        write(value, into) {
+            FfiConverterOptionalBoolean.write(value.exists, into);
+            FfiConverterOptionalTypeBoundsExpectation.write(value.bounds, into);
+        }
+        allocationSize(value) {
+            return FfiConverterOptionalBoolean.allocationSize(value.exists) +
+                FfiConverterOptionalTypeBoundsExpectation.allocationSize(value.bounds);
+        }
+    }
+    ;
+    return new FFIConverter();
+})();
+/**
+ * Generated factory for {@link StatePredicate} record objects.
+ */
+export const StatePredicate = (() => {
+    const defaults = () => ({});
+    const create = (() => {
+        return uniffiCreateRecord(defaults);
+    })();
+    return Object.freeze({
+        create,
+        new: create,
+        defaults: () => Object.freeze(defaults()),
+    });
+})();
+const FfiConverterTypeStatePredicate = (() => {
+    class FFIConverter extends AbstractFfiConverterByteArray {
+        read(from) {
+            return {
+                window: FfiConverterOptionalTypeWindowPredicate.read(from),
+                element: FfiConverterOptionalTypeElementPredicate.read(from)
+            };
+        }
+        write(value, into) {
+            FfiConverterOptionalTypeWindowPredicate.write(value.window, into);
+            FfiConverterOptionalTypeElementPredicate.write(value.element, into);
+        }
+        allocationSize(value) {
+            return FfiConverterOptionalTypeWindowPredicate.allocationSize(value.window) +
+                FfiConverterOptionalTypeElementPredicate.allocationSize(value.element);
+        }
+    }
+    ;
+    return new FFIConverter();
+})();
 /**
  * Generated factory for {@link TypeTextInput} record objects.
  */
@@ -1498,6 +2393,98 @@ const FfiConverterTypeTypeTextInput = (() => {
     ;
     return new FFIConverter();
 })();
+/**
+ * Generated factory for {@link VerifyStateInput} record objects.
+ */
+export const VerifyStateInput = (() => {
+    const defaults = () => ({});
+    const create = (() => {
+        return uniffiCreateRecord(defaults);
+    })();
+    return Object.freeze({
+        create,
+        new: create,
+        defaults: () => Object.freeze(defaults()),
+    });
+})();
+const FfiConverterTypeVerifyStateInput = (() => {
+    class FFIConverter extends AbstractFfiConverterByteArray {
+        read(from) {
+            return {
+                pid: FfiConverterInt64.read(from),
+                windowId: FfiConverterUInt64.read(from),
+                expect: FfiConverterSequenceTypeStatePredicate.read(from),
+                session: FfiConverterOptionalString.read(from),
+                timeoutMs: FfiConverterOptionalUInt64.read(from),
+                stableSamples: FfiConverterOptionalUInt64.read(from),
+                includeScreenshot: FfiConverterOptionalBoolean.read(from)
+            };
+        }
+        write(value, into) {
+            FfiConverterInt64.write(value.pid, into);
+            FfiConverterUInt64.write(value.windowId, into);
+            FfiConverterSequenceTypeStatePredicate.write(value.expect, into);
+            FfiConverterOptionalString.write(value.session, into);
+            FfiConverterOptionalUInt64.write(value.timeoutMs, into);
+            FfiConverterOptionalUInt64.write(value.stableSamples, into);
+            FfiConverterOptionalBoolean.write(value.includeScreenshot, into);
+        }
+        allocationSize(value) {
+            return FfiConverterInt64.allocationSize(value.pid) +
+                FfiConverterUInt64.allocationSize(value.windowId) +
+                FfiConverterSequenceTypeStatePredicate.allocationSize(value.expect) +
+                FfiConverterOptionalString.allocationSize(value.session) +
+                FfiConverterOptionalUInt64.allocationSize(value.timeoutMs) +
+                FfiConverterOptionalUInt64.allocationSize(value.stableSamples) +
+                FfiConverterOptionalBoolean.allocationSize(value.includeScreenshot);
+        }
+    }
+    ;
+    return new FFIConverter();
+})();
+/**
+ * Generated factory for {@link VerifyStateOutput} record objects.
+ */
+export const VerifyStateOutput = (() => {
+    const defaults = () => ({});
+    const create = (() => {
+        return uniffiCreateRecord(defaults);
+    })();
+    return Object.freeze({
+        create,
+        new: create,
+        defaults: () => Object.freeze(defaults()),
+    });
+})();
+const FfiConverterTypeVerifyStateOutput = (() => {
+    class FFIConverter extends AbstractFfiConverterByteArray {
+        read(from) {
+            return {
+                status: FfiConverterTypeVerificationStatus.read(from),
+                stable: FfiConverterBool.read(from),
+                elapsedMs: FfiConverterUInt64.read(from),
+                samples: FfiConverterUInt64.read(from),
+                predicates: FfiConverterSequenceTypePredicateOutcome.read(from)
+            };
+        }
+        write(value, into) {
+            FfiConverterTypeVerificationStatus.write(value.status, into);
+            FfiConverterBool.write(value.stable, into);
+            FfiConverterUInt64.write(value.elapsedMs, into);
+            FfiConverterUInt64.write(value.samples, into);
+            FfiConverterSequenceTypePredicateOutcome.write(value.predicates, into);
+        }
+        allocationSize(value) {
+            return FfiConverterTypeVerificationStatus.allocationSize(value.status) +
+                FfiConverterBool.allocationSize(value.stable) +
+                FfiConverterUInt64.allocationSize(value.elapsedMs) +
+                FfiConverterUInt64.allocationSize(value.samples) +
+                FfiConverterSequenceTypePredicateOutcome.allocationSize(value.predicates);
+        }
+    }
+    ;
+    return new FFIConverter();
+})();
 export var Platform;
 (function (Platform) {
     Platform[Platform["Macos"] = 0] = "Macos";
@@ -1528,30 +2515,52 @@ const FfiConverterTypePlatform = (() => {
     }
     return new FFIConverter();
 })();
+// FfiConverter for number | undefined
+const FfiConverterOptionalUInt32 = new FfiConverterOptional(FfiConverterUInt32);
+// FfiConverter for ActionDelivery | undefined
+const FfiConverterOptionalTypeActionDelivery = new FfiConverterOptional(FfiConverterTypeActionDelivery);
+// FfiConverter for Array<ActionEvidence>
+const FfiConverterSequenceTypeActionEvidence = new FfiConverterArray(FfiConverterTypeActionEvidence);
+// FfiConverter for Array<ActionEvidence> | undefined
+const FfiConverterOptionalSequenceTypeActionEvidence = new FfiConverterOptional(FfiConverterSequenceTypeActionEvidence);
+// FfiConverter for ActionEscalation | undefined
+const FfiConverterOptionalTypeActionEscalation = new FfiConverterOptional(FfiConverterTypeActionEscalation);
+// FfiConverter for number | undefined
+const FfiConverterOptionalFloat64 = new FfiConverterOptional(FfiConverterFloat64);
 // FfiConverter for string | undefined
 const FfiConverterOptionalString = new FfiConverterOptional(FfiConverterString);
 // FfiConverter for ClickButton | undefined
 const FfiConverterOptionalTypeClickButton = new FfiConverterOptional(FfiConverterTypeClickButton);
-// FfiConverter for number | undefined
-const FfiConverterOptionalUInt32 = new FfiConverterOptional(FfiConverterUInt32);
 // FfiConverter for Array<string>
 const FfiConverterSequenceString = new FfiConverterArray(FfiConverterString);
 // FfiConverter for bigint | undefined
 const FfiConverterOptionalUInt64 = new FfiConverterOptional(FfiConverterUInt64);
 // FfiConverter for Array<string> | undefined
 const FfiConverterOptionalSequenceString = new FfiConverterOptional(FfiConverterSequenceString);
+// FfiConverter for boolean | undefined
+const FfiConverterOptionalBoolean = new FfiConverterOptional(FfiConverterBool);
 // FfiConverter for CursorPointOutput | undefined
 const FfiConverterOptionalTypeCursorPointOutput = new FfiConverterOptional(FfiConverterTypeCursorPointOutput);
+// FfiConverter for UnknownReason | undefined
+const FfiConverterOptionalTypeUnknownReason = new FfiConverterOptional(FfiConverterTypeUnknownReason);
 // FfiConverter for ScrollBy | undefined
 const FfiConverterOptionalTypeScrollBy = new FfiConverterOptional(FfiConverterTypeScrollBy);
 // FfiConverter for EscalationReason | undefined
 const FfiConverterOptionalTypeEscalationReason = new FfiConverterOptional(FfiConverterTypeEscalationReason);
-// FfiConverter for number | undefined
-const FfiConverterOptionalFloat64 = new FfiConverterOptional(FfiConverterFloat64);
 // FfiConverter for CaptureScope | undefined
 const FfiConverterOptionalTypeCaptureScope = new FfiConverterOptional(FfiConverterTypeCaptureScope);
 // FfiConverter for CursorThemeSelection | undefined
 const FfiConverterOptionalTypeCursorThemeSelection = new FfiConverterOptional(FfiConverterTypeCursorThemeSelection);
+// FfiConverter for BoundsExpectation | undefined
+const FfiConverterOptionalTypeBoundsExpectation = new FfiConverterOptional(FfiConverterTypeBoundsExpectation);
+// FfiConverter for WindowPredicate | undefined
+const FfiConverterOptionalTypeWindowPredicate = new FfiConverterOptional(FfiConverterTypeWindowPredicate);
+// FfiConverter for ElementPredicate | undefined
+const FfiConverterOptionalTypeElementPredicate = new FfiConverterOptional(FfiConverterTypeElementPredicate);
+// FfiConverter for Array<StatePredicate>
+const FfiConverterSequenceTypeStatePredicate = new FfiConverterArray(FfiConverterTypeStatePredicate);
+// FfiConverter for Array<PredicateOutcome>
+const FfiConverterSequenceTypePredicateOutcome = new FfiConverterArray(FfiConverterTypePredicateOutcome);
 /**
  * This should be called before anything else.
  *
@@ -1574,9 +2583,24 @@ function uniffiEnsureInitialized() {
 export default Object.freeze({
     initialize: uniffiEnsureInitialized,
     converters: {
+        FfiConverterTypeActionDelivery,
+        FfiConverterTypeActionDeliveryMode,
+        FfiConverterTypeActionEffect,
+        FfiConverterTypeActionEscalation,
+        FfiConverterTypeActionEscalationReason,
+        FfiConverterTypeActionEscalationTarget,
+        FfiConverterTypeActionEvidence,
+        FfiConverterTypeActionEvidenceKind,
+        FfiConverterTypeActionResult,
+        FfiConverterTypeActionRoute,
+        FfiConverterTypeBoundsExpectation,
         FfiConverterTypeCaptureScope,
         FfiConverterTypeClickButton,
         FfiConverterTypeClickInput,
+        FfiConverterTypeClipboardReadInput,
+        FfiConverterTypeClipboardReadOutput,
+        FfiConverterTypeClipboardWriteInput,
+        FfiConverterTypeClipboardWriteOutput,
         FfiConverterTypeCursorAction,
         FfiConverterTypeCursorMotionOutput,
         FfiConverterTypeCursorPointOutput,
@@ -1587,6 +2611,8 @@ export default Object.freeze({
         FfiConverterTypeDesktopScope,
         FfiConverterTypeDragInput,
         FfiConverterTypeEffectiveScope,
+        FfiConverterTypeElementPredicate,
+        FfiConverterTypeElementSelector,
         FfiConverterTypeEndSessionInput,
         FfiConverterTypeEndSessionOutput,
         FfiConverterTypeEscalateSessionInput,
@@ -1598,8 +2624,10 @@ export default Object.freeze({
         FfiConverterTypeGetScreenSizeInput,
         FfiConverterTypeGetSessionStateInput,
         FfiConverterTypeHotkeyInput,
+        FfiConverterTypeInvokeMenuInput,
         FfiConverterTypeMoveCursorInput,
         FfiConverterTypePlatform,
+        FfiConverterTypePredicateOutcome,
         FfiConverterTypePressKeyInput,
         FfiConverterTypeScrollBy,
         FfiConverterTypeScrollDirection,
@@ -1611,8 +2639,15 @@ export default Object.freeze({
         FfiConverterTypeSetAgentCursorMotionOutput,
         FfiConverterTypeSetAgentCursorThemeInput,
         FfiConverterTypeSetAgentCursorThemeOutput,
+        FfiConverterTypeSetWindowFrameInput,
         FfiConverterTypeStartSessionInput,
         FfiConverterTypeStartSessionOutput,
+        FfiConverterTypeStatePredicate,
         FfiConverterTypeTypeTextInput,
+        FfiConverterTypeUnknownReason,
+        FfiConverterTypeVerificationStatus,
+        FfiConverterTypeVerifyStateInput,
+        FfiConverterTypeVerifyStateOutput,
+        FfiConverterTypeWindowPredicate,
     }
 });