@opengeni/sdk 0.48.0 → 0.57.0

package/dist/interaction.d.ts

@@ -0,0 +1,1484 @@
+import type { OpenGeniRequestOptions } from "./client.js";
+import type { RetainedArtifactReference } from "./types.js";
+/** Public Browser/Computer protocol version. Driver and provider details stay private. */
+export declare const INTERACTION_PROTOCOL_VERSION: 1;
+export declare const BROWSER_CONTROL_WEBSOCKET_PROTOCOL: "opengeni.browser.v1";
+export declare const COMPUTER_CONTROL_WEBSOCKET_PROTOCOL: "opengeni.computer.v1";
+export declare const BROWSER_CONTROL_WEBSOCKET_BEARER_PREFIX: "opengeni.auth.";
+export declare const BROWSER_CONTROL_MAX_FRAME_HEADER_BYTES: number;
+export declare const BROWSER_FRAME_MAX_BYTES: number;
+export declare const BROWSER_FRAME_MAX_DIMENSION = 32768;
+export declare const BROWSER_FRAME_MAX_PIXELS = 100000000;
+/** Latest-wins invalidation cursor for workspace Browser/Computer resources. */
+export type WorkspaceInteractionRevisionEvent = {
+    workspaceId: string;
+    sequence: number;
+    revision: number;
+    type: "workspace.interaction.changed";
+    occurredAt: string;
+};
+export type InteractionJsonValue = null | string | number | boolean | InteractionJsonValue[] | {
+    [key: string]: InteractionJsonValue;
+};
+export type InteractionPlacement = {
+    kind: "sandbox_group";
+    sandboxGroupId: string;
+} | {
+    kind: "connected_machine";
+    sandboxId: string;
+} | {
+    kind: "attached_device";
+    deviceId: string;
+} | {
+    kind: "external_provider";
+    providerId: string;
+    placementId: string;
+};
+export type AttachedBrowserDeviceCapabilities = {
+    tabInventory: boolean;
+    debuggerAttachment: boolean;
+    semanticObservation: boolean;
+    screenshots: boolean;
+    liveFrames: boolean;
+    humanInput: boolean;
+    diagnostics: boolean;
+    rawCdp: boolean;
+    linkedComputer: boolean;
+};
+/** One live browser-profile endpoint on an enrolled machine. Saved, reusable
+ *  login state is represented separately by BrowserIdentity. */
+export type AttachedBrowserDevice = {
+    id: string;
+    accountId: string;
+    workspaceId: string;
+    enrollmentId: string;
+    name: string;
+    profileLabel: string | null;
+    browserName: string;
+    browserVersion: string;
+    extensionVersion: string;
+    platform: "linux" | "macos" | "windows";
+    architecture: "x64" | "arm64";
+    state: "connected" | "disconnected";
+    connectionGeneration: string;
+    inventoryRevision: number;
+    tabCount: number;
+    capabilities: AttachedBrowserDeviceCapabilities;
+    lastSeenAt: string;
+    disconnectedAt: string | null;
+    createdAt: string;
+    updatedAt: string;
+};
+export type AttachedBrowserDeviceListResponse = {
+    revision: number;
+    devices: AttachedBrowserDevice[];
+};
+export type InteractionControllerBinding = {
+    controllerId: string;
+    controllerGeneration: string;
+    placementInstanceId: string;
+};
+export type InteractionAssociation = {
+    sessionId: string;
+    turnId: string | null;
+    attemptId: string | null;
+    relationship: "created" | "using" | "observing" | "related";
+    actorSubjectId: string;
+    lastUsedAt: string;
+};
+export type InteractionLifecycle = "starting" | "active" | "suspending" | "suspended" | "restoring" | "repair_required" | "lost" | "ending" | "ended" | "failed";
+export type BrowserSessionCapabilities = {
+    semanticObservation: boolean;
+    screenshots: boolean;
+    liveFrames: boolean;
+    humanInput: boolean;
+    tabs: boolean;
+    downloads: boolean;
+    uploads: boolean;
+    clipboard: boolean;
+    permissions: boolean;
+    diagnostics: boolean;
+    rawCdp: boolean;
+    linkedComputer: boolean;
+    privateCheckpoint: boolean;
+    identityPublication: boolean;
+    parallelTargets: boolean;
+};
+export type BrowserSession = {
+    id: string;
+    accountId: string;
+    workspaceId: string;
+    name: string;
+    lifecycle: InteractionLifecycle;
+    placement: InteractionPlacement;
+    controller: InteractionControllerBinding | null;
+    driverId: string;
+    engine: "chromium" | "chrome" | "firefox" | "webkit" | "lightpanda" | "external";
+    engineVersion: string | null;
+    headless: boolean;
+    identityId: string | null;
+    baseRevisionId: string | null;
+    networkRouteId: string | null;
+    linkedComputerSessionId: string | null;
+    capabilities: BrowserSessionCapabilities;
+    associations: InteractionAssociation[];
+    createdBySubjectId: string;
+    createdAt: string;
+    lastUsedAt: string;
+    failureCode: string | null;
+};
+export type BrowserClipboard = {
+    browserSessionId: string;
+    controllerGeneration: string;
+    revision: number;
+    text: string;
+    source: "empty" | "write" | "clear" | "copy" | "paste";
+    sourceTargetId: string | null;
+    updatedAt: string | null;
+};
+export type InteractionCredentialAuthorityRef = {
+    connectionId: string;
+    connectionSubjectId: string | null;
+    providerDomain: string;
+};
+export type NetworkRouteConfiguration = {
+    kind: "direct";
+} | {
+    kind: "proxy";
+    protocol: "http" | "https" | "socks5";
+    host: string;
+    port: number;
+    credential: InteractionCredentialAuthorityRef | null;
+} | {
+    kind: "managed";
+    providerId: string;
+    routeId: string;
+    egressClass: "datacenter" | "residential" | "isp";
+    region: string | null;
+    credential: InteractionCredentialAuthorityRef | null;
+} | {
+    kind: "tunnel";
+    placement: InteractionPlacement;
+    tunnelId: string;
+};
+export type NetworkRouteConsistency = {
+    dns: "placement" | "proxy" | "provider";
+    expectedPublicIp: string | null;
+    expectedRegion: string | null;
+    locale: string | null;
+    timezone: string | null;
+    geolocation: {
+        latitude: number;
+        longitude: number;
+        accuracyMeters: number;
+    } | null;
+    webRtc: "default" | "disable_non_proxied_udp" | "proxy_only";
+    stability: "session" | "sticky" | "persistent";
+};
+export type NetworkRoute = {
+    id: string;
+    accountId: string;
+    workspaceId: string;
+    name: string;
+    status: "active" | "archived";
+    configuration: NetworkRouteConfiguration;
+    consistency: NetworkRouteConsistency;
+    version: number;
+    createdBySubjectId: string;
+    createdAt: string;
+    updatedAt: string;
+};
+export type NetworkRouteListResponse = {
+    revision: number;
+    routes: NetworkRoute[];
+};
+export type CreateNetworkRouteRequest = {
+    operationId: string;
+    name: string;
+    configuration: NetworkRouteConfiguration;
+    consistency: NetworkRouteConsistency;
+};
+export type UpdateNetworkRouteRequest = {
+    operationId: string;
+    expectedVersion: number;
+    name?: string | undefined;
+    status?: "active" | "archived" | undefined;
+    configuration?: NetworkRouteConfiguration | undefined;
+    consistency?: NetworkRouteConsistency | undefined;
+};
+export type NetworkRouteMutationResponse = {
+    route: NetworkRoute;
+    operationId: string;
+    replayed: boolean;
+};
+export type SiteAuthFieldPurpose = "identifier" | "password" | "secret" | "totp";
+export type SiteAuthAuthority = {
+    id: string;
+    kind: "connection_fields";
+    label: string;
+    credential: InteractionCredentialAuthorityRef;
+    fields: Array<{
+        id: string;
+        purpose: SiteAuthFieldPurpose;
+        credentialKey: string;
+        digits?: number | undefined;
+        periodSeconds?: number | undefined;
+        algorithm?: "sha1" | "sha256" | "sha512" | undefined;
+    }>;
+} | {
+    id: string;
+    kind: "human";
+    label: string;
+    fields: Array<{
+        id: string;
+        purpose: SiteAuthFieldPurpose;
+    }>;
+} | {
+    id: string;
+    kind: "external_provider";
+    label: string;
+    adapterId: string;
+    connectionId: string;
+    credential: InteractionCredentialAuthorityRef | null;
+};
+export type SiteAuthMethod = {
+    id: string;
+    kind: "password" | "sso" | "magic_link" | "passkey" | "external";
+    label: string;
+    authorityIds: string[];
+};
+export type SiteAuthHealthPolicy = {
+    mode: "on_use" | "maintained";
+    intervalSeconds: number | null;
+    automaticRepair: boolean;
+};
+export type SiteAuthConnectionConfiguration = {
+    name: string;
+    accountLabel: string;
+    origins: string[];
+    loginUrl: string | null;
+    verificationUrlPrefixes: string[];
+    authorities: SiteAuthAuthority[];
+    methods: SiteAuthMethod[];
+    preferredIdentityId: string | null;
+    preferredPlacement: InteractionPlacement | null;
+    preferredNetworkRouteId: string | null;
+    healthPolicy: SiteAuthHealthPolicy;
+};
+export type SiteAuthConnection = SiteAuthConnectionConfiguration & {
+    id: string;
+    accountId: string;
+    workspaceId: string;
+    status: "active" | "archived";
+    verificationState: "unknown" | "verified" | "needs_repair" | "failed";
+    lastVerifiedAt: string | null;
+    lastVerifiedUrl: string | null;
+    lastCheckedAt: string | null;
+    nextCheckAt: string | null;
+    maintenance: {
+        action: "health_check" | "repair";
+        sessionId: string | null;
+        dueAt: string;
+        startedAt: string | null;
+    } | null;
+    repairCode: string | null;
+    version: number;
+    createdBySubjectId: string;
+    createdAt: string;
+    updatedAt: string;
+};
+export type SiteAuthConnectionListResponse = {
+    revision: number;
+    connections: SiteAuthConnection[];
+};
+export type CreateSiteAuthConnectionRequest = SiteAuthConnectionConfiguration & {
+    operationId: string;
+};
+export type UpdateSiteAuthConnectionRequest = Partial<SiteAuthConnectionConfiguration> & {
+    operationId: string;
+    expectedVersion: number;
+    status?: "active" | "archived" | undefined;
+};
+export type SiteAuthConnectionMutationResponse = {
+    connection: SiteAuthConnection;
+    operationId: string;
+    replayed: boolean;
+};
+export type AuthRun = {
+    id: string;
+    accountId: string;
+    workspaceId: string;
+    siteAuthConnectionId: string;
+    browserSessionId: string;
+    targetId: string;
+    controllerGeneration: string;
+    targetGeneration: string;
+    documentGeneration: string | null;
+    purpose: "authenticate" | "health_check" | "repair";
+    methodId: string | null;
+    authorityId: string | null;
+    state: "discovering" | "awaiting_choice" | "awaiting_secret" | "awaiting_external_action" | "working" | "verified" | "failed" | "cancelled";
+    choices: Array<{
+        id: string;
+        label: string;
+        methodId: string;
+    }>;
+    pendingFields: Array<{
+        id: string;
+        label: string;
+        purpose: SiteAuthFieldPurpose;
+    }>;
+    externalAction: {
+        kind: "push" | "security_key" | "passkey" | "device" | "human" | "other";
+        label: string;
+        expiresAt: string | null;
+    } | null;
+    interventionId: string | null;
+    verifiedUrl: string | null;
+    failureCode: string | null;
+    version: number;
+    operationId: string;
+    createdBySubjectId: string;
+    createdAt: string;
+    updatedAt: string;
+    settledAt: string | null;
+};
+export type AuthRunListResponse = {
+    runs: AuthRun[];
+};
+export type AuthRunMutationResponse = {
+    run: AuthRun;
+    operationId: string;
+    replayed: boolean;
+};
+export type StartAuthRunRequest = {
+    operationId: string;
+    siteAuthConnectionId: string;
+    targetId: string;
+    expectedTargetGeneration: string;
+    expectedDocumentGeneration: string | null;
+    purpose?: "authenticate" | "health_check" | "repair" | undefined;
+    methodId?: string | undefined;
+    authorityId?: string | undefined;
+};
+export type ReportAuthRunRequest = {
+    operationId: string;
+    expectedVersion: number;
+    methodId?: string | undefined;
+    authorityId?: string | undefined;
+    state: "awaiting_choice" | "awaiting_secret" | "awaiting_external_action" | "working" | "failed" | "cancelled";
+    choices?: AuthRun["choices"] | undefined;
+    pendingFields?: AuthRun["pendingFields"] | undefined;
+    externalAction?: AuthRun["externalAction"] | undefined;
+    failureCode?: string | null | undefined;
+};
+export type ProtectedAuthFillRequest = {
+    operationId: string;
+    expectedVersion: number;
+    expectedTargetGeneration: string;
+    expectedDocumentGeneration: string | null;
+    expectedFrameId: string | null;
+    authorityId: string;
+    fields: Array<{
+        fieldId: string;
+        locator: BrowserLocator;
+    }>;
+    submit: {
+        type: "none";
+    } | {
+        type: "click";
+        locator: BrowserLocator;
+    } | {
+        type: "press";
+        key: string;
+        locator?: BrowserLocator | undefined;
+    };
+};
+export type ProtectedAuthFillResponse = {
+    run: AuthRun;
+    status: "submitted" | "working" | "needs_human" | "stale" | "failed";
+    operationId: string;
+    replayed: boolean;
+};
+export type ExternalAuthRunRequest = {
+    operationId: string;
+    expectedVersion: number;
+    action: "start" | "poll";
+};
+export type ExternalAuthRunResponse = {
+    run: AuthRun;
+    status: "working" | "needs_human" | "ready_to_verify" | "failed";
+    operationId: string;
+    replayed: boolean;
+};
+export type ExternalAuthInteractiveRequest = {
+    operationId: string;
+    expectedVersion: number;
+};
+export type ExternalAuthInteractiveResponse = {
+    authRunId: string;
+    url: string;
+    expiresAt: string | null;
+};
+export type VerifyAuthRunRequest = {
+    operationId: string;
+    expectedVersion: number;
+};
+export type InteractionIntervention = {
+    id: string;
+    accountId: string;
+    workspaceId: string;
+    resourceKind: "browser_session" | "computer_session";
+    resourceId: string;
+    targetId: string;
+    controllerGeneration: string;
+    targetGeneration: string;
+    documentGeneration: string | null;
+    kind: "manual_login" | "mfa" | "external_action" | "confirmation" | "other";
+    reason: string;
+    status: "open" | "completed" | "dismissed" | "expired" | "cancelled";
+    authRunId: string | null;
+    originatingSessionId: string;
+    originatingTurnId: string | null;
+    originatingAttemptId: string | null;
+    originatingToolOperationId: string | null;
+    responseActorSubjectId: string | null;
+    version: number;
+    operationId: string;
+    expiresAt: string;
+    createdAt: string;
+    updatedAt: string;
+    settledAt: string | null;
+};
+export type InteractionInterventionListResponse = {
+    interventions: InteractionIntervention[];
+};
+export type CreateInteractionInterventionRequest = {
+    operationId: string;
+    resourceKind: "browser_session" | "computer_session";
+    resourceId: string;
+    targetId: string;
+    expectedControllerGeneration: string;
+    expectedTargetGeneration: string;
+    expectedDocumentGeneration: string | null;
+    kind: InteractionIntervention["kind"];
+    reason: string;
+    authRunId?: string | undefined;
+    expiresInSeconds?: number | undefined;
+};
+export type ResolveInteractionInterventionRequest = {
+    operationId: string;
+    expectedVersion: number;
+    outcome: "completed" | "dismissed";
+};
+export type InteractionInterventionMutationResponse = {
+    intervention: InteractionIntervention;
+    operationId: string;
+    replayed: boolean;
+};
+export type BrowserIdentityStatus = "active" | "archived";
+export type BrowserRevisionComponentKind = "chromium_profile" | "normalized_web_state" | "provider_snapshot";
+export type BrowserRevisionPortability = "portable" | "provider_bound" | "placement_bound";
+export type BrowserRevisionMaterialization = {
+    portability: BrowserRevisionPortability;
+    reason: string | null;
+    platform: "linux" | "macos" | "windows" | null;
+    architecture: "x64" | "arm64" | null;
+    engine: "chromium" | "chrome" | "firefox" | "webkit" | "lightpanda" | "external";
+    engineVersion: string | null;
+    driverId: string;
+    driverSchemaVersion: number;
+    profileCrypto: "chromium_basic" | "chromium_mock_keychain" | "platform_bound";
+    providerId: string | null;
+    placement: InteractionPlacement | null;
+};
+export type BrowserRevisionComponent = {
+    id: string;
+    kind: BrowserRevisionComponentKind;
+    format: string;
+    artifactDigest: string;
+    sizeBytes: number;
+    materialization: BrowserRevisionMaterialization;
+};
+export type BrowserRevision = {
+    id: string;
+    accountId: string;
+    workspaceId: string;
+    identityId: string;
+    parentRevisionId: string | null;
+    ordinal: number;
+    sourceBrowserSessionId: string;
+    manifestDigest: string;
+    components: BrowserRevisionComponent[];
+    createdBySubjectId: string;
+    createdAt: string;
+};
+export type BrowserIdentity = {
+    id: string;
+    accountId: string;
+    workspaceId: string;
+    name: string;
+    status: BrowserIdentityStatus;
+    version: number;
+    defaultRevisionId: string | null;
+    headGeneration: number;
+    revisionCount: number;
+    createdBySubjectId: string;
+    createdAt: string;
+    updatedAt: string;
+};
+export type BrowserIdentityListResponse = {
+    revision: number;
+    identities: BrowserIdentity[];
+};
+export type BrowserRevisionListResponse = {
+    identity: BrowserIdentity;
+    revisions: BrowserRevision[];
+};
+export type CreateBrowserIdentityRequest = {
+    operationId: string;
+    name: string;
+};
+export type UpdateBrowserIdentityRequest = {
+    operationId: string;
+    expectedVersion: number;
+    name?: string | undefined;
+    status?: BrowserIdentityStatus | undefined;
+    defaultRevisionId?: string | undefined;
+};
+export type BrowserIdentityMutationResponse = {
+    identity: BrowserIdentity;
+    operationId: string;
+    replayed: boolean;
+};
+export type PublishBrowserRevisionRequest = {
+    operationId: string;
+    identityId: string;
+    expectedHeadGeneration: number;
+    advanceDefault?: boolean | undefined;
+};
+export type PublishBrowserRevisionResponse = {
+    identity: BrowserIdentity;
+    revision: BrowserRevision;
+    outcome: "saved_as_default" | "saved_not_default";
+    replayed: boolean;
+};
+export type BrowserTarget = {
+    id: string;
+    browserSessionId: string;
+    controllerGeneration: string;
+    targetGeneration: string;
+    documentGeneration: string | null;
+    kind: "page" | "popup" | "background_page" | "worker";
+    title: string;
+    url: string;
+    selected: boolean;
+    attached: boolean;
+    createdAt: string;
+};
+export type BrowserDownloadStatus = "in_progress" | "completed" | "cancelled" | "failed" | "unavailable";
+/** One browser-produced file. Its bytes remain private to the exact browser
+ * controller until an explicit save publishes them into the workspace. */
+export type BrowserDownload = {
+    id: string;
+    browserSessionId: string;
+    controllerGeneration: string;
+    targetId: string | null;
+    filename: string;
+    status: BrowserDownloadStatus;
+    receivedBytes: number;
+    totalBytes: number | null;
+    sha256: string | null;
+    version: number;
+    startedAt: string;
+    settledAt: string | null;
+    failureCode: string | null;
+};
+export type BrowserDownloadListResponse = {
+    browserSessionId: string;
+    controllerGeneration: string;
+    downloads: BrowserDownload[];
+};
+export type BrowserDownloadSaveRequest = {
+    operationId: string;
+    destinationPath: string;
+    overwrite?: boolean | undefined;
+};
+export type BrowserDownloadSaveResponse = {
+    download: BrowserDownload;
+    destinationPath: string;
+    fileId: string;
+    operationId: string;
+    replayed: boolean;
+};
+export type InteractionRect = {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+};
+export type InteractionRedactedValue = {
+    redacted: true;
+    reason: "password" | "payment" | "private" | "policy";
+};
+export type InteractionSemanticNode = {
+    ref: string;
+    role: string;
+    identifier?: string | undefined;
+    name?: string | undefined;
+    description?: string | undefined;
+    value?: string | InteractionRedactedValue | undefined;
+    states: string[];
+    bounds?: InteractionRect | undefined;
+    actions: string[];
+    children?: InteractionSemanticNode[] | undefined;
+    native?: {
+        platform: "dom" | "mac_ax" | "at_spi" | "uia";
+        data: unknown;
+    } | undefined;
+};
+export type InteractionSemanticSnapshot = {
+    kind: "snapshot";
+    roots: InteractionSemanticNode[];
+    nodeCount: number;
+};
+export type InteractionSemanticDiff = {
+    kind: "diff";
+    baseObservationId: string;
+    removedRefs: string[];
+    changed: InteractionSemanticNode[];
+};
+export type InteractionDiagnosticSummary = {
+    consoleErrorCount: number;
+    failedRequestCount: number;
+    downloadCount: number;
+    pageErrorCount: number;
+};
+export type BrowserDialog = {
+    type: "alert" | "confirm" | "prompt" | "beforeunload";
+    message: string;
+    defaultPrompt: string;
+    openedAt: string;
+};
+export type BrowserObservation = {
+    protocolVersion: typeof INTERACTION_PROTOCOL_VERSION;
+    observationId: string;
+    browserSessionId: string;
+    target: BrowserTarget;
+    frameId: string | null;
+    semantic: InteractionSemanticSnapshot | InteractionSemanticDiff | null;
+    screenshot: RetainedArtifactReference | null;
+    focusedRef: string | null;
+    changedRegions: InteractionRect[];
+    diagnostics: InteractionDiagnosticSummary;
+    dialog: BrowserDialog | null;
+    observedAt: string;
+};
+export type BrowserDiagnosticKind = "console" | "page_error" | "failed_request" | "download";
+export type BrowserDiagnosticEntry = {
+    sequence: number;
+    kind: BrowserDiagnosticKind;
+    level: "debug" | "info" | "warning" | "error" | null;
+    message: string;
+    url: string | null;
+    method: string | null;
+    status: number | null;
+    filename: string | null;
+    occurredAt: string;
+};
+export type BrowserDiagnosticBatch = {
+    browserSessionId: string;
+    controllerGeneration: string;
+    targetId: string;
+    targetGeneration: string;
+    entries: BrowserDiagnosticEntry[];
+    cursor: number;
+    truncated: boolean;
+};
+export type BrowserLocator = {
+    kind: "ref";
+    ref: string;
+} | {
+    kind: "role";
+    role: string;
+    name?: string | undefined;
+    exact?: boolean | undefined;
+} | {
+    kind: "label";
+    text: string;
+} | {
+    kind: "text";
+    text: string;
+} | {
+    kind: "placeholder";
+    text: string;
+} | {
+    kind: "test_id";
+    value: string;
+} | {
+    kind: "css";
+    selector: string;
+};
+export type BrowserPermission = "geolocation" | "notifications" | "camera" | "microphone" | "midi" | "midi_sysex" | "sensors" | "idle_detection" | "local_fonts" | "window_management";
+export type BrowserPermissionSetting = "granted" | "denied" | "prompt";
+export type BrowserAction = {
+    type: "navigate";
+    url: string;
+} | {
+    type: "click";
+    locator: BrowserLocator;
+    button?: "left" | "right" | "middle" | undefined;
+} | {
+    type: "double_click";
+    locator: BrowserLocator;
+} | {
+    type: "hover";
+    locator: BrowserLocator;
+} | {
+    type: "fill";
+    locator: BrowserLocator;
+    value: string;
+} | {
+    type: "type";
+    locator?: BrowserLocator | undefined;
+    text: string;
+} | {
+    type: "press";
+    locator?: BrowserLocator | undefined;
+    key: string;
+} | {
+    type: "select";
+    locator: BrowserLocator;
+    values: string[];
+} | {
+    type: "check";
+    locator: BrowserLocator;
+    checked: boolean;
+} | {
+    type: "scroll";
+    locator?: BrowserLocator | undefined;
+    deltaX: number;
+    deltaY: number;
+} | {
+    type: "drag";
+    from: BrowserLocator;
+    to: BrowserLocator;
+} | {
+    type: "pointer";
+    action: "click" | "double_click" | "move" | "scroll" | "drag";
+    x: number;
+    y: number;
+    endX?: number | undefined;
+    endY?: number | undefined;
+    deltaX?: number | undefined;
+    deltaY?: number | undefined;
+    button?: "left" | "right" | "middle" | undefined;
+    clickCount?: 1 | 2 | undefined;
+} | {
+    type: "handle_dialog";
+    response: "accept" | "dismiss";
+    promptText?: string | undefined;
+} | {
+    type: "upload";
+    locator: BrowserLocator;
+    workspaceFileIds: string[];
+} | {
+    type: "clipboard";
+    operation: "write" | "clear" | "copy" | "paste";
+    text?: string | undefined;
+    locator?: BrowserLocator | undefined;
+    content?: "selection" | "value" | "text" | undefined;
+} | {
+    type: "permission";
+    permission: BrowserPermission;
+    setting: BrowserPermissionSetting;
+} | {
+    type: "wait";
+    condition: "load" | "network_idle" | "visible" | "hidden";
+    locator?: BrowserLocator | undefined;
+    timeoutMs?: number | undefined;
+};
+export type BrowserActionBatch = {
+    type: "batch";
+    actions: BrowserAction[];
+};
+export type InteractionError = {
+    code: "resource_not_found" | "resource_unavailable" | "controller_stale" | "target_not_found" | "target_stale" | "observation_stale" | "document_stale" | "frame_stale" | "locator_not_found" | "locator_ambiguous" | "unsupported" | "permission_denied" | "machine_locked" | "attempt_stale" | "operation_conflict" | "outcome_unknown" | "invalid_action" | "timeout" | "controller_lost" | "driver_failed";
+    message: string;
+    retryable: boolean;
+    details?: Record<string, InteractionJsonValue> | undefined;
+};
+export type InteractionOperationState = "prepared" | "dispatched" | "completed" | "failed" | "outcome_unknown";
+export type InteractionLifecycleOperationReceipt = {
+    operationId: string;
+    resourceKind: "browser_session" | "computer_session";
+    resourceId: string;
+    kind: "create" | "resume" | "suspend" | "end" | "publish";
+    state: InteractionOperationState;
+    replayed: boolean;
+    error: InteractionError | null;
+    createdAt: string;
+    dispatchedAt: string | null;
+    settledAt: string | null;
+};
+export type CreateBrowserSessionRequest = {
+    operationId: string;
+    sessionId: string;
+    name?: string | undefined;
+    initialUrl?: string | undefined;
+    headless?: boolean | undefined;
+    engine?: "chromium" | "lightpanda" | undefined;
+    placement?: InteractionPlacement | undefined;
+    identityId?: string | undefined;
+    baseRevisionId?: string | undefined;
+    networkRouteId?: string | undefined;
+    linkedComputerSessionId?: string | undefined;
+};
+export type BrowserSessionListResponse = {
+    revision: number;
+    sessions: BrowserSession[];
+};
+export type BrowserSessionMutationResponse = {
+    session: BrowserSession;
+    operation: InteractionLifecycleOperationReceipt;
+};
+export type BrowserSessionLifecycleRequest = {
+    operationId: string;
+};
+export type BrowserOpenTargetRequest = {
+    url?: string | undefined;
+};
+export type BrowserTargetListResponse = {
+    browserSessionId: string;
+    controllerGeneration: string;
+    targets: BrowserTarget[];
+};
+export type InteractionFrameStreamAttachment<RelayKind extends 3 | 4 = 3 | 4> = {
+    kind: "direct_websocket";
+    url: string;
+    protocols: string[];
+} | {
+    kind: "relay";
+    url: string;
+    token: string;
+    channel: {
+        channelId: string;
+        workspaceId: string;
+        agentId: string;
+        kind: RelayKind;
+        port: number;
+    };
+};
+export type ComputerFrameStreamAttachment = InteractionFrameStreamAttachment<4> | {
+    kind: "direct_rfb";
+    url: string;
+    protocols: string[];
+};
+export type BrowserSessionAttachment = {
+    browserSessionId: string;
+    controllerGeneration: string;
+    targetId: string;
+    stream: InteractionFrameStreamAttachment<3>;
+    expiresAt: string;
+};
+export type BrowserSessionAttachmentRequest = {
+    targetId: string;
+    expiresInSeconds?: number | undefined;
+    stream?: BrowserFrameStreamOptions | undefined;
+};
+export type BrowserActionRequest = {
+    operationId: string;
+    targetId: string;
+    expectedTargetGeneration: string;
+    expectedDocumentGeneration: string | null;
+    expectedFrameId: string | null;
+    observationMode?: "full" | "none" | undefined;
+    action: BrowserAction | BrowserActionBatch;
+};
+export type BrowserActionReceipt = {
+    protocolVersion: typeof INTERACTION_PROTOCOL_VERSION;
+    operationId: string;
+    browserSessionId: string;
+    controllerGeneration: string;
+    targetId: string;
+    state: InteractionOperationState;
+    dispatchedAt: string | null;
+    settledAt: string | null;
+    observation: BrowserObservation | null;
+    error: InteractionError | null;
+};
+export type BrowserSessionHeartbeatResponse = {
+    browserSessionId: string;
+    controllerGeneration: string;
+    alive: true;
+};
+export type ComputerSessionCapabilities = {
+    semanticObservation: boolean;
+    appDiscovery: boolean;
+    appLaunch: boolean;
+    windowCapture: boolean;
+    screenCapture: boolean;
+    semanticActions: boolean;
+    pointerInput: boolean;
+    keyboardInput: boolean;
+    clipboard: boolean;
+    backgroundActions: boolean;
+    parallelApps: boolean;
+};
+export type ComputerClipboard = {
+    computerSessionId: string;
+    controllerGeneration: string;
+    text: string | null;
+    truncated: boolean;
+    observedAt: string;
+};
+export type ComputerSession = {
+    id: string;
+    accountId: string;
+    workspaceId: string;
+    name: string;
+    lifecycle: InteractionLifecycle;
+    placement: InteractionPlacement;
+    controller: InteractionControllerBinding | null;
+    platform: "linux" | "macos" | "windows" | null;
+    adapter: string | null;
+    seatId: string | null;
+    displayId: string | null;
+    capabilities: ComputerSessionCapabilities | null;
+    associations: InteractionAssociation[];
+    createdBySubjectId: string;
+    createdAt: string;
+    lastUsedAt: string;
+    failureCode: string | null;
+};
+export type ComputerTarget = {
+    id: string;
+    computerSessionId: string;
+    controllerGeneration: string;
+    targetGeneration: string;
+    kind: "app" | "window" | "screen";
+    applicationId: string | null;
+    processId: number | null;
+    title: string;
+    bounds: InteractionRect | null;
+    focused: boolean;
+};
+export type ComputerObservation = {
+    protocolVersion: typeof INTERACTION_PROTOCOL_VERSION;
+    observationId: string;
+    computerSessionId: string;
+    target: ComputerTarget;
+    frameId: string | null;
+    semantic: InteractionSemanticSnapshot | InteractionSemanticDiff | null;
+    screenshot: RetainedArtifactReference | null;
+    focusedRef: string | null;
+    changedRegions: InteractionRect[];
+    observedAt: string;
+};
+export type ComputerLocator = {
+    kind: "ref";
+    ref: string;
+} | {
+    kind: "role";
+    role: string;
+    name?: string | undefined;
+    exact?: boolean | undefined;
+} | {
+    kind: "label";
+    text: string;
+    exact?: boolean | undefined;
+} | {
+    kind: "text";
+    text: string;
+    exact?: boolean | undefined;
+} | {
+    kind: "identifier";
+    value: string;
+};
+export type ComputerAction = {
+    type: "semantic";
+    locator: ComputerLocator;
+    action: "invoke" | "focus" | "set_value" | "increment" | "decrement" | "select" | "deselect" | "expand" | "collapse" | "show_menu" | "scroll_into_view";
+    value?: string | number | boolean | undefined;
+} | {
+    type: "pointer";
+    frameId: string;
+    action: "click" | "double_click" | "move" | "scroll" | "drag";
+    x: number;
+    y: number;
+    endX?: number | undefined;
+    endY?: number | undefined;
+    deltaX?: number | undefined;
+    deltaY?: number | undefined;
+    button?: "left" | "right" | "middle" | undefined;
+} | {
+    type: "keyboard";
+    action: "type" | "press";
+    value: string;
+} | {
+    type: "clipboard";
+    operation: "write" | "clear" | "copy" | "paste";
+    text?: string | undefined;
+} | {
+    type: "focus";
+    targetId: string;
+} | {
+    type: "launch";
+    applicationId: string;
+};
+export type CreateComputerSessionRequest = {
+    operationId: string;
+    sessionId: string;
+    name?: string | undefined;
+    placement?: InteractionPlacement | undefined;
+};
+export type ComputerSessionListResponse = {
+    revision: number;
+    sessions: ComputerSession[];
+};
+export type ComputerSessionMutationResponse = {
+    session: ComputerSession;
+    operation: InteractionLifecycleOperationReceipt;
+};
+export type ComputerSessionLifecycleRequest = {
+    operationId: string;
+};
+export type ComputerTargetListResponse = {
+    computerSessionId: string;
+    controllerGeneration: string;
+    targets: ComputerTarget[];
+};
+export type InteractionFrameStreamOptions = {
+    format?: "jpeg" | "png" | undefined;
+    quality?: number | undefined;
+    maxWidth?: number | undefined;
+    maxHeight?: number | undefined;
+    everyNthFrame?: number | undefined;
+};
+export type ComputerFrameStreamOptions = InteractionFrameStreamOptions;
+export type ComputerSessionAttachment = {
+    computerSessionId: string;
+    controllerGeneration: string;
+    targetId: string;
+    stream: ComputerFrameStreamAttachment;
+    expiresAt: string;
+};
+export type ComputerSessionAttachmentRequest = {
+    targetId: string;
+    expiresInSeconds?: number | undefined;
+    stream?: ComputerFrameStreamOptions | undefined;
+};
+export type ComputerActionRequest = {
+    operationId: string;
+    targetId: string;
+    expectedTargetGeneration: string;
+    expectedObservationId: string | null;
+    expectedFrameId: string | null;
+    action: ComputerAction;
+};
+export type ComputerActionReceipt = {
+    protocolVersion: typeof INTERACTION_PROTOCOL_VERSION;
+    operationId: string;
+    computerSessionId: string;
+    controllerGeneration: string;
+    targetId: string;
+    state: InteractionOperationState;
+    dispatchedAt: string | null;
+    settledAt: string | null;
+    observation: ComputerObservation | null;
+    error: InteractionError | null;
+};
+export type ComputerSessionHeartbeatResponse = {
+    computerSessionId: string;
+    controllerGeneration: string;
+    alive: true;
+};
+export type BrowserDiagnosticsOptions = {
+    kinds?: BrowserDiagnosticKind[] | undefined;
+    after?: number | undefined;
+    limit?: number | undefined;
+    signal?: AbortSignal | undefined;
+};
+/** The exact HTTP surface needed by the framework-free interaction client. */
+export interface InteractionTransport {
+    listNetworkRoutes(workspaceId: string, options?: NetworkRouteListOptions): Promise<NetworkRouteListResponse>;
+    getNetworkRoute(workspaceId: string, networkRouteId: string, options?: OpenGeniRequestOptions): Promise<NetworkRoute>;
+    createNetworkRoute(workspaceId: string, request: CreateNetworkRouteRequest, options?: OpenGeniRequestOptions): Promise<NetworkRouteMutationResponse>;
+    updateNetworkRoute(workspaceId: string, networkRouteId: string, request: UpdateNetworkRouteRequest, options?: OpenGeniRequestOptions): Promise<NetworkRouteMutationResponse>;
+    listSiteAuthConnections(workspaceId: string, options?: SiteAuthConnectionListOptions): Promise<SiteAuthConnectionListResponse>;
+    getSiteAuthConnection(workspaceId: string, siteAuthConnectionId: string, options?: OpenGeniRequestOptions): Promise<SiteAuthConnection>;
+    createSiteAuthConnection(workspaceId: string, request: CreateSiteAuthConnectionRequest, options?: OpenGeniRequestOptions): Promise<SiteAuthConnectionMutationResponse>;
+    updateSiteAuthConnection(workspaceId: string, siteAuthConnectionId: string, request: UpdateSiteAuthConnectionRequest, options?: OpenGeniRequestOptions): Promise<SiteAuthConnectionMutationResponse>;
+    listAuthRuns(workspaceId: string, options?: AuthRunListOptions): Promise<AuthRunListResponse>;
+    getAuthRun(workspaceId: string, authRunId: string, options?: OpenGeniRequestOptions): Promise<AuthRun>;
+    startBrowserAuthRun(workspaceId: string, browserSessionId: string, request: StartAuthRunRequest, options?: OpenGeniRequestOptions): Promise<AuthRunMutationResponse>;
+    reportBrowserAuthRun(workspaceId: string, browserSessionId: string, authRunId: string, request: ReportAuthRunRequest, options?: OpenGeniRequestOptions): Promise<AuthRunMutationResponse>;
+    protectedBrowserAuthFill(workspaceId: string, browserSessionId: string, authRunId: string, request: ProtectedAuthFillRequest, options?: OpenGeniRequestOptions): Promise<ProtectedAuthFillResponse>;
+    advanceExternalBrowserAuthRun(workspaceId: string, browserSessionId: string, authRunId: string, request: ExternalAuthRunRequest, options?: OpenGeniRequestOptions): Promise<ExternalAuthRunResponse>;
+    openExternalBrowserAuthFlow(workspaceId: string, browserSessionId: string, authRunId: string, request: ExternalAuthInteractiveRequest, options?: OpenGeniRequestOptions): Promise<ExternalAuthInteractiveResponse>;
+    verifyBrowserAuthRun(workspaceId: string, browserSessionId: string, authRunId: string, request: VerifyAuthRunRequest, options?: OpenGeniRequestOptions): Promise<AuthRunMutationResponse>;
+    listInteractionInterventions(workspaceId: string, options?: InteractionInterventionListOptions): Promise<InteractionInterventionListResponse>;
+    getInteractionIntervention(workspaceId: string, interventionId: string, options?: OpenGeniRequestOptions): Promise<InteractionIntervention>;
+    createInteractionIntervention(workspaceId: string, request: CreateInteractionInterventionRequest, options?: OpenGeniRequestOptions): Promise<InteractionInterventionMutationResponse>;
+    resolveInteractionIntervention(workspaceId: string, interventionId: string, request: ResolveInteractionInterventionRequest, options?: OpenGeniRequestOptions): Promise<InteractionInterventionMutationResponse>;
+    listAttachedBrowsers(workspaceId: string, options?: AttachedBrowserDeviceListOptions): Promise<AttachedBrowserDeviceListResponse>;
+    getAttachedBrowser(workspaceId: string, deviceId: string, options?: OpenGeniRequestOptions): Promise<AttachedBrowserDevice>;
+    listBrowserIdentities(workspaceId: string, options?: BrowserIdentityListOptions): Promise<BrowserIdentityListResponse>;
+    getBrowserIdentity(workspaceId: string, identityId: string, options?: OpenGeniRequestOptions): Promise<BrowserIdentity>;
+    createBrowserIdentity(workspaceId: string, request: CreateBrowserIdentityRequest, options?: OpenGeniRequestOptions): Promise<BrowserIdentityMutationResponse>;
+    updateBrowserIdentity(workspaceId: string, identityId: string, request: UpdateBrowserIdentityRequest, options?: OpenGeniRequestOptions): Promise<BrowserIdentityMutationResponse>;
+    listBrowserRevisions(workspaceId: string, identityId: string, options?: OpenGeniRequestOptions): Promise<BrowserRevisionListResponse>;
+    listBrowserSessions(workspaceId: string, options?: OpenGeniRequestOptions): Promise<BrowserSessionListResponse>;
+    getBrowserSession(workspaceId: string, browserSessionId: string, options?: OpenGeniRequestOptions): Promise<BrowserSession>;
+    readBrowserClipboard(workspaceId: string, browserSessionId: string, options?: OpenGeniRequestOptions): Promise<BrowserClipboard>;
+    listBrowserDownloads(workspaceId: string, browserSessionId: string, options?: OpenGeniRequestOptions): Promise<BrowserDownloadListResponse>;
+    getBrowserDownload(workspaceId: string, browserSessionId: string, downloadId: string, options?: OpenGeniRequestOptions): Promise<BrowserDownload>;
+    saveBrowserDownload(workspaceId: string, browserSessionId: string, downloadId: string, request: BrowserDownloadSaveRequest, options?: OpenGeniRequestOptions): Promise<BrowserDownloadSaveResponse>;
+    createBrowserSession(workspaceId: string, request: CreateBrowserSessionRequest, options?: OpenGeniRequestOptions): Promise<BrowserSessionMutationResponse>;
+    listBrowserTargets(workspaceId: string, browserSessionId: string, options?: OpenGeniRequestOptions): Promise<BrowserTargetListResponse>;
+    openBrowserTarget(workspaceId: string, browserSessionId: string, request?: BrowserOpenTargetRequest, options?: OpenGeniRequestOptions): Promise<BrowserObservation>;
+    selectBrowserTarget(workspaceId: string, browserSessionId: string, targetId: string, options?: OpenGeniRequestOptions): Promise<BrowserObservation>;
+    closeBrowserTarget(workspaceId: string, browserSessionId: string, targetId: string, options?: OpenGeniRequestOptions): Promise<BrowserTargetListResponse>;
+    observeBrowserTarget(workspaceId: string, browserSessionId: string, targetId: string, options?: OpenGeniRequestOptions): Promise<BrowserObservation>;
+    actInBrowser(workspaceId: string, browserSessionId: string, request: BrowserActionRequest, options?: OpenGeniRequestOptions): Promise<BrowserActionReceipt>;
+    getBrowserActionReceipt(workspaceId: string, browserSessionId: string, operationId: string, options?: OpenGeniRequestOptions): Promise<BrowserActionReceipt>;
+    listBrowserDiagnostics(workspaceId: string, browserSessionId: string, targetId: string, options?: BrowserDiagnosticsOptions): Promise<BrowserDiagnosticBatch>;
+    attachBrowserSession(workspaceId: string, browserSessionId: string, request: BrowserSessionAttachmentRequest, options?: OpenGeniRequestOptions): Promise<BrowserSessionAttachment>;
+    heartbeatBrowserSession(workspaceId: string, browserSessionId: string, options?: OpenGeniRequestOptions): Promise<BrowserSessionHeartbeatResponse>;
+    publishBrowserRevision(workspaceId: string, browserSessionId: string, request: PublishBrowserRevisionRequest, options?: OpenGeniRequestOptions): Promise<PublishBrowserRevisionResponse>;
+    suspendBrowserSession(workspaceId: string, browserSessionId: string, request: BrowserSessionLifecycleRequest, options?: OpenGeniRequestOptions): Promise<BrowserSessionMutationResponse>;
+    resumeBrowserSession(workspaceId: string, browserSessionId: string, request: BrowserSessionLifecycleRequest, options?: OpenGeniRequestOptions): Promise<BrowserSessionMutationResponse>;
+    endBrowserSession(workspaceId: string, browserSessionId: string, request: BrowserSessionLifecycleRequest, options?: OpenGeniRequestOptions): Promise<BrowserSessionMutationResponse>;
+    listComputerSessions(workspaceId: string, options?: OpenGeniRequestOptions): Promise<ComputerSessionListResponse>;
+    getComputerSession(workspaceId: string, computerSessionId: string, options?: OpenGeniRequestOptions): Promise<ComputerSession>;
+    readComputerClipboard(workspaceId: string, computerSessionId: string, options?: OpenGeniRequestOptions): Promise<ComputerClipboard>;
+    createComputerSession(workspaceId: string, request: CreateComputerSessionRequest, options?: OpenGeniRequestOptions): Promise<ComputerSessionMutationResponse>;
+    listComputerTargets(workspaceId: string, computerSessionId: string, options?: OpenGeniRequestOptions): Promise<ComputerTargetListResponse>;
+    observeComputerTarget(workspaceId: string, computerSessionId: string, targetId: string, options?: OpenGeniRequestOptions): Promise<ComputerObservation>;
+    actInComputer(workspaceId: string, computerSessionId: string, request: ComputerActionRequest, options?: OpenGeniRequestOptions): Promise<ComputerActionReceipt>;
+    getComputerActionReceipt(workspaceId: string, computerSessionId: string, operationId: string, options?: OpenGeniRequestOptions): Promise<ComputerActionReceipt>;
+    attachComputerSession(workspaceId: string, computerSessionId: string, request: ComputerSessionAttachmentRequest, options?: OpenGeniRequestOptions): Promise<ComputerSessionAttachment>;
+    heartbeatComputerSession(workspaceId: string, computerSessionId: string, options?: OpenGeniRequestOptions): Promise<ComputerSessionHeartbeatResponse>;
+    endComputerSession(workspaceId: string, computerSessionId: string, request: ComputerSessionLifecycleRequest, options?: OpenGeniRequestOptions): Promise<ComputerSessionMutationResponse>;
+}
+/** @deprecated Use InteractionTransport. */
+export type BrowserInteractionTransport = InteractionTransport;
+export type BrowserIdentityListOptions = OpenGeniRequestOptions & {
+    includeArchived?: boolean | undefined;
+};
+export type NetworkRouteListOptions = OpenGeniRequestOptions & {
+    includeArchived?: boolean | undefined;
+};
+export type SiteAuthConnectionListOptions = OpenGeniRequestOptions & {
+    includeArchived?: boolean | undefined;
+};
+export type AuthRunListOptions = OpenGeniRequestOptions & {
+    browserSessionId?: string | undefined;
+    siteAuthConnectionId?: string | undefined;
+    includeSettled?: boolean | undefined;
+};
+export type InteractionInterventionListOptions = OpenGeniRequestOptions & {
+    resourceKind?: "browser_session" | "computer_session" | undefined;
+    resourceId?: string | undefined;
+    includeSettled?: boolean | undefined;
+};
+export type AttachedBrowserDeviceListOptions = OpenGeniRequestOptions & {
+    includeDisconnected?: boolean | undefined;
+};
+export type BrowserDownloadSaveOptions = OpenGeniRequestOptions & {
+    operationId?: string | undefined;
+    overwrite?: boolean | undefined;
+};
+export type CurrentOrOpenBrowserOptions = {
+    workspaceId: string;
+    associationSessionId: string;
+    operationId?: string | undefined;
+    name?: string | undefined;
+    initialUrl?: string | undefined;
+    headless?: boolean | undefined;
+    placement?: InteractionPlacement | undefined;
+    identityId?: string | undefined;
+    baseRevisionId?: string | undefined;
+    networkRouteId?: string | undefined;
+    linkedComputerSessionId?: string | undefined;
+    signal?: AbortSignal | undefined;
+};
+export type CurrentOrOpenComputerOptions = {
+    workspaceId: string;
+    associationSessionId: string;
+    operationId?: string | undefined;
+    name?: string | undefined;
+    placement?: InteractionPlacement | undefined;
+    signal?: AbortSignal | undefined;
+};
+/** Framework-free resource facade over the public interaction HTTP API. */
+export declare class OpenGeniInteractionClient {
+    readonly attachedBrowsers: AttachedBrowserDeviceCollection;
+    readonly authRuns: AuthRunCollection;
+    readonly browsers: BrowserSessionCollection;
+    readonly computers: ComputerSessionCollection;
+    readonly identities: BrowserIdentityCollection;
+    readonly interventions: InteractionInterventionCollection;
+    readonly networkRoutes: NetworkRouteCollection;
+    readonly siteAuthConnections: SiteAuthConnectionCollection;
+    constructor(transport: BrowserInteractionTransport);
+}
+export declare class NetworkRouteCollection {
+    private readonly transport;
+    constructor(transport: BrowserInteractionTransport);
+    list(workspaceId: string, options?: NetworkRouteListOptions): Promise<NetworkRouteListResponse>;
+    route(workspaceId: string, networkRouteId: string): NetworkRouteResource;
+    create(workspaceId: string, request: CreateNetworkRouteRequest, options?: OpenGeniRequestOptions): Promise<NetworkRouteResource>;
+}
+export declare class NetworkRouteResource {
+    private readonly transport;
+    readonly workspaceId: string;
+    readonly id: string;
+    constructor(transport: BrowserInteractionTransport, workspaceId: string, id: string);
+    get(options?: OpenGeniRequestOptions): Promise<NetworkRoute>;
+    update(request: UpdateNetworkRouteRequest, options?: OpenGeniRequestOptions): Promise<NetworkRouteMutationResponse>;
+}
+export declare class SiteAuthConnectionCollection {
+    private readonly transport;
+    constructor(transport: BrowserInteractionTransport);
+    list(workspaceId: string, options?: SiteAuthConnectionListOptions): Promise<SiteAuthConnectionListResponse>;
+    connection(workspaceId: string, connectionId: string): SiteAuthConnectionResource;
+    create(workspaceId: string, request: CreateSiteAuthConnectionRequest, options?: OpenGeniRequestOptions): Promise<SiteAuthConnectionResource>;
+}
+export declare class SiteAuthConnectionResource {
+    private readonly transport;
+    readonly workspaceId: string;
+    readonly id: string;
+    constructor(transport: BrowserInteractionTransport, workspaceId: string, id: string);
+    get(options?: OpenGeniRequestOptions): Promise<SiteAuthConnection>;
+    update(request: UpdateSiteAuthConnectionRequest, options?: OpenGeniRequestOptions): Promise<SiteAuthConnectionMutationResponse>;
+}
+export declare class AuthRunCollection {
+    private readonly transport;
+    constructor(transport: BrowserInteractionTransport);
+    list(workspaceId: string, options?: AuthRunListOptions): Promise<AuthRunListResponse>;
+    get(workspaceId: string, authRunId: string, options?: OpenGeniRequestOptions): Promise<AuthRun>;
+    run(workspaceId: string, browserSessionId: string, authRunId: string): AuthRunResource;
+}
+export declare class BrowserAuthRunCollection {
+    private readonly transport;
+    readonly workspaceId: string;
+    readonly browserSessionId: string;
+    constructor(transport: BrowserInteractionTransport, workspaceId: string, browserSessionId: string);
+    list(options?: Omit<AuthRunListOptions, "browserSessionId">): Promise<AuthRunListResponse>;
+    run(authRunId: string): AuthRunResource;
+    start(request: StartAuthRunRequest, options?: OpenGeniRequestOptions): Promise<AuthRunResource>;
+}
+export declare class AuthRunResource {
+    private readonly transport;
+    readonly workspaceId: string;
+    readonly browserSessionId: string;
+    readonly id: string;
+    constructor(transport: BrowserInteractionTransport, workspaceId: string, browserSessionId: string, id: string);
+    get(options?: OpenGeniRequestOptions): Promise<AuthRun>;
+    report(request: ReportAuthRunRequest, options?: OpenGeniRequestOptions): Promise<AuthRunMutationResponse>;
+    protectedFill(request: ProtectedAuthFillRequest, options?: OpenGeniRequestOptions): Promise<ProtectedAuthFillResponse>;
+    advanceExternal(request: ExternalAuthRunRequest, options?: OpenGeniRequestOptions): Promise<ExternalAuthRunResponse>;
+    /** Human-session helper. Hosted provider URLs never appear in model tools. */
+    openExternalFlow(request: ExternalAuthInteractiveRequest, options?: OpenGeniRequestOptions): Promise<ExternalAuthInteractiveResponse>;
+    verify(request: VerifyAuthRunRequest, options?: OpenGeniRequestOptions): Promise<AuthRunMutationResponse>;
+}
+export declare class InteractionInterventionCollection {
+    private readonly transport;
+    constructor(transport: BrowserInteractionTransport);
+    list(workspaceId: string, options?: InteractionInterventionListOptions): Promise<InteractionInterventionListResponse>;
+    intervention(workspaceId: string, interventionId: string): InteractionInterventionResource;
+    create(workspaceId: string, request: CreateInteractionInterventionRequest, options?: OpenGeniRequestOptions): Promise<InteractionInterventionResource>;
+}
+export declare class InteractionInterventionResource {
+    private readonly transport;
+    readonly workspaceId: string;
+    readonly id: string;
+    constructor(transport: BrowserInteractionTransport, workspaceId: string, id: string);
+    get(options?: OpenGeniRequestOptions): Promise<InteractionIntervention>;
+    resolve(request: ResolveInteractionInterventionRequest, options?: OpenGeniRequestOptions): Promise<InteractionInterventionMutationResponse>;
+}
+export declare class AttachedBrowserDeviceCollection {
+    private readonly transport;
+    constructor(transport: BrowserInteractionTransport);
+    list(workspaceId: string, options?: AttachedBrowserDeviceListOptions): Promise<AttachedBrowserDeviceListResponse>;
+    device(workspaceId: string, deviceId: string): AttachedBrowserDeviceResource;
+}
+export declare class AttachedBrowserDeviceResource {
+    private readonly transport;
+    readonly workspaceId: string;
+    readonly id: string;
+    constructor(transport: BrowserInteractionTransport, workspaceId: string, id: string);
+    get(options?: OpenGeniRequestOptions): Promise<AttachedBrowserDevice>;
+}
+export declare class BrowserIdentityCollection {
+    private readonly transport;
+    constructor(transport: BrowserInteractionTransport);
+    list(workspaceId: string, options?: BrowserIdentityListOptions): Promise<BrowserIdentityListResponse>;
+    identity(workspaceId: string, identityId: string): BrowserIdentityResource;
+    create(workspaceId: string, request: CreateBrowserIdentityRequest, options?: OpenGeniRequestOptions): Promise<BrowserIdentityResource>;
+}
+export declare class BrowserIdentityResource {
+    private readonly transport;
+    readonly workspaceId: string;
+    readonly id: string;
+    constructor(transport: BrowserInteractionTransport, workspaceId: string, id: string);
+    get(options?: OpenGeniRequestOptions): Promise<BrowserIdentity>;
+    revisions(options?: OpenGeniRequestOptions): Promise<BrowserRevisionListResponse>;
+    update(request: UpdateBrowserIdentityRequest, options?: OpenGeniRequestOptions): Promise<BrowserIdentityMutationResponse>;
+}
+export declare class BrowserSessionCollection {
+    private readonly transport;
+    constructor(transport: BrowserInteractionTransport);
+    list(workspaceId: string, options?: OpenGeniRequestOptions): Promise<BrowserSessionListResponse>;
+    session(workspaceId: string, browserSessionId: string): BrowserSessionResource;
+    open(workspaceId: string, request: CreateBrowserSessionRequest, options?: OpenGeniRequestOptions): Promise<BrowserSessionResource>;
+    currentOrOpen(options: CurrentOrOpenBrowserOptions): Promise<BrowserSessionResource>;
+}
+export declare class BrowserSessionResource {
+    private readonly transport;
+    readonly workspaceId: string;
+    readonly id: string;
+    readonly auth: BrowserAuthRunCollection;
+    readonly clipboard: BrowserClipboardResource;
+    readonly downloads: BrowserDownloadCollection;
+    readonly tabs: BrowserTargetCollection;
+    /** Alias for hosts that prefer the protocol term. */
+    readonly targets: BrowserTargetCollection;
+    constructor(transport: BrowserInteractionTransport, workspaceId: string, id: string);
+    get(options?: OpenGeniRequestOptions): Promise<BrowserSession>;
+    observe(targetId: string, options?: OpenGeniRequestOptions): Promise<BrowserObservation>;
+    act(request: BrowserActionRequest, options?: OpenGeniRequestOptions): Promise<BrowserActionReceipt>;
+    receipt(operationId: string, options?: OpenGeniRequestOptions): Promise<BrowserActionReceipt>;
+    diagnostics(targetId: string, options?: BrowserDiagnosticsOptions): Promise<BrowserDiagnosticBatch>;
+    attach(request: BrowserSessionAttachmentRequest, options?: OpenGeniRequestOptions): Promise<BrowserSessionAttachment>;
+    heartbeat(options?: OpenGeniRequestOptions): Promise<BrowserSessionHeartbeatResponse>;
+    publishRevision(request: PublishBrowserRevisionRequest, options?: OpenGeniRequestOptions): Promise<PublishBrowserRevisionResponse>;
+    suspend(request?: BrowserSessionLifecycleRequest, options?: OpenGeniRequestOptions): Promise<BrowserSessionMutationResponse>;
+    resume(request?: BrowserSessionLifecycleRequest, options?: OpenGeniRequestOptions): Promise<BrowserSessionMutationResponse>;
+    end(request?: BrowserSessionLifecycleRequest, options?: OpenGeniRequestOptions): Promise<BrowserSessionMutationResponse>;
+}
+export declare class BrowserClipboardResource {
+    private readonly transport;
+    readonly workspaceId: string;
+    readonly browserSessionId: string;
+    constructor(transport: BrowserInteractionTransport, workspaceId: string, browserSessionId: string);
+    read(options?: OpenGeniRequestOptions): Promise<BrowserClipboard>;
+}
+export declare class BrowserDownloadCollection {
+    private readonly transport;
+    readonly workspaceId: string;
+    readonly browserSessionId: string;
+    constructor(transport: BrowserInteractionTransport, workspaceId: string, browserSessionId: string);
+    list(options?: OpenGeniRequestOptions): Promise<BrowserDownloadListResponse>;
+    download(downloadId: string): BrowserDownloadResource;
+}
+export declare class BrowserDownloadResource {
+    private readonly transport;
+    readonly workspaceId: string;
+    readonly browserSessionId: string;
+    readonly id: string;
+    constructor(transport: BrowserInteractionTransport, workspaceId: string, browserSessionId: string, id: string);
+    get(options?: OpenGeniRequestOptions): Promise<BrowserDownload>;
+    /** Publish this exact private browser download into the source session's
+     * workspace. Pass an operationId when the caller needs retry identity across
+     * process boundaries; otherwise one is generated for this call. */
+    saveToWorkspace(destinationPath: string, options?: BrowserDownloadSaveOptions): Promise<BrowserDownloadSaveResponse>;
+}
+export declare class BrowserTargetCollection {
+    private readonly transport;
+    private readonly workspaceId;
+    private readonly browserSessionId;
+    constructor(transport: BrowserInteractionTransport, workspaceId: string, browserSessionId: string);
+    list(options?: OpenGeniRequestOptions): Promise<BrowserTargetListResponse>;
+    open(url?: string, options?: OpenGeniRequestOptions): Promise<BrowserObservation>;
+    select(targetId: string, options?: OpenGeniRequestOptions): Promise<BrowserObservation>;
+    close(targetId: string, options?: OpenGeniRequestOptions): Promise<BrowserTargetListResponse>;
+}
+export declare class ComputerSessionCollection {
+    private readonly transport;
+    constructor(transport: BrowserInteractionTransport);
+    list(workspaceId: string, options?: OpenGeniRequestOptions): Promise<ComputerSessionListResponse>;
+    session(workspaceId: string, computerSessionId: string): ComputerSessionResource;
+    open(workspaceId: string, request: CreateComputerSessionRequest, options?: OpenGeniRequestOptions): Promise<ComputerSessionResource>;
+    currentOrOpen(options: CurrentOrOpenComputerOptions): Promise<ComputerSessionResource>;
+}
+export declare class ComputerSessionResource {
+    private readonly transport;
+    readonly workspaceId: string;
+    readonly id: string;
+    readonly targets: ComputerTargetCollection;
+    /** Native application/window targets are also the public app collection. */
+    readonly apps: ComputerTargetCollection;
+    readonly clipboard: ComputerClipboardResource;
+    constructor(transport: BrowserInteractionTransport, workspaceId: string, id: string);
+    get(options?: OpenGeniRequestOptions): Promise<ComputerSession>;
+    observe(targetId: string, options?: OpenGeniRequestOptions): Promise<ComputerObservation>;
+    act(request: ComputerActionRequest, options?: OpenGeniRequestOptions): Promise<ComputerActionReceipt>;
+    receipt(operationId: string, options?: OpenGeniRequestOptions): Promise<ComputerActionReceipt>;
+    attach(request: ComputerSessionAttachmentRequest, options?: OpenGeniRequestOptions): Promise<ComputerSessionAttachment>;
+    heartbeat(options?: OpenGeniRequestOptions): Promise<ComputerSessionHeartbeatResponse>;
+    end(request?: ComputerSessionLifecycleRequest, options?: OpenGeniRequestOptions): Promise<ComputerSessionMutationResponse>;
+}
+export declare class ComputerClipboardResource {
+    private readonly transport;
+    readonly workspaceId: string;
+    readonly computerSessionId: string;
+    constructor(transport: BrowserInteractionTransport, workspaceId: string, computerSessionId: string);
+    read(options?: OpenGeniRequestOptions): Promise<ComputerClipboard>;
+}
+export declare class ComputerTargetCollection {
+    private readonly transport;
+    private readonly workspaceId;
+    private readonly computerSessionId;
+    constructor(transport: BrowserInteractionTransport, workspaceId: string, computerSessionId: string);
+    list(options?: OpenGeniRequestOptions): Promise<ComputerTargetListResponse>;
+}
+export type BrowserFrameMetadata = {
+    frameId: string;
+    browserSessionId: string;
+    controllerGeneration: string;
+    targetId: string;
+    targetGeneration: string;
+    documentGeneration: string;
+    sequence: number;
+    mediaType: "image/jpeg" | "image/png";
+    width: number;
+    height: number;
+    deviceScaleFactor: number;
+    scrollX: number;
+    scrollY: number;
+    capturedAt: string;
+};
+export type BrowserFrame = BrowserFrameMetadata & {
+    data: Uint8Array;
+};
+export type ComputerFrameMetadata = {
+    frameId: string;
+    computerSessionId: string;
+    controllerGeneration: string;
+    targetId: string;
+    targetGeneration: string;
+    sequence: number;
+    mediaType: "image/jpeg" | "image/png";
+    width: number;
+    height: number;
+    capturedAt: string;
+    sha256: string;
+};
+export type ComputerFrame = ComputerFrameMetadata & {
+    data: Uint8Array;
+};
+export type BrowserFrameStreamOptions = InteractionFrameStreamOptions;
+/** Convert a short-lived HTTP attachment URL into its browser WebSocket URL. */
+export declare function browserFrameSocketUrl(attachment: BrowserSessionAttachment, options?: BrowserFrameStreamOptions): string;
+/** Convert a direct ComputerSession attachment into its WebSocket URL. */
+export declare function computerFrameSocketUrl(attachment: ComputerSessionAttachment, options?: ComputerFrameStreamOptions): string;
+/** Decode one bounded binary frame message from the placement controller. */
+export declare function decodeBrowserFrameMessage(message: ArrayBuffer | Uint8Array): BrowserFrame;
+/** Decode and authenticate one bounded ComputerSession frame. Computer frames
+ * carry a content digest because native capture adapters may cross process and
+ * relay boundaries before reaching the SDK. */
+export declare function decodeComputerFrameMessage(message: ArrayBuffer | Uint8Array): Promise<ComputerFrame>;
+export declare function parseBrowserFrameMetadata(value: unknown): BrowserFrameMetadata;
+export declare function parseComputerFrameMetadata(value: unknown): ComputerFrameMetadata;