@trycua/cua-driver 0.24.0 → 0.26.0

package/dist/native/cua_driver_contract.js

@@ -359,6 +359,73 @@ const FfiConverterTypeActionResult = (() => {
     ;
     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.
+ */
+export const AppInfo = (() => {
+    const defaults = () => ({});
+    const create = (() => {
+        return uniffiCreateRecord(defaults);
+    })();
+    return Object.freeze({
+        create,
+        new: create,
+        defaults: () => Object.freeze(defaults()),
+    });
+})();
+const FfiConverterTypeAppInfo = (() => {
+    class FFIConverter extends AbstractFfiConverterByteArray {
+        read(from) {
+            return {
+                pid: FfiConverterUInt32.read(from),
+                name: FfiConverterString.read(from),
+                running: FfiConverterBool.read(from),
+                active: FfiConverterBool.read(from),
+                bundleId: FfiConverterOptionalString.read(from),
+                launchPath: FfiConverterOptionalString.read(from),
+                kind: FfiConverterOptionalString.read(from),
+                lastUsed: FfiConverterOptionalString.read(from)
+            };
+        }
+        write(value, into) {
+            FfiConverterUInt32.write(value.pid, into);
+            FfiConverterString.write(value.name, into);
+            FfiConverterBool.write(value.running, into);
+            FfiConverterBool.write(value.active, into);
+            FfiConverterOptionalString.write(value.bundleId, into);
+            FfiConverterOptionalString.write(value.launchPath, into);
+            FfiConverterOptionalString.write(value.kind, into);
+            FfiConverterOptionalString.write(value.lastUsed, into);
+        }
+        allocationSize(value) {
+            return FfiConverterUInt32.allocationSize(value.pid) +
+                FfiConverterString.allocationSize(value.name) +
+                FfiConverterBool.allocationSize(value.running) +
+                FfiConverterBool.allocationSize(value.active) +
+                FfiConverterOptionalString.allocationSize(value.bundleId) +
+                FfiConverterOptionalString.allocationSize(value.launchPath) +
+                FfiConverterOptionalString.allocationSize(value.kind) +
+                FfiConverterOptionalString.allocationSize(value.lastUsed);
+        }
+    }
+    ;
+    return new FFIConverter();
+})();
 /**
  * Generated factory for {@link BoundsExpectation} record objects.
  */
@@ -402,21 +469,6 @@ const FfiConverterTypeBoundsExpectation = (() => {
     ;
     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);
 // Enum: ActionTarget
 export var ActionTarget_Tags;
 (function (ActionTarget_Tags) {
@@ -530,22 +582,131 @@ const FfiConverterTypeActionTarget = (() => {
     }
     return new FFIConverter();
 })();
-export var DesktopScope;
-(function (DesktopScope) {
-    DesktopScope[DesktopScope["Desktop"] = 0] = "Desktop";
-})(DesktopScope || (DesktopScope = {}));
-const FfiConverterTypeDesktopScope = (() => {
+// Enum: ClickPosition
+export var ClickPosition_Tags;
+(function (ClickPosition_Tags) {
+    ClickPosition_Tags["Coordinates"] = "Coordinates";
+    ClickPosition_Tags["Element"] = "Element";
+})(ClickPosition_Tags || (ClickPosition_Tags = {}));
+export const ClickPosition = (() => {
+    class Coordinates_ extends UniffiEnum {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        [uniffiTypeNameSymbol] = "ClickPosition";
+        tag = ClickPosition_Tags.Coordinates;
+        inner;
+        constructor(inner) {
+            super("ClickPosition", "Coordinates");
+            this.inner = Object.freeze(inner);
+        }
+        static new(inner) {
+            return new Coordinates_(inner);
+        }
+        static instanceOf(obj) {
+            return obj.tag === ClickPosition_Tags.Coordinates;
+        }
+    }
+    class Element_ extends UniffiEnum {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        [uniffiTypeNameSymbol] = "ClickPosition";
+        tag = ClickPosition_Tags.Element;
+        inner;
+        constructor(inner) {
+            super("ClickPosition", "Element");
+            this.inner = Object.freeze(inner);
+        }
+        static new(inner) {
+            return new Element_(inner);
+        }
+        static instanceOf(obj) {
+            return obj.tag === ClickPosition_Tags.Element;
+        }
+    }
+    function instanceOf(obj) {
+        return obj[uniffiTypeNameSymbol] === "ClickPosition";
+    }
+    return Object.freeze({
+        instanceOf,
+        Coordinates: Coordinates_,
+        Element: Element_
+    });
+})();
+// FfiConverter for enum ClickPosition
+const FfiConverterTypeClickPosition = (() => {
     const ordinalConverter = FfiConverterInt32;
     class FFIConverter extends AbstractFfiConverterByteArray {
         read(from) {
             switch (ordinalConverter.read(from)) {
-                case 1: return DesktopScope.Desktop;
+                case 1: return new ClickPosition.Coordinates({ x: FfiConverterFloat64.read(from), y: FfiConverterFloat64.read(from) });
+                case 2: return new ClickPosition.Element({ elementToken: FfiConverterString.read(from) });
+                default: throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+        write(value, into) {
+            switch (value.tag) {
+                case ClickPosition_Tags.Coordinates: {
+                    ordinalConverter.write(1, into);
+                    const inner = value.inner;
+                    FfiConverterFloat64.write(inner.x, into);
+                    FfiConverterFloat64.write(inner.y, into);
+                    return;
+                }
+                case ClickPosition_Tags.Element: {
+                    ordinalConverter.write(2, into);
+                    const inner = value.inner;
+                    FfiConverterString.write(inner.elementToken, into);
+                    return;
+                }
+                default:
+                    // Throwing from here means that ClickPosition_Tags hasn't matched an ordinal.
+                    throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+        allocationSize(value) {
+            switch (value.tag) {
+                case ClickPosition_Tags.Coordinates: {
+                    const inner = value.inner;
+                    let size = ordinalConverter.allocationSize(1);
+                    size += FfiConverterFloat64.allocationSize(inner.x);
+                    size += FfiConverterFloat64.allocationSize(inner.y);
+                    return size;
+                }
+                case ClickPosition_Tags.Element: {
+                    const inner = value.inner;
+                    let size = ordinalConverter.allocationSize(2);
+                    size += FfiConverterString.allocationSize(inner.elementToken);
+                    return size;
+                }
+                default: throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+    }
+    return new FFIConverter();
+})();
+export var InputDeliveryMode;
+(function (InputDeliveryMode) {
+    InputDeliveryMode[InputDeliveryMode["Background"] = 0] = "Background";
+    InputDeliveryMode[InputDeliveryMode["Foreground"] = 1] = "Foreground";
+})(InputDeliveryMode || (InputDeliveryMode = {}));
+const FfiConverterTypeInputDeliveryMode = (() => {
+    const ordinalConverter = FfiConverterInt32;
+    class FFIConverter extends AbstractFfiConverterByteArray {
+        read(from) {
+            switch (ordinalConverter.read(from)) {
+                case 1: return InputDeliveryMode.Background;
+                case 2: return InputDeliveryMode.Foreground;
                 default: throw new UniffiInternalError.UnexpectedEnumCase();
             }
         }
         write(value, into) {
             switch (value) {
-                case DesktopScope.Desktop: return ordinalConverter.write(1, into);
+                case InputDeliveryMode.Background: return ordinalConverter.write(1, into);
+                case InputDeliveryMode.Foreground: return ordinalConverter.write(2, into);
             }
         }
         allocationSize(value) {
@@ -602,29 +763,26 @@ const FfiConverterTypeClickInput = (() => {
     class FFIConverter extends AbstractFfiConverterByteArray {
         read(from) {
             return {
-                x: FfiConverterFloat64.read(from),
-                y: FfiConverterFloat64.read(from),
-                target: FfiConverterOptionalTypeActionTarget.read(from),
-                scope: FfiConverterOptionalTypeDesktopScope.read(from),
+                target: FfiConverterTypeActionTarget.read(from),
+                position: FfiConverterTypeClickPosition.read(from),
+                deliveryMode: FfiConverterTypeInputDeliveryMode.read(from),
                 session: FfiConverterOptionalString.read(from),
                 button: FfiConverterOptionalTypeClickButton.read(from),
                 count: FfiConverterOptionalUInt32.read(from)
             };
         }
         write(value, into) {
-            FfiConverterFloat64.write(value.x, into);
-            FfiConverterFloat64.write(value.y, into);
-            FfiConverterOptionalTypeActionTarget.write(value.target, into);
-            FfiConverterOptionalTypeDesktopScope.write(value.scope, into);
+            FfiConverterTypeActionTarget.write(value.target, into);
+            FfiConverterTypeClickPosition.write(value.position, into);
+            FfiConverterTypeInputDeliveryMode.write(value.deliveryMode, into);
             FfiConverterOptionalString.write(value.session, into);
             FfiConverterOptionalTypeClickButton.write(value.button, into);
             FfiConverterOptionalUInt32.write(value.count, into);
         }
         allocationSize(value) {
-            return FfiConverterFloat64.allocationSize(value.x) +
-                FfiConverterFloat64.allocationSize(value.y) +
-                FfiConverterOptionalTypeActionTarget.allocationSize(value.target) +
-                FfiConverterOptionalTypeDesktopScope.allocationSize(value.scope) +
+            return FfiConverterTypeActionTarget.allocationSize(value.target) +
+                FfiConverterTypeClickPosition.allocationSize(value.position) +
+                FfiConverterTypeInputDeliveryMode.allocationSize(value.deliveryMode) +
                 FfiConverterOptionalString.allocationSize(value.session) +
                 FfiConverterOptionalTypeClickButton.allocationSize(value.button) +
                 FfiConverterOptionalUInt32.allocationSize(value.count);
@@ -1092,6 +1250,30 @@ const FfiConverterTypeCursorVisualOutput = (() => {
     ;
     return new FFIConverter();
 })();
+export var DesktopScope;
+(function (DesktopScope) {
+    DesktopScope[DesktopScope["Desktop"] = 0] = "Desktop";
+})(DesktopScope || (DesktopScope = {}));
+const FfiConverterTypeDesktopScope = (() => {
+    const ordinalConverter = FfiConverterInt32;
+    class FFIConverter extends AbstractFfiConverterByteArray {
+        read(from) {
+            switch (ordinalConverter.read(from)) {
+                case 1: return DesktopScope.Desktop;
+                default: throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+        write(value, into) {
+            switch (value) {
+                case DesktopScope.Desktop: return ordinalConverter.write(1, into);
+            }
+        }
+        allocationSize(value) {
+            return ordinalConverter.allocationSize(0);
+        }
+    }
+    return new FFIConverter();
+})();
 /**
  * Generated factory for {@link DragInput} record objects.
  */
@@ -1153,6 +1335,46 @@ const FfiConverterTypeDragInput = (() => {
     ;
     return new FFIConverter();
 })();
+/**
+ * Generated factory for {@link ElementFrame} record objects.
+ */
+export const ElementFrame = (() => {
+    const defaults = () => ({});
+    const create = (() => {
+        return uniffiCreateRecord(defaults);
+    })();
+    return Object.freeze({
+        create,
+        new: create,
+        defaults: () => Object.freeze(defaults()),
+    });
+})();
+const FfiConverterTypeElementFrame = (() => {
+    class FFIConverter extends AbstractFfiConverterByteArray {
+        read(from) {
+            return {
+                x: FfiConverterFloat64.read(from),
+                y: FfiConverterFloat64.read(from),
+                w: FfiConverterFloat64.read(from),
+                h: FfiConverterFloat64.read(from)
+            };
+        }
+        write(value, into) {
+            FfiConverterFloat64.write(value.x, into);
+            FfiConverterFloat64.write(value.y, into);
+            FfiConverterFloat64.write(value.w, into);
+            FfiConverterFloat64.write(value.h, into);
+        }
+        allocationSize(value) {
+            return FfiConverterFloat64.allocationSize(value.x) +
+                FfiConverterFloat64.allocationSize(value.y) +
+                FfiConverterFloat64.allocationSize(value.w) +
+                FfiConverterFloat64.allocationSize(value.h);
+        }
+    }
+    ;
+    return new FFIConverter();
+})();
 /**
  * Generated factory for {@link ElementSelector} record objects.
  */
@@ -1603,6 +1825,64 @@ const FfiConverterTypeGetSessionStateInput = (() => {
     ;
     return new FFIConverter();
 })();
+/**
+ * Generated factory for {@link GetWindowStateInput} record objects.
+ */
+export const GetWindowStateInput = (() => {
+    const defaults = () => ({});
+    const create = (() => {
+        return uniffiCreateRecord(defaults);
+    })();
+    return Object.freeze({
+        create,
+        new: create,
+        defaults: () => Object.freeze(defaults()),
+    });
+})();
+const FfiConverterTypeGetWindowStateInput = (() => {
+    class FFIConverter extends AbstractFfiConverterByteArray {
+        read(from) {
+            return {
+                pid: FfiConverterUInt32.read(from),
+                windowId: FfiConverterUInt64.read(from),
+                session: FfiConverterOptionalString.read(from),
+                query: FfiConverterOptionalString.read(from),
+                includeAccessibilityTree: FfiConverterOptionalBoolean.read(from),
+                includeScreenshot: FfiConverterOptionalBoolean.read(from),
+                screenshotOutFile: FfiConverterOptionalString.read(from),
+                maxElements: FfiConverterOptionalUInt32.read(from),
+                maxDepth: FfiConverterOptionalUInt32.read(from),
+                maxDimension: FfiConverterOptionalUInt32.read(from)
+            };
+        }
+        write(value, into) {
+            FfiConverterUInt32.write(value.pid, into);
+            FfiConverterUInt64.write(value.windowId, into);
+            FfiConverterOptionalString.write(value.session, into);
+            FfiConverterOptionalString.write(value.query, into);
+            FfiConverterOptionalBoolean.write(value.includeAccessibilityTree, into);
+            FfiConverterOptionalBoolean.write(value.includeScreenshot, into);
+            FfiConverterOptionalString.write(value.screenshotOutFile, into);
+            FfiConverterOptionalUInt32.write(value.maxElements, into);
+            FfiConverterOptionalUInt32.write(value.maxDepth, into);
+            FfiConverterOptionalUInt32.write(value.maxDimension, into);
+        }
+        allocationSize(value) {
+            return FfiConverterUInt32.allocationSize(value.pid) +
+                FfiConverterUInt64.allocationSize(value.windowId) +
+                FfiConverterOptionalString.allocationSize(value.session) +
+                FfiConverterOptionalString.allocationSize(value.query) +
+                FfiConverterOptionalBoolean.allocationSize(value.includeAccessibilityTree) +
+                FfiConverterOptionalBoolean.allocationSize(value.includeScreenshot) +
+                FfiConverterOptionalString.allocationSize(value.screenshotOutFile) +
+                FfiConverterOptionalUInt32.allocationSize(value.maxElements) +
+                FfiConverterOptionalUInt32.allocationSize(value.maxDepth) +
+                FfiConverterOptionalUInt32.allocationSize(value.maxDimension);
+        }
+    }
+    ;
+    return new FFIConverter();
+})();
 /**
  * Generated factory for {@link HotkeyInput} record objects.
  */
@@ -1683,6 +1963,65 @@ const FfiConverterTypeInvokeMenuInput = (() => {
     ;
     return new FFIConverter();
 })();
+/**
+ * Generated factory for {@link ListAppsInput} record objects.
+ */
+export const ListAppsInput = (() => {
+    const defaults = () => ({});
+    const create = (() => {
+        return uniffiCreateRecord(defaults);
+    })();
+    return Object.freeze({
+        create,
+        new: create,
+        defaults: () => Object.freeze(defaults()),
+    });
+})();
+const FfiConverterTypeListAppsInput = (() => {
+    class FFIConverter extends AbstractFfiConverterByteArray {
+        read(from) {
+            return {};
+        }
+        write(value, into) {
+        }
+        allocationSize(value) {
+            return 0;
+        }
+    }
+    ;
+    return new FFIConverter();
+})();
+/**
+ * Generated factory for {@link ListAppsOutput} record objects.
+ */
+export const ListAppsOutput = (() => {
+    const defaults = () => ({});
+    const create = (() => {
+        return uniffiCreateRecord(defaults);
+    })();
+    return Object.freeze({
+        create,
+        new: create,
+        defaults: () => Object.freeze(defaults()),
+    });
+})();
+const FfiConverterTypeListAppsOutput = (() => {
+    class FFIConverter extends AbstractFfiConverterByteArray {
+        read(from) {
+            return {
+                apps: FfiConverterSequenceTypeAppInfo.read(from)
+            };
+        }
+        write(value, into) {
+            FfiConverterSequenceTypeAppInfo.write(value.apps, into);
+        }
+        allocationSize(value) {
+            return FfiConverterSequenceTypeAppInfo.allocationSize(value.apps);
+        }
+    }
+    ;
+    return new FFIConverter();
+})();
 /**
  * Generated factory for {@link ListSessionsInput} record objects.
  */
@@ -1902,6 +2241,178 @@ const FfiConverterTypeListSessionsOutput = (() => {
     ;
     return new FFIConverter();
 })();
+/**
+ * Generated factory for {@link ListWindowsInput} record objects.
+ */
+export const ListWindowsInput = (() => {
+    const defaults = () => ({});
+    const create = (() => {
+        return uniffiCreateRecord(defaults);
+    })();
+    return Object.freeze({
+        create,
+        new: create,
+        defaults: () => Object.freeze(defaults()),
+    });
+})();
+const FfiConverterTypeListWindowsInput = (() => {
+    class FFIConverter extends AbstractFfiConverterByteArray {
+        read(from) {
+            return {
+                pid: FfiConverterOptionalUInt32.read(from),
+                onScreenOnly: FfiConverterOptionalBoolean.read(from)
+            };
+        }
+        write(value, into) {
+            FfiConverterOptionalUInt32.write(value.pid, into);
+            FfiConverterOptionalBoolean.write(value.onScreenOnly, into);
+        }
+        allocationSize(value) {
+            return FfiConverterOptionalUInt32.allocationSize(value.pid) +
+                FfiConverterOptionalBoolean.allocationSize(value.onScreenOnly);
+        }
+    }
+    ;
+    return new FFIConverter();
+})();
+/**
+ * Generated factory for {@link WindowBounds} record objects.
+ */
+export const WindowBounds = (() => {
+    const defaults = () => ({});
+    const create = (() => {
+        return uniffiCreateRecord(defaults);
+    })();
+    return Object.freeze({
+        create,
+        new: create,
+        defaults: () => Object.freeze(defaults()),
+    });
+})();
+const FfiConverterTypeWindowBounds = (() => {
+    class FFIConverter extends AbstractFfiConverterByteArray {
+        read(from) {
+            return {
+                x: FfiConverterFloat64.read(from),
+                y: FfiConverterFloat64.read(from),
+                width: FfiConverterFloat64.read(from),
+                height: FfiConverterFloat64.read(from)
+            };
+        }
+        write(value, into) {
+            FfiConverterFloat64.write(value.x, into);
+            FfiConverterFloat64.write(value.y, into);
+            FfiConverterFloat64.write(value.width, into);
+            FfiConverterFloat64.write(value.height, into);
+        }
+        allocationSize(value) {
+            return FfiConverterFloat64.allocationSize(value.x) +
+                FfiConverterFloat64.allocationSize(value.y) +
+                FfiConverterFloat64.allocationSize(value.width) +
+                FfiConverterFloat64.allocationSize(value.height);
+        }
+    }
+    ;
+    return new FFIConverter();
+})();
+/**
+ * Generated factory for {@link WindowInfo} record objects.
+ */
+export const WindowInfo = (() => {
+    const defaults = () => ({});
+    const create = (() => {
+        return uniffiCreateRecord(defaults);
+    })();
+    return Object.freeze({
+        create,
+        new: create,
+        defaults: () => Object.freeze(defaults()),
+    });
+})();
+const FfiConverterTypeWindowInfo = (() => {
+    class FFIConverter extends AbstractFfiConverterByteArray {
+        read(from) {
+            return {
+                windowId: FfiConverterUInt64.read(from),
+                pid: FfiConverterOptionalUInt32.read(from),
+                appName: FfiConverterString.read(from),
+                title: FfiConverterString.read(from),
+                bounds: FfiConverterTypeWindowBounds.read(from),
+                isOnScreen: FfiConverterBool.read(from),
+                zIndex: FfiConverterOptionalInt64.read(from),
+                layer: FfiConverterOptionalInt32.read(from),
+                minimized: FfiConverterOptionalBoolean.read(from),
+                currentSpaceId: FfiConverterOptionalUInt64.read(from),
+                onCurrentSpace: FfiConverterOptionalBoolean.read(from),
+                spaceIds: FfiConverterOptionalSequenceUInt64.read(from)
+            };
+        }
+        write(value, into) {
+            FfiConverterUInt64.write(value.windowId, into);
+            FfiConverterOptionalUInt32.write(value.pid, into);
+            FfiConverterString.write(value.appName, into);
+            FfiConverterString.write(value.title, into);
+            FfiConverterTypeWindowBounds.write(value.bounds, into);
+            FfiConverterBool.write(value.isOnScreen, into);
+            FfiConverterOptionalInt64.write(value.zIndex, into);
+            FfiConverterOptionalInt32.write(value.layer, into);
+            FfiConverterOptionalBoolean.write(value.minimized, into);
+            FfiConverterOptionalUInt64.write(value.currentSpaceId, into);
+            FfiConverterOptionalBoolean.write(value.onCurrentSpace, into);
+            FfiConverterOptionalSequenceUInt64.write(value.spaceIds, into);
+        }
+        allocationSize(value) {
+            return FfiConverterUInt64.allocationSize(value.windowId) +
+                FfiConverterOptionalUInt32.allocationSize(value.pid) +
+                FfiConverterString.allocationSize(value.appName) +
+                FfiConverterString.allocationSize(value.title) +
+                FfiConverterTypeWindowBounds.allocationSize(value.bounds) +
+                FfiConverterBool.allocationSize(value.isOnScreen) +
+                FfiConverterOptionalInt64.allocationSize(value.zIndex) +
+                FfiConverterOptionalInt32.allocationSize(value.layer) +
+                FfiConverterOptionalBoolean.allocationSize(value.minimized) +
+                FfiConverterOptionalUInt64.allocationSize(value.currentSpaceId) +
+                FfiConverterOptionalBoolean.allocationSize(value.onCurrentSpace) +
+                FfiConverterOptionalSequenceUInt64.allocationSize(value.spaceIds);
+        }
+    }
+    ;
+    return new FFIConverter();
+})();
+/**
+ * Generated factory for {@link ListWindowsOutput} record objects.
+ */
+export const ListWindowsOutput = (() => {
+    const defaults = () => ({});
+    const create = (() => {
+        return uniffiCreateRecord(defaults);
+    })();
+    return Object.freeze({
+        create,
+        new: create,
+        defaults: () => Object.freeze(defaults()),
+    });
+})();
+const FfiConverterTypeListWindowsOutput = (() => {
+    class FFIConverter extends AbstractFfiConverterByteArray {
+        read(from) {
+            return {
+                windows: FfiConverterSequenceTypeWindowInfo.read(from),
+                currentSpaceId: FfiConverterOptionalUInt64.read(from)
+            };
+        }
+        write(value, into) {
+            FfiConverterSequenceTypeWindowInfo.write(value.windows, into);
+            FfiConverterOptionalUInt64.write(value.currentSpaceId, into);
+        }
+        allocationSize(value) {
+            return FfiConverterSequenceTypeWindowInfo.allocationSize(value.windows) +
+                FfiConverterOptionalUInt64.allocationSize(value.currentSpaceId);
+        }
+    }
+    ;
+    return new FFIConverter();
+})();
 /**
  * Generated factory for {@link MoveCursorInput} record objects.
  */
@@ -2598,6 +3109,40 @@ const FfiConverterTypeSetWindowFrameInput = (() => {
     ;
     return new FFIConverter();
 })();
+/**
+ * Generated factory for {@link SnapshotImage} record objects.
+ */
+export const SnapshotImage = (() => {
+    const defaults = () => ({});
+    const create = (() => {
+        return uniffiCreateRecord(defaults);
+    })();
+    return Object.freeze({
+        create,
+        new: create,
+        defaults: () => Object.freeze(defaults()),
+    });
+})();
+const FfiConverterTypeSnapshotImage = (() => {
+    class FFIConverter extends AbstractFfiConverterByteArray {
+        read(from) {
+            return {
+                mimeType: FfiConverterString.read(from),
+                dataBase64: FfiConverterString.read(from)
+            };
+        }
+        write(value, into) {
+            FfiConverterString.write(value.mimeType, into);
+            FfiConverterString.write(value.dataBase64, into);
+        }
+        allocationSize(value) {
+            return FfiConverterString.allocationSize(value.mimeType) +
+                FfiConverterString.allocationSize(value.dataBase64);
+        }
+    }
+    ;
+    return new FFIConverter();
+})();
 /**
  * Generated factory for {@link StartSessionInput} record objects.
  */
@@ -2872,6 +3417,179 @@ const FfiConverterTypeVerifyStateOutput = (() => {
     ;
     return new FFIConverter();
 })();
+/**
+ * Generated factory for {@link WindowElement} record objects.
+ */
+export const WindowElement = (() => {
+    const defaults = () => ({});
+    const create = (() => {
+        return uniffiCreateRecord(defaults);
+    })();
+    return Object.freeze({
+        create,
+        new: create,
+        defaults: () => Object.freeze(defaults()),
+    });
+})();
+const FfiConverterTypeWindowElement = (() => {
+    class FFIConverter extends AbstractFfiConverterByteArray {
+        read(from) {
+            return {
+                elementIndex: FfiConverterUInt64.read(from),
+                role: FfiConverterString.read(from),
+                depth: FfiConverterUInt32.read(from),
+                elementToken: FfiConverterOptionalString.read(from),
+                label: FfiConverterOptionalString.read(from),
+                value: FfiConverterOptionalString.read(from),
+                valueDescription: FfiConverterOptionalString.read(from),
+                enabled: FfiConverterOptionalBoolean.read(from),
+                selected: FfiConverterOptionalBoolean.read(from),
+                inWebContent: FfiConverterOptionalBoolean.read(from),
+                actions: FfiConverterOptionalSequenceString.read(from),
+                parentIndex: FfiConverterOptionalUInt64.read(from),
+                frame: FfiConverterOptionalTypeElementFrame.read(from),
+                min: FfiConverterOptionalFloat64.read(from),
+                max: FfiConverterOptionalFloat64.read(from)
+            };
+        }
+        write(value, into) {
+            FfiConverterUInt64.write(value.elementIndex, into);
+            FfiConverterString.write(value.role, into);
+            FfiConverterUInt32.write(value.depth, into);
+            FfiConverterOptionalString.write(value.elementToken, into);
+            FfiConverterOptionalString.write(value.label, into);
+            FfiConverterOptionalString.write(value.value, into);
+            FfiConverterOptionalString.write(value.valueDescription, into);
+            FfiConverterOptionalBoolean.write(value.enabled, into);
+            FfiConverterOptionalBoolean.write(value.selected, into);
+            FfiConverterOptionalBoolean.write(value.inWebContent, into);
+            FfiConverterOptionalSequenceString.write(value.actions, into);
+            FfiConverterOptionalUInt64.write(value.parentIndex, into);
+            FfiConverterOptionalTypeElementFrame.write(value.frame, into);
+            FfiConverterOptionalFloat64.write(value.min, into);
+            FfiConverterOptionalFloat64.write(value.max, into);
+        }
+        allocationSize(value) {
+            return FfiConverterUInt64.allocationSize(value.elementIndex) +
+                FfiConverterString.allocationSize(value.role) +
+                FfiConverterUInt32.allocationSize(value.depth) +
+                FfiConverterOptionalString.allocationSize(value.elementToken) +
+                FfiConverterOptionalString.allocationSize(value.label) +
+                FfiConverterOptionalString.allocationSize(value.value) +
+                FfiConverterOptionalString.allocationSize(value.valueDescription) +
+                FfiConverterOptionalBoolean.allocationSize(value.enabled) +
+                FfiConverterOptionalBoolean.allocationSize(value.selected) +
+                FfiConverterOptionalBoolean.allocationSize(value.inWebContent) +
+                FfiConverterOptionalSequenceString.allocationSize(value.actions) +
+                FfiConverterOptionalUInt64.allocationSize(value.parentIndex) +
+                FfiConverterOptionalTypeElementFrame.allocationSize(value.frame) +
+                FfiConverterOptionalFloat64.allocationSize(value.min) +
+                FfiConverterOptionalFloat64.allocationSize(value.max);
+        }
+    }
+    ;
+    return new FFIConverter();
+})();
+/**
+ * Generated factory for {@link WindowStateOutput} record objects.
+ */
+export const WindowStateOutput = (() => {
+    const defaults = () => ({});
+    const create = (() => {
+        return uniffiCreateRecord(defaults);
+    })();
+    return Object.freeze({
+        create,
+        new: create,
+        defaults: () => Object.freeze(defaults()),
+    });
+})();
+const FfiConverterTypeWindowStateOutput = (() => {
+    class FFIConverter extends AbstractFfiConverterByteArray {
+        read(from) {
+            return {
+                pid: FfiConverterUInt32.read(from),
+                windowId: FfiConverterUInt64.read(from),
+                snapshotId: FfiConverterOptionalString.read(from),
+                appName: FfiConverterOptionalString.read(from),
+                windowTitle: FfiConverterOptionalString.read(from),
+                treeMarkdown: FfiConverterOptionalString.read(from),
+                elements: FfiConverterOptionalSequenceTypeWindowElement.read(from),
+                elementCount: FfiConverterOptionalUInt64.read(from),
+                totalElementCount: FfiConverterOptionalUInt64.read(from),
+                returnedElementCount: FfiConverterOptionalUInt64.read(from),
+                filteredElementCount: FfiConverterOptionalUInt64.read(from),
+                elementsComplete: FfiConverterOptionalBoolean.read(from),
+                degraded: FfiConverterOptionalBoolean.read(from),
+                degradedReason: FfiConverterOptionalString.read(from),
+                truncated: FfiConverterOptionalBoolean.read(from),
+                truncationReason: FfiConverterOptionalString.read(from),
+                screenshotWidth: FfiConverterOptionalUInt32.read(from),
+                screenshotHeight: FfiConverterOptionalUInt32.read(from),
+                screenshotScale: FfiConverterOptionalFloat64.read(from),
+                screenshotMimeType: FfiConverterOptionalString.read(from),
+                screenshotFilePath: FfiConverterOptionalString.read(from),
+                screenshotFrameValid: FfiConverterOptionalBoolean.read(from),
+                windowBounds: FfiConverterOptionalTypeWindowBounds.read(from),
+                images: FfiConverterSequenceTypeSnapshotImage.read(from)
+            };
+        }
+        write(value, into) {
+            FfiConverterUInt32.write(value.pid, into);
+            FfiConverterUInt64.write(value.windowId, into);
+            FfiConverterOptionalString.write(value.snapshotId, into);
+            FfiConverterOptionalString.write(value.appName, into);
+            FfiConverterOptionalString.write(value.windowTitle, into);
+            FfiConverterOptionalString.write(value.treeMarkdown, into);
+            FfiConverterOptionalSequenceTypeWindowElement.write(value.elements, into);
+            FfiConverterOptionalUInt64.write(value.elementCount, into);
+            FfiConverterOptionalUInt64.write(value.totalElementCount, into);
+            FfiConverterOptionalUInt64.write(value.returnedElementCount, into);
+            FfiConverterOptionalUInt64.write(value.filteredElementCount, into);
+            FfiConverterOptionalBoolean.write(value.elementsComplete, into);
+            FfiConverterOptionalBoolean.write(value.degraded, into);
+            FfiConverterOptionalString.write(value.degradedReason, into);
+            FfiConverterOptionalBoolean.write(value.truncated, into);
+            FfiConverterOptionalString.write(value.truncationReason, into);
+            FfiConverterOptionalUInt32.write(value.screenshotWidth, into);
+            FfiConverterOptionalUInt32.write(value.screenshotHeight, into);
+            FfiConverterOptionalFloat64.write(value.screenshotScale, into);
+            FfiConverterOptionalString.write(value.screenshotMimeType, into);
+            FfiConverterOptionalString.write(value.screenshotFilePath, into);
+            FfiConverterOptionalBoolean.write(value.screenshotFrameValid, into);
+            FfiConverterOptionalTypeWindowBounds.write(value.windowBounds, into);
+            FfiConverterSequenceTypeSnapshotImage.write(value.images, into);
+        }
+        allocationSize(value) {
+            return FfiConverterUInt32.allocationSize(value.pid) +
+                FfiConverterUInt64.allocationSize(value.windowId) +
+                FfiConverterOptionalString.allocationSize(value.snapshotId) +
+                FfiConverterOptionalString.allocationSize(value.appName) +
+                FfiConverterOptionalString.allocationSize(value.windowTitle) +
+                FfiConverterOptionalString.allocationSize(value.treeMarkdown) +
+                FfiConverterOptionalSequenceTypeWindowElement.allocationSize(value.elements) +
+                FfiConverterOptionalUInt64.allocationSize(value.elementCount) +
+                FfiConverterOptionalUInt64.allocationSize(value.totalElementCount) +
+                FfiConverterOptionalUInt64.allocationSize(value.returnedElementCount) +
+                FfiConverterOptionalUInt64.allocationSize(value.filteredElementCount) +
+                FfiConverterOptionalBoolean.allocationSize(value.elementsComplete) +
+                FfiConverterOptionalBoolean.allocationSize(value.degraded) +
+                FfiConverterOptionalString.allocationSize(value.degradedReason) +
+                FfiConverterOptionalBoolean.allocationSize(value.truncated) +
+                FfiConverterOptionalString.allocationSize(value.truncationReason) +
+                FfiConverterOptionalUInt32.allocationSize(value.screenshotWidth) +
+                FfiConverterOptionalUInt32.allocationSize(value.screenshotHeight) +
+                FfiConverterOptionalFloat64.allocationSize(value.screenshotScale) +
+                FfiConverterOptionalString.allocationSize(value.screenshotMimeType) +
+                FfiConverterOptionalString.allocationSize(value.screenshotFilePath) +
+                FfiConverterOptionalBoolean.allocationSize(value.screenshotFrameValid) +
+                FfiConverterOptionalTypeWindowBounds.allocationSize(value.windowBounds) +
+                FfiConverterSequenceTypeSnapshotImage.allocationSize(value.images);
+        }
+    }
+    ;
+    return new FFIConverter();
+})();
 export var Platform;
 (function (Platform) {
     Platform[Platform["Macos"] = 0] = "Macos";
@@ -2912,18 +3630,18 @@ const FfiConverterSequenceTypeActionEvidence = new FfiConverterArray(FfiConverte
 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 ActionTarget | undefined
-const FfiConverterOptionalTypeActionTarget = new FfiConverterOptional(FfiConverterTypeActionTarget);
-// FfiConverter for DesktopScope | undefined
-const FfiConverterOptionalTypeDesktopScope = new FfiConverterOptional(FfiConverterTypeDesktopScope);
 // FfiConverter for string | undefined
 const FfiConverterOptionalString = new FfiConverterOptional(FfiConverterString);
+// FfiConverter for number | undefined
+const FfiConverterOptionalFloat64 = new FfiConverterOptional(FfiConverterFloat64);
 // FfiConverter for ClickButton | undefined
 const FfiConverterOptionalTypeClickButton = new FfiConverterOptional(FfiConverterTypeClickButton);
 // FfiConverter for Array<string>
 const FfiConverterSequenceString = new FfiConverterArray(FfiConverterString);
+// FfiConverter for ActionTarget | undefined
+const FfiConverterOptionalTypeActionTarget = new FfiConverterOptional(FfiConverterTypeActionTarget);
+// FfiConverter for DesktopScope | undefined
+const FfiConverterOptionalTypeDesktopScope = new FfiConverterOptional(FfiConverterTypeDesktopScope);
 // FfiConverter for bigint | undefined
 const FfiConverterOptionalUInt64 = new FfiConverterOptional(FfiConverterUInt64);
 // FfiConverter for Array<string> | undefined
@@ -2932,8 +3650,20 @@ const FfiConverterOptionalSequenceString = new FfiConverterOptional(FfiConverter
 const FfiConverterOptionalBoolean = new FfiConverterOptional(FfiConverterBool);
 // FfiConverter for CursorPointOutput | undefined
 const FfiConverterOptionalTypeCursorPointOutput = new FfiConverterOptional(FfiConverterTypeCursorPointOutput);
+// FfiConverter for Array<AppInfo>
+const FfiConverterSequenceTypeAppInfo = new FfiConverterArray(FfiConverterTypeAppInfo);
 // FfiConverter for Array<SessionOutput>
 const FfiConverterSequenceTypeSessionOutput = new FfiConverterArray(FfiConverterTypeSessionOutput);
+// FfiConverter for bigint | undefined
+const FfiConverterOptionalInt64 = new FfiConverterOptional(FfiConverterInt64);
+// FfiConverter for number | undefined
+const FfiConverterOptionalInt32 = new FfiConverterOptional(FfiConverterInt32);
+// FfiConverter for Array<bigint>
+const FfiConverterSequenceUInt64 = new FfiConverterArray(FfiConverterUInt64);
+// FfiConverter for Array<bigint> | undefined
+const FfiConverterOptionalSequenceUInt64 = new FfiConverterOptional(FfiConverterSequenceUInt64);
+// FfiConverter for Array<WindowInfo>
+const FfiConverterSequenceTypeWindowInfo = new FfiConverterArray(FfiConverterTypeWindowInfo);
 // FfiConverter for UnknownReason | undefined
 const FfiConverterOptionalTypeUnknownReason = new FfiConverterOptional(FfiConverterTypeUnknownReason);
 // FfiConverter for ScrollBy | undefined
@@ -2954,6 +3684,16 @@ const FfiConverterOptionalTypeElementPredicate = new FfiConverterOptional(FfiCon
 const FfiConverterSequenceTypeStatePredicate = new FfiConverterArray(FfiConverterTypeStatePredicate);
 // FfiConverter for Array<PredicateOutcome>
 const FfiConverterSequenceTypePredicateOutcome = new FfiConverterArray(FfiConverterTypePredicateOutcome);
+// FfiConverter for ElementFrame | undefined
+const FfiConverterOptionalTypeElementFrame = new FfiConverterOptional(FfiConverterTypeElementFrame);
+// FfiConverter for Array<WindowElement>
+const FfiConverterSequenceTypeWindowElement = new FfiConverterArray(FfiConverterTypeWindowElement);
+// FfiConverter for Array<WindowElement> | undefined
+const FfiConverterOptionalSequenceTypeWindowElement = new FfiConverterOptional(FfiConverterSequenceTypeWindowElement);
+// FfiConverter for WindowBounds | undefined
+const FfiConverterOptionalTypeWindowBounds = new FfiConverterOptional(FfiConverterTypeWindowBounds);
+// FfiConverter for Array<SnapshotImage>
+const FfiConverterSequenceTypeSnapshotImage = new FfiConverterArray(FfiConverterTypeSnapshotImage);
 /**
  * This should be called before anything else.
  *
@@ -2987,10 +3727,12 @@ export default Object.freeze({
         FfiConverterTypeActionResult,
         FfiConverterTypeActionRoute,
         FfiConverterTypeActionTarget,
+        FfiConverterTypeAppInfo,
         FfiConverterTypeBoundsExpectation,
         FfiConverterTypeCaptureScope,
         FfiConverterTypeClickButton,
         FfiConverterTypeClickInput,
+        FfiConverterTypeClickPosition,
         FfiConverterTypeClipboardReadInput,
         FfiConverterTypeClipboardReadOutput,
         FfiConverterTypeClipboardWriteInput,
@@ -3005,6 +3747,7 @@ export default Object.freeze({
         FfiConverterTypeDesktopScope,
         FfiConverterTypeDragInput,
         FfiConverterTypeEffectiveScope,
+        FfiConverterTypeElementFrame,
         FfiConverterTypeElementPredicate,
         FfiConverterTypeElementSelector,
         FfiConverterTypeEndSessionInput,
@@ -3018,10 +3761,16 @@ export default Object.freeze({
         FfiConverterTypeGetScreenSizeInput,
         FfiConverterTypeGetSessionInput,
         FfiConverterTypeGetSessionStateInput,
+        FfiConverterTypeGetWindowStateInput,
         FfiConverterTypeHotkeyInput,
+        FfiConverterTypeInputDeliveryMode,
         FfiConverterTypeInvokeMenuInput,
+        FfiConverterTypeListAppsInput,
+        FfiConverterTypeListAppsOutput,
         FfiConverterTypeListSessionsInput,
         FfiConverterTypeListSessionsOutput,
+        FfiConverterTypeListWindowsInput,
+        FfiConverterTypeListWindowsOutput,
         FfiConverterTypeMoveCursorInput,
         FfiConverterTypePlatform,
         FfiConverterTypePredicateOutcome,
@@ -3041,6 +3790,7 @@ export default Object.freeze({
         FfiConverterTypeSetAgentCursorThemeInput,
         FfiConverterTypeSetAgentCursorThemeOutput,
         FfiConverterTypeSetWindowFrameInput,
+        FfiConverterTypeSnapshotImage,
         FfiConverterTypeStartSessionInput,
         FfiConverterTypeStartSessionOutput,
         FfiConverterTypeStatePredicate,
@@ -3049,6 +3799,10 @@ export default Object.freeze({
         FfiConverterTypeVerificationStatus,
         FfiConverterTypeVerifyStateInput,
         FfiConverterTypeVerifyStateOutput,
+        FfiConverterTypeWindowBounds,
+        FfiConverterTypeWindowElement,
+        FfiConverterTypeWindowInfo,
         FfiConverterTypeWindowPredicate,
+        FfiConverterTypeWindowStateOutput,
     }
 });