import * as react_jsx_runtime from 'react/jsx-runtime';
import { ReactNode } from 'react';
import { AgentBuilderConfig, Message, ThreadMessage, SubagentThreadMessage, GroupedThreadMessage, ConnectionStatus as ConnectionStatus$1, SendMessagePayload, ThreadFile, PendingAttachment } from '@standardagents/client';
export { AgentBuilderClient, AgentBuilderConfig, AttachmentPayload, AttachmentRef, CreateThreadPayload, CustomEvent, ErrorEvent, FileUploadManager, GetMessagesOptions, GroupedThreadMessage, LogDataEvent, LogStreamEvent, LogWebSocketCallbacks, Message, MessageChunkEvent, MessageDataEvent, MessageStreamEvent, MessageWebSocketCallbacks, PendingAttachment, SendMessagePayload, StatusMessage, StoppedByUserEvent, SubagentBlockMessage, SubagentThreadMessage, Thread, ThreadConnectionCallbacks, ThreadConnectionManager, ThreadConnectionOptions, ThreadEvent, ThreadFile, ThreadMessage, WorkItem, WorkMessage, generatePendingFileId, isImageMimeType, messagesToFiles, parseAttachments, readFileAsDataUrl, transformToSubagentBlocks, transformToWorkblocks } from '@standardagents/client';

interface AgentBuilderProviderProps {
    config: AgentBuilderConfig;
    children: ReactNode;
}
/**
 * AgentBuilderProvider provides the AgentBuilder client instance to all child components.
 * This should wrap the part of your app where you want to use AgentBuilder functionality.
 *
 * @example
 * ```tsx
 * <AgentBuilderProvider config={{ endpoint: 'https://api.example.com' }}>
 *   <YourApp />
 * </AgentBuilderProvider>
 * ```
 */
declare function AgentBuilderProvider({ config, children }: AgentBuilderProviderProps): react_jsx_runtime.JSX.Element;

interface ThreadProviderOptions {
    /** Whether to preload messages on mount (default: true) */
    preload?: boolean;
    /** Whether to connect to live updates (default: true) */
    live?: boolean;
    /** Transform messages to workblocks (default: false) */
    useWorkblocks?: boolean;
    /** Transform messages to subagent blocks (default: false) */
    useSubagentBlocks?: boolean;
    /** Maximum message depth to fetch/stream (default: 0) */
    depth?: number;
    /** Whether to include silent messages (default: false) */
    includeSilent?: boolean;
}

/**
 * Event listener callback type
 */
type EventListener<T = unknown> = (data: T) => void;
/**
 * WebSocket connection status
 */
type ConnectionStatus = ConnectionStatus$1;
/**
 * Thread context value - the public interface returned by useThread()
 */
interface ThreadContextValue {
    /** The thread ID */
    threadId: string;
    /** Current messages in the thread */
    messages: Message[];
    /** Messages transformed to workblocks (if useWorkblocks is true) */
    workblocks: ThreadMessage[];
    /** Messages transformed to subagent blocks (if useSubagentBlocks is true) */
    subagentBlocks: SubagentThreadMessage[];
    /** Active grouped message view based on options (subagent blocks > workblocks > raw) */
    groupedMessages: GroupedThreadMessage[];
    /** Whether messages are currently loading (alias: isLoading) */
    loading: boolean;
    /** Whether messages are currently loading (alias for loading) */
    isLoading: boolean;
    /** Any error that occurred */
    error: Error | null;
    /** WebSocket connection status (alias: status) */
    connectionStatus: ConnectionStatus;
    /** WebSocket connection status (alias for connectionStatus) */
    status: ConnectionStatus;
    /** Subscribe to a specific event type (alias: onEvent) */
    subscribeToEvent: <T = unknown>(eventType: string, listener: EventListener<T>) => () => void;
    /** Subscribe to a specific event type (alias for subscribeToEvent) */
    onEvent: <T = unknown>(eventType: string, listener: EventListener<T>) => () => void;
    /** Options passed to the provider */
    options: ThreadProviderOptions;
    /** Send a message to the thread (auto-includes pending attachments) */
    sendMessage: (payload: Omit<SendMessagePayload, 'attachments'>) => Promise<Message>;
    /** Stop the current execution */
    stopExecution: () => Promise<void>;
    /** Delete a message from the thread (optimistically removes from UI) */
    deleteMessage: (messageId: string) => Promise<void>;
    /** All files in the thread (pending uploads + committed from messages) */
    files: ThreadFile[];
    /** Add files and start uploading immediately to filesystem */
    addFiles: (files: File[] | FileList) => void;
    /** Remove a pending file (cannot remove committed files) */
    removeFile: (id: string) => void;
    /** Get the full URL for a file */
    getFileUrl: (file: ThreadFile) => string;
    /** Get the thumbnail URL for an image file */
    getThumbnailUrl: (file: ThreadFile) => string;
    /** Get preview URL - localPreviewUrl for pending images, thumbnail for committed */
    getPreviewUrl: (file: ThreadFile) => string | null;
    /** Pending attachments to be sent with next message */
    attachments: PendingAttachment[];
    /** Add attachment(s) to be sent with next message (no upload, stored locally) */
    addAttachment: (files: File | File[] | FileList) => void;
    /** Remove a pending attachment */
    removeAttachment: (id: string) => void;
    /** Clear all pending attachments */
    clearAttachments: () => void;
}
interface ThreadProviderProps {
    /** The thread ID to connect to */
    threadId: string;
    /** Provider options */
    options?: ThreadProviderOptions;
    /** Whether to preload messages on mount (default: true) */
    preload?: boolean;
    /** Whether to enable live updates via WebSocket (default: true) */
    live?: boolean;
    /** Transform messages to workblocks (default: false) */
    useWorkblocks?: boolean;
    /** Transform messages to subagent blocks (default: false) */
    useSubagentBlocks?: boolean;
    /** Maximum message depth to fetch/stream (default: 0 for top-level only) */
    depth?: number;
    /** Whether to include silent messages (default: false) */
    includeSilent?: boolean;
    /** Optional endpoint override */
    endpoint?: string;
    children: ReactNode;
}
/**
 * ThreadProvider establishes a WebSocket connection to a thread and provides
 * context for child components to access messages and events.
 *
 * Must be nested inside AgentBuilderProvider.
 *
 * @example
 * ```tsx
 * <AgentBuilderProvider config={{ endpoint: 'https://api.example.com' }}>
 *   <ThreadProvider threadId="thread-123">
 *     <ChatMessages />
 *   </ThreadProvider>
 * </AgentBuilderProvider>
 * ```
 */
declare function ThreadProvider({ threadId, options, preload, live, useWorkblocks, useSubagentBlocks, depth, includeSilent, endpoint: endpointOverride, children, }: ThreadProviderProps): react_jsx_runtime.JSX.Element;
/**
 * @deprecated Use `useThread()` instead.
 *
 * Hook to access the thread context.
 * Must be used within a ThreadProvider.
 *
 * @throws Error if used outside of ThreadProvider
 */
declare function useThreadContext(): ThreadContextValue;
/**
 * Hook to get the current thread ID from context.
 * Must be used within a ThreadProvider.
 */
declare function useThreadId(): string;

/**
 * Hook to access the thread context.
 *
 * Must be used within a ThreadProvider. Returns the full thread context
 * including messages, actions, and file management.
 *
 * @returns The thread context value
 *
 * @example
 * ```tsx
 * function ChatMessages() {
 *   const { messages, sendMessage, files } = useThread()
 *
 *   return (
 *     <div>
 *       {messages.map(msg => <Message key={msg.id} message={msg} />)}
 *       <button onClick={() => sendMessage({ role: 'user', content: 'Hello!' })}>
 *         Send
 *       </button>
 *     </div>
 *   )
 * }
 *
 * // Wrap with ThreadProvider
 * <ThreadProvider threadId="thread-123">
 *   <ChatMessages />
 * </ThreadProvider>
 * ```
 */
declare function useThread(): ThreadContextValue;

/**
 * Hook to listen for custom events emitted from a thread via the stream WebSocket.
 * Calls the provided callback whenever an event of the specified type is received.
 *
 * Must be used within a ThreadProvider. Events are emitted from the backend
 * using `emitThreadEvent(flow, 'event-type', data)`.
 *
 * @param type - The custom event type to filter for
 * @param callback - Function to call when an event of this type is received
 *
 * @example
 * ```tsx
 * function GamePreview() {
 *   const [gameHtml, setGameHtml] = useState<string | null>(null)
 *
 *   onThreadEvent('game_built', (data: { success: boolean }) => {
 *     if (data.success) {
 *       fetchGameHtml()
 *     }
 *   })
 *
 *   return <iframe srcDoc={gameHtml} />
 * }
 * ```
 *
 * @example
 * ```tsx
 * function ProgressIndicator() {
 *   const [progress, setProgress] = useState(0)
 *
 *   onThreadEvent('progress', (data: { step: number; total: number }) => {
 *     setProgress(data.step / data.total * 100)
 *   })
 *
 *   return <ProgressBar value={progress} />
 * }
 * ```
 */
declare function onThreadEvent<T = unknown>(type: string, callback: (data: T) => void): void;
/**
 * Hook to get the latest event data for a specific event type as React state.
 * Returns the most recent event data, or null if no event has been received.
 *
 * Must be used within a ThreadProvider. Events are emitted from the backend
 * using `emitThreadEvent(flow, 'event-type', data)`.
 *
 * @param type - The custom event type to filter for
 * @returns The latest event data matching the specified type, or null if none received
 *
 * @example
 * ```tsx
 * function ProgressIndicator() {
 *   const progress = useThreadEvent<{ step: number; total: number }>('progress')
 *
 *   if (!progress) return null
 *
 *   return (
 *     <div>
 *       Step {progress.step} of {progress.total}
 *     </div>
 *   )
 * }
 * ```
 *
 * @example
 * ```tsx
 * function StatusDisplay() {
 *   const status = useThreadEvent<{ message: string }>('status')
 *
 *   useEffect(() => {
 *     if (status) {
 *       console.log('Status updated:', status.message)
 *     }
 *   }, [status])
 *
 *   return <div>{status?.message ?? 'No status'}</div>
 * }
 * ```
 */
declare function useThreadEvent<T = unknown>(type: string): T | null;

/**
 * @deprecated Use `const { sendMessage } = useThread()` instead.
 *
 * Hook that returns a function to send messages to the current thread.
 * Must be used within a ThreadProvider.
 *
 * This hook automatically uses the thread ID from the ThreadProvider context,
 * so you don't need to pass it manually.
 *
 * @returns A function that sends a message to the current thread
 *
 * @throws Error if used outside of ThreadProvider
 *
 * @example
 * ```tsx
 * // NEW - Recommended
 * const { sendMessage } = useThread()
 * await sendMessage({ role: 'user', content: 'Hello!' })
 *
 * // OLD - Deprecated
 * const sendMessage = useSendMessage()
 * await sendMessage({ role: 'user', content: 'Hello!' })
 * ```
 */
declare function useSendMessage(): (payload: SendMessagePayload) => Promise<Message>;

/**
 * @deprecated Use `const { stopExecution } = useThread()` instead.
 *
 * Hook that returns a function to stop the current thread's execution.
 * Must be used within a ThreadProvider.
 *
 * This hook automatically uses the thread ID from the ThreadProvider context,
 * so you don't need to pass it manually.
 *
 * @returns A function that stops the current thread's execution
 *
 * @throws Error if used outside of ThreadProvider
 *
 * @example
 * ```tsx
 * // NEW - Recommended
 * const { stopExecution } = useThread()
 * await stopExecution()
 *
 * // OLD - Deprecated
 * const stopThread = useStopThread()
 * await stopThread()
 * ```
 */
declare function useStopThread(): () => Promise<void>;

/**
 * Send a message to a specific thread.
 *
 * This is a standalone function that sends messages to threads.
 * It requires that an AgentBuilderProvider is mounted somewhere in your app
 * to set the global endpoint configuration.
 *
 * @param id - The thread ID to send the message to
 * @param payload - The message payload containing role, content, and optional silent flag
 * @returns Promise resolving to the created message
 *
 * @throws Error if called before AgentBuilderProvider is mounted
 *
 * @example
 * ```tsx
 * import { sendMessage } from '@standardagents/react'
 *
 * await sendMessage('thread-123', {
 *   role: 'user',
 *   content: 'Hello, agent!',
 * })
 *
 * // Send a silent message
 * await sendMessage('thread-123', {
 *   role: 'user',
 *   content: 'Silent message',
 *   silent: true,
 * })
 * ```
 */
declare function sendMessage(id: string, payload: SendMessagePayload): Promise<Message>;

interface StopThreadOptions {
    /**
     * Override the endpoint URL for this request.
     * If not provided, uses the endpoint from AgentBuilderProvider.
     */
    endpoint?: string;
}
/**
 * Stop execution of a thread.
 *
 * This is a standalone function that stops a running thread execution.
 * It requires that an AgentBuilderProvider is mounted somewhere in your app
 * to set the global endpoint configuration, or you can provide a custom endpoint.
 *
 * @param id - The thread ID to stop
 * @param options - Optional configuration including custom endpoint
 * @returns Promise that resolves when the thread is stopped
 *
 * @throws Error if called before AgentBuilderProvider is mounted and no endpoint is provided
 *
 * @example
 * ```tsx
 * import { stopThread } from '@standardagents/react'
 *
 * // Using global endpoint from AgentBuilderProvider
 * await stopThread('thread-123')
 *
 * // Using custom endpoint
 * await stopThread('thread-123', {
 *   endpoint: 'https://custom.example.com/api'
 * })
 * ```
 */
declare function stopThread(id: string, options?: StopThreadOptions): Promise<void>;

export { AgentBuilderProvider, type ConnectionStatus, type ThreadContextValue, ThreadProvider, type ThreadProviderOptions, onThreadEvent, sendMessage, stopThread, useSendMessage, useStopThread, useThread, useThreadContext, useThreadEvent, useThreadId };