import * as React from 'react';
import { RefObject } from 'react';
import { R as Run, G as GroupedMessage } from './run-PfLmDAox.js';
import { S as SessionMessage } from './message-BHWbxBtT.js';
import { S as SessionPart } from './parts-dj7AcUg0.js';
import { R as RegisterActiveSessionOptions, g as ActiveSessionTransportMode, c as ActiveSessionConnectionState } from './active-sessions-store-CeOmXgv5.js';
import { F as FeedSegment } from './tool-call-feed-D9iofJgW.js';
import 'nanostores';
import 'react/jsx-runtime';

/**
 * Scroll-to-bottom behaviour: sticks to the bottom while streaming,
 * pauses when user scrolls up, resumes when user scrolls back down.
 */
declare function useAutoScroll(containerRef: RefObject<HTMLElement | null>, deps?: unknown[]): {
    isAtBottom: boolean;
    scrollToBottom: () => void;
};

interface UseDropdownMenuOptions {
    closeOnEsc?: boolean;
}
declare function useDropdownMenu(options?: UseDropdownMenuOptions): {
    open: boolean;
    setOpen: React.Dispatch<React.SetStateAction<boolean>>;
    ref: React.RefObject<HTMLDivElement | null>;
    toggle: () => void;
    close: () => void;
};

/**
 * Manages per-run collapse state with auto-collapse after run completion.
 *
 * - Runs stay expanded by default
 * - Collapse is manual only
 */
declare function useRunCollapseState(runs: Run[]): {
    isCollapsed: (runId: string) => boolean;
    toggleCollapse: (runId: string) => void;
};

interface UseRunGroupsOptions {
    messages: SessionMessage[];
    partMap: Record<string, SessionPart[]>;
    isStreaming: boolean;
}
declare function useRunGroups({ messages, partMap, isStreaming, }: UseRunGroupsOptions): GroupedMessage[];

/**
 * useToolCallStream — parses SSE events into ToolCallFeed segments.
 *
 * Takes raw SSE event data from the orchestrator stream and produces
 * structured FeedSegments that ToolCallFeed can render.
 */

interface UseToolCallStreamReturn {
    /** Current feed segments (text + tool calls interleaved) */
    segments: FeedSegment[];
    /** Push a raw SSE event into the stream */
    pushEvent: (event: {
        type: string;
        data: Record<string, unknown>;
    }) => void;
    /** Push a text delta (from message.part.updated) */
    pushText: (delta: string) => void;
    /** Mark a tool call as complete */
    completeToolCall: (id: string, result: {
        output?: string;
        error?: string;
        duration?: number;
    }) => void;
    /** Reset the stream */
    reset: () => void;
}
declare function useToolCallStream(): UseToolCallStreamReturn;

interface SdkSessionAttachment {
    name: string;
    size?: number;
}
interface SdkSessionSeed {
    id: string;
    role: SessionMessage["role"];
    createdAt?: number | string | Date;
    content?: string;
    attachments?: SdkSessionAttachment[];
    parts?: SessionPart[];
}
interface SdkSessionEvent {
    type: string;
    data?: Record<string, unknown>;
}
interface BeginAssistantMessageOptions {
    id?: string;
    role?: Extract<SessionMessage["role"], "assistant" | "system">;
    createdAt?: number | string | Date;
}
interface AppendUserMessageOptions {
    id?: string;
    role?: Extract<SessionMessage["role"], "user" | "system">;
    content: string;
    createdAt?: number | string | Date;
    attachments?: SdkSessionAttachment[];
}
interface CompleteAssistantMessageOptions {
    messageId?: string;
    finalText?: string;
}
interface ApplySdkEventOptions {
    messageId?: string;
}
interface UseSdkSessionOptions {
    initialMessages?: SdkSessionSeed[];
}
interface UseSdkSessionReturn {
    messages: SessionMessage[];
    partMap: Record<string, SessionPart[]>;
    isStreaming: boolean;
    activeAssistantMessageId: string | null;
    replaceHistory: (messages: SdkSessionSeed[]) => void;
    appendUserMessage: (message: AppendUserMessageOptions) => string;
    beginAssistantMessage: (options?: BeginAssistantMessageOptions) => string;
    applySdkEvent: (event: SdkSessionEvent, options?: ApplySdkEventOptions) => void;
    completeAssistantMessage: (options?: CompleteAssistantMessageOptions) => void;
    failAssistantMessage: (error: string, options?: {
        messageId?: string;
    }) => void;
    setStreaming: (value: boolean) => void;
    reset: () => void;
}
declare function useSdkSession({ initialMessages, }?: UseSdkSessionOptions): UseSdkSessionReturn;

interface RealtimeSessionOptions extends RegisterActiveSessionOptions {
    connectUrl?: string | null;
    enabled?: boolean;
    foreground?: boolean;
    keepRegistered?: boolean;
    reconnect?: boolean;
    reconnectIntervalMs?: number;
    maxReconnectAttempts?: number;
    transportMode?: ActiveSessionTransportMode;
    onEvent?: (event: SdkSessionEvent) => void;
    onOpen?: () => void;
    onClose?: () => void;
    onError?: (error: Error) => void;
}
interface RealtimeSessionState {
    connectionState: ActiveSessionConnectionState;
    lastError: string | null;
    reconnectAttempts: number;
    isConnected: boolean;
}
interface RealtimeSessionTarget extends RealtimeSessionOptions {
    key?: string;
}
interface RealtimeSessionRegistryProps {
    sessions: RealtimeSessionTarget[];
}
declare function useRealtimeSession({ sessionId, projectId, projectLabel, title, href, metadata, connectUrl, enabled, foreground, keepRegistered, reconnect, reconnectIntervalMs, maxReconnectAttempts, transportMode, onEvent, onOpen, onClose, onError, }: RealtimeSessionOptions): RealtimeSessionState;
declare function RealtimeSessionRegistry({ sessions }: RealtimeSessionRegistryProps): React.FunctionComponentElement<RealtimeSessionTarget>[];

/**
 * SSE Event data structure
 */
interface SSEEvent<T = unknown> {
    id?: string;
    event: string;
    data: T;
    timestamp: number;
}
/**
 * Connection state for SSE streams
 */
type ConnectionState = "connecting" | "connected" | "reconnecting" | "disconnected" | "error";
/**
 * SSE stream options
 */
interface UseSSEStreamOptions<T = unknown> {
    /** URL to connect to */
    url: string;
    /** Authorization header value */
    authToken?: string;
    /** Enable automatic reconnection (default: true) */
    autoReconnect?: boolean;
    /** Max reconnection attempts (default: 5) */
    maxRetries?: number;
    /** Base delay between reconnects in ms (default: 1000) */
    reconnectDelay?: number;
    /** Event types to listen for (default: all) */
    eventTypes?: string[];
    /** Callback for each event */
    onEvent?: (event: SSEEvent<T>) => void;
    /** Callback on connection state change */
    onStateChange?: (state: ConnectionState) => void;
    /** Callback on error */
    onError?: (error: Error) => void;
    /** Custom headers */
    headers?: Record<string, string>;
    /** Whether to start connected (default: true) */
    enabled?: boolean;
}
/**
 * SSE stream result
 */
interface UseSSEStreamResult<T = unknown> {
    /** Current connection state */
    state: ConnectionState;
    /** All received events */
    events: SSEEvent<T>[];
    /** Most recent event */
    lastEvent: SSEEvent<T> | null;
    /** Error if any */
    error: Error | null;
    /** Manually connect */
    connect: () => void;
    /** Manually disconnect */
    disconnect: () => void;
    /** Clear events buffer */
    clearEvents: () => void;
    /** Retry count */
    retryCount: number;
    /** Time since last event (ms) */
    timeSinceLastEvent: number;
}
/**
 * React hook for consuming SSE streams with automatic reconnection,
 * event buffering, and state management.
 *
 * @example
 * ```tsx
 * const { events, state, lastEvent } = useSSEStream({
 *   url: '/api/v1/tasks/123/stream',
 *   authToken: 'Bearer xxx',
 *   onEvent: (e) => console.log('Event:', e),
 * });
 *
 * return (
 *   <div>
 *     <p>Status: {state}</p>
 *     {events.map((e, i) => (
 *       <div key={i}>{e.event}: {JSON.stringify(e.data)}</div>
 *     ))}
 *   </div>
 * );
 * ```
 */
declare function useSSEStream<T = unknown>(options: UseSSEStreamOptions<T>): UseSSEStreamResult<T>;
/**
 * Typed event types for common streaming scenarios
 */
interface TaskStreamEvent {
    task_id: string;
    status?: string;
    progress?: number;
    message?: string;
    result?: unknown;
    error?: string;
}
interface AgentStreamEvent {
    type: "message.updated" | "tool_call" | "tool_result" | "llm_response" | "error" | "session.idle" | "execution.started" | "execution.result";
    data: unknown;
    timestamp?: number;
}
interface TerminalStreamEvent {
    type: "output" | "input" | "error" | "exit";
    data: string;
    timestamp: number;
}
interface AutomationStreamEvent {
    automation_id: string;
    event_id?: string;
    status?: string;
    variant_id?: string;
    output?: string;
    action_result?: unknown;
    error?: string;
}
interface BotStreamEvent {
    bot_id: string;
    type: "balance" | "trade" | "decision" | "log" | "error";
    data: unknown;
    timestamp: number;
}

export { type AgentStreamEvent, type AppendUserMessageOptions, type ApplySdkEventOptions, type AutomationStreamEvent, type BeginAssistantMessageOptions, type BotStreamEvent, type CompleteAssistantMessageOptions, type ConnectionState, type RealtimeSessionOptions, RealtimeSessionRegistry, type RealtimeSessionRegistryProps, type RealtimeSessionState, type RealtimeSessionTarget, type SSEEvent, type SdkSessionAttachment, type SdkSessionEvent, type SdkSessionSeed, type TaskStreamEvent, type TerminalStreamEvent, type UseRunGroupsOptions, type UseSSEStreamOptions, type UseSSEStreamResult, type UseSdkSessionOptions, type UseSdkSessionReturn, type UseToolCallStreamReturn, useAutoScroll, useDropdownMenu, useRealtimeSession, useRunCollapseState, useRunGroups, useSSEStream, useSdkSession, useToolCallStream };