@trycua/cua-driver 0.14.1 → 0.16.0

package/dist/native/cua_driver_contract.d.ts

@@ -1,4 +1,107 @@
 import { type UniffiByteArray, RustBuffer } from "@ubjs/core";
+export declare enum ActionDeliveryMode {
+    Background = 0,
+    Foreground = 1,
+    NotApplicable = 2,
+    Unknown = 3
+}
+export type ActionDelivery = {
+    mode: ActionDeliveryMode;
+    deliveredCount?: number;
+};
+/**
+ * Generated factory for {@link ActionDelivery} record objects.
+ */
+export declare const ActionDelivery: Readonly<{
+    create: (partial: Partial<ActionDelivery> & Required<Omit<ActionDelivery, "deliveredCount">>) => ActionDelivery;
+    new: (partial: Partial<ActionDelivery> & Required<Omit<ActionDelivery, "deliveredCount">>) => ActionDelivery;
+    defaults: () => Partial<ActionDelivery>;
+}>;
+export declare enum ActionEscalationTarget {
+    Pixel = 0,
+    Foreground = 1,
+    Page = 2,
+    Session = 3
+}
+export declare enum ActionEscalationReason {
+    RouteUnavailable = 0,
+    DeliveryFailed = 1,
+    EffectUnconfirmed = 2,
+    SuspectedNoop = 3,
+    PermissionRequired = 4
+}
+export type ActionEscalation = {
+    target: ActionEscalationTarget;
+    reason: ActionEscalationReason;
+};
+/**
+ * Generated factory for {@link ActionEscalation} record objects.
+ */
+export declare const ActionEscalation: Readonly<{
+    create: (partial: Partial<ActionEscalation> & Required<Omit<ActionEscalation, never>>) => ActionEscalation;
+    new: (partial: Partial<ActionEscalation> & Required<Omit<ActionEscalation, never>>) => ActionEscalation;
+    defaults: () => Partial<ActionEscalation>;
+}>;
+export declare enum ActionEvidenceKind {
+    ValueReadback = 0,
+    WindowChange = 1
+}
+export type ActionEvidence = {
+    kind: ActionEvidenceKind;
+};
+/**
+ * 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;
+    defaults: () => Partial<ActionEvidence>;
+}>;
+export declare enum ActionEffect {
+    Confirmed = 0,
+    Partial = 1,
+    Unverifiable = 2,
+    SuspectedNoop = 3,
+    Refused = 4
+}
+export declare enum ActionRoute {
+    Accessibility = 0,
+    SyntheticEvents = 1,
+    GlobalInput = 2,
+    SystemApi = 3,
+    Dom = 4,
+    TrustedInput = 5
+}
+export type ActionResult = {
+    effect: ActionEffect;
+    route: ActionRoute;
+    delivery?: ActionDelivery;
+    evidence?: Array<ActionEvidence>;
+    escalation?: ActionEscalation;
+};
+/**
+ * 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;
+    defaults: () => Partial<ActionResult>;
+}>;
+export type BoundsExpectation = {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    tolerancePx?: number;
+};
+/**
+ * Generated factory for {@link BoundsExpectation} record objects.
+ */
+export declare const BoundsExpectation: Readonly<{
+    create: (partial: Partial<BoundsExpectation> & Required<Omit<BoundsExpectation, "tolerancePx">>) => BoundsExpectation;
+    new: (partial: Partial<BoundsExpectation> & Required<Omit<BoundsExpectation, "tolerancePx">>) => BoundsExpectation;
+    defaults: () => Partial<BoundsExpectation>;
+}>;
 export declare enum DesktopScope {
     Desktop = 0
 }
@@ -26,6 +129,81 @@ export declare const ClickInput: Readonly<{
     new: (partial: Partial<ClickInput> & Required<Omit<ClickInput, "session" | "button" | "count">>) => ClickInput;
     defaults: () => Partial<ClickInput>;
 }>;
+export type ClipboardReadInput = {
+    /**
+     * Return plain-text clipboard content in addition to the available types.
+     * Clipboard content is privacy-sensitive and is never retained in telemetry.
+     */
+    includeText: boolean;
+    /**
+     * Optional session id.
+     */
+    session?: string;
+};
+/**
+ * Generated factory for {@link ClipboardReadInput} record objects.
+ */
+export declare const ClipboardReadInput: Readonly<{
+    create: (partial: Partial<ClipboardReadInput> & Required<Omit<ClipboardReadInput, "session">>) => ClipboardReadInput;
+    new: (partial: Partial<ClipboardReadInput> & Required<Omit<ClipboardReadInput, "session">>) => ClipboardReadInput;
+    defaults: () => Partial<ClipboardReadInput>;
+}>;
+export type ClipboardReadOutput = {
+    supported: boolean;
+    types: Array<string>;
+    text?: string;
+    privacySensitive: boolean;
+    contentRedactedFromTelemetry: boolean;
+};
+/**
+ * Generated factory for {@link ClipboardReadOutput} record objects.
+ */
+export declare const ClipboardReadOutput: Readonly<{
+    create: (partial: Partial<ClipboardReadOutput> & Required<Omit<ClipboardReadOutput, "text">>) => ClipboardReadOutput;
+    new: (partial: Partial<ClipboardReadOutput> & Required<Omit<ClipboardReadOutput, "text">>) => ClipboardReadOutput;
+    defaults: () => Partial<ClipboardReadOutput>;
+}>;
+export type ClipboardWriteInput = {
+    /**
+     * Plain text to place on the clipboard.
+     */
+    text?: string;
+    /**
+     * Absolute path to a local image to place on the clipboard.
+     */
+    imagePath?: string;
+    /**
+     * Absolute path to a local file to place on the clipboard as a file URL.
+     */
+    filePath?: string;
+    /**
+     * Optional session id.
+     */
+    session?: string;
+};
+/**
+ * Generated factory for {@link ClipboardWriteInput} record objects.
+ */
+export declare const ClipboardWriteInput: Readonly<{
+    create: (partial: Partial<ClipboardWriteInput> & Required<Omit<ClipboardWriteInput, "session" | "text" | "imagePath" | "filePath">>) => ClipboardWriteInput;
+    new: (partial: Partial<ClipboardWriteInput> & Required<Omit<ClipboardWriteInput, "session" | "text" | "imagePath" | "filePath">>) => ClipboardWriteInput;
+    defaults: () => Partial<ClipboardWriteInput>;
+}>;
+export type ClipboardWriteOutput = {
+    supported: boolean;
+    writtenType: string;
+    types: Array<string>;
+    privacySensitive: boolean;
+    contentRedactedFromTelemetry: boolean;
+};
+/**
+ * Generated factory for {@link ClipboardWriteOutput} record objects.
+ */
+export declare const ClipboardWriteOutput: Readonly<{
+    create: (partial: Partial<ClipboardWriteOutput> & Required<Omit<ClipboardWriteOutput, never>>) => ClipboardWriteOutput;
+    new: (partial: Partial<ClipboardWriteOutput> & Required<Omit<ClipboardWriteOutput, never>>) => ClipboardWriteOutput;
+    defaults: () => Partial<ClipboardWriteOutput>;
+}>;
 export type CursorMotionOutput = {
     startHandle: number;
     endHandle: number;
@@ -142,6 +320,40 @@ export declare const DragInput: Readonly<{
     new: (partial: Partial<DragInput> & Required<Omit<DragInput, "session" | "button" | "durationMs" | "steps" | "modifier">>) => DragInput;
     defaults: () => Partial<DragInput>;
 }>;
+export type ElementSelector = {
+    role?: string;
+    labelContains?: string;
+};
+/**
+ * Generated factory for {@link ElementSelector} record objects.
+ */
+export declare const ElementSelector: Readonly<{
+    create: (partial: Partial<ElementSelector> & Required<Omit<ElementSelector, "role" | "labelContains">>) => ElementSelector;
+    new: (partial: Partial<ElementSelector> & Required<Omit<ElementSelector, "role" | "labelContains">>) => ElementSelector;
+    defaults: () => Partial<ElementSelector>;
+}>;
+export type ElementPredicate = {
+    selector: ElementSelector;
+    /**
+     * Assert that at least one trusted element matches the selector.
+     *
+     * Element walks are not yet exhaustive on every platform, so absence
+     * cannot be proven. `false` is rejected instead of returning an
+     * indefinitely-unknown predicate.
+     */
+    exists?: boolean;
+    valueEquals?: string;
+    enabled?: boolean;
+    selected?: boolean;
+};
+/**
+ * Generated factory for {@link ElementPredicate} record objects.
+ */
+export declare const ElementPredicate: Readonly<{
+    create: (partial: Partial<ElementPredicate> & Required<Omit<ElementPredicate, "exists" | "valueEquals" | "enabled" | "selected">>) => ElementPredicate;
+    new: (partial: Partial<ElementPredicate> & Required<Omit<ElementPredicate, "exists" | "valueEquals" | "enabled" | "selected">>) => ElementPredicate;
+    defaults: () => Partial<ElementPredicate>;
+}>;
 export type EndSessionInput = {
     /**
      * The session id to end.
@@ -311,6 +523,37 @@ export declare const MoveCursorInput: Readonly<{
     new: (partial: Partial<MoveCursorInput> & Required<Omit<MoveCursorInput, "session">>) => MoveCursorInput;
     defaults: () => Partial<MoveCursorInput>;
 }>;
+export declare enum VerificationStatus {
+    Satisfied = 0,
+    Unsatisfied = 1,
+    Unknown = 2
+}
+export declare enum UnknownReason {
+    InvalidPredicate = 0,
+    UnsupportedPredicate = 1,
+    UntrustedSource = 2,
+    MultiMatch = 3,
+    TargetMissing = 4,
+    ObservationUnavailable = 5,
+    StabilityUnproven = 6
+}
+export type PredicateOutcome = {
+    index: bigint;
+    status: VerificationStatus;
+    unknownReason?: UnknownReason;
+    /**
+     * Normalized, bounded JSON projection of the matched state.
+     */
+    observedJson?: string;
+};
+/**
+ * Generated factory for {@link PredicateOutcome} record objects.
+ */
+export declare const PredicateOutcome: Readonly<{
+    create: (partial: Partial<PredicateOutcome> & Required<Omit<PredicateOutcome, "unknownReason" | "observedJson">>) => PredicateOutcome;
+    new: (partial: Partial<PredicateOutcome> & Required<Omit<PredicateOutcome, "unknownReason" | "observedJson">>) => PredicateOutcome;
+    defaults: () => Partial<PredicateOutcome>;
+}>;
 export type PressKeyInput = {
     key: string;
     scope: DesktopScope;
@@ -467,6 +710,26 @@ export declare const SetAgentCursorThemeOutput: Readonly<{
     new: (partial: Partial<SetAgentCursorThemeOutput> & Required<Omit<SetAgentCursorThemeOutput, never>>) => SetAgentCursorThemeOutput;
     defaults: () => Partial<SetAgentCursorThemeOutput>;
 }>;
+export type SetWindowFrameInput = {
+    pid: number;
+    windowId: bigint;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    /**
+     * Optional session id.
+     */
+    session?: string;
+};
+/**
+ * Generated factory for {@link SetWindowFrameInput} record objects.
+ */
+export declare const SetWindowFrameInput: Readonly<{
+    create: (partial: Partial<SetWindowFrameInput> & Required<Omit<SetWindowFrameInput, "session">>) => SetWindowFrameInput;
+    new: (partial: Partial<SetWindowFrameInput> & Required<Omit<SetWindowFrameInput, "session">>) => SetWindowFrameInput;
+    defaults: () => Partial<SetWindowFrameInput>;
+}>;
 export type StartSessionInput = {
     /**
      * Stable session id for this run (e.g. "research-run-1").
@@ -506,6 +769,30 @@ export declare const StartSessionOutput: Readonly<{
     new: (partial: Partial<StartSessionOutput> & Required<Omit<StartSessionOutput, never>>) => StartSessionOutput;
     defaults: () => Partial<StartSessionOutput>;
 }>;
+export type WindowPredicate = {
+    exists?: boolean;
+    bounds?: BoundsExpectation;
+};
+/**
+ * Generated factory for {@link WindowPredicate} record objects.
+ */
+export declare const WindowPredicate: Readonly<{
+    create: (partial: Partial<WindowPredicate> & Required<Omit<WindowPredicate, "exists" | "bounds">>) => WindowPredicate;
+    new: (partial: Partial<WindowPredicate> & Required<Omit<WindowPredicate, "exists" | "bounds">>) => WindowPredicate;
+    defaults: () => Partial<WindowPredicate>;
+}>;
+export type StatePredicate = {
+    window?: WindowPredicate;
+    element?: ElementPredicate;
+};
+/**
+ * Generated factory for {@link StatePredicate} record objects.
+ */
+export declare const StatePredicate: Readonly<{
+    create: (partial: Partial<StatePredicate> & Required<Omit<StatePredicate, "window" | "element">>) => StatePredicate;
+    new: (partial: Partial<StatePredicate> & Required<Omit<StatePredicate, "window" | "element">>) => StatePredicate;
+    defaults: () => Partial<StatePredicate>;
+}>;
 export type TypeTextInput = {
     text: string;
     scope: DesktopScope;
@@ -522,6 +809,60 @@ export declare const TypeTextInput: Readonly<{
     new: (partial: Partial<TypeTextInput> & Required<Omit<TypeTextInput, "session">>) => TypeTextInput;
     defaults: () => Partial<TypeTextInput>;
 }>;
+export type VerifyStateInput = {
+    /**
+     * Exact process whose window may be observed.
+     */
+    pid: bigint;
+    /**
+     * Exact native window identifier.
+     */
+    windowId: bigint;
+    /**
+     * One to eight predicates, combined with logical AND.
+     */
+    expect: Array<StatePredicate>;
+    /**
+     * Optional session id for capture-scope and authorization continuity.
+     */
+    session?: string;
+    /**
+     * Bounded wait. Zero performs one sample.
+     */
+    timeoutMs?: bigint;
+    /**
+     * Consecutive satisfied samples required before returning success.
+     */
+    stableSamples?: bigint;
+    /**
+     * Return the final window screenshot as image content for a multimodal
+     * caller. The driver does not interpret that image.
+     */
+    includeScreenshot?: boolean;
+};
+/**
+ * Generated factory for {@link VerifyStateInput} record objects.
+ */
+export declare const VerifyStateInput: Readonly<{
+    create: (partial: Partial<VerifyStateInput> & Required<Omit<VerifyStateInput, "session" | "timeoutMs" | "stableSamples" | "includeScreenshot">>) => VerifyStateInput;
+    new: (partial: Partial<VerifyStateInput> & Required<Omit<VerifyStateInput, "session" | "timeoutMs" | "stableSamples" | "includeScreenshot">>) => VerifyStateInput;
+    defaults: () => Partial<VerifyStateInput>;
+}>;
+export type VerifyStateOutput = {
+    status: VerificationStatus;
+    stable: boolean;
+    elapsedMs: bigint;
+    samples: bigint;
+    predicates: Array<PredicateOutcome>;
+};
+/**
+ * Generated factory for {@link VerifyStateOutput} record objects.
+ */
+export declare const VerifyStateOutput: Readonly<{
+    create: (partial: Partial<VerifyStateOutput> & Required<Omit<VerifyStateOutput, never>>) => VerifyStateOutput;
+    new: (partial: Partial<VerifyStateOutput> & Required<Omit<VerifyStateOutput, never>>) => VerifyStateOutput;
+    defaults: () => Partial<VerifyStateOutput>;
+}>;
 export declare enum Platform {
     Macos = 0,
     Windows = 1,
@@ -541,6 +882,83 @@ declare function uniffiEnsureInitialized(): void;
 declare const _default: Readonly<{
     initialize: typeof uniffiEnsureInitialized;
     converters: {
+        FfiConverterTypeActionDelivery: {
+            read(from: RustBuffer): ActionDelivery;
+            write(value: ActionDelivery, into: RustBuffer): void;
+            allocationSize(value: ActionDelivery): number;
+            lift(value: UniffiByteArray): ActionDelivery;
+            lower(value: ActionDelivery, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
+        };
+        FfiConverterTypeActionDeliveryMode: {
+            read(from: RustBuffer): ActionDeliveryMode;
+            write(value: ActionDeliveryMode, into: RustBuffer): void;
+            allocationSize(value: ActionDeliveryMode): number;
+            lift(value: UniffiByteArray): ActionDeliveryMode;
+            lower(value: ActionDeliveryMode, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
+        };
+        FfiConverterTypeActionEffect: {
+            read(from: RustBuffer): ActionEffect;
+            write(value: ActionEffect, into: RustBuffer): void;
+            allocationSize(value: ActionEffect): number;
+            lift(value: UniffiByteArray): ActionEffect;
+            lower(value: ActionEffect, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
+        };
+        FfiConverterTypeActionEscalation: {
+            read(from: RustBuffer): ActionEscalation;
+            write(value: ActionEscalation, into: RustBuffer): void;
+            allocationSize(value: ActionEscalation): number;
+            lift(value: UniffiByteArray): ActionEscalation;
+            lower(value: ActionEscalation, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
+        };
+        FfiConverterTypeActionEscalationReason: {
+            read(from: RustBuffer): ActionEscalationReason;
+            write(value: ActionEscalationReason, into: RustBuffer): void;
+            allocationSize(value: ActionEscalationReason): number;
+            lift(value: UniffiByteArray): ActionEscalationReason;
+            lower(value: ActionEscalationReason, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
+        };
+        FfiConverterTypeActionEscalationTarget: {
+            read(from: RustBuffer): ActionEscalationTarget;
+            write(value: ActionEscalationTarget, into: RustBuffer): void;
+            allocationSize(value: ActionEscalationTarget): number;
+            lift(value: UniffiByteArray): ActionEscalationTarget;
+            lower(value: ActionEscalationTarget, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
+        };
+        FfiConverterTypeActionEvidence: {
+            read(from: RustBuffer): ActionEvidence;
+            write(value: ActionEvidence, into: RustBuffer): void;
+            allocationSize(value: ActionEvidence): number;
+            lift(value: UniffiByteArray): ActionEvidence;
+            lower(value: ActionEvidence, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
+        };
+        FfiConverterTypeActionEvidenceKind: {
+            read(from: RustBuffer): ActionEvidenceKind;
+            write(value: ActionEvidenceKind, into: RustBuffer): void;
+            allocationSize(value: ActionEvidenceKind): number;
+            lift(value: UniffiByteArray): ActionEvidenceKind;
+            lower(value: ActionEvidenceKind, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
+        };
+        FfiConverterTypeActionResult: {
+            read(from: RustBuffer): ActionResult;
+            write(value: ActionResult, into: RustBuffer): void;
+            allocationSize(value: ActionResult): number;
+            lift(value: UniffiByteArray): ActionResult;
+            lower(value: ActionResult, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
+        };
+        FfiConverterTypeActionRoute: {
+            read(from: RustBuffer): ActionRoute;
+            write(value: ActionRoute, into: RustBuffer): void;
+            allocationSize(value: ActionRoute): number;
+            lift(value: UniffiByteArray): ActionRoute;
+            lower(value: ActionRoute, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
+        };
+        FfiConverterTypeBoundsExpectation: {
+            read(from: RustBuffer): BoundsExpectation;
+            write(value: BoundsExpectation, into: RustBuffer): void;
+            allocationSize(value: BoundsExpectation): number;
+            lift(value: UniffiByteArray): BoundsExpectation;
+            lower(value: BoundsExpectation, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
+        };
         FfiConverterTypeCaptureScope: {
             read(from: RustBuffer): CaptureScope;
             write(value: CaptureScope, into: RustBuffer): void;
@@ -562,6 +980,34 @@ declare const _default: Readonly<{
             lift(value: UniffiByteArray): ClickInput;
             lower(value: ClickInput, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
         };
+        FfiConverterTypeClipboardReadInput: {
+            read(from: RustBuffer): ClipboardReadInput;
+            write(value: ClipboardReadInput, into: RustBuffer): void;
+            allocationSize(value: ClipboardReadInput): number;
+            lift(value: UniffiByteArray): ClipboardReadInput;
+            lower(value: ClipboardReadInput, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
+        };
+        FfiConverterTypeClipboardReadOutput: {
+            read(from: RustBuffer): ClipboardReadOutput;
+            write(value: ClipboardReadOutput, into: RustBuffer): void;
+            allocationSize(value: ClipboardReadOutput): number;
+            lift(value: UniffiByteArray): ClipboardReadOutput;
+            lower(value: ClipboardReadOutput, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
+        };
+        FfiConverterTypeClipboardWriteInput: {
+            read(from: RustBuffer): ClipboardWriteInput;
+            write(value: ClipboardWriteInput, into: RustBuffer): void;
+            allocationSize(value: ClipboardWriteInput): number;
+            lift(value: UniffiByteArray): ClipboardWriteInput;
+            lower(value: ClipboardWriteInput, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
+        };
+        FfiConverterTypeClipboardWriteOutput: {
+            read(from: RustBuffer): ClipboardWriteOutput;
+            write(value: ClipboardWriteOutput, into: RustBuffer): void;
+            allocationSize(value: ClipboardWriteOutput): number;
+            lift(value: UniffiByteArray): ClipboardWriteOutput;
+            lower(value: ClipboardWriteOutput, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
+        };
         FfiConverterTypeCursorAction: {
             read(from: RustBuffer): CursorAction;
             write(value: CursorAction, into: RustBuffer): void;
@@ -632,6 +1078,20 @@ declare const _default: Readonly<{
             lift(value: UniffiByteArray): EffectiveScope;
             lower(value: EffectiveScope, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
         };
+        FfiConverterTypeElementPredicate: {
+            read(from: RustBuffer): ElementPredicate;
+            write(value: ElementPredicate, into: RustBuffer): void;
+            allocationSize(value: ElementPredicate): number;
+            lift(value: UniffiByteArray): ElementPredicate;
+            lower(value: ElementPredicate, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
+        };
+        FfiConverterTypeElementSelector: {
+            read(from: RustBuffer): ElementSelector;
+            write(value: ElementSelector, into: RustBuffer): void;
+            allocationSize(value: ElementSelector): number;
+            lift(value: UniffiByteArray): ElementSelector;
+            lower(value: ElementSelector, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
+        };
         FfiConverterTypeEndSessionInput: {
             read(from: RustBuffer): EndSessionInput;
             write(value: EndSessionInput, into: RustBuffer): void;
@@ -723,6 +1183,13 @@ declare const _default: Readonly<{
             lift(value: UniffiByteArray): Platform;
             lower(value: Platform, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
         };
+        FfiConverterTypePredicateOutcome: {
+            read(from: RustBuffer): PredicateOutcome;
+            write(value: PredicateOutcome, into: RustBuffer): void;
+            allocationSize(value: PredicateOutcome): number;
+            lift(value: UniffiByteArray): PredicateOutcome;
+            lower(value: PredicateOutcome, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
+        };
         FfiConverterTypePressKeyInput: {
             read(from: RustBuffer): PressKeyInput;
             write(value: PressKeyInput, into: RustBuffer): void;
@@ -800,6 +1267,13 @@ declare const _default: Readonly<{
             lift(value: UniffiByteArray): SetAgentCursorThemeOutput;
             lower(value: SetAgentCursorThemeOutput, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
         };
+        FfiConverterTypeSetWindowFrameInput: {
+            read(from: RustBuffer): SetWindowFrameInput;
+            write(value: SetWindowFrameInput, into: RustBuffer): void;
+            allocationSize(value: SetWindowFrameInput): number;
+            lift(value: UniffiByteArray): SetWindowFrameInput;
+            lower(value: SetWindowFrameInput, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
+        };
         FfiConverterTypeStartSessionInput: {
             read(from: RustBuffer): StartSessionInput;
             write(value: StartSessionInput, into: RustBuffer): void;
@@ -814,6 +1288,13 @@ declare const _default: Readonly<{
             lift(value: UniffiByteArray): StartSessionOutput;
             lower(value: StartSessionOutput, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
         };
+        FfiConverterTypeStatePredicate: {
+            read(from: RustBuffer): StatePredicate;
+            write(value: StatePredicate, into: RustBuffer): void;
+            allocationSize(value: StatePredicate): number;
+            lift(value: UniffiByteArray): StatePredicate;
+            lower(value: StatePredicate, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
+        };
         FfiConverterTypeTypeTextInput: {
             read(from: RustBuffer): TypeTextInput;
             write(value: TypeTextInput, into: RustBuffer): void;
@@ -821,6 +1302,41 @@ declare const _default: Readonly<{
             lift(value: UniffiByteArray): TypeTextInput;
             lower(value: TypeTextInput, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
         };
+        FfiConverterTypeUnknownReason: {
+            read(from: RustBuffer): UnknownReason;
+            write(value: UnknownReason, into: RustBuffer): void;
+            allocationSize(value: UnknownReason): number;
+            lift(value: UniffiByteArray): UnknownReason;
+            lower(value: UnknownReason, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
+        };
+        FfiConverterTypeVerificationStatus: {
+            read(from: RustBuffer): VerificationStatus;
+            write(value: VerificationStatus, into: RustBuffer): void;
+            allocationSize(value: VerificationStatus): number;
+            lift(value: UniffiByteArray): VerificationStatus;
+            lower(value: VerificationStatus, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
+        };
+        FfiConverterTypeVerifyStateInput: {
+            read(from: RustBuffer): VerifyStateInput;
+            write(value: VerifyStateInput, into: RustBuffer): void;
+            allocationSize(value: VerifyStateInput): number;
+            lift(value: UniffiByteArray): VerifyStateInput;
+            lower(value: VerifyStateInput, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
+        };
+        FfiConverterTypeVerifyStateOutput: {
+            read(from: RustBuffer): VerifyStateOutput;
+            write(value: VerifyStateOutput, into: RustBuffer): void;
+            allocationSize(value: VerifyStateOutput): number;
+            lift(value: UniffiByteArray): VerifyStateOutput;
+            lower(value: VerifyStateOutput, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
+        };
+        FfiConverterTypeWindowPredicate: {
+            read(from: RustBuffer): WindowPredicate;
+            write(value: WindowPredicate, into: RustBuffer): void;
+            allocationSize(value: WindowPredicate): number;
+            lift(value: UniffiByteArray): WindowPredicate;
+            lower(value: WindowPredicate, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
+        };
     };
 }>;
 export default _default;