@trycua/cua-driver 0.28.2 → 0.28.3

package/dist/native/cua_driver_contract.d.ts

@@ -17,6 +17,21 @@ export declare const ActionDelivery: Readonly<{
     new: (partial: Partial<ActionDelivery> & Required<Omit<ActionDelivery, "deliveredCount">>) => ActionDelivery;
     defaults: () => Partial<ActionDelivery>;
 }>;
+/**
+ * Why a `refused` action sent no input, and what to do instead.
+ */
+export type ActionError = {
+    code: string;
+    hint?: string;
+};
+/**
+ * Generated factory for {@link ActionError} record objects.
+ */
+export declare const ActionError: Readonly<{
+    create: (partial: Partial<ActionError> & Required<Omit<ActionError, "hint">>) => ActionError;
+    new: (partial: Partial<ActionError> & Required<Omit<ActionError, "hint">>) => ActionError;
+    defaults: () => Partial<ActionError>;
+}>;
 export declare enum ActionEscalationTarget {
     Pixel = 0,
     Foreground = 1,
@@ -48,13 +63,18 @@ export declare enum ActionEvidenceKind {
 }
 export type ActionEvidence = {
     kind: ActionEvidenceKind;
+    /**
+     * Human-readable readback the evidence rests on (what changed, which
+     * popup or window appeared and how to target it). Never request data.
+     */
+    detail?: string;
 };
 /**
  * Generated factory for {@link ActionEvidence} record objects.
  */
 export declare const ActionEvidence: Readonly<{
-    create: (partial: Partial<ActionEvidence> & Required<Omit<ActionEvidence, never>>) => ActionEvidence;
-    new: (partial: Partial<ActionEvidence> & Required<Omit<ActionEvidence, never>>) => ActionEvidence;
+    create: (partial: Partial<ActionEvidence> & Required<Omit<ActionEvidence, "detail">>) => ActionEvidence;
+    new: (partial: Partial<ActionEvidence> & Required<Omit<ActionEvidence, "detail">>) => ActionEvidence;
     defaults: () => Partial<ActionEvidence>;
 }>;
 export declare enum ActionEffect {
@@ -78,13 +98,24 @@ export type ActionResult = {
     delivery?: ActionDelivery;
     evidence?: Array<ActionEvidence>;
     escalation?: ActionEscalation;
+    /**
+     * The producer's human summary of what happened (resolved points, the
+     * element hit, popups that opened, focus outcome, follow-up calls).
+     * Clients that read only `structuredContent` still get everything the
+     * text content says.
+     */
+    summary?: string;
+    /**
+     * Present only with `effect: refused`.
+     */
+    error?: ActionError;
 };
 /**
  * Generated factory for {@link ActionResult} record objects.
  */
 export declare const ActionResult: Readonly<{
-    create: (partial: Partial<ActionResult> & Required<Omit<ActionResult, "delivery" | "evidence" | "escalation">>) => ActionResult;
-    new: (partial: Partial<ActionResult> & Required<Omit<ActionResult, "delivery" | "evidence" | "escalation">>) => ActionResult;
+    create: (partial: Partial<ActionResult> & Required<Omit<ActionResult, "delivery" | "evidence" | "escalation" | "summary" | "error">>) => ActionResult;
+    new: (partial: Partial<ActionResult> & Required<Omit<ActionResult, "delivery" | "evidence" | "escalation" | "summary" | "error">>) => ActionResult;
     defaults: () => Partial<ActionResult>;
 }>;
 export type AppInfo = {
@@ -227,7 +258,8 @@ export declare const ActionTarget: Readonly<{
 export type ActionTarget = InstanceType<typeof ActionTarget['Window' | 'Desktop']>;
 export declare enum ClickPosition_Tags {
     Coordinates = "Coordinates",
-    Element = "Element"
+    Element = "Element",
+    CapturedCoordinates = "CapturedCoordinates"
 }
 export declare const ClickPosition: Readonly<{
     instanceOf: (obj: any) => obj is ClickPosition;
@@ -314,8 +346,57 @@ export declare const ClickPosition: Readonly<{
             readonly [uniffiTypeNameSymbol]: "ClickPosition";
         };
     };
+    CapturedCoordinates: {
+        new (inner: {
+            x: number;
+            y: number;
+            captureId: string;
+        }): {
+            readonly tag: ClickPosition_Tags.CapturedCoordinates;
+            readonly inner: Readonly<{
+                x: number;
+                y: number;
+                captureId: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "ClickPosition";
+        };
+        "new"(inner: {
+            x: number;
+            y: number;
+            captureId: string;
+        }): {
+            readonly tag: ClickPosition_Tags.CapturedCoordinates;
+            readonly inner: Readonly<{
+                x: number;
+                y: number;
+                captureId: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "ClickPosition";
+        };
+        instanceOf(obj: any): obj is {
+            readonly tag: ClickPosition_Tags.CapturedCoordinates;
+            readonly inner: Readonly<{
+                x: number;
+                y: number;
+                captureId: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "ClickPosition";
+        };
+    };
 }>;
-export type ClickPosition = InstanceType<typeof ClickPosition['Coordinates' | 'Element']>;
+export type ClickPosition = InstanceType<typeof ClickPosition['Coordinates' | 'Element' | 'CapturedCoordinates']>;
 export declare enum InputDeliveryMode {
     Background = 0,
     Foreground = 1
@@ -695,13 +776,19 @@ export type GetDesktopStateInput = {
      * Write the PNG here instead of returning base64.
      */
     screenshotOutFile?: string;
+    /**
+     * Optional long-edge cap for the returned PNG, in pixels. Omitted or 0
+     * returns the full-size capture. When the cap downsizes the image,
+     * desktop-scope x/y taken from it are mapped back automatically.
+     */
+    maxImageDimension?: number;
 };
 /**
  * Generated factory for {@link GetDesktopStateInput} record objects.
  */
 export declare const GetDesktopStateInput: Readonly<{
-    create: (partial: Partial<GetDesktopStateInput> & Required<Omit<GetDesktopStateInput, "session" | "screenshotOutFile">>) => GetDesktopStateInput;
-    new: (partial: Partial<GetDesktopStateInput> & Required<Omit<GetDesktopStateInput, "session" | "screenshotOutFile">>) => GetDesktopStateInput;
+    create: (partial: Partial<GetDesktopStateInput> & Required<Omit<GetDesktopStateInput, "session" | "screenshotOutFile" | "maxImageDimension">>) => GetDesktopStateInput;
+    new: (partial: Partial<GetDesktopStateInput> & Required<Omit<GetDesktopStateInput, "session" | "screenshotOutFile" | "maxImageDimension">>) => GetDesktopStateInput;
     defaults: () => Partial<GetDesktopStateInput>;
 }>;
 export type GetScreenSizeInput = {
@@ -760,13 +847,24 @@ export type GetWindowStateInput = {
     maxElements?: number;
     maxDepth?: number;
     maxDimension?: number;
+    /**
+     * Optional per-call long-edge ceiling. Zero requests native resolution;
+     * omit it to preserve the configured session or global behavior.
+     */
+    maxImageDimension?: number;
+    /**
+     * Wall-clock budget for the accessibility walk in milliseconds
+     * (default 1000 on every platform). A walk that runs out returns a
+     * partial tree flagged `truncated` rather than failing.
+     */
+    timeoutMs?: number;
 };
 /**
  * Generated factory for {@link GetWindowStateInput} record objects.
  */
 export declare const GetWindowStateInput: Readonly<{
-    create: (partial: Partial<GetWindowStateInput> & Required<Omit<GetWindowStateInput, "session" | "screenshotOutFile" | "query" | "includeAccessibilityTree" | "includeScreenshot" | "maxElements" | "maxDepth" | "maxDimension">>) => GetWindowStateInput;
-    new: (partial: Partial<GetWindowStateInput> & Required<Omit<GetWindowStateInput, "session" | "screenshotOutFile" | "query" | "includeAccessibilityTree" | "includeScreenshot" | "maxElements" | "maxDepth" | "maxDimension">>) => GetWindowStateInput;
+    create: (partial: Partial<GetWindowStateInput> & Required<Omit<GetWindowStateInput, "session" | "screenshotOutFile" | "maxImageDimension" | "query" | "includeAccessibilityTree" | "includeScreenshot" | "maxElements" | "maxDepth" | "maxDimension" | "timeoutMs">>) => GetWindowStateInput;
+    new: (partial: Partial<GetWindowStateInput> & Required<Omit<GetWindowStateInput, "session" | "screenshotOutFile" | "maxImageDimension" | "query" | "includeAccessibilityTree" | "includeScreenshot" | "maxElements" | "maxDepth" | "maxDimension" | "timeoutMs">>) => GetWindowStateInput;
     defaults: () => Partial<GetWindowStateInput>;
 }>;
 export type HotkeyInput = {
@@ -994,6 +1092,411 @@ export declare const MoveCursorInput: Readonly<{
     new: (partial: Partial<MoveCursorInput> & Required<Omit<MoveCursorInput, "target" | "session" | "scope">>) => MoveCursorInput;
     defaults: () => Partial<MoveCursorInput>;
 }>;
+export declare enum VisualRegionKind {
+    Text = 0,
+    Icon = 1
+}
+/**
+ * Optional, model-neutral controls for one bounded parse.
+ */
+export type ParseVisualRegionsOptions = {
+    kinds?: Array<VisualRegionKind>;
+    minConfidence?: number;
+    maxRegions?: number;
+};
+/**
+ * Generated factory for {@link ParseVisualRegionsOptions} record objects.
+ */
+export declare const ParseVisualRegionsOptions: Readonly<{
+    create: (partial: Partial<ParseVisualRegionsOptions> & Required<Omit<ParseVisualRegionsOptions, "kinds" | "minConfidence" | "maxRegions">>) => ParseVisualRegionsOptions;
+    new: (partial: Partial<ParseVisualRegionsOptions> & Required<Omit<ParseVisualRegionsOptions, "kinds" | "minConfidence" | "maxRegions">>) => ParseVisualRegionsOptions;
+    defaults: () => Partial<ParseVisualRegionsOptions>;
+}>;
+/**
+ * Transport-free request. Runtime use requires the future capture registry.
+ */
+export type ParseVisualRegionsInput = {
+    captureId: string;
+    options: ParseVisualRegionsOptions;
+};
+/**
+ * Generated factory for {@link ParseVisualRegionsInput} record objects.
+ */
+export declare const ParseVisualRegionsInput: Readonly<{
+    create: (partial: Partial<ParseVisualRegionsInput> & Required<Omit<ParseVisualRegionsInput, never>>) => ParseVisualRegionsInput;
+    new: (partial: Partial<ParseVisualRegionsInput> & Required<Omit<ParseVisualRegionsInput, never>>) => ParseVisualRegionsInput;
+    defaults: () => Partial<ParseVisualRegionsInput>;
+}>;
+export declare enum VisualCaptureSource_Tags {
+    Window = "Window",
+    PrimaryDesktop = "PrimaryDesktop"
+}
+/**
+ * Exact screen content that produced the immutable capture.
+ */
+export declare const VisualCaptureSource: Readonly<{
+    instanceOf: (obj: any) => obj is VisualCaptureSource;
+    Window: {
+        new (inner: {
+            pid: number;
+            windowId: bigint;
+        }): {
+            readonly tag: VisualCaptureSource_Tags.Window;
+            readonly inner: Readonly<{
+                pid: number;
+                windowId: bigint;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "VisualCaptureSource";
+        };
+        "new"(inner: {
+            pid: number;
+            windowId: bigint;
+        }): {
+            readonly tag: VisualCaptureSource_Tags.Window;
+            readonly inner: Readonly<{
+                pid: number;
+                windowId: bigint;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "VisualCaptureSource";
+        };
+        instanceOf(obj: any): obj is {
+            readonly tag: VisualCaptureSource_Tags.Window;
+            readonly inner: Readonly<{
+                pid: number;
+                windowId: bigint;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "VisualCaptureSource";
+        };
+    };
+    PrimaryDesktop: {
+        new (inner: {
+            displayId: string;
+        }): {
+            readonly tag: VisualCaptureSource_Tags.PrimaryDesktop;
+            readonly inner: Readonly<{
+                displayId: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "VisualCaptureSource";
+        };
+        "new"(inner: {
+            displayId: string;
+        }): {
+            readonly tag: VisualCaptureSource_Tags.PrimaryDesktop;
+            readonly inner: Readonly<{
+                displayId: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "VisualCaptureSource";
+        };
+        instanceOf(obj: any): obj is {
+            readonly tag: VisualCaptureSource_Tags.PrimaryDesktop;
+            readonly inner: Readonly<{
+                displayId: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "VisualCaptureSource";
+        };
+    };
+}>;
+/**
+ * Exact screen content that produced the immutable capture.
+ */
+export type VisualCaptureSource = InstanceType<typeof VisualCaptureSource['Window' | 'PrimaryDesktop']>;
+/**
+ * Screenshot identity and geometry retained by the future capture registry.
+ */
+export type VisualScreenshotReference = {
+    /**
+     * Opaque identity for these exact encoded pixels, such as a content digest.
+     */
+    reference: string;
+    width: number;
+    height: number;
+    mimeType: string;
+    sha256?: string;
+};
+/**
+ * Generated factory for {@link VisualScreenshotReference} record objects.
+ */
+export declare const VisualScreenshotReference: Readonly<{
+    create: (partial: Partial<VisualScreenshotReference> & Required<Omit<VisualScreenshotReference, "sha256">>) => VisualScreenshotReference;
+    new: (partial: Partial<VisualScreenshotReference> & Required<Omit<VisualScreenshotReference, "sha256">>) => VisualScreenshotReference;
+    defaults: () => Partial<VisualScreenshotReference>;
+}>;
+export declare enum VisualActionCoordinateSpace_Tags {
+    ScreenshotPixels = "ScreenshotPixels",
+    Affine = "Affine"
+}
+/**
+ * Normative mapping from source screenshot pixels to Driver action coordinates.
+ *
+ * Screenshot coordinates always originate at the encoded PNG's top-left; X
+ * increases right and Y increases down. The affine form maps a source point
+ * `(px, py)` exactly as:
+ *
+ * `action_x = m11 * px + m12 * py + tx`
+ *
+ * `action_y = m21 * px + m22 * py + ty`
+ */
+export declare const VisualActionCoordinateSpace: Readonly<{
+    instanceOf: (obj: any) => obj is VisualActionCoordinateSpace;
+    ScreenshotPixels: {
+        new (): {
+            readonly tag: VisualActionCoordinateSpace_Tags.ScreenshotPixels;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "VisualActionCoordinateSpace";
+        };
+        "new"(): {
+            readonly tag: VisualActionCoordinateSpace_Tags.ScreenshotPixels;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "VisualActionCoordinateSpace";
+        };
+        instanceOf(obj: any): obj is {
+            readonly tag: VisualActionCoordinateSpace_Tags.ScreenshotPixels;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "VisualActionCoordinateSpace";
+        };
+    };
+    Affine: {
+        new (inner: {
+            m11: number;
+            m12: number;
+            m21: number;
+            m22: number;
+            tx: number;
+            ty: number;
+        }): {
+            readonly tag: VisualActionCoordinateSpace_Tags.Affine;
+            readonly inner: Readonly<{
+                m11: number;
+                m12: number;
+                m21: number;
+                m22: number;
+                tx: number;
+                ty: number;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "VisualActionCoordinateSpace";
+        };
+        "new"(inner: {
+            m11: number;
+            m12: number;
+            m21: number;
+            m22: number;
+            tx: number;
+            ty: number;
+        }): {
+            readonly tag: VisualActionCoordinateSpace_Tags.Affine;
+            readonly inner: Readonly<{
+                m11: number;
+                m12: number;
+                m21: number;
+                m22: number;
+                tx: number;
+                ty: number;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "VisualActionCoordinateSpace";
+        };
+        instanceOf(obj: any): obj is {
+            readonly tag: VisualActionCoordinateSpace_Tags.Affine;
+            readonly inner: Readonly<{
+                m11: number;
+                m12: number;
+                m21: number;
+                m22: number;
+                tx: number;
+                ty: number;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "VisualActionCoordinateSpace";
+        };
+    };
+}>;
+/**
+ * Normative mapping from source screenshot pixels to Driver action coordinates.
+ *
+ * Screenshot coordinates always originate at the encoded PNG's top-left; X
+ * increases right and Y increases down. The affine form maps a source point
+ * `(px, py)` exactly as:
+ *
+ * `action_x = m11 * px + m12 * py + tx`
+ *
+ * `action_y = m21 * px + m22 * py + ty`
+ */
+export type VisualActionCoordinateSpace = InstanceType<typeof VisualActionCoordinateSpace['ScreenshotPixels' | 'Affine']>;
+/**
+ * Immutable capture provenance echoed by a parse result.
+ */
+export type VisualCaptureProvenance = {
+    captureId: string;
+    source: VisualCaptureSource;
+    screenshot: VisualScreenshotReference;
+    actionCoordinateSpace: VisualActionCoordinateSpace;
+    capturedAt?: string;
+};
+/**
+ * Generated factory for {@link VisualCaptureProvenance} record objects.
+ */
+export declare const VisualCaptureProvenance: Readonly<{
+    create: (partial: Partial<VisualCaptureProvenance> & Required<Omit<VisualCaptureProvenance, "capturedAt">>) => VisualCaptureProvenance;
+    new: (partial: Partial<VisualCaptureProvenance> & Required<Omit<VisualCaptureProvenance, "capturedAt">>) => VisualCaptureProvenance;
+    defaults: () => Partial<VisualCaptureProvenance>;
+}>;
+/**
+ * Identity of the extension and model that produced a result.
+ */
+export type VisualParserMetadata = {
+    extensionId: string;
+    extensionVersion: string;
+    modelId: string;
+    modelVersion: string;
+    runtime?: string;
+    backend?: string;
+    modelSourceRevision?: string;
+    modelManifestSha256?: string;
+    onnxRuntimeVersion?: string;
+    onnxRuntimeLibrarySha256?: string;
+    fixtureSha256?: string;
+};
+/**
+ * Generated factory for {@link VisualParserMetadata} record objects.
+ */
+export declare const VisualParserMetadata: Readonly<{
+    create: (partial: Partial<VisualParserMetadata> & Required<Omit<VisualParserMetadata, "runtime" | "backend" | "modelSourceRevision" | "modelManifestSha256" | "onnxRuntimeVersion" | "onnxRuntimeLibrarySha256" | "fixtureSha256">>) => VisualParserMetadata;
+    new: (partial: Partial<VisualParserMetadata> & Required<Omit<VisualParserMetadata, "runtime" | "backend" | "modelSourceRevision" | "modelManifestSha256" | "onnxRuntimeVersion" | "onnxRuntimeLibrarySha256" | "fixtureSha256">>) => VisualParserMetadata;
+    defaults: () => Partial<VisualParserMetadata>;
+}>;
+/**
+ * Integer pixel-edge bounds `[x, x + width) x [y, y + height)`.
+ *
+ * `x` and `y` name the left and top pixel edges. The right and bottom edges
+ * are excluded. A region therefore covers every pixel whose center lies in
+ * this half-open box; its geometric center may lie between pixels.
+ */
+export type VisualRegionBounds = {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+};
+/**
+ * Generated factory for {@link VisualRegionBounds} record objects.
+ */
+export declare const VisualRegionBounds: Readonly<{
+    create: (partial: Partial<VisualRegionBounds> & Required<Omit<VisualRegionBounds, never>>) => VisualRegionBounds;
+    new: (partial: Partial<VisualRegionBounds> & Required<Omit<VisualRegionBounds, never>>) => VisualRegionBounds;
+    defaults: () => Partial<VisualRegionBounds>;
+}>;
+/**
+ * One parser-observed region in the exact source screenshot pixel space.
+ */
+export type VisualRegion = {
+    /**
+     * Stable identifier unique within this parse result.
+     */
+    id: string;
+    kind: VisualRegionKind;
+    bounds: VisualRegionBounds;
+    text?: string;
+    label?: string;
+    confidence: number;
+    interactive: boolean;
+    parentId?: string;
+    groupId?: string;
+    readingOrder?: number;
+};
+/**
+ * Generated factory for {@link VisualRegion} record objects.
+ */
+export declare const VisualRegion: Readonly<{
+    create: (partial: Partial<VisualRegion> & Required<Omit<VisualRegion, "text" | "label" | "parentId" | "groupId" | "readingOrder">>) => VisualRegion;
+    new: (partial: Partial<VisualRegion> & Required<Omit<VisualRegion, "text" | "label" | "parentId" | "groupId" | "readingOrder">>) => VisualRegion;
+    defaults: () => Partial<VisualRegion>;
+}>;
+export type VisualParseWarning = {
+    code: string;
+    message: string;
+    detail?: string;
+};
+/**
+ * Generated factory for {@link VisualParseWarning} record objects.
+ */
+export declare const VisualParseWarning: Readonly<{
+    create: (partial: Partial<VisualParseWarning> & Required<Omit<VisualParseWarning, "detail">>) => VisualParseWarning;
+    new: (partial: Partial<VisualParseWarning> & Required<Omit<VisualParseWarning, "detail">>) => VisualParseWarning;
+    defaults: () => Partial<VisualParseWarning>;
+}>;
+export type VisualParseTiming = {
+    durationMs: bigint;
+    preprocessMs?: bigint;
+    inferenceMs?: bigint;
+};
+/**
+ * Generated factory for {@link VisualParseTiming} record objects.
+ */
+export declare const VisualParseTiming: Readonly<{
+    create: (partial: Partial<VisualParseTiming> & Required<Omit<VisualParseTiming, "preprocessMs" | "inferenceMs">>) => VisualParseTiming;
+    new: (partial: Partial<VisualParseTiming> & Required<Omit<VisualParseTiming, "preprocessMs" | "inferenceMs">>) => VisualParseTiming;
+    defaults: () => Partial<VisualParseTiming>;
+}>;
+export type ParseVisualRegionsOutput = {
+    schema: string;
+    capture: VisualCaptureProvenance;
+    parser: VisualParserMetadata;
+    regions: Array<VisualRegion>;
+    warnings: Array<VisualParseWarning>;
+    timing: VisualParseTiming;
+    requestId?: string;
+};
+/**
+ * Generated factory for {@link ParseVisualRegionsOutput} record objects.
+ */
+export declare const ParseVisualRegionsOutput: Readonly<{
+    create: (partial: Partial<ParseVisualRegionsOutput> & Required<Omit<ParseVisualRegionsOutput, "requestId">>) => ParseVisualRegionsOutput;
+    new: (partial: Partial<ParseVisualRegionsOutput> & Required<Omit<ParseVisualRegionsOutput, "requestId">>) => ParseVisualRegionsOutput;
+    defaults: () => Partial<ParseVisualRegionsOutput>;
+}>;
 export declare enum VerificationStatus {
     Satisfied = 0,
     Unsatisfied = 1,
@@ -1376,6 +1879,41 @@ export declare const VerifyStateOutput: Readonly<{
     new: (partial: Partial<VerifyStateOutput> & Required<Omit<VerifyStateOutput, never>>) => VerifyStateOutput;
     defaults: () => Partial<VerifyStateOutput>;
 }>;
+/**
+ * Stable machine-readable failures for capture lookup and visual parsing.
+ */
+export declare enum VisualParseErrorCode {
+    NotInstalled = 0,
+    CaptureNotFound = 1,
+    CaptureExpired = 2,
+    CaptureStale = 3,
+    CaptureGenerationMismatch = 4,
+    UnsupportedTarget = 5,
+    UnsupportedPlatform = 6,
+    IncompatibleProtocol = 7,
+    InvalidFrame = 8,
+    WorkerLaunchFailed = 9,
+    WorkerCrashed = 10,
+    WorkerCancelled = 11,
+    Timeout = 12,
+    ResourceLimitExceeded = 13,
+    ArtifactInvalid = 14,
+    InferenceFailed = 15
+}
+export type VisualParseError = {
+    code: VisualParseErrorCode;
+    message: string;
+    retryable: boolean;
+    detail?: string;
+};
+/**
+ * Generated factory for {@link VisualParseError} record objects.
+ */
+export declare const VisualParseError: Readonly<{
+    create: (partial: Partial<VisualParseError> & Required<Omit<VisualParseError, "detail">>) => VisualParseError;
+    new: (partial: Partial<VisualParseError> & Required<Omit<VisualParseError, "detail">>) => VisualParseError;
+    defaults: () => Partial<VisualParseError>;
+}>;
 export type WindowElement = {
     elementIndex: bigint;
     role: string;
@@ -1478,6 +2016,13 @@ declare const _default: Readonly<{
             lift(value: UniffiByteArray): ActionEffect;
             lower(value: ActionEffect, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
         };
+        FfiConverterTypeActionError: {
+            read(from: RustBuffer): ActionError;
+            write(value: ActionError, into: RustBuffer): void;
+            allocationSize(value: ActionError): number;
+            lift(value: UniffiByteArray): ActionError;
+            lower(value: ActionError, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
+        };
         FfiConverterTypeActionEscalation: {
             read(from: RustBuffer): ActionEscalation;
             write(value: ActionEscalation, into: RustBuffer): void;
@@ -1849,6 +2394,27 @@ declare const _default: Readonly<{
             lift(value: UniffiByteArray): MoveCursorInput;
             lower(value: MoveCursorInput, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
         };
+        FfiConverterTypeParseVisualRegionsInput: {
+            read(from: RustBuffer): ParseVisualRegionsInput;
+            write(value: ParseVisualRegionsInput, into: RustBuffer): void;
+            allocationSize(value: ParseVisualRegionsInput): number;
+            lift(value: UniffiByteArray): ParseVisualRegionsInput;
+            lower(value: ParseVisualRegionsInput, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
+        };
+        FfiConverterTypeParseVisualRegionsOptions: {
+            read(from: RustBuffer): ParseVisualRegionsOptions;
+            write(value: ParseVisualRegionsOptions, into: RustBuffer): void;
+            allocationSize(value: ParseVisualRegionsOptions): number;
+            lift(value: UniffiByteArray): ParseVisualRegionsOptions;
+            lower(value: ParseVisualRegionsOptions, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
+        };
+        FfiConverterTypeParseVisualRegionsOutput: {
+            read(from: RustBuffer): ParseVisualRegionsOutput;
+            write(value: ParseVisualRegionsOutput, into: RustBuffer): void;
+            allocationSize(value: ParseVisualRegionsOutput): number;
+            lift(value: UniffiByteArray): ParseVisualRegionsOutput;
+            lower(value: ParseVisualRegionsOutput, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
+        };
         FfiConverterTypePlatform: {
             read(from: RustBuffer): Platform;
             write(value: Platform, into: RustBuffer): void;
@@ -2038,6 +2604,90 @@ declare const _default: Readonly<{
             lift(value: UniffiByteArray): VerifyStateOutput;
             lower(value: VerifyStateOutput, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
         };
+        FfiConverterTypeVisualActionCoordinateSpace: {
+            read(from: RustBuffer): VisualActionCoordinateSpace;
+            write(value: VisualActionCoordinateSpace, into: RustBuffer): void;
+            allocationSize(value: VisualActionCoordinateSpace): number;
+            lift(value: UniffiByteArray): VisualActionCoordinateSpace;
+            lower(value: VisualActionCoordinateSpace, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
+        };
+        FfiConverterTypeVisualCaptureProvenance: {
+            read(from: RustBuffer): VisualCaptureProvenance;
+            write(value: VisualCaptureProvenance, into: RustBuffer): void;
+            allocationSize(value: VisualCaptureProvenance): number;
+            lift(value: UniffiByteArray): VisualCaptureProvenance;
+            lower(value: VisualCaptureProvenance, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
+        };
+        FfiConverterTypeVisualCaptureSource: {
+            read(from: RustBuffer): VisualCaptureSource;
+            write(value: VisualCaptureSource, into: RustBuffer): void;
+            allocationSize(value: VisualCaptureSource): number;
+            lift(value: UniffiByteArray): VisualCaptureSource;
+            lower(value: VisualCaptureSource, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
+        };
+        FfiConverterTypeVisualParseError: {
+            read(from: RustBuffer): VisualParseError;
+            write(value: VisualParseError, into: RustBuffer): void;
+            allocationSize(value: VisualParseError): number;
+            lift(value: UniffiByteArray): VisualParseError;
+            lower(value: VisualParseError, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
+        };
+        FfiConverterTypeVisualParseErrorCode: {
+            read(from: RustBuffer): VisualParseErrorCode;
+            write(value: VisualParseErrorCode, into: RustBuffer): void;
+            allocationSize(value: VisualParseErrorCode): number;
+            lift(value: UniffiByteArray): VisualParseErrorCode;
+            lower(value: VisualParseErrorCode, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
+        };
+        FfiConverterTypeVisualParseTiming: {
+            read(from: RustBuffer): VisualParseTiming;
+            write(value: VisualParseTiming, into: RustBuffer): void;
+            allocationSize(value: VisualParseTiming): number;
+            lift(value: UniffiByteArray): VisualParseTiming;
+            lower(value: VisualParseTiming, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
+        };
+        FfiConverterTypeVisualParseWarning: {
+            read(from: RustBuffer): VisualParseWarning;
+            write(value: VisualParseWarning, into: RustBuffer): void;
+            allocationSize(value: VisualParseWarning): number;
+            lift(value: UniffiByteArray): VisualParseWarning;
+            lower(value: VisualParseWarning, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
+        };
+        FfiConverterTypeVisualParserMetadata: {
+            read(from: RustBuffer): VisualParserMetadata;
+            write(value: VisualParserMetadata, into: RustBuffer): void;
+            allocationSize(value: VisualParserMetadata): number;
+            lift(value: UniffiByteArray): VisualParserMetadata;
+            lower(value: VisualParserMetadata, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
+        };
+        FfiConverterTypeVisualRegion: {
+            read(from: RustBuffer): VisualRegion;
+            write(value: VisualRegion, into: RustBuffer): void;
+            allocationSize(value: VisualRegion): number;
+            lift(value: UniffiByteArray): VisualRegion;
+            lower(value: VisualRegion, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
+        };
+        FfiConverterTypeVisualRegionBounds: {
+            read(from: RustBuffer): VisualRegionBounds;
+            write(value: VisualRegionBounds, into: RustBuffer): void;
+            allocationSize(value: VisualRegionBounds): number;
+            lift(value: UniffiByteArray): VisualRegionBounds;
+            lower(value: VisualRegionBounds, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
+        };
+        FfiConverterTypeVisualRegionKind: {
+            read(from: RustBuffer): VisualRegionKind;
+            write(value: VisualRegionKind, into: RustBuffer): void;
+            allocationSize(value: VisualRegionKind): number;
+            lift(value: UniffiByteArray): VisualRegionKind;
+            lower(value: VisualRegionKind, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
+        };
+        FfiConverterTypeVisualScreenshotReference: {
+            read(from: RustBuffer): VisualScreenshotReference;
+            write(value: VisualScreenshotReference, into: RustBuffer): void;
+            allocationSize(value: VisualScreenshotReference): number;
+            lift(value: UniffiByteArray): VisualScreenshotReference;
+            lower(value: VisualScreenshotReference, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
+        };
         FfiConverterTypeWindowBounds: {
             read(from: RustBuffer): WindowBounds;
             write(value: WindowBounds, into: RustBuffer): void;