agent-device 0.11.13 → 0.11.15

package/dist/src/index.d.ts

@@ -1,6 +1,8 @@
-declare type AgentDeviceClient = {
+export declare type AgentDeviceClient = {
+    command: AgentDeviceCommandClient;
     devices: {
         list: (options?: AgentDeviceRequestOverrides & AgentDeviceSelectionOptions) => Promise<AgentDeviceDevice[]>;
+        boot: (options?: DeviceBootOptions) => Promise<CommandRequestResult>;
     };
     sessions: {
         list: (options?: AgentDeviceRequestOverrides) => Promise<AgentDeviceSession[]>;
@@ -15,8 +17,11 @@ declare type AgentDeviceClient = {
         install: (options: AppDeployOptions) => Promise<AppDeployResult>;
         reinstall: (options: AppDeployOptions) => Promise<AppDeployResult>;
         installFromSource: (options: AppInstallFromSourceOptions) => Promise<AppInstallFromSourceResult>;
+        list: (options?: AppListOptions) => Promise<string[]>;
         open: (options: AppOpenOptions) => Promise<AppOpenResult>;
         close: (options?: AppCloseOptions) => Promise<AppCloseResult>;
+        push: (options: AppPushOptions) => Promise<CommandRequestResult>;
+        triggerEvent: (options: AppTriggerEventOptions) => Promise<CommandRequestResult>;
     };
     materializations: {
         release: (options: MaterializationReleaseOptions) => Promise<MaterializationReleaseResult>;
@@ -27,14 +32,50 @@ declare type AgentDeviceClient = {
     capture: {
         snapshot: (options?: CaptureSnapshotOptions) => Promise<CaptureSnapshotResult>;
         screenshot: (options?: CaptureScreenshotOptions) => Promise<CaptureScreenshotResult>;
+        diff: (options: CaptureDiffOptions) => Promise<CommandRequestResult>;
+    };
+    interactions: {
+        click: (options: ClickOptions) => Promise<CommandRequestResult>;
+        press: (options: PressOptions) => Promise<CommandRequestResult>;
+        longPress: (options: LongPressOptions) => Promise<CommandRequestResult>;
+        swipe: (options: SwipeOptions) => Promise<CommandRequestResult>;
+        focus: (options: FocusOptions_2) => Promise<CommandRequestResult>;
+        type: (options: TypeTextOptions) => Promise<CommandRequestResult>;
+        fill: (options: FillOptions) => Promise<CommandRequestResult>;
+        scroll: (options: ScrollOptions_2) => Promise<CommandRequestResult>;
+        scrollIntoView: (options: ScrollIntoViewOptions_2) => Promise<CommandRequestResult>;
+        pinch: (options: PinchOptions) => Promise<CommandRequestResult>;
+        get: (options: GetOptions) => Promise<CommandRequestResult>;
+        is: (options: IsOptions) => Promise<CommandRequestResult>;
+        find: (options: FindOptions) => Promise<CommandRequestResult>;
+    };
+    replay: {
+        run: (options: ReplayRunOptions) => Promise<CommandRequestResult>;
+        test: (options: ReplayTestOptions) => Promise<CommandRequestResult>;
+    };
+    batch: {
+        run: (options: BatchRunOptions) => Promise<CommandRequestResult>;
+    };
+    observability: {
+        perf: (options?: PerfOptions) => Promise<CommandRequestResult>;
+        logs: (options?: LogsOptions) => Promise<CommandRequestResult>;
+        network: (options?: NetworkOptions) => Promise<CommandRequestResult>;
+    };
+    recording: {
+        record: (options: RecordOptions) => Promise<CommandRequestResult>;
+        trace: (options: TraceOptions) => Promise<CommandRequestResult>;
+    };
+    settings: {
+        update: (options: SettingsUpdateOptions) => Promise<CommandRequestResult>;
     };
 };
 
-declare type AgentDeviceClientConfig = {
+export declare type AgentDeviceClientConfig = {
     session?: string;
     lockPolicy?: DaemonLockPolicy;
     lockPlatform?: PlatformSelector;
     requestId?: string;
+    remoteConfig?: string;
     stateDir?: string;
     daemonBaseUrl?: string;
     daemonAuthToken?: string;
@@ -48,9 +89,21 @@ declare type AgentDeviceClientConfig = {
     debug?: boolean;
 };
 
-declare type AgentDeviceDaemonTransport = (req: Omit<DaemonRequest, 'token'>) => Promise<DaemonResponse>;
+export declare type AgentDeviceCommandClient = {
+    wait: (options: WaitCommandOptions) => Promise<WaitCommandResult>;
+    alert: (options?: AlertCommandOptions) => Promise<AlertCommandResult>;
+    appState: (options?: AppStateCommandOptions) => Promise<AppStateCommandResult>;
+    back: (options?: BackCommandOptions) => Promise<BackCommandResult>;
+    home: (options?: HomeCommandOptions) => Promise<HomeCommandResult>;
+    rotate: (options: RotateCommandOptions) => Promise<RotateCommandResult>;
+    appSwitcher: (options?: AppSwitcherCommandOptions) => Promise<AppSwitcherCommandResult>;
+    keyboard: (options?: KeyboardCommandOptions) => Promise<KeyboardCommandResult>;
+    clipboard: (options: ClipboardCommandOptions) => Promise<ClipboardCommandResult>;
+};
+
+export declare type AgentDeviceDaemonTransport = (req: Omit<DaemonRequest, 'token'>) => Promise<DaemonResponse>;
 
-declare type AgentDeviceDevice = {
+export declare type AgentDeviceDevice = {
     platform: Platform;
     target: DeviceTarget;
     kind: DeviceKind;
@@ -66,7 +119,7 @@ declare type AgentDeviceDevice = {
     };
 };
 
-declare type AgentDeviceIdentifiers = {
+export declare type AgentDeviceIdentifiers = {
     session?: string;
     deviceId?: string;
     deviceName?: string;
@@ -77,9 +130,9 @@ declare type AgentDeviceIdentifiers = {
     package?: string;
 };
 
-declare type AgentDeviceRequestOverrides = Pick<AgentDeviceClientConfig, 'session' | 'lockPolicy' | 'lockPlatform' | 'requestId' | 'tenant' | 'sessionIsolation' | 'runId' | 'leaseId' | 'cwd' | 'debug'>;
+export declare type AgentDeviceRequestOverrides = Pick<AgentDeviceClientConfig, 'session' | 'lockPolicy' | 'lockPlatform' | 'requestId' | 'tenant' | 'sessionIsolation' | 'runId' | 'leaseId' | 'cwd' | 'debug'>;
 
-declare type AgentDeviceSelectionOptions = {
+export declare type AgentDeviceSelectionOptions = {
     platform?: PlatformSelector;
     target?: DeviceTarget;
     device?: string;
@@ -89,14 +142,14 @@ declare type AgentDeviceSelectionOptions = {
     androidDeviceAllowlist?: string;
 };
 
-declare type AgentDeviceSession = {
+export declare type AgentDeviceSession = {
     name: string;
     createdAt: number;
     device: AgentDeviceSessionDevice;
     identifiers: AgentDeviceIdentifiers;
 };
 
-declare type AgentDeviceSessionDevice = {
+export declare type AgentDeviceSessionDevice = {
     platform: Platform;
     target: DeviceTarget;
     id: string;
@@ -111,24 +164,31 @@ declare type AgentDeviceSessionDevice = {
     };
 };
 
-declare type AppCloseOptions = AgentDeviceRequestOverrides & {
+export declare type AlertCommandOptions = DeviceCommandBaseOptions & {
+    action?: 'get' | 'accept' | 'dismiss' | 'wait';
+    timeoutMs?: number;
+};
+
+export declare type AlertCommandResult = DaemonResponseData;
+
+export declare type AppCloseOptions = AgentDeviceRequestOverrides & {
     app?: string;
     shutdown?: boolean;
 };
 
-declare type AppCloseResult = {
+export declare type AppCloseResult = {
     session: string;
     closedApp?: string;
     shutdown?: Record<string, unknown>;
     identifiers: AgentDeviceIdentifiers;
 };
 
-declare type AppDeployOptions = AgentDeviceRequestOverrides & AgentDeviceSelectionOptions & {
+export declare type AppDeployOptions = AgentDeviceRequestOverrides & AgentDeviceSelectionOptions & {
     app: string;
     appPath: string;
 };
 
-declare type AppDeployResult = {
+export declare type AppDeployResult = {
     app: string;
     appPath: string;
     platform: Platform;
@@ -151,13 +211,13 @@ declare type AppErrorDetails = Record<string, unknown> & {
     logPath?: string;
 };
 
-declare type AppInstallFromSourceOptions = AgentDeviceRequestOverrides & AgentDeviceSelectionOptions & {
+export declare type AppInstallFromSourceOptions = AgentDeviceRequestOverrides & AgentDeviceSelectionOptions & {
     source: DaemonInstallSource;
     retainPaths?: boolean;
     retentionMs?: number;
 };
 
-declare type AppInstallFromSourceResult = {
+export declare type AppInstallFromSourceResult = {
     appName?: string;
     appId?: string;
     bundleId?: string;
@@ -172,8 +232,12 @@ declare type AppInstallFromSourceResult = {
 
 declare type ApplePlatform = 'ios' | 'macos';
 
-declare type AppOpenOptions = AgentDeviceRequestOverrides & AgentDeviceSelectionOptions & {
-    app: string;
+export declare type AppListOptions = AgentDeviceRequestOverrides & AgentDeviceSelectionOptions & {
+    appsFilter?: 'all' | 'user-installed';
+};
+
+export declare type AppOpenOptions = AgentDeviceRequestOverrides & AgentDeviceSelectionOptions & {
+    app?: string;
     url?: string;
     surface?: 'app' | 'frontmost-app' | 'desktop' | 'menubar';
     activity?: string;
@@ -183,7 +247,7 @@ declare type AppOpenOptions = AgentDeviceRequestOverrides & AgentDeviceSelection
     runtime?: SessionRuntimeHints;
 };
 
-declare type AppOpenResult = {
+export declare type AppOpenResult = {
     session: string;
     appName?: string;
     appBundleId?: string;
@@ -194,25 +258,78 @@ declare type AppOpenResult = {
     identifiers: AgentDeviceIdentifiers;
 };
 
-declare type BatchStep = {
+export declare type AppPushOptions = ClientCommandBaseOptions & {
+    app: string;
+    payload: string | Record<string, unknown>;
+};
+
+export declare type AppStateCommandOptions = DeviceCommandBaseOptions;
+
+export declare type AppStateCommandResult = DaemonResponseData & {
+    platform?: Platform;
+    appName?: string;
+    appBundleId?: string;
+    package?: string;
+    activity?: string;
+    source?: 'session';
+    surface?: 'app' | 'frontmost-app' | 'desktop' | 'menubar';
+};
+
+export declare type AppSwitcherCommandOptions = DeviceCommandBaseOptions;
+
+export declare type AppSwitcherCommandResult = CommandActionResult<'app-switcher'>;
+
+export declare type AppTriggerEventOptions = ClientCommandBaseOptions & {
+    event: string;
+    payload?: Record<string, unknown>;
+};
+
+export declare type BackCommandOptions = DeviceCommandBaseOptions & {
+    mode?: 'in-app' | 'system';
+};
+
+export declare type BackCommandResult = CommandActionResult<'back'> & {
+    mode?: 'in-app' | 'system';
+};
+
+export declare type BatchRunOptions = AgentDeviceRequestOverrides & {
+    steps: BatchStep[];
+    onError?: 'stop';
+    maxSteps?: number;
+    out?: string;
+};
+
+export declare type BatchStep = {
+    command: string;
+    positionals?: string[];
+    flags?: Record<string, unknown>;
+};
+
+declare type BatchStep_2 = {
     command: string;
     positionals?: string[];
     flags?: Partial<CommandFlags>;
     runtime?: unknown;
 };
 
-declare type CaptureScreenshotOptions = AgentDeviceRequestOverrides & {
+export declare type CaptureDiffOptions = ClientCommandBaseOptions & Pick<CaptureSnapshotOptions, 'interactiveOnly' | 'compact' | 'depth' | 'scope' | 'raw'> & {
+    kind: 'snapshot';
+    out?: string;
+};
+
+export declare type CaptureScreenshotOptions = AgentDeviceRequestOverrides & {
     path?: string;
     overlayRefs?: boolean;
+    fullscreen?: boolean;
 };
 
-declare type CaptureScreenshotResult = {
+export declare type CaptureScreenshotResult = {
     path: string;
     overlayRefs?: ScreenshotOverlayRef[];
     identifiers: AgentDeviceIdentifiers;
 };
 
-declare type CaptureSnapshotOptions = AgentDeviceRequestOverrides & AgentDeviceSelectionOptions & {
+export declare type CaptureSnapshotOptions = AgentDeviceRequestOverrides & AgentDeviceSelectionOptions & {
     interactiveOnly?: boolean;
     compact?: boolean;
     depth?: number;
@@ -220,7 +337,7 @@ declare type CaptureSnapshotOptions = AgentDeviceRequestOverrides & AgentDeviceS
     raw?: boolean;
 };
 
-declare type CaptureSnapshotResult = {
+export declare type CaptureSnapshotResult = {
     nodes: SnapshotNode[];
     truncated: boolean;
     appName?: string;
@@ -230,6 +347,12 @@ declare type CaptureSnapshotResult = {
     identifiers: AgentDeviceIdentifiers;
 };
 
+export declare type ClickOptions = ClientCommandBaseOptions & SelectorSnapshotCommandOptions & InteractionTarget & RepeatedPressOptions & {
+    button?: 'primary' | 'secondary' | 'middle';
+};
+
+declare type ClientCommandBaseOptions = AgentDeviceRequestOverrides & AgentDeviceSelectionOptions;
+
 declare type CliFlags = {
     json: boolean;
     config?: string;
@@ -334,10 +457,31 @@ declare type CliFlags = {
     version: boolean;
 };
 
+export declare type ClipboardCommandOptions = (DeviceCommandBaseOptions & {
+    action: 'read';
+}) | (DeviceCommandBaseOptions & {
+    action: 'write';
+    text: string;
+});
+
+export declare type ClipboardCommandResult = (DaemonResponseData & {
+    action: 'read';
+    text: string;
+}) | (DaemonResponseData & {
+    action: 'write';
+    textLength: number;
+});
+
+declare type CommandActionResult<T extends string> = DaemonResponseData & {
+    action?: T;
+};
+
 declare type CommandFlags = Omit<CliFlags, 'json' | 'help' | 'version' | 'batchSteps'> & {
-    batchSteps?: BatchStep[];
+    batchSteps?: BatchStep_2[];
 };
 
+export declare type CommandRequestResult = DaemonResponseData;
+
 export declare function createAgentDeviceClient(config?: AgentDeviceClientConfig, deps?: {
     transport?: AgentDeviceDaemonTransport;
 }): AgentDeviceClient;
@@ -419,13 +563,15 @@ declare type DaemonResponse = DaemonResponse_2;
 
 declare type DaemonResponse_2 = {
     ok: true;
-    data?: DaemonResponseData;
+    data?: DaemonResponseData_2;
 } | {
     ok: false;
     error: DaemonError;
 };
 
-declare type DaemonResponseData = Record<string, unknown> & {
+declare type DaemonResponseData = DaemonResponseData_2;
+
+declare type DaemonResponseData_2 = Record<string, unknown> & {
     artifacts?: DaemonArtifact[];
 };
 
@@ -433,11 +579,19 @@ declare type DaemonServerMode = 'socket' | 'http' | 'dual';
 
 declare type DaemonTransportMode = 'auto' | 'socket' | 'http';
 
+export declare type DeviceBootOptions = ClientCommandBaseOptions & {
+    headless?: boolean;
+};
+
+declare type DeviceCommandBaseOptions = AgentDeviceRequestOverrides & AgentDeviceSelectionOptions;
+
 declare type DeviceKind = 'simulator' | 'emulator' | 'device';
 
 declare type DeviceTarget = 'mobile' | 'tv' | 'desktop';
 
-declare type EnsureSimulatorOptions = AgentDeviceRequestOverrides & {
+export declare type ElementTarget = RefTarget | SelectorTarget;
+
+export declare type EnsureSimulatorOptions = AgentDeviceRequestOverrides & {
     device: string;
     runtime?: string;
     boot?: boolean;
@@ -445,7 +599,7 @@ declare type EnsureSimulatorOptions = AgentDeviceRequestOverrides & {
     iosSimulatorDeviceSet?: string;
 };
 
-declare type EnsureSimulatorResult = {
+export declare type EnsureSimulatorResult = {
     udid: string;
     device: string;
     runtime: string;
@@ -457,13 +611,96 @@ declare type EnsureSimulatorResult = {
 
 declare type ErrorCode = 'INVALID_ARGS' | 'DEVICE_NOT_FOUND' | 'TOOL_MISSING' | 'APP_NOT_INSTALLED' | 'UNSUPPORTED_PLATFORM' | 'UNSUPPORTED_OPERATION' | 'COMMAND_FAILED' | 'SESSION_NOT_FOUND' | 'UNAUTHORIZED' | 'UNKNOWN';
 
+export declare type FillOptions = ClientCommandBaseOptions & SelectorSnapshotCommandOptions & InteractionTarget & {
+    text: string;
+    delayMs?: number;
+};
+
+declare type FindBaseOptions = ClientCommandBaseOptions & FindSnapshotCommandOptions & {
+    locator?: FindLocator;
+    query: string;
+    first?: boolean;
+    last?: boolean;
+};
+
+export declare type FindLocator = 'any' | 'text' | 'label' | 'value' | 'role' | 'id';
+
+export declare type FindOptions = (FindBaseOptions & {
+    action?: 'click' | 'focus' | 'exists' | 'getText' | 'getAttrs';
+}) | (FindBaseOptions & {
+    action: 'wait';
+    timeoutMs?: number;
+}) | (FindBaseOptions & {
+    action: 'fill' | 'type';
+    value: string;
+});
+
+declare type FindSnapshotCommandOptions = Pick<CaptureSnapshotOptions, 'depth' | 'raw'>;
+
+declare type FocusOptions_2 = ClientCommandBaseOptions & {
+    x: number;
+    y: number;
+};
+export { FocusOptions_2 as FocusOptions }
+
+export declare type GetOptions = ClientCommandBaseOptions & SelectorSnapshotCommandOptions & ElementTarget & {
+    format: 'text' | 'attrs';
+};
+
+export declare type HomeCommandOptions = DeviceCommandBaseOptions;
+
+export declare type HomeCommandResult = CommandActionResult<'home'>;
+
+export declare type InteractionTarget = PointTarget | RefTarget | SelectorTarget;
+
+export declare type IsOptions = IsTextPredicateOptions | IsStatePredicateOptions;
+
+declare type IsStatePredicateOptions = ClientCommandBaseOptions & SelectorSnapshotCommandOptions & {
+    predicate: 'visible' | 'hidden' | 'exists' | 'editable' | 'selected';
+    selector: string;
+    value?: never;
+};
+
+declare type IsTextPredicateOptions = ClientCommandBaseOptions & SelectorSnapshotCommandOptions & {
+    predicate: 'text';
+    selector: string;
+    value: string;
+};
+
+export declare type KeyboardCommandOptions = DeviceCommandBaseOptions & {
+    action?: 'status' | 'dismiss';
+};
+
+export declare type KeyboardCommandResult = DaemonResponseData & {
+    platform?: 'android' | 'ios';
+    action?: 'status' | 'dismiss';
+    visible?: boolean;
+    inputType?: string | null;
+    type?: string | null;
+    wasVisible?: boolean;
+    dismissed?: boolean;
+    attempts?: number;
+};
+
 declare type LeaseBackend = 'ios-simulator' | 'ios-instance' | 'android-instance';
 
-declare type MaterializationReleaseOptions = AgentDeviceRequestOverrides & {
+export declare type LogsOptions = AgentDeviceRequestOverrides & {
+    action?: 'path' | 'start' | 'stop' | 'doctor' | 'mark' | 'clear';
+    message?: string;
+    restart?: boolean;
+};
+
+export declare type LongPressOptions = ClientCommandBaseOptions & {
+    x: number;
+    y: number;
+    durationMs?: number;
+};
+
+export declare type MaterializationReleaseOptions = AgentDeviceRequestOverrides & {
     materializationId: string;
 };
 
-declare type MaterializationReleaseResult = {
+export declare type MaterializationReleaseResult = {
     released: boolean;
     materializationId: string;
     identifiers: AgentDeviceIdentifiers;
@@ -501,7 +738,7 @@ declare type MetroBridgeResult = {
 
 declare type MetroPrepareKind = 'auto' | 'react-native' | 'expo';
 
-declare type MetroPrepareOptions = {
+export declare type MetroPrepareOptions = {
     projectRoot?: string;
     kind?: MetroPrepareKind;
     publicBaseUrl: string;
@@ -521,17 +758,42 @@ declare type MetroPrepareOptions = {
     logPath?: string;
 };
 
-declare type MetroPrepareResult = PrepareMetroRuntimeResult;
+export declare type MetroPrepareResult = PrepareMetroRuntimeResult;
 
+/** Re-export of {@link SessionRuntimeHints} under the Metro-specific alias used by public API consumers. */
 declare type MetroRuntimeHints = SessionRuntimeHints_2;
 
+export declare type NetworkOptions = AgentDeviceRequestOverrides & {
+    action?: 'dump' | 'log';
+    limit?: number;
+    include?: 'summary' | 'headers' | 'body' | 'all';
+};
+
+export declare type PerfOptions = ClientCommandBaseOptions;
+
+export declare type PermissionTarget = 'camera' | 'microphone' | 'photos' | 'contacts' | 'contacts-limited' | 'notifications' | 'calendar' | 'location' | 'location-always' | 'media-library' | 'motion' | 'reminders' | 'siri' | 'accessibility' | 'screen-recording' | 'input-monitoring';
+
+export declare type PinchOptions = ClientCommandBaseOptions & {
+    scale: number;
+    x?: number;
+    y?: number;
+};
+
 declare type Platform = ApplePlatform | 'android' | 'linux';
 
 declare type PlatformSelector = Platform | 'apple';
 
-declare type Point = {
+export declare type Point = {
+    x: number;
+    y: number;
+};
+
+declare type PointTarget = {
     x: number;
     y: number;
+    ref?: never;
+    selector?: never;
+    label?: never;
 };
 
 declare type PrepareMetroRuntimeResult = {
@@ -550,6 +812,8 @@ declare type PrepareMetroRuntimeResult = {
     bridge: MetroBridgeResult | null;
 };
 
+export declare type PressOptions = ClientCommandBaseOptions & SelectorSnapshotCommandOptions & InteractionTarget & RepeatedPressOptions;
+
 declare type RawSnapshotNode = {
     index: number;
     type?: string;
@@ -573,16 +837,62 @@ declare type RawSnapshotNode = {
     hiddenContentBelow?: boolean;
 };
 
-declare type Rect = {
+export declare type RecordOptions = AgentDeviceRequestOverrides & {
+    action: 'start' | 'stop';
+    path?: string;
+    fps?: number;
+    hideTouches?: boolean;
+};
+
+export declare type Rect = {
     x: number;
     y: number;
     width: number;
     height: number;
 };
 
+declare type RefTarget = {
+    ref: string;
+    label?: string;
+    x?: never;
+    y?: never;
+    selector?: never;
+};
+
+declare type RepeatedPressOptions = {
+    count?: number;
+    intervalMs?: number;
+    holdMs?: number;
+    jitterPx?: number;
+    doubleTap?: boolean;
+};
+
+export declare type ReplayRunOptions = AgentDeviceRequestOverrides & {
+    path: string;
+    update?: boolean;
+};
+
+export declare type ReplayTestOptions = AgentDeviceRequestOverrides & AgentDeviceSelectionOptions & {
+    paths: string[];
+    update?: boolean;
+    failFast?: boolean;
+    timeoutMs?: number;
+    retries?: number;
+    artifactsDir?: string;
+    reportJunit?: string;
+};
+
 declare type ResolvedMetroKind = Exclude<MetroPrepareKind, 'auto'>;
 
-declare type ScreenshotOverlayRef = {
+export declare type RotateCommandOptions = DeviceCommandBaseOptions & {
+    orientation: 'portrait' | 'portrait-upside-down' | 'landscape-left' | 'landscape-right';
+};
+
+export declare type RotateCommandResult = CommandActionResult<'rotate'> & {
+    orientation?: RotateCommandOptions['orientation'];
+};
+
+export declare type ScreenshotOverlayRef = {
     ref: string;
     label?: string;
     rect: Rect;
@@ -590,7 +900,37 @@ declare type ScreenshotOverlayRef = {
     center: Point;
 };
 
-declare type SessionCloseResult = {
+declare type ScrollIntoViewOptions_2 = ClientCommandBaseOptions & ({
+    text: string;
+    ref?: never;
+    label?: never;
+} | {
+    ref: string;
+    label?: string;
+    text?: never;
+}) & {
+    maxScrolls?: number;
+};
+export { ScrollIntoViewOptions_2 as ScrollIntoViewOptions }
+
+declare type ScrollOptions_2 = ClientCommandBaseOptions & {
+    direction: 'up' | 'down' | 'left' | 'right';
+    amount?: number;
+    pixels?: number;
+};
+export { ScrollOptions_2 as ScrollOptions }
+
+declare type SelectorSnapshotCommandOptions = Pick<CaptureSnapshotOptions, 'depth' | 'scope' | 'raw'>;
+
+declare type SelectorTarget = {
+    selector: string;
+    x?: never;
+    y?: never;
+    ref?: never;
+    label?: never;
+};
+
+export declare type SessionCloseResult = {
     session: string;
     shutdown?: Record<string, unknown>;
     identifiers: AgentDeviceIdentifiers;
@@ -608,20 +948,39 @@ declare type SessionRuntimeHints_2 = {
     launchUrl?: string;
 };
 
-declare type SnapshotNode = RawSnapshotNode & {
+export declare type SettingsUpdateOptions = (ClientCommandBaseOptions & {
+    setting: 'wifi' | 'airplane' | 'location';
+    state: 'on' | 'off';
+}) | (ClientCommandBaseOptions & {
+    setting: 'appearance';
+    state: 'light' | 'dark' | 'toggle';
+}) | (ClientCommandBaseOptions & {
+    setting: 'faceid' | 'touchid';
+    state: 'match' | 'nonmatch' | 'enroll' | 'unenroll';
+}) | (ClientCommandBaseOptions & {
+    setting: 'fingerprint';
+    state: 'match' | 'nonmatch';
+}) | (ClientCommandBaseOptions & {
+    setting: 'permission';
+    state: 'grant' | 'deny' | 'reset';
+    permission: PermissionTarget;
+    mode?: 'full' | 'limited';
+});
+
+export declare type SnapshotNode = RawSnapshotNode & {
     ref: string;
 };
 
-declare type SnapshotVisibility = {
+export declare type SnapshotVisibility = {
     partial: boolean;
     visibleNodeCount: number;
     totalNodeCount: number;
     reasons: SnapshotVisibilityReason[];
 };
 
-declare type SnapshotVisibilityReason = 'offscreen-nodes' | 'scroll-hidden-above' | 'scroll-hidden-below';
+export declare type SnapshotVisibilityReason = 'offscreen-nodes' | 'scroll-hidden-above' | 'scroll-hidden-below';
 
-declare type StartupPerfSample = {
+export declare type StartupPerfSample = {
     durationMs: number;
     measuredAt: string;
     method: string;
@@ -629,4 +988,65 @@ declare type StartupPerfSample = {
     appBundleId?: string;
 };
 
+export declare type SwipeOptions = ClientCommandBaseOptions & {
+    from: {
+        x: number;
+        y: number;
+    };
+    to: {
+        x: number;
+        y: number;
+    };
+    durationMs?: number;
+    count?: number;
+    pauseMs?: number;
+    pattern?: 'one-way' | 'ping-pong';
+};
+
+export declare type TraceOptions = AgentDeviceRequestOverrides & {
+    action: 'start' | 'stop';
+    path?: string;
+};
+
+export declare type TypeTextOptions = ClientCommandBaseOptions & {
+    text: string;
+    delayMs?: number;
+};
+
+export declare type WaitCommandOptions = DeviceCommandBaseOptions & WaitCommandTarget;
+
+export declare type WaitCommandResult = DaemonResponseData & {
+    waitedMs?: number;
+    text?: string;
+    selector?: string;
+};
+
+declare type WaitCommandTarget = {
+    durationMs: number;
+    text?: never;
+    ref?: never;
+    selector?: never;
+    timeoutMs?: never;
+} | (WaitSnapshotOptions & {
+    text: string;
+    durationMs?: never;
+    ref?: never;
+    selector?: never;
+    timeoutMs?: number;
+}) | (WaitSnapshotOptions & {
+    ref: string;
+    durationMs?: never;
+    text?: never;
+    selector?: never;
+    timeoutMs?: number;
+}) | (WaitSnapshotOptions & {
+    selector: string;
+    durationMs?: never;
+    text?: never;
+    ref?: never;
+    timeoutMs?: number;
+});
+
+declare type WaitSnapshotOptions = Pick<CaptureSnapshotOptions, 'depth' | 'scope' | 'raw'>;
+
 export { }