@beeuni/sdk 0.2.0 → 0.3.0

package/dist/core/client/session-readiness.d.ts

@@ -1,8 +1,10 @@
 import { type BeeuniPlatformConfig } from '../http/config.js';
+import type { ProjectSession } from '../rest/projects-client/sessions.js';
 import { type SessionRuntimeEntry } from '../session/session-runtime-registry.js';
 export declare function bindSessionReadiness(projectId: string, sessionId: string, config: BeeuniPlatformConfig): {
     ensureReady: (opts?: {
         readyTimeoutMs?: number;
+        session?: ProjectSession;
     }) => Promise<SessionRuntimeEntry>;
     tryResolveReady: () => SessionRuntimeEntry | null;
     requireReady: (action: string) => SessionRuntimeEntry;

package/dist/core/client/session-readiness.js

@@ -1,6 +1,9 @@
 import { platformConfig } from '../http/config.js';
+import { projectSessionStartSeed } from '../rest/projects-client/session-sandbox.js';
+import { setCurrentRuntime } from '../session/current-runtime.js';
 import { loadPreviewUrlTemplate } from '../session/preview-config.js';
-import { clearSessionRuntime, getSessionRuntime, } from '../session/session-runtime-registry.js';
+import { getSandboxUrlForExternalId } from '../session/server-store/url-helpers.js';
+import { clearSessionRuntime, getSessionRuntime, setSessionRuntime, } from '../session/session-runtime-registry.js';
 import { SessionNotReadyError, inFlightSessionStarts } from './session-shared.js';
 import { bindSessionStart } from './session-start.js';
 export function bindSessionReadiness(projectId, sessionId, config) {
@@ -20,6 +23,22 @@ export function bindSessionReadiness(projectId, sessionId, config) {
             return cached;
         const readyTimeoutMs = opts?.readyTimeoutMs ?? 180_000;
         const previewConfig = loadPreviewUrlTemplate(platformConfig().backendUrl ?? config.backendUrl).catch(() => null);
+        const seed = opts?.session?.session_id === sessionId ? projectSessionStartSeed(opts.session) : null;
+        const seededSandbox = seed?.sandbox?.external_id;
+        const seededRuntimeSession = seed?.runtime_session_id;
+        if (seededSandbox && seededRuntimeSession) {
+            const runtimeUrl = getSandboxUrlForExternalId(seededSandbox);
+            setCurrentRuntime(runtimeUrl, seededSandbox);
+            _ready = {
+                runtimeSessionId: seededRuntimeSession,
+                opencodeSessionId: seededRuntimeSession,
+                runtimeUrl,
+                sandboxId: seededSandbox,
+            };
+            setSessionRuntime(projectId, sessionId, _ready);
+            await previewConfig;
+            return _ready;
+        }
         const key = `${projectId}\n${sessionId}`;
         const inFlight = inFlightSessionStarts.get(key);
         if (inFlight) {

package/dist/core/http/api-client.d.ts

@@ -21,6 +21,7 @@ export interface ApiResponse<T = any> {
 export declare const FEATURE_NOT_SUPPORTED_CODE = "feature_not_supported";
 export declare const MODEL_NOT_SERVABLE_CODE = "model_not_servable";
 export declare const PROVISION_IN_FLIGHT_CODE = "provision_in_flight";
+export declare const SANDBOX_STATE_CHANGE_IN_PROGRESS_CODE = "sandbox_state_change_in_progress";
 export declare const ANALYTICS_UNAVAILABLE_CODE = "analytics_unavailable";
 export declare const ACCOUNTS_LIST_UNAVAILABLE_CODE = "accounts_list_unavailable";
 declare function postStream(endpoint: string, data: unknown, options?: ApiClientOptions): Promise<Response>;

package/dist/core/http/api-client.js

@@ -8,6 +8,7 @@ export { ApiError, AuthError, BillingError, RequestTooLargeError, parseBillingEr
 export const FEATURE_NOT_SUPPORTED_CODE = 'feature_not_supported';
 export const MODEL_NOT_SERVABLE_CODE = 'model_not_servable';
 export const PROVISION_IN_FLIGHT_CODE = 'provision_in_flight';
+export const SANDBOX_STATE_CHANGE_IN_PROGRESS_CODE = 'sandbox_state_change_in_progress';
 export const ANALYTICS_UNAVAILABLE_CODE = 'analytics_unavailable';
 export const ACCOUNTS_LIST_UNAVAILABLE_CODE = 'accounts_list_unavailable';
 async function postStream(endpoint, data, options = {}) {

package/dist/core/http/config.d.ts

@@ -10,11 +10,13 @@ export interface BeeuniPlatformConfig {
     getToken: (() => Promise<string | null>) & {
         invalidate?: (rejectedToken: string) => void;
     };
+    credentialHeader?: string;
     fetch?: (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
     eventStreamTransport?: RuntimeEventTransport;
     clientSource?: 'api' | 'cli' | 'mobile' | 'tui' | 'web';
     clientVersion?: string;
     onError?: (error: unknown, context?: unknown) => void;
+    onAccessRemedy?: (code: 'sso_required' | 'account_mfa_required') => void;
     sandboxId?: string | null;
     billingEnabled?: boolean;
     getUserId?: () => Promise<string | null>;

package/dist/core/http/response-error.js

@@ -1,5 +1,5 @@
 import { abortable, createAbortError } from './abort.js';
-import { ACCOUNTS_LIST_UNAVAILABLE_CODE, ANALYTICS_UNAVAILABLE_CODE, FEATURE_NOT_SUPPORTED_CODE, MODEL_NOT_SERVABLE_CODE, PROVISION_IN_FLIGHT_CODE, } from './api-client.js';
+import { ACCOUNTS_LIST_UNAVAILABLE_CODE, ANALYTICS_UNAVAILABLE_CODE, FEATURE_NOT_SUPPORTED_CODE, MODEL_NOT_SERVABLE_CODE, PROVISION_IN_FLIGHT_CODE, SANDBOX_STATE_CHANGE_IN_PROGRESS_CODE, } from './api-client.js';
 import { ApiError, RequestTooLargeError, parseBillingError } from './api/errors.js';
 import { platformConfig } from './config.js';
 const REQUEST_DEADLINE_CODE = 'request_deadline';
@@ -22,6 +22,15 @@ const isGitMirrorUnavailableResponse = (status, errorData, message) => {
         : undefined;
     return (code === GIT_MIRROR_UNAVAILABLE_CODE || LEGACY_GIT_MIRROR_UNAVAILABLE_MESSAGE.test(message));
 };
+const CONNECTORS_PROVIDER_UNAVAILABLE_CODE = 'connectors_provider_unavailable';
+const isConnectorsProviderUnavailableResponse = (status, errorData) => {
+    if (status !== 503)
+        return false;
+    const code = typeof errorData === 'object' && errorData !== null && 'code' in errorData
+        ? errorData.code
+        : undefined;
+    return code === CONNECTORS_PROVIDER_UNAVAILABLE_CODE;
+};
 async function readErrorBody(response, signal) {
     let message = `HTTP ${response.status}: ${response.statusText}`;
     let data = null;
@@ -46,9 +55,12 @@ async function readErrorBody(response, signal) {
 function isExpectedResponse(status, data, message) {
     return (isRequestDeadlineResponse(status, data, message) ||
         isGitMirrorUnavailableResponse(status, data, message) ||
+        isConnectorsProviderUnavailableResponse(status, data) ||
         (status === 501 && data?.code === FEATURE_NOT_SUPPORTED_CODE) ||
         (status === 409 &&
-            (data?.code === MODEL_NOT_SERVABLE_CODE || data?.code === PROVISION_IN_FLIGHT_CODE)) ||
+            (data?.code === MODEL_NOT_SERVABLE_CODE ||
+                data?.code === PROVISION_IN_FLIGHT_CODE ||
+                data?.code === SANDBOX_STATE_CHANGE_IN_PROGRESS_CODE)) ||
         (status === 503 &&
             (data?.code === ANALYTICS_UNAVAILABLE_CODE || data?.code === ACCOUNTS_LIST_UNAVAILABLE_CODE)));
 }
@@ -66,18 +78,21 @@ export async function handleErrorResponse(response, signal, showErrors, errorCon
     });
     if (response.status === 402)
         error = parseBillingError(error);
-    const remedyEvent = response.status !== 403
-        ? null
-        : data?.code === 'account_mfa_required'
-            ? 'beeuni:mfa-required'
-            : data?.code === 'sso_required'
-                ? 'beeuni:sso-required'
-                : null;
-    if (remedyEvent && typeof window !== 'undefined' && typeof window.dispatchEvent === 'function') {
+    const remedyCode = response.status === 403 &&
+        (data?.code === 'account_mfa_required' || data?.code === 'sso_required')
+        ? data.code
+        : null;
+    if (remedyCode) {
         try {
-            window.dispatchEvent(new CustomEvent(remedyEvent));
+            platformConfig().onAccessRemedy?.(remedyCode);
         }
         catch { }
+        if (typeof window !== 'undefined' && typeof window.dispatchEvent === 'function') {
+            try {
+                window.dispatchEvent(new CustomEvent(remedyCode === 'account_mfa_required' ? 'beeuni:mfa-required' : 'beeuni:sso-required'));
+            }
+            catch { }
+        }
     }
     if (response.status === 431) {
         error = new RequestTooLargeError(431, {

package/dist/core/http/transport.js

@@ -45,7 +45,12 @@ function withPlatformHeaders(url, base, token) {
         setHeader(headers, 'x-beeuni-admin-bypass', '1');
     for (const [name, value] of Object.entries(impersonationHeaders(url)))
         setHeader(headers, name, value);
-    if (!hasHeader(headers, 'authorization'))
+    const credentialHeader = platformConfig().credentialHeader?.trim();
+    if (credentialHeader) {
+        if (!hasHeader(headers, credentialHeader))
+            setHeader(headers, credentialHeader, token);
+    }
+    else if (!hasHeader(headers, 'authorization'))
         setHeader(headers, 'Authorization', `Bearer ${token}`);
     return headers;
 }

package/dist/core/models/composer-model.d.ts

@@ -3,6 +3,20 @@ import type { ModelDefaultsResponse } from '../rest/projects-client/model-defaul
 import { type FlatModel } from './model-flatten.js';
 import { type ModelKey } from './model-key.js';
 export declare function resolveModelDefault(data: ModelDefaultsResponse | undefined, agentName: string | undefined): ModelKey | undefined;
+export declare function latestPromptModel(messages: ReadonlyArray<{
+    role: string;
+    model?: {
+        provider?: string;
+        model?: string;
+    } | null;
+}> | null | undefined): ModelKey | undefined;
+export declare function sessionModelCandidates(input: {
+    session?: {
+        metadata?: Record<string, unknown> | null;
+    } | null;
+    lastPromptModel?: ModelKey;
+    gatewayEnabled: boolean;
+}): ModelKey[];
 export interface ComposerModelResolution {
     model: ModelKey | undefined;
     explicit: ModelKey | undefined;

package/dist/core/models/composer-model.js

@@ -1,7 +1,8 @@
 import { autoSeedableModels } from '@beeuni/llm-catalog/lite';
+import { sessionModelPin } from '../rest/projects-client/sessions.js';
 import { healBedrockModelKey } from './bedrock-invokable.js';
 import { isOfferedModel } from './model-flatten.js';
-import { wireToModelKey } from './model-key.js';
+import { modelRefToKey, wireToModelKey } from './model-key.js';
 export function resolveModelDefault(data, agentName) {
     const wire = (agentName ? data?.agentDefaults?.[agentName] : undefined) ??
         data?.projectDefault ??
@@ -9,6 +10,25 @@ export function resolveModelDefault(data, agentName) {
         data?.platformDefault;
     return wire ? wireToModelKey(wire) : undefined;
 }
+export function latestPromptModel(messages) {
+    for (let i = (messages?.length ?? 0) - 1; i >= 0; i--) {
+        const message = messages[i];
+        const { provider, model } = message.model ?? {};
+        if (message.role === 'user' && provider && model)
+            return { providerID: provider, modelID: model };
+    }
+    return undefined;
+}
+const CHOSEN_PIN_SOURCES = new Set(['explicit', 'repointed']);
+export function sessionModelCandidates(input) {
+    const pin = input.session ? sessionModelPin(input.session) : null;
+    const pinKey = pin ? modelRefToKey(pin, input.gatewayEnabled) : undefined;
+    const chosen = CHOSEN_PIN_SOURCES.has(String(input.session?.metadata?.opencode_model_source));
+    const ordered = chosen
+        ? [pinKey, input.lastPromptModel]
+        : [input.lastPromptModel, pinKey];
+    return ordered.filter((model) => !!model);
+}
 export function resolveComposerModel(input) {
     const { models, providers } = input;
     const isValid = (model) => isOfferedModel(models, model);

package/dist/core/rest/platform-client/capture.d.ts

@@ -0,0 +1,363 @@
+import type { CaptureExclusionGroup, CaptureLayer, CaptureMaxHeight } from '../../capture/rules.js';
+export * from '../../capture/rules.js';
+export type CaptureLiveState = 'recording' | 'paused' | 'permission_missing' | 'not_recording' | 'offline' | 'unknown' | (string & {});
+export interface CapturePolicy {
+    layers: {
+        screen: boolean;
+        actions: boolean;
+        audio: boolean;
+    };
+    privacy: {
+        redact_pii: boolean;
+        excluded_bundle_ids: string[];
+        excluded_domains: string[];
+        exclusion_groups: CaptureExclusionGroup[];
+        exclude_private_browsing: boolean;
+    };
+    retention: {
+        local_hours: number;
+        remote_days: number;
+    };
+    recording: {
+        paused: boolean;
+        paused_until_ms: number | null;
+        interval_ms?: number | null;
+        max_height?: CaptureMaxHeight | null;
+    };
+    notice: string;
+    experimental?: {
+        privacy_controls: boolean;
+    };
+}
+export interface CapturePolicyRecord {
+    policy: CapturePolicy;
+    updated_at: string | null;
+    updated_by: string | null;
+}
+export interface CaptureDisplay {
+    id: number;
+    name: string | null;
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+    scale: number | null;
+    main: boolean;
+}
+export interface CaptureFocusSpan {
+    device_id: string;
+    display_id: number;
+    start_at: string;
+    end_at: string;
+}
+export type CaptureHealthReason = 'offline' | 'stalled' | 'error' | 'never_reported' | 'unseen' | 'permission_missing' | 'paused' | 'sync_error' | 'backlog' | 'behind_version';
+export interface CaptureDeviceHealth {
+    state: 'healthy' | 'attention' | 'not_recording';
+    idle: boolean;
+    reasons: CaptureHealthReason[];
+    since: string | null;
+    latest_version: string | null;
+}
+export interface CaptureHealthSummary {
+    recording: number;
+    idle: number;
+    attention: number;
+    not_recording: number;
+    latest_version: string | null;
+}
+export type CaptureHealthBucket = 'recording' | 'idle' | 'attention' | 'not_recording';
+export declare function captureHealthBucket(device: Pick<CaptureDevice, 'health'>): CaptureHealthBucket;
+export interface CaptureDevice {
+    device_id: string;
+    user_id: string | null;
+    name: string | null;
+    os: string | null;
+    os_version: string | null;
+    arch: string | null;
+    app_version: string | null;
+    displays: CaptureDisplay[];
+    live: {
+        state: CaptureLiveState;
+        status: Record<string, unknown> | null;
+        reported_at: string | null;
+    };
+    last_credentials_at: string | null;
+    revoked_at: string | null;
+    health: CaptureDeviceHealth;
+    enrollment_token_id?: string | null;
+    created_at: string;
+}
+export interface CaptureEnrollmentToken {
+    token_id: string;
+    name: string;
+    token_prefix: string;
+    state: 'active' | 'revoked' | 'expired';
+    email_domains: string[];
+    max_devices: number | null;
+    device_count: number;
+    require_approval: boolean;
+    user_id: string | null;
+    expires_at: string | null;
+    revoked_at: string | null;
+    last_used_at: string | null;
+    created_by: string;
+    created_at: string;
+}
+export interface CaptureEnrollmentTokenSecret extends CaptureEnrollmentToken {
+    token: string;
+}
+export interface CaptureEnrollmentTokenInput {
+    name: string;
+    email_domains?: string[];
+    max_devices?: number | null;
+    require_approval?: boolean;
+    expires_in_days?: number | null;
+    user_id?: string | null;
+}
+export type CaptureEnrollmentStatus = 'pending' | 'approved' | 'denied' | 'enrolled';
+export interface CaptureEnrollment {
+    enrollment_id: string;
+    token_id: string;
+    token_name: string | null;
+    status: CaptureEnrollmentStatus;
+    reason: 'approval_required' | null;
+    principal_name: string | null;
+    account_name: string | null;
+    device: {
+        name: string | null;
+        os: string | null;
+        os_version: string | null;
+        arch: string | null;
+        app_version: string | null;
+    };
+    user_id: string | null;
+    device_id: string | null;
+    decided_by: string | null;
+    decided_at: string | null;
+    created_at: string;
+    last_seen_at: string;
+}
+export interface CaptureWindowQuery {
+    day?: string;
+    from?: string;
+    to?: string;
+    userId?: string;
+    deviceId?: string;
+    displayId?: number | 'all';
+}
+export interface CaptureActivityRun {
+    device_id: string;
+    app: string | null;
+    title: string | null;
+    url: string | null;
+    start_at: string;
+    end_at: string;
+    frames: number;
+}
+export interface CaptureChunk {
+    chunk_id: string;
+    device_id: string;
+    kind: 'chunk' | 'audio' | 'actions';
+    start_at: string;
+    end_at: string;
+    item_count: number;
+    encrypted: boolean;
+    display_id: number | null;
+    display: CaptureDisplay | null;
+}
+export interface CaptureTimeline {
+    user_id: string;
+    from: string;
+    to: string;
+    displays: CaptureDisplay[];
+    focus: CaptureFocusSpan[];
+    runs: CaptureActivityRun[];
+    chunks: CaptureChunk[];
+}
+export interface CaptureFrame {
+    frame_id: string;
+    ts: string;
+    device_id: string;
+    chunk_id: string;
+    frame_index: number | null;
+    app: string | null;
+    bundle_id: string | null;
+    title: string | null;
+    url: string | null;
+    domain: string | null;
+    ocr_text: string | null;
+    inactive: boolean;
+    display_id: number | null;
+    focused: boolean;
+    ocr_boxes?: Array<{
+        text: string;
+        x: number;
+        y: number;
+        w: number;
+        h: number;
+    }> | null;
+}
+export interface CaptureAction {
+    action_id: string;
+    ts: string;
+    device_id: string;
+    chunk_id: string;
+    kind: string;
+    app: string | null;
+    window_title: string | null;
+    description: string | null;
+    target: Record<string, unknown> | null;
+    screenshot: string | null;
+}
+export interface CaptureAudioLine {
+    line_id: string;
+    ts: string;
+    end_at: string;
+    device_id: string;
+    chunk_id: string;
+    text: string;
+}
+export interface CaptureTimelineItems {
+    user_id: string;
+    from: string;
+    to: string;
+    frames: CaptureFrame[];
+    actions: CaptureAction[];
+    audio: CaptureAudioLine[];
+}
+export interface CaptureDaysQuery {
+    tz?: string;
+    userId?: string;
+    deviceId?: string;
+}
+export interface CaptureDay {
+    day: string;
+    start_at: string;
+    end_at: string;
+    screen_seconds: number;
+}
+export interface CaptureDays {
+    user_id: string;
+    tz: string;
+    days: CaptureDay[];
+}
+export type CaptureSearchKind = CaptureLayer;
+export interface CaptureSearchQuery extends Omit<CaptureWindowQuery, 'day' | 'displayId'> {
+    q: string;
+    kinds?: CaptureSearchKind[];
+    app?: string;
+    limit?: number;
+    scope?: 'mine' | 'account';
+}
+export interface CaptureSearchHit {
+    kind: CaptureSearchKind;
+    id: string;
+    ts: string;
+    user_id: string;
+    device_id: string;
+    chunk_id: string;
+    app: string | null;
+    title: string | null;
+    url: string | null;
+    display_id: number | null;
+    display_name: string | null;
+    snippet: string;
+}
+export interface CaptureSearchResult {
+    user_id: string | null;
+    q: string;
+    hits: CaptureSearchHit[];
+}
+export interface CaptureSignedUrl {
+    url: string;
+    expires_at: string;
+}
+export interface CaptureMediaUrl extends CaptureSignedUrl {
+    encrypted: boolean;
+}
+export interface CaptureFrameDetail {
+    frame: CaptureFrame;
+    display?: CaptureDisplay | null;
+    video: (CaptureMediaUrl & {
+        offset_ms: number;
+    }) | null;
+    screenshot?: (CaptureMediaUrl & {
+        name: string;
+        ts: string;
+    }) | null;
+}
+export interface CaptureChunkMedia {
+    chunk_id: string;
+    kind: CaptureChunk['kind'];
+    video: CaptureMediaUrl | null;
+    audio: CaptureMediaUrl | null;
+}
+export interface CaptureDeviceGrant {
+    user_code: string;
+    status: 'pending' | 'approved' | 'denied' | 'consumed' | 'expired';
+    expires_at: string;
+    device: {
+        name: string | null;
+        os: string | null;
+        os_version: string | null;
+        arch: string | null;
+        app_version: string | null;
+    };
+    account_id: string | null;
+    device_id: string | null;
+}
+export interface CaptureDeviceGrantDetail extends CaptureDeviceGrant {
+    accounts: {
+        account_id: string;
+        name: string;
+    }[];
+}
+export interface CaptureWorkspace {
+    account_id: string;
+    enabled: boolean;
+    can_read_all: boolean;
+    can_manage: boolean;
+    updated_at: string | null;
+}
+export declare function listCaptureDevices(accountId: string, opts?: {
+    userId?: string;
+    scope?: 'mine' | 'account';
+}): Promise<{
+    devices: CaptureDevice[];
+    health: CaptureHealthSummary;
+}>;
+export declare function revokeCaptureDevice(accountId: string, deviceId: string): Promise<CaptureDevice>;
+export declare function linkCaptureDevice(accountId: string, deviceId: string, userId: string | null): Promise<CaptureDevice>;
+export declare function listCaptureEnrollmentTokens(accountId: string): Promise<{
+    tokens: CaptureEnrollmentToken[];
+}>;
+export declare function createCaptureEnrollmentToken(accountId: string, input: CaptureEnrollmentTokenInput): Promise<CaptureEnrollmentTokenSecret>;
+export declare function revokeCaptureEnrollmentToken(accountId: string, tokenId: string): Promise<CaptureEnrollmentToken>;
+export declare function listCaptureEnrollments(accountId: string, opts?: {
+    status?: CaptureEnrollmentStatus;
+}): Promise<{
+    enrollments: CaptureEnrollment[];
+}>;
+export declare function approveCaptureEnrollment(accountId: string, enrollmentId: string, userId?: string | null): Promise<CaptureEnrollment>;
+export declare function denyCaptureEnrollment(accountId: string, enrollmentId: string): Promise<CaptureEnrollment>;
+export declare function getCapturePolicy(accountId: string): Promise<CapturePolicyRecord>;
+export declare function setCapturePolicy(accountId: string, policy: CapturePolicy): Promise<CapturePolicyRecord>;
+export declare function getCaptureTimeline(accountId: string, query?: CaptureWindowQuery): Promise<CaptureTimeline>;
+export declare function getCaptureTimelineItems(accountId: string, query?: CaptureWindowQuery): Promise<CaptureTimelineItems>;
+export declare function getCaptureDays(accountId: string, query?: CaptureDaysQuery): Promise<CaptureDays>;
+export declare function searchCapture(accountId: string, query: CaptureSearchQuery): Promise<CaptureSearchResult>;
+export declare function getCaptureFrame(accountId: string, frameId: string, opts?: {
+    userId?: string;
+}): Promise<CaptureFrameDetail>;
+export declare function getCaptureChunkMedia(accountId: string, chunkId: string, opts?: {
+    userId?: string;
+}): Promise<CaptureChunkMedia>;
+export declare function getCaptureAssetUrl(accountId: string, deviceId: string, name: string): Promise<CaptureSignedUrl>;
+export declare function getCaptureDeviceGrant(userCode: string): Promise<CaptureDeviceGrantDetail>;
+export declare function approveCaptureDeviceGrant(userCode: string, accountId?: string): Promise<CaptureDeviceGrant>;
+export declare function denyCaptureDeviceGrant(userCode: string): Promise<CaptureDeviceGrant>;
+export declare function getCaptureWorkspace(accountId: string): Promise<CaptureWorkspace>;
+export declare function setCaptureEnabled(accountId: string, enabled: boolean): Promise<CaptureWorkspace>;
+export declare function searchMyCapture(query: CaptureSearchQuery): Promise<CaptureSearchResult>;
+export declare function getMyCaptureTimeline(query?: Omit<CaptureWindowQuery, 'userId'>): Promise<CaptureTimeline>;
+export declare function getMyCaptureFrame(frameId: string): Promise<CaptureFrameDetail>;