instavm 0.15.0 → 0.17.0

package/dist/InstaVM-DjkmUcaP.d.mts

@@ -0,0 +1,1393 @@
+import FormData from 'form-data';
+import { EventEmitter } from 'eventemitter3';
+
+interface ApiResponse<T = any> {
+    success?: boolean;
+    data?: T;
+    error?: string;
+    message?: string;
+}
+interface HttpClientConfig {
+    baseURL: string;
+    timeout: number;
+    maxRetries: number;
+    retryDelay: number;
+    apiKey: string;
+}
+interface RequestConfig {
+    method: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' | 'OPTIONS' | 'HEAD';
+    url: string;
+    headers?: Record<string, string>;
+    data?: any;
+    params?: Record<string, any>;
+    timeout?: number;
+}
+interface RetryConfig {
+    retries: number;
+    retryDelay: number;
+    retryCondition?: (error: any) => boolean;
+}
+
+/**
+ * HTTP client with authentication, retry logic, and error handling
+ */
+declare class HTTPClient {
+    private client;
+    private config;
+    get apiKey(): string;
+    get baseURL(): string;
+    constructor(config: HttpClientConfig);
+    private setupInterceptors;
+    /**
+     * Make an HTTP request with retry logic
+     */
+    request<T = any>(requestConfig: RequestConfig): Promise<T>;
+    /**
+     * POST request with JSON body
+     */
+    post<T = any>(url: string, data?: any, headers?: Record<string, string>, timeout?: number): Promise<T>;
+    /**
+     * POST request for code execution (uses X-API-Key header like Python client)
+     */
+    postExecution<T = any>(url: string, data: any, headers?: Record<string, string>, timeout?: number): Promise<T>;
+    /**
+     * POST request with form data (for file uploads)
+     */
+    postFormData<T = any>(url: string, formData: FormData, headers?: Record<string, string>): Promise<T>;
+    /**
+     * POST request with URL-encoded form data (like Python requests data= parameter)
+     */
+    postFormUrlEncoded<T = any>(url: string, data: any, headers?: Record<string, string>): Promise<T>;
+    /**
+     * GET request
+     */
+    get<T = any>(url: string, params?: Record<string, any>, headers?: Record<string, string>): Promise<T>;
+    /**
+     * DELETE request
+     */
+    delete<T = any>(url: string, headers?: Record<string, string>): Promise<T>;
+    /**
+     * PUT request
+     */
+    put<T = any>(url: string, data?: any, headers?: Record<string, string>): Promise<T>;
+    /**
+     * PATCH request
+     */
+    patch<T = any>(url: string, data?: any, headers?: Record<string, string>): Promise<T>;
+    /**
+     * OPTIONS request
+     */
+    options<T = any>(url: string, headers?: Record<string, string>, params?: Record<string, any>): Promise<T>;
+    /**
+     * POST request that returns raw binary data (for file downloads)
+     */
+    postRaw(url: string, data?: any, headers?: Record<string, string>): Promise<ArrayBuffer>;
+}
+
+interface BrowserSessionOptions {
+    viewportWidth?: number;
+    viewportHeight?: number;
+    userAgent?: string;
+}
+interface BrowserSessionInfo {
+    sessionId: string;
+    status: 'active' | 'inactive' | 'closed';
+    createdAt: string;
+    viewportWidth: number;
+    viewportHeight: number;
+    userAgent?: string;
+}
+interface NavigateOptions {
+    waitTimeout?: number;
+    waitUntil?: 'load' | 'domcontentloaded' | 'networkidle';
+}
+interface NavigationResult {
+    success: boolean;
+    url: string;
+    title?: string;
+    status?: number;
+}
+interface ClickOptions {
+    timeout?: number;
+    button?: 'left' | 'right' | 'middle';
+    clickCount?: number;
+    force?: boolean;
+}
+interface TypeOptions {
+    timeout?: number;
+    delay?: number;
+    clear?: boolean;
+}
+interface FillOptions {
+    timeout?: number;
+    force?: boolean;
+}
+interface ScrollOptions {
+    /** Scroll element into view when set */
+    selector?: string;
+    x?: number;
+    y?: number;
+    behavior?: 'auto' | 'smooth';
+}
+interface ScreenshotOptions {
+    fullPage?: boolean;
+    format?: 'png' | 'jpeg';
+    quality?: number;
+    clip?: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+}
+type WaitCondition = {
+    type: 'visible';
+    selector: string;
+} | {
+    type: 'hidden';
+    selector: string;
+} | {
+    type: 'attached';
+    selector: string;
+} | {
+    type: 'detached';
+    selector: string;
+} | {
+    type: 'timeout';
+    ms: number;
+};
+interface ExtractedElement {
+    text?: string;
+    href?: string;
+    src?: string;
+    class?: string;
+    id?: string;
+    tagName?: string;
+    [attribute: string]: any;
+}
+interface ExtractOptions {
+    attributes?: string[];
+    maxResults?: number;
+}
+interface ExtractContentOptions {
+    /** Cloud mode: browser session id (uses default manager session if omitted). */
+    sessionId?: string;
+    url?: string;
+    includeInteractive?: boolean;
+    includeAnchors?: boolean;
+    maxAnchors?: number;
+}
+interface InteractiveElement {
+    type: 'button' | 'link' | 'input' | 'select' | 'textarea';
+    selector: string;
+    text?: string;
+    label?: string;
+    placeholder?: string;
+    value?: string;
+}
+interface ContentAnchor {
+    text: string;
+    selector: string;
+}
+interface ExtractedContent {
+    readableContent: {
+        content: string;
+        title?: string;
+        byline?: string;
+        excerpt?: string;
+        siteName?: string;
+    };
+    interactiveElements?: InteractiveElement[];
+    contentAnchors?: ContentAnchor[];
+}
+
+/**
+ * Browser session for automation
+ */
+declare class BrowserSession extends EventEmitter {
+    readonly sessionId: string;
+    private httpClient;
+    private _isActive;
+    constructor(sessionId: string, httpClient: HTTPClient);
+    /**
+     * Navigate to a URL
+     */
+    navigate(url: string, options?: NavigateOptions): Promise<NavigationResult>;
+    /**
+     * Click an element
+     */
+    click(selector: string, options?: ClickOptions): Promise<void>;
+    /**
+     * Type text into an element
+     */
+    type(selector: string, text: string, options?: TypeOptions): Promise<void>;
+    /**
+     * Fill a form field
+     */
+    fill(selector: string, value: string, options?: FillOptions): Promise<void>;
+    /**
+     * Scroll the page
+     */
+    scroll(options?: ScrollOptions): Promise<void>;
+    /**
+     * Take a screenshot
+     */
+    screenshot(options?: ScreenshotOptions): Promise<string>;
+    /**
+     * Extract elements from the page
+     */
+    extractElements(selector?: string | null, attributes?: string[], options?: ExtractOptions): Promise<ExtractedElement[]>;
+    /**
+     * Extract LLM-friendly content from the current page
+     *
+     * Returns clean article content, interactive elements, and content anchors
+     * for intelligent browser automation with LLMs.
+     *
+     * @param options - Content extraction options
+     * @returns Extracted content with readable text, interactive elements, and content anchors
+     *
+     * @example
+     * ```typescript
+     * const content = await session.extractContent();
+     *
+     * // LLM reads clean content
+     * const article = content.readableContent.content;
+     *
+     * // LLM finds "Sign Up" in content and uses anchors to get selector
+     * const signUpAnchor = content.contentAnchors?.find(
+     *   anchor => anchor.text.toLowerCase().includes('sign up')
+     * );
+     * if (signUpAnchor) {
+     *   await session.click(signUpAnchor.selector);
+     * }
+     * ```
+     */
+    extractContent(options?: ExtractContentOptions): Promise<ExtractedContent>;
+    /**
+     * Wait for a string condition (parity with Python ``wait_for``).
+     */
+    waitFor(condition: string, selector?: string | null, timeout?: number): Promise<Record<string, any>>;
+    /**
+     * Wait for a condition
+     */
+    wait(condition: WaitCondition, timeout?: number): Promise<void>;
+    /**
+     * Close the browser session
+     */
+    close(): Promise<void>;
+    /**
+     * Check if session is active
+     */
+    get isActive(): boolean;
+    /**
+     * Ensure session is active before operations
+     */
+    private ensureActive;
+}
+
+/**
+ * Browser automation manager (parity with Python ``BrowserManager``).
+ */
+declare class BrowserManager {
+    private httpClient;
+    private activeSessions;
+    private local;
+    private getClient?;
+    private _defaultBrowserSessionId;
+    private _defaultSessionPromise;
+    constructor(httpClient: HTTPClient, local?: boolean, getClient?: () => InstaVM);
+    private ensureDefaultBrowserSessionId;
+    /**
+     * Create a new browser session
+     */
+    createSession(options?: BrowserSessionOptions): Promise<BrowserSession>;
+    /**
+     * Get information about a specific session
+     */
+    getSession(sessionId: string): Promise<BrowserSessionInfo>;
+    /**
+     * List all browser sessions
+     */
+    listSessions(): Promise<BrowserSessionInfo[]>;
+    getLocalSession(sessionId: string): BrowserSession | undefined;
+    attachSession(sessionId: string): BrowserSession;
+    getLocalSessions(): BrowserSession[];
+    closeAllSessions(): Promise<void>;
+    /**
+     * Navigate to a URL (local: no session; cloud: auto default browser session)
+     */
+    navigate(url: string, options?: NavigateOptions): Promise<NavigationResult>;
+    click(selector: string, sessionId?: string, force?: boolean, timeout?: number): Promise<void>;
+    type(selector: string, text: string, sessionId?: string, delay?: number, timeout?: number): Promise<void>;
+    fill(selector: string, value: string, sessionId?: string, timeout?: number): Promise<void>;
+    scroll(options?: {
+        sessionId?: string;
+        selector?: string;
+        x?: number;
+        y?: number;
+    }): Promise<void>;
+    waitFor(condition: string, selector?: string, sessionId?: string, timeout?: number): Promise<Record<string, any>>;
+    extractElements(selector?: string, sessionId?: string, attributes?: string[], options?: ExtractOptions): Promise<ExtractedElement[]>;
+    /**
+     * Extract LLM-friendly content (local: URL required; cloud: optional session)
+     */
+    extractContent(options?: ExtractContentOptions): Promise<ExtractedContent>;
+    /**
+     * Closes the default browser session if one was created for cloud convenience.
+     */
+    close(): Promise<void>;
+    dispose(): Promise<void>;
+}
+
+type JsonMap$4 = Record<string, any>;
+interface VMCreateRequest extends JsonMap$4 {
+    session_id?: string | null;
+    vm_lifetime_seconds?: number | null;
+    memory_mb?: number | null;
+    vcpu_count?: number | null;
+    metadata?: JsonMap$4 | null;
+    egress_policy?: JsonMap$4 | null;
+    snapshot_id?: string | null;
+    snapshot_on_terminate?: boolean | null;
+    snapshot_name?: string | null;
+    share?: JsonMap$4 | null;
+    custom_domain?: JsonMap$4 | null;
+    image_variant?: string | null;
+    volumes?: VMVolumeMountRequest[] | null;
+}
+interface VMUpdateRequest extends JsonMap$4 {
+    memory_mb?: number | null;
+    egress_policy?: JsonMap$4 | null;
+    snapshot_on_terminate?: boolean | null;
+    snapshot_name?: string | null;
+}
+interface VMCloneRequest extends JsonMap$4 {
+    snapshot_name?: string | null;
+}
+interface VMSnapshotRequest extends JsonMap$4 {
+    name?: string | null;
+}
+interface SnapshotBuildArgs extends JsonMap$4 {
+    extra_apt_packages?: string | null;
+    extra_pip_packages?: string | null;
+    extra_npm_packages?: string | null;
+    git_clone_url?: string | null;
+    git_clone_branch?: string | null;
+    disk_size_gb?: number | null;
+    envs?: Record<string, string> | null;
+    post_build_cmd?: string | null;
+}
+interface SnapshotCreateRequest extends JsonMap$4 {
+    oci_image: string;
+    name?: string | null;
+    vcpu_count?: number;
+    memory_mb?: number;
+    build_args?: SnapshotBuildArgs | null;
+    type?: 'user' | 'system';
+}
+interface SnapshotQueryOptions {
+    type?: 'user' | 'system';
+}
+interface VolumeCreateRequest extends JsonMap$4 {
+    name: string;
+    quota_bytes: number;
+}
+interface VolumeUpdateRequest extends JsonMap$4 {
+    name?: string | null;
+    quota_bytes?: number | null;
+}
+interface VolumeResponse extends JsonMap$4 {
+    id: string;
+    name: string;
+    quota_bytes: number;
+    used_bytes: number;
+    status: string;
+    created_at?: string | null;
+    updated_at?: string | null;
+}
+interface VolumeCheckpointCreateRequest extends JsonMap$4 {
+    name?: string | null;
+}
+interface VolumeCheckpointResponse extends JsonMap$4 {
+    id: string;
+    volume_id: string;
+    name?: string | null;
+    status: string;
+    created_at?: string | null;
+}
+interface VolumeFileEntry extends JsonMap$4 {
+    path: string;
+    filename: string;
+    size: number;
+}
+interface VolumeFileDownloadResponse extends JsonMap$4 {
+    path: string;
+    filename: string;
+    size: number;
+    content: Buffer;
+}
+interface VolumeFileUploadRequest extends JsonMap$4 {
+    path: string;
+    overwrite?: boolean;
+    filePath?: string;
+    fileContent?: Buffer | string;
+    filename?: string;
+}
+interface VolumeFileListQuery {
+    prefix?: string;
+    recursive?: boolean;
+    limit?: number;
+}
+interface VMVolumeMountRequest extends JsonMap$4 {
+    volume_id: string;
+    mount_path: string;
+    mode?: string;
+    checkpoint_id?: string | null;
+}
+interface VMMountedVolumeResponse extends JsonMap$4 {
+    volume_id: string;
+    mount_path: string;
+    mode: string;
+    checkpoint_id?: string | null;
+    status: string;
+}
+interface ShareCreateRequest extends JsonMap$4 {
+    session_id?: string | null;
+    vm_id?: string | null;
+    port: number;
+    is_public?: boolean;
+}
+interface ShareUpdateRequest extends JsonMap$4 {
+    is_public?: boolean | null;
+    revoke?: boolean | null;
+}
+interface CustomDomainCreateRequest extends JsonMap$4 {
+    domain: string;
+    share_id: string;
+    dns_provider: string;
+    dns_credentials?: Record<string, string> | null;
+}
+interface ComputerUseProxyOptions {
+    params?: Record<string, any>;
+    body?: any;
+}
+interface APIKeyCreateRequest extends JsonMap$4 {
+    description?: string | null;
+    expires_at?: string | null;
+}
+interface APIKey extends JsonMap$4 {
+    id?: number;
+    description?: string | null;
+    /** @deprecated Use key_prefix instead */
+    prefix?: string;
+    key_prefix?: string;
+    full_key?: string;
+    created_at?: string;
+    expires_at?: string | null;
+}
+interface AuditEventQuery {
+    event_group?: string;
+    event_type?: string;
+    status?: string;
+    user_id?: number;
+    vm_id?: string;
+    session_id?: string;
+    cursor?: string;
+    limit?: number;
+}
+interface WebhookEndpointCreateRequest extends JsonMap$4 {
+    url: string;
+    description?: string | null;
+    event_patterns?: string[] | null;
+    timeout_seconds?: number;
+    max_retries?: number;
+}
+interface WebhookEndpointUpdateRequest extends JsonMap$4 {
+    url?: string | null;
+    description?: string | null;
+    enabled?: boolean | null;
+    event_patterns?: string[] | null;
+    timeout_seconds?: number | null;
+    max_retries?: number | null;
+}
+interface WebhookDeliveryQuery {
+    endpoint_id?: string;
+    status?: string;
+    event_type?: string;
+    cursor?: string;
+    limit?: number;
+}
+
+declare class VMsManager {
+    private httpClient;
+    private local;
+    constructor(httpClient: HTTPClient, local?: boolean);
+    private ensureCloud;
+    create(payload?: VMCreateRequest, wait?: boolean): Promise<JsonMap$4>;
+    list(): Promise<JsonMap$4[]>;
+    listAll(): Promise<JsonMap$4[]>;
+    /**
+     * Calls GET /v1/vms/ (trailing slash), a distinct route from GET /v1/vms.
+     */
+    listAllRecords(): Promise<JsonMap$4[]>;
+    get(itemId: string | number): Promise<JsonMap$4>;
+    update(vmId: string, payload?: VMUpdateRequest): Promise<JsonMap$4>;
+    delete(vmId: string): Promise<JsonMap$4>;
+    clone(vmId: string, payload?: VMCloneRequest, wait?: boolean): Promise<JsonMap$4>;
+    snapshot(vmId: string, payload?: VMSnapshotRequest, wait?: boolean): Promise<JsonMap$4>;
+    mountVolume(vmId: string, payload: VMVolumeMountRequest, wait?: boolean): Promise<VMMountedVolumeResponse>;
+    listVolumes(vmId: string): Promise<VMMountedVolumeResponse[]>;
+    unmountVolume(vmId: string, volumeId: string, mountPath: string, wait?: boolean): Promise<JsonMap$4>;
+}
+
+declare class SnapshotsManager {
+    private httpClient;
+    private local;
+    constructor(httpClient: HTTPClient, local?: boolean);
+    private ensureCloud;
+    create(payload: SnapshotCreateRequest): Promise<JsonMap$4>;
+    list(options?: SnapshotQueryOptions): Promise<JsonMap$4[]>;
+    get(snapshotId: string): Promise<JsonMap$4>;
+    delete(snapshotId: string): Promise<JsonMap$4>;
+}
+
+declare class SharesManager {
+    private httpClient;
+    private local;
+    private getSessionId;
+    constructor(httpClient: HTTPClient, local?: boolean, getSessionId?: () => string | null);
+    private ensureCloud;
+    create(payload: ShareCreateRequest): Promise<JsonMap$4>;
+    update(shareId: string, payload: ShareUpdateRequest): Promise<JsonMap$4>;
+}
+
+declare class CustomDomainsManager {
+    private httpClient;
+    private local;
+    constructor(httpClient: HTTPClient, local?: boolean);
+    private ensureCloud;
+    create(payload: CustomDomainCreateRequest): Promise<JsonMap$4>;
+    list(): Promise<JsonMap$4[]>;
+    health(domainId: number): Promise<JsonMap$4>;
+    verify(domainId: number): Promise<JsonMap$4>;
+    delete(domainId: number): Promise<JsonMap$4>;
+}
+
+type ProxyMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' | 'OPTIONS' | 'HEAD';
+declare class ComputerUseManager {
+    private httpClient;
+    private local;
+    constructor(httpClient: HTTPClient, local?: boolean);
+    private ensureCloud;
+    viewerUrl(sessionId: string): Promise<JsonMap$4>;
+    proxy(sessionId: string, path: string, method?: ProxyMethod, options?: ComputerUseProxyOptions): Promise<any>;
+    get(sessionId: string, path: string, params?: Record<string, any>): Promise<any>;
+    post(sessionId: string, path: string, body?: any): Promise<any>;
+    put(sessionId: string, path: string, body?: any): Promise<any>;
+    patch(sessionId: string, path: string, body?: any): Promise<any>;
+    delete(sessionId: string, path: string, params?: Record<string, any>): Promise<any>;
+    options(sessionId: string, path: string, params?: Record<string, any>): Promise<any>;
+    head(sessionId: string, path: string, params?: Record<string, any>): Promise<any>;
+    /**
+     * Get the VNC WebSocket URL for a computer-use session.
+     * Returns the URL to connect to; the actual connection requires a WebSocket client.
+     */
+    vncWebsockify(sessionId: string): Promise<JsonMap$4>;
+}
+
+declare class APIKeysManager {
+    private httpClient;
+    private local;
+    constructor(httpClient: HTTPClient, local?: boolean);
+    private ensureCloud;
+    create(payload?: APIKeyCreateRequest): Promise<APIKey>;
+    list(): Promise<APIKey[]>;
+    get(itemId: number): Promise<APIKey>;
+    update(itemId: number, payload: APIKeyCreateRequest): Promise<APIKey>;
+    delete(itemId: number): Promise<JsonMap$4>;
+}
+
+declare class AuditManager {
+    private httpClient;
+    private local;
+    constructor(httpClient: HTTPClient, local?: boolean);
+    private ensureCloud;
+    catalog(): Promise<JsonMap$4>;
+    events(query?: AuditEventQuery): Promise<JsonMap$4>;
+    getEvent(eventId: string): Promise<JsonMap$4>;
+}
+
+declare class WebhooksManager {
+    private httpClient;
+    private local;
+    constructor(httpClient: HTTPClient, local?: boolean);
+    private ensureCloud;
+    createEndpoint(payload: WebhookEndpointCreateRequest): Promise<JsonMap$4>;
+    listEndpoints(): Promise<JsonMap$4[]>;
+    getEndpoint(endpointId: string): Promise<JsonMap$4>;
+    updateEndpoint(endpointId: string, payload: WebhookEndpointUpdateRequest): Promise<JsonMap$4>;
+    deleteEndpoint(endpointId: string): Promise<JsonMap$4>;
+    rotateSecret(endpointId: string): Promise<JsonMap$4>;
+    sendTestEvent(endpointId: string): Promise<JsonMap$4>;
+    verifyEndpoint(endpointId: string): Promise<JsonMap$4>;
+    listDeliveries(query?: WebhookDeliveryQuery): Promise<JsonMap$4>;
+    replayDelivery(deliveryId: string): Promise<JsonMap$4>;
+}
+
+declare class VolumesManager {
+    private httpClient;
+    private local;
+    constructor(httpClient: HTTPClient, local?: boolean);
+    private ensureCloud;
+    create(payload: VolumeCreateRequest): Promise<VolumeResponse>;
+    list(refreshUsage?: boolean): Promise<VolumeResponse[]>;
+    get(volumeId: string, refreshUsage?: boolean): Promise<VolumeResponse>;
+    update(volumeId: string, payload: VolumeUpdateRequest): Promise<VolumeResponse>;
+    delete(volumeId: string): Promise<JsonMap$4>;
+    createCheckpoint(volumeId: string, payload?: VolumeCheckpointCreateRequest): Promise<VolumeCheckpointResponse>;
+    listCheckpoints(volumeId: string): Promise<VolumeCheckpointResponse[]>;
+    deleteCheckpoint(volumeId: string, checkpointId: string): Promise<JsonMap$4>;
+    uploadFile(volumeId: string, payload: VolumeFileUploadRequest): Promise<VolumeFileEntry>;
+    downloadFile(volumeId: string, path: string): Promise<VolumeFileDownloadResponse>;
+    listFiles(volumeId: string, options?: VolumeFileListQuery): Promise<VolumeFileEntry[]>;
+    deleteFile(volumeId: string, targetPath: string): Promise<JsonMap$4>;
+}
+
+/** Time-travel tape types. */
+interface TapeStartOptions {
+    recordEgressContent?: boolean;
+    recordFs?: boolean;
+    retentionDays?: number;
+}
+interface TapeListQuery {
+    sessionId?: string;
+    vmId?: string;
+    status?: string;
+    limit?: number;
+    offset?: number;
+}
+interface TapeEventsQuery {
+    afterStep?: number;
+    kind?: string;
+    limit?: number;
+}
+interface TapeAppendEventOptions {
+    payload?: Record<string, any>;
+    stepId?: number;
+    parentStepId?: number;
+    checkpointId?: string;
+}
+interface TapeBranchOptions {
+    /** Either "live" (fork as a new live VM) or "replay". */
+    mode?: 'live' | 'replay';
+}
+interface TapeRecord {
+    id: string;
+    session_id?: string;
+    vm_id?: string;
+    status?: string;
+    created_at?: string;
+    stopped_at?: string | null;
+    retention_days?: number;
+    [key: string]: any;
+}
+interface TapeEvent {
+    step_id: number;
+    kind: string;
+    payload?: Record<string, any>;
+    ts?: string;
+    parent_step_id?: number | null;
+    checkpoint_id?: string | null;
+    [key: string]: any;
+}
+interface TapeLanesResponse {
+    tape_id?: string;
+    lanes: Record<string, number>;
+    [key: string]: any;
+}
+interface TapeDiffResponse {
+    tape_id?: string;
+    from?: number;
+    to?: number;
+    changes?: Array<Record<string, any>>;
+    [key: string]: any;
+}
+interface TapeBranchResponse {
+    tape_id?: string;
+    branch_id?: string;
+    vm_id?: string;
+    [key: string]: any;
+}
+interface TapeExportBundle {
+    tape: TapeRecord;
+    events: TapeEvent[];
+    [key: string]: any;
+}
+
+type JsonMap$3 = Record<string, any>;
+declare class TapesManager {
+    private httpClient;
+    private local;
+    constructor(httpClient: HTTPClient, local?: boolean);
+    private ensureCloud;
+    private authHeaders;
+    start(sessionId: string, options?: TapeStartOptions): Promise<TapeRecord>;
+    stop(tapeId: string): Promise<TapeRecord>;
+    list(query?: TapeListQuery): Promise<TapeRecord[]>;
+    get(tapeId: string): Promise<TapeRecord>;
+    events(tapeId: string, query?: TapeEventsQuery): Promise<TapeEvent[]>;
+    appendEvent(tapeId: string, kind: string, options?: TapeAppendEventOptions): Promise<TapeEvent>;
+    lanes(tapeId: string): Promise<TapeLanesResponse>;
+    diff(tapeId: string, fromStep: number, toStep: number): Promise<TapeDiffResponse>;
+    branch(tapeId: string, atStep: number, options?: TapeBranchOptions): Promise<TapeBranchResponse>;
+    delete(tapeId: string): Promise<JsonMap$3>;
+    export(tapeId: string): Promise<TapeExportBundle>;
+}
+
+/** Secrets-vault types. */
+interface VaultRecord {
+    id: string;
+    name: string;
+    description?: string | null;
+    organization_id?: string;
+    created_at?: string;
+    [key: string]: any;
+}
+interface VaultCredential {
+    id: string;
+    name: string;
+    credential_type?: string;
+    description?: string | null;
+    created_at?: string;
+    [key: string]: any;
+}
+interface VaultService {
+    id: string;
+    host: string;
+    auth_config: Record<string, any>;
+    description?: string | null;
+    enabled?: boolean;
+    created_at?: string;
+    [key: string]: any;
+}
+interface VaultRequestLog {
+    id?: string;
+    host?: string;
+    status?: number | string;
+    ts?: string;
+    [key: string]: any;
+}
+interface VaultDiscoverResponse {
+    vault: VaultRecord;
+    credentials?: Array<{
+        name: string;
+        credential_type?: string;
+    }>;
+    services?: Array<{
+        id?: string;
+        host: string;
+    }>;
+    [key: string]: any;
+}
+interface VaultCatalogTemplate {
+    id: string;
+    name: string;
+    host?: string;
+    description?: string;
+    auth_config_template?: Record<string, any>;
+    [key: string]: any;
+}
+interface AddVaultCredentialOptions {
+    description?: string;
+    credentialType?: string;
+}
+interface AddVaultServiceOptions {
+    description?: string;
+    enabled?: boolean;
+}
+interface UpdateVaultOptions {
+    name?: string;
+    description?: string;
+}
+
+type JsonMap$2 = Record<string, any>;
+declare class VaultsManager {
+    private httpClient;
+    private local;
+    constructor(httpClient: HTTPClient, local?: boolean);
+    private ensureCloud;
+    private auth;
+    list(): Promise<VaultRecord[]>;
+    create(name: string, description?: string): Promise<VaultRecord>;
+    get(vaultId: string): Promise<VaultRecord>;
+    update(vaultId: string, updates: UpdateVaultOptions): Promise<VaultRecord>;
+    delete(vaultId: string): Promise<JsonMap$2>;
+    discover(vaultId: string): Promise<VaultDiscoverResponse>;
+    listCredentials(vaultId: string): Promise<VaultCredential[]>;
+    addCredential(vaultId: string, name: string, value: string, options?: AddVaultCredentialOptions): Promise<VaultCredential>;
+    rotateCredential(vaultId: string, credentialId: string, value: string): Promise<VaultCredential>;
+    deleteCredential(vaultId: string, credentialId: string): Promise<JsonMap$2>;
+    listServices(vaultId: string): Promise<VaultService[]>;
+    addService(vaultId: string, host: string, authConfig: Record<string, any>, options?: AddVaultServiceOptions): Promise<VaultService>;
+    addServicesFromTemplates(vaultId: string, templateIds: string[]): Promise<JsonMap$2>;
+    deleteService(vaultId: string, serviceId: string): Promise<JsonMap$2>;
+    getCatalog(): Promise<VaultCatalogTemplate[]>;
+    getRequestLogs(vaultId: string, limit?: number): Promise<VaultRequestLog[]>;
+}
+
+/** PTY (interactive terminal) types. */
+interface PTYCreateOptions {
+    cols?: number;
+    rows?: number;
+    /** Shell program (e.g. "/bin/zsh"). Maps to backend "shell" field. */
+    command?: string;
+    /** Optional explicit pty session id. */
+    ptyId?: string;
+}
+interface PTYRecord {
+    session_id?: string;
+    id?: string;
+    cols?: number;
+    rows?: number;
+    shell?: string;
+    alive?: boolean;
+    exit_code?: number | null;
+    created_at?: string;
+    [key: string]: any;
+}
+
+type JsonMap$1 = Record<string, any>;
+declare class PTYManager {
+    private httpClient;
+    private local;
+    private getBaseURL;
+    constructor(httpClient: HTTPClient, local: boolean, getBaseURL: () => string);
+    private ensureCloud;
+    private auth;
+    private buildPayload;
+    private buildWsUrl;
+    create(sessionId: string, options?: PTYCreateOptions): Promise<PTYRecord>;
+    list(sessionId: string): Promise<PTYRecord[]>;
+    get(sessionId: string, ptyId: string): Promise<PTYRecord>;
+    resize(sessionId: string, ptyId: string, cols: number, rows: number): Promise<JsonMap$1>;
+    kill(sessionId: string, ptyId: string): Promise<JsonMap$1>;
+    wsUrl(sessionId: string, ptyId: string): string;
+    createForVm(vmId: string, options?: PTYCreateOptions): Promise<PTYRecord>;
+    listForVm(vmId: string): Promise<PTYRecord[]>;
+    getForVm(vmId: string, ptyId: string): Promise<PTYRecord>;
+    resizeForVm(vmId: string, ptyId: string, cols: number, rows: number): Promise<JsonMap$1>;
+    killForVm(vmId: string, ptyId: string): Promise<JsonMap$1>;
+    wsUrlForVm(vmId: string, ptyId: string): string;
+}
+
+/** Computer-use session recording types. */
+interface RecordingRecord {
+    id: string;
+    session_id?: string;
+    status?: 'uploading' | 'ready' | 'failed' | string;
+    duration_seconds?: number;
+    size_bytes?: number;
+    created_at?: string;
+    completed_at?: string | null;
+    [key: string]: any;
+}
+interface RecordingListQuery {
+    sessionId?: string;
+    status?: string;
+    limit?: number;
+    offset?: number;
+}
+interface RecordingDownloadResult {
+    recordingId: string;
+    path: string;
+    bytes: number;
+}
+
+type JsonMap = Record<string, any>;
+declare class RecordingsManager {
+    private httpClient;
+    private local;
+    private getBaseURL;
+    constructor(httpClient: HTTPClient, local: boolean, getBaseURL: () => string);
+    private ensureCloud;
+    private auth;
+    private sdkHeaders;
+    list(query?: RecordingListQuery): Promise<RecordingRecord[]>;
+    get(recordingId: string): Promise<RecordingRecord>;
+    /**
+     * Resolve the presigned download URL for a recording without following the
+     * 302 redirect. The returned URL is short-lived and pre-authorised.
+     */
+    getDownloadUrl(recordingId: string): Promise<string>;
+    /**
+     * Stream a recording to a local file using the presigned URL. The S3 URL
+     * must NOT carry our X-API-Key header — fetch it with a clean axios call.
+     */
+    download(recordingId: string, outputPath: string): Promise<RecordingDownloadResult>;
+    delete(recordingId: string): Promise<JsonMap>;
+}
+
+/** Credit / billing types. */
+type CreditPeriod = 'current_month' | 'last_30_days' | 'all' | string;
+type CreditTrendsPeriod = '7d' | '30d' | '90d' | string;
+type CreditTrendsGranularity = 'hourly' | 'daily' | 'weekly' | string;
+interface CreditAllocation {
+    period?: string;
+    total_credits?: number;
+    used_credits?: number;
+    remaining_credits?: number;
+    buckets?: Record<string, any>;
+    [key: string]: any;
+}
+interface CreditUsageEntry {
+    ts?: string;
+    usage_type?: string;
+    credits?: number;
+    amount_usd?: number;
+    resource_id?: string;
+    [key: string]: any;
+}
+interface CreditSummary {
+    period?: string;
+    total_credits?: number;
+    total_usd?: number;
+    by_type?: Record<string, any>;
+    [key: string]: any;
+}
+interface CreditCheckResponse {
+    has_credits?: boolean;
+    remaining_credits?: number;
+    required_credits?: number;
+    usage_type?: string;
+    [key: string]: any;
+}
+interface CreditRates {
+    rates?: Record<string, any>;
+    [key: string]: any;
+}
+interface CreditTrendsResponse {
+    period?: string;
+    granularity?: string;
+    series?: Array<Record<string, any>>;
+    [key: string]: any;
+}
+interface CreditForecastResponse {
+    forecast?: Record<string, any>;
+    recommendations?: Array<Record<string, any>>;
+    [key: string]: any;
+}
+
+declare class CreditsManager {
+    private httpClient;
+    private local;
+    constructor(httpClient: HTTPClient, local?: boolean);
+    private ensureCloud;
+    private auth;
+    allocation(): Promise<CreditAllocation>;
+    usage(period?: CreditPeriod, options?: {
+        usageType?: string;
+        limit?: number;
+    }): Promise<CreditUsageEntry[]>;
+    summary(period?: CreditPeriod): Promise<CreditSummary>;
+    check(usageType: string, requiredCredits: number): Promise<CreditCheckResponse>;
+    rates(): Promise<CreditRates>;
+    usageTrends(period?: CreditTrendsPeriod, granularity?: CreditTrendsGranularity): Promise<CreditTrendsResponse>;
+    usageForecast(): Promise<CreditForecastResponse>;
+}
+
+/**
+ * Start/stop a tape for a session (parity with Python ``TapeContext``).
+ *
+ * Usage:
+ * ```ts
+ * const ctx = client.tape(sessionId, { recordFs: true });
+ * await ctx.start();
+ * try {
+ *   // ...
+ * } finally {
+ *   await ctx.stop();
+ * }
+ * ```
+ */
+declare class TapeContext {
+    private readonly tapes;
+    private readonly sessionId;
+    private readonly startOpts;
+    info: TapeRecord | null;
+    constructor(tapes: TapesManager, sessionId: string | undefined, startOpts: TapeStartOptions);
+    get id(): string | undefined;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    [Symbol.asyncDispose](): Promise<void>;
+}
+
+/**
+ * Record tool-call spans into an active tape (parity with Python ``ToolCallRecorder``).
+ */
+declare class ToolCallRecorder {
+    private readonly tapes;
+    private readonly tapeId;
+    constructor(tapes: TapesManager, tapeId: string);
+    event(kind: string, payload?: Record<string, any>, stepId?: number): Promise<TapeEvent>;
+    span(name: string, payload?: Record<string, any>): ToolCallSpan;
+}
+declare class ToolCallSpan {
+    private readonly recorder;
+    private readonly name;
+    private readonly startPayload;
+    private endPayload;
+    private stepId;
+    constructor(recorder: ToolCallRecorder, name: string, startPayload: Record<string, any>);
+    attach(payload: Record<string, any>): void;
+    enter(): Promise<void>;
+    exit(err?: unknown): Promise<void>;
+}
+
+interface ExecuteOptions {
+    language?: 'python' | 'bash';
+    timeout?: number;
+    sessionId?: string;
+}
+interface ExecutionResult {
+    stdout: string;
+    stderr: string;
+    success: boolean;
+    executionTime?: number;
+    cpuTime?: number;
+    createdAt?: string;
+    sessionId?: string;
+    error?: string;
+}
+interface AsyncExecutionResult {
+    taskId: string;
+    status: 'pending' | 'running' | 'completed' | 'failed';
+    output?: string;
+    success?: boolean;
+    executionTime?: number;
+    sessionId?: string;
+    error?: string;
+}
+interface TaskResult {
+    stdout: string;
+    stderr: string;
+    executionTime?: number;
+    cpuTime?: number;
+    createdAt?: string;
+}
+interface FileUpload {
+    name: string;
+    content: Buffer | string;
+    path?: string;
+}
+interface UploadOptions {
+    sessionId?: string;
+    remotePath?: string;
+    recursive?: boolean;
+}
+interface UploadResult {
+    success: boolean;
+    files: string[];
+    message?: string;
+}
+interface UsageStats {
+    sessionsUsed: number;
+    executionTime: number;
+    quotaRemaining: number;
+    quotaLimit: number;
+}
+interface DownloadOptions {
+    sessionId?: string;
+}
+interface DownloadResult {
+    success: boolean;
+    filename: string;
+    content: Buffer;
+    size: number;
+}
+
+interface EgressPolicy {
+    allowPackageManagers: boolean;
+    allowHttp: boolean;
+    allowHttps: boolean;
+    allowedDomains: string[];
+    allowedCidrs: string[];
+}
+interface EgressPolicyOptions {
+    allowPackageManagers?: boolean;
+    allowHttp?: boolean;
+    allowHttps?: boolean;
+    allowedDomains?: string[];
+    allowedCidrs?: string[];
+}
+
+interface SSHKey {
+    id: number;
+    fingerprint: string;
+    keyType: string;
+    comment: string | null;
+    createdAt: string;
+}
+
+interface CurrentUserResponse extends Record<string, any> {
+    id: number;
+    name: string;
+    email: string;
+    is_verified: boolean;
+}
+interface SessionStatusResponse extends Record<string, any> {
+    session_id: string;
+    exists: boolean;
+    vm_assigned: boolean;
+    vm_status?: string | null;
+    vm_id?: string | null;
+    vm_alive: boolean;
+    uptime_seconds?: number | null;
+    expires_in_seconds?: number | null;
+    created_at?: string | null;
+}
+
+interface InstaVMOptions {
+    baseURL?: string;
+    /**
+     * Timeout in milliseconds. Used for HTTP request timeout and sent to API as VM lifetime (in seconds).
+     * Default: 300000 (5 minutes)
+     */
+    timeout?: number;
+    maxRetries?: number;
+    retryDelay?: number;
+    local?: boolean;
+    localURL?: string;
+    /** VM memory in megabytes (optional). Range: 128-8192 MB */
+    memory_mb?: number;
+    /** VM vCPU count (optional). Valid values: 1, 2, 4, 6, 8 */
+    cpu_count?: number;
+    /** Optional user-defined metadata for filtering */
+    metadata?: Record<string, any>;
+    /** Optional environment variables to set in the VM */
+    env?: Record<string, any>;
+    /**
+     * When true (default), start a cloud execution session during construction (mirrors Python).
+     * Set false for management-only CLI commands.
+     */
+    auto_start_session?: boolean;
+}
+/**
+ * Main InstaVM client class
+ */
+declare class InstaVM {
+    private httpClient;
+    private _sessionId;
+    readonly browser: BrowserManager;
+    readonly vms: VMsManager;
+    readonly snapshots: SnapshotsManager;
+    readonly shares: SharesManager;
+    readonly customDomains: CustomDomainsManager;
+    readonly computerUse: ComputerUseManager;
+    readonly apiKeys: APIKeysManager;
+    readonly audit: AuditManager;
+    readonly webhooks: WebhooksManager;
+    readonly volumes: VolumesManager;
+    readonly tapes: TapesManager;
+    readonly vaults: VaultsManager;
+    readonly pty: PTYManager;
+    readonly recordings: RecordingsManager;
+    readonly credits: CreditsManager;
+    readonly local: boolean;
+    private readonly timeout;
+    readonly memory_mb?: number;
+    readonly cpu_count?: number;
+    readonly metadata?: Record<string, any>;
+    readonly env?: Record<string, any>;
+    private _vmUsed;
+    private readonly _autoStartSession;
+    private sessionBootstrap?;
+    constructor(apiKey: string, options?: InstaVMOptions);
+    private awaitSessionBootstrap;
+    /**
+     * Ensure operation is not called in local mode
+     */
+    private ensureNotLocal;
+    private authHeaders;
+    /**
+     * Execute code synchronously
+     *
+     * @param command - Command to execute
+     * @param options - Execution options
+     * @param options.timeout - Request timeout in milliseconds (used for HTTP request timeout and sent to API in seconds)
+     * @returns Execution result
+     */
+    execute(command: string, options?: ExecuteOptions): Promise<ExecutionResult>;
+    /**
+     * Execute code asynchronously
+     */
+    executeAsync(command: string, options?: ExecuteOptions): Promise<AsyncExecutionResult>;
+    /**
+     * Poll for async task result
+     *
+     * @param taskId - The task ID from executeAsync
+     * @param pollInterval - Seconds between polls (default: 1)
+     * @param timeout - Maximum seconds to wait (default: 60)
+     * @returns Task result with stdout, stderr, execution time, etc.
+     * @throws Error if task doesn't complete within timeout
+     */
+    getTaskResult(taskId: string, pollInterval?: number, timeout?: number): Promise<TaskResult>;
+    /**
+     * Upload files to the execution environment
+     */
+    upload(files: FileUpload[], options?: UploadOptions): Promise<UploadResult>;
+    /**
+     * Create a new execution session
+     */
+    createSession(): Promise<string>;
+    /**
+     * Close a session
+     * Note: Sessions auto-expire on the server side. This just clears local state.
+     */
+    closeSession(sessionId?: string): Promise<void>;
+    /**
+     * Check if current session is still active by checking VM status
+     *
+     * @returns true if session is active, false otherwise
+     */
+    isSessionActive(sessionId?: string): Promise<boolean>;
+    /**
+     * Get the app URL for a session
+     *
+     * @param sessionId - Session ID (uses current session if not provided)
+     * @param port - Port to expose (1-65535, default: 80)
+     */
+    getSessionAppUrl(sessionId?: string, port?: number): Promise<Record<string, any>>;
+    /**
+     * List sandbox records with optional filtering
+     *
+     * @param options.metadata - JSON-serializable metadata filters
+     * @param options.limit - Maximum number of results (1-1000, default: 100)
+     */
+    listSandboxes(options?: {
+        metadata?: Record<string, any>;
+        limit?: number;
+    }): Promise<Record<string, any>[]>;
+    /**
+     * Get usage statistics for a session
+     */
+    getUsage(sessionId?: string): Promise<UsageStats>;
+    /**
+     * Get the current user profile.
+     */
+    getCurrentUser(): Promise<CurrentUserResponse>;
+    /**
+     * Get the current status of a session.
+     */
+    getSessionStatus(sessionId?: string): Promise<SessionStatusResponse>;
+    /**
+     * Get session record details from ``GET /v1/sessions/session/{session_id}`` (Python: ``get_session_info``).
+     */
+    getSessionInfo(sessionId?: string): Promise<Record<string, any>>;
+    /**
+     * Day-wise usage breakdown from ``GET /v1/users/me/usage-breakdown`` (Python: ``get_usage_breakdown``).
+     */
+    getUsageBreakdown(options?: {
+        startDate?: string;
+        endDate?: string;
+        days?: number;
+    }): Promise<Record<string, any>>;
+    /**
+     * Time-travel tape context manager (Python: ``tape()`` / ``TapeContext``).
+     */
+    tape(sessionId?: string | null, options?: TapeStartOptions): TapeContext;
+    /** Build a tool-call recorder for an active tape id (Python: ``ToolCallRecorder``). */
+    toolCallRecorder(tapeId: string): ToolCallRecorder;
+    /**
+     * @deprecated Streaming is not supported by the API; yields a single chunk from ``execute``.
+     */
+    executeStreaming(command: string, onOutput?: (chunk: string) => void): AsyncGenerator<string, void, undefined>;
+    listVaults(): Promise<VaultRecord[]>;
+    createVault(name: string, description?: string): Promise<VaultRecord>;
+    getVault(vaultId: string): Promise<VaultRecord>;
+    updateVault(vaultId: string, updates: UpdateVaultOptions): Promise<VaultRecord>;
+    deleteVault(vaultId: string): Promise<Record<string, any>>;
+    discoverVault(vaultId: string): Promise<VaultDiscoverResponse>;
+    listVaultCredentials(vaultId: string): Promise<VaultCredential[]>;
+    addVaultCredential(vaultId: string, name: string, value: string, options?: AddVaultCredentialOptions): Promise<VaultCredential>;
+    rotateVaultCredential(vaultId: string, credentialId: string, value: string): Promise<VaultCredential>;
+    deleteVaultCredential(vaultId: string, credentialId: string): Promise<Record<string, any>>;
+    listVaultServices(vaultId: string): Promise<VaultService[]>;
+    addVaultService(vaultId: string, host: string, authConfig: Record<string, any>, options?: AddVaultServiceOptions): Promise<VaultService>;
+    deleteVaultService(vaultId: string, serviceId: string): Promise<Record<string, any>>;
+    addVaultServicesFromTemplates(vaultId: string, templateIds: string[]): Promise<Record<string, any>>;
+    getVaultCatalog(): Promise<VaultCatalogTemplate[]>;
+    getVaultRequestLogs(vaultId: string, limit?: number): Promise<VaultRequestLog[]>;
+    createBrowserSession(viewportWidth?: number, viewportHeight?: number, userAgent?: string): Promise<string>;
+    getBrowserSession(sessionId: string): Promise<Record<string, any>>;
+    closeBrowserSession(sessionId: string): Promise<boolean>;
+    listBrowserSessions(): Promise<Record<string, any>[]>;
+    browserNavigate(url: string, sessionId?: string | null, waitTimeout?: number): Promise<Record<string, any>>;
+    browserClick(selector: string, sessionId: string, force?: boolean, timeout?: number): Promise<Record<string, any>>;
+    browserType(selector: string, text: string, sessionId: string, delay?: number, timeout?: number): Promise<Record<string, any>>;
+    browserFill(selector: string, value: string, sessionId: string, timeout?: number): Promise<Record<string, any>>;
+    browserScroll(sessionId: string, selector?: string | null, x?: number | null, y?: number | null): Promise<Record<string, any>>;
+    browserWait(condition: string, sessionId: string, selector?: string | null, timeout?: number): Promise<Record<string, any>>;
+    browserScreenshot(sessionId: string, fullPage?: boolean, clip?: Record<string, any> | null, format?: string, quality?: number | null): Promise<string>;
+    browserExtractElements(sessionId: string, selector?: string | null, attributes?: string[] | null): Promise<Record<string, any>[]>;
+    browserExtractContent(sessionId?: string | null, url?: string | null, includeInteractive?: boolean, includeAnchors?: boolean, maxAnchors?: number): Promise<Record<string, any>>;
+    /**
+     * Download a file from the remote VM
+     */
+    download(filename: string, options?: DownloadOptions): Promise<DownloadResult>;
+    /**
+     * Get the current session ID
+     */
+    get sessionId(): string | null;
+    /**
+     * Kill the VM associated with a session
+     *
+     * @param sessionId - The session UUID whose VM should be killed. If not provided, uses current sessionId
+     * @returns Result containing success message and killed VM ID
+     */
+    kill(sessionId?: string): Promise<{
+        success: boolean;
+        killed: string;
+    }>;
+    /**
+     * Set egress policy for a session
+     */
+    setSessionEgress(options?: EgressPolicyOptions, sessionId?: string): Promise<{
+        status: string;
+        sessionId: string;
+    }>;
+    /**
+     * Get egress policy for a session
+     */
+    getSessionEgress(sessionId?: string): Promise<EgressPolicy>;
+    /**
+     * Set egress policy for a specific VM
+     */
+    setVmEgress(vmId: string, options?: EgressPolicyOptions): Promise<{
+        status: string;
+        vmId: string;
+    }>;
+    /**
+     * Get egress policy for a specific VM
+     */
+    getVmEgress(vmId: string): Promise<EgressPolicy>;
+    /**
+     * Add an SSH public key
+     */
+    addSshKey(publicKey: string): Promise<SSHKey>;
+    /**
+     * List all active SSH keys
+     */
+    listSshKeys(): Promise<SSHKey[]>;
+    /**
+     * Delete an SSH key by ID
+     */
+    deleteSshKey(keyId: number): Promise<{
+        status: string;
+    }>;
+    /**
+     * Clean up resources
+     */
+    dispose(): Promise<void>;
+}
+
+export { type CurrentUserResponse as $, APIKeysManager as A, BrowserManager as B, CustomDomainsManager as C, type DownloadOptions as D, type ExecuteOptions as E, type FileUpload as F, type ExtractOptions as G, type ExtractContentOptions as H, InstaVM as I, type ExtractedContent as J, type InteractiveElement as K, type ContentAnchor as L, type ApiResponse as M, type NavigateOptions as N, type HttpClientConfig as O, PTYManager as P, type RequestConfig as Q, RecordingsManager as R, SnapshotsManager as S, TapesManager as T, type UploadOptions as U, VMsManager as V, WebhooksManager as W, type RetryConfig as X, type EgressPolicy as Y, type EgressPolicyOptions as Z, type SSHKey as _, type InstaVMOptions as a, type WebhookEndpointUpdateRequest as a$, type SessionStatusResponse as a0, type TapeStartOptions as a1, type TapeListQuery as a2, type TapeEventsQuery as a3, type TapeAppendEventOptions as a4, type TapeBranchOptions as a5, type TapeRecord as a6, type TapeEvent as a7, type TapeLanesResponse as a8, type TapeDiffResponse as a9, type JsonMap$4 as aA, type VMCreateRequest as aB, type VMUpdateRequest as aC, type VMCloneRequest as aD, type VMSnapshotRequest as aE, type SnapshotBuildArgs as aF, type SnapshotCreateRequest as aG, type SnapshotQueryOptions as aH, type VolumeCreateRequest as aI, type VolumeUpdateRequest as aJ, type VolumeResponse as aK, type VolumeCheckpointCreateRequest as aL, type VolumeCheckpointResponse as aM, type VolumeFileEntry as aN, type VolumeFileDownloadResponse as aO, type VolumeFileUploadRequest as aP, type VolumeFileListQuery as aQ, type VMVolumeMountRequest as aR, type VMMountedVolumeResponse as aS, type ShareCreateRequest as aT, type ShareUpdateRequest as aU, type CustomDomainCreateRequest as aV, type ComputerUseProxyOptions as aW, type APIKey as aX, type APIKeyCreateRequest as aY, type AuditEventQuery as aZ, type WebhookEndpointCreateRequest as a_, type TapeBranchResponse as aa, type TapeExportBundle as ab, type VaultRecord as ac, type VaultCredential as ad, type VaultService as ae, type VaultRequestLog as af, type VaultDiscoverResponse as ag, type VaultCatalogTemplate as ah, type AddVaultCredentialOptions as ai, type AddVaultServiceOptions as aj, type UpdateVaultOptions as ak, type PTYCreateOptions as al, type PTYRecord as am, type RecordingListQuery as an, type RecordingRecord as ao, type RecordingDownloadResult as ap, type CreditAllocation as aq, type CreditCheckResponse as ar, type CreditForecastResponse as as, type CreditPeriod as at, type CreditRates as au, type CreditSummary as av, type CreditTrendsGranularity as aw, type CreditTrendsPeriod as ax, type CreditTrendsResponse as ay, type CreditUsageEntry as az, BrowserSession as b, type WebhookDeliveryQuery as b0, SharesManager as c, ComputerUseManager as d, AuditManager as e, VolumesManager as f, VaultsManager as g, CreditsManager as h, TapeContext as i, ToolCallRecorder as j, ToolCallSpan as k, type ExecutionResult as l, type AsyncExecutionResult as m, type UploadResult as n, type UsageStats as o, type DownloadResult as p, type BrowserSessionOptions as q, type BrowserSessionInfo as r, type NavigationResult as s, type ClickOptions as t, type TypeOptions as u, type FillOptions as v, type ScrollOptions as w, type ScreenshotOptions as x, type WaitCondition as y, type ExtractedElement as z };