@erdoai/ui 0.1.5

package/dist/index.d.ts

@@ -0,0 +1,931 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import * as React from 'react';
+import React__default from 'react';
+import { ErdoClient, ContentItem, SSEEvent, InvokeResult, InvokeParams } from '@erdoai/types';
+export { ContentItem } from '@erdoai/types';
+import * as RechartsPrimitive from 'recharts';
+import { UseQueryResult } from '@tanstack/react-query';
+import { ClassValue } from 'clsx';
+
+/**
+ * Interface for custom data fetching implementations.
+ * Use this when you need to override the default REST API behavior,
+ * e.g., when using an Encore client or custom backend.
+ *
+ * Must be a STABLE object reference - create outside components to avoid
+ * recreating on every render.
+ */
+interface DataFetcher {
+    fetchDatasetContents: (slug: string, invocationId: string) => Promise<any[]>;
+}
+/**
+ * Configuration for the ErdoProvider.
+ */
+interface ErdoProviderConfig {
+    /**
+     * Base URL for API calls (e.g., 'https://api.erdo.ai')
+     * Used by default REST implementation in hooks.
+     */
+    baseUrl: string;
+    /**
+     * Optional auth token for API calls.
+     * Will be sent as Bearer token in Authorization header.
+     * Use this for long-lived API keys (B2B backend-to-backend).
+     */
+    authToken?: string;
+    /**
+     * Optional session token for B2B2C use cases.
+     * When provided, uses the session-authenticated endpoint for dataset queries.
+     * Session tokens are short-lived, scoped to specific datasets, and created
+     * by B2B customers for their end users.
+     *
+     * Example B2B2C flow:
+     * 1. B2B backend creates session token via POST /dataset-sessions
+     * 2. B2B frontend passes session token to ErdoProvider
+     * 3. End user can query only the datasets scoped to that session
+     */
+    sessionToken?: string;
+    /**
+     * Optional ErdoClient for invoking bots.
+     * Required if using useInvocation hook.
+     */
+    client?: ErdoClient;
+    /**
+     * Optional custom data fetcher for non-standard backends.
+     * When provided, hooks will use this instead of the default REST implementation.
+     *
+     * Example usage with Encore client:
+     * ```typescript
+     * // lib/erdo-fetcher.ts - Create ONCE outside components
+     * export const erdoDataFetcher: DataFetcher = {
+     *   fetchDatasetContents: async (slug, invocationId) => {
+     *     const client = await getRequestClient();
+     *     return client.dataset.GetDatasetContents({ slug, invocationId });
+     *   },
+     * };
+     * ```
+     */
+    dataFetcher?: DataFetcher;
+}
+interface ErdoProviderProps {
+    children: React__default.ReactNode;
+    config: ErdoProviderConfig;
+}
+/**
+ * Provider component that configures data fetching for Erdo UI components.
+ *
+ * @example Simple usage with baseUrl (B2B customers):
+ * ```tsx
+ * <ErdoProvider config={{ baseUrl: 'https://api.erdo.ai', authToken: 'xxx' }}>
+ *   <App />
+ * </ErdoProvider>
+ * ```
+ *
+ * @example With custom data fetcher (Erdo frontend):
+ * ```tsx
+ * <ErdoProvider config={{ baseUrl: '', dataFetcher: erdoDataFetcher }}>
+ *   <App />
+ * </ErdoProvider>
+ * ```
+ */
+declare function ErdoProvider({ children, config }: ErdoProviderProps): react_jsx_runtime.JSX.Element;
+/**
+ * Hook to access the Erdo provider configuration.
+ * Must be used within an ErdoProvider.
+ */
+declare function useErdoConfig(): ErdoProviderConfig;
+/**
+ * Hook to check if we're inside an ErdoProvider.
+ * Returns the config if available, null otherwise.
+ */
+declare function useErdoConfigOptional(): ErdoProviderConfig | null;
+
+declare const THEMES: {
+    readonly light: "";
+    readonly dark: ".dark";
+};
+type ChartConfig = {
+    [k in string]: {
+        label?: React.ReactNode;
+        icon?: React.ComponentType;
+    } & ({
+        color?: string;
+        theme?: never;
+    } | {
+        color?: never;
+        theme: Record<keyof typeof THEMES, string>;
+    });
+};
+declare function ChartContainer({ id, className, children, config, debounceResize, ...props }: React.ComponentProps<'div'> & {
+    config: ChartConfig;
+    children: React.ComponentProps<typeof RechartsPrimitive.ResponsiveContainer>['children'];
+    /** Debounce resize events by 200ms to prevent animation restarts during streaming */
+    debounceResize?: boolean;
+}): react_jsx_runtime.JSX.Element;
+declare const ChartStyle: ({ id, config }: {
+    id: string;
+    config: ChartConfig;
+}) => react_jsx_runtime.JSX.Element | null;
+declare const ChartTooltip: typeof RechartsPrimitive.Tooltip;
+interface ChartTooltipContentProps {
+    active?: boolean;
+    payload?: ReadonlyArray<{
+        dataKey?: string;
+        name?: string;
+        value?: any;
+        color?: string;
+        payload?: any;
+        [key: string]: any;
+    }>;
+    label?: string | number;
+    className?: string;
+    indicator?: 'line' | 'dot' | 'dashed';
+    hideLabel?: boolean;
+    hideIndicator?: boolean;
+    labelFormatter?: (label: any, payload: any) => React.ReactNode;
+    labelClassName?: string;
+    formatter?: (value: any, name: any, item: any, index: number, payload: any) => React.ReactNode;
+    color?: string;
+    nameKey?: string;
+    labelKey?: string;
+}
+declare function ChartTooltipContent({ active, payload, className, indicator, hideLabel, hideIndicator, label, labelFormatter, labelClassName, formatter, color, nameKey, labelKey, }: ChartTooltipContentProps): react_jsx_runtime.JSX.Element | null;
+declare const ChartLegend: typeof RechartsPrimitive.Legend;
+interface ChartLegendContentProps {
+    className?: string;
+    hideIcon?: boolean;
+    payload?: ReadonlyArray<{
+        value?: string;
+        color?: string;
+        dataKey?: any;
+        [key: string]: any;
+    }>;
+    verticalAlign?: 'top' | 'bottom' | 'middle';
+    nameKey?: string;
+}
+declare function ChartLegendContent({ className, hideIcon, payload, verticalAlign, nameKey, }: ChartLegendContentProps): react_jsx_runtime.JSX.Element | null;
+
+interface Axis$2 {
+    label: string;
+    key: string;
+    maxValue?: string | null;
+    minValue?: string | null;
+    format?: string | null;
+    type?: 'number' | 'category' | 'date' | null;
+}
+interface DataConfig {
+    chartType: 'bar' | 'line' | 'pie' | 'histogram' | 'scatter' | 'heatmap';
+    xAxis: Axis$2;
+    yAxes: Array<Axis$2>;
+    series: Array<{
+        key: string;
+        name: string;
+        color: string;
+        axisIndex?: number;
+    }>;
+}
+interface BaseChartProps {
+    title: string;
+    subtitle?: string | null;
+    data: any[];
+    displayConfig: ChartConfig;
+    dataConfig: DataConfig;
+    disableAnimation?: boolean;
+    onZoomChange?: (domain: {
+        x: [number | null, number | null];
+        y: [number | null, number | null];
+    }) => void;
+    stacked?: boolean;
+    /** Enable download button (default: true) */
+    enableDownload?: boolean;
+    /** Callback when download succeeds */
+    onDownloadSuccess?: (fileName: string) => void;
+    /** Callback when download fails */
+    onDownloadError?: (error: string) => void;
+}
+interface ChartProps extends BaseChartProps {
+    ChartComponent: React__default.ComponentType<any>;
+    PointComponent: React__default.ComponentType<any>;
+}
+declare function Chart(props: ChartProps): react_jsx_runtime.JSX.Element;
+
+declare function BarChart(props: any): react_jsx_runtime.JSX.Element;
+
+declare function LineChart(props: any): react_jsx_runtime.JSX.Element;
+
+declare function PieChart(props: BaseChartProps): react_jsx_runtime.JSX.Element;
+
+declare function ScatterChart(props: any): react_jsx_runtime.JSX.Element;
+
+declare function HeatmapChart(props: any): react_jsx_runtime.JSX.Element;
+
+interface Axis$1 {
+    label: string;
+    key: string;
+    type?: 'number' | 'category' | 'date' | null;
+    format?: string | null;
+    maxValue?: string | null;
+    minValue?: string | null;
+}
+interface Series$1 {
+    name: string;
+    key: string;
+    color: string;
+    datasetSlug: string;
+    axisIndex?: number;
+    filters?: Filter$1[];
+}
+interface Filter$1 {
+    key: string;
+    operator: 'equals' | 'not_equals' | 'greater_than' | 'less_than' | 'contains' | 'between';
+    value: string[];
+}
+interface SortCondition$1 {
+    key: string;
+    direction: 'asc' | 'desc';
+}
+interface DatasetChartProps {
+    chartType: 'bar' | 'line' | 'pie' | 'histogram' | 'scatter' | 'heatmap';
+    title: string;
+    invocationId: string;
+    datasetSlugs: string[];
+    xAxis: Axis$1;
+    yAxes: Axis$1[];
+    series: Series$1[];
+    dataReduction?: {
+        strategy: 'none' | 'sample' | 'aggregate' | 'bin';
+        target_points: number;
+    };
+    stacked?: boolean;
+    sort?: SortCondition$1[];
+    /** Optional callback for scroll updates when chart loads */
+    onScrollUpdate?: () => void;
+}
+declare const DatasetChart: React__default.NamedExoticComponent<DatasetChartProps>;
+
+declare class ErrorBoundary extends React__default.Component<{
+    fallback: React__default.ReactNode;
+    children: React__default.ReactNode;
+}, {
+    hasError: boolean;
+}> {
+    constructor(props: {
+        fallback: React__default.ReactNode;
+        children: React__default.ReactNode;
+    });
+    static getDerivedStateFromError(_: Error): {
+        hasError: boolean;
+    };
+    componentDidCatch(error: Error, errorInfo: React__default.ErrorInfo): void;
+    render(): React__default.ReactNode;
+}
+
+interface Axis {
+    axis_label: string;
+    key: string;
+    max_value?: string | null;
+    min_value?: string | null;
+    value_type?: 'number' | 'category' | 'date' | null;
+    format?: string | null;
+}
+interface Series {
+    series_name: string;
+    key: string;
+    color: string;
+    dataset_slug?: string;
+    axis_index?: number;
+    filters?: Filter[];
+}
+interface Filter {
+    key: string;
+    operator: 'equals' | 'not_equals' | 'greater_than' | 'less_than' | 'contains' | 'between';
+    value: string[];
+}
+interface SortCondition {
+    key: string;
+    direction: 'asc' | 'desc';
+}
+interface ContentChartConfig {
+    chart_type: 'bar' | 'line' | 'pie' | 'histogram' | 'scatter' | 'heatmap';
+    chart_title: string;
+    x_axis: Axis;
+    y_axes: Axis[];
+    series: Series[];
+    data_reduction?: {
+        strategy: 'none' | 'sample' | 'aggregate' | 'bin';
+        target_points: number;
+    };
+    stacked?: boolean;
+    sort?: SortCondition[];
+}
+interface ChartContentProps {
+    config: ContentChartConfig;
+    data: any[];
+    className?: string;
+}
+declare function ChartContent({ config, data, className }: ChartContentProps): react_jsx_runtime.JSX.Element;
+
+interface ContentProps {
+    item: ContentItem;
+    className?: string;
+    components?: Partial<{
+        text: React__default.ComponentType<{
+            content: string;
+            className?: string;
+        }>;
+        json: React__default.ComponentType<{
+            content: string | object;
+            className?: string;
+        }>;
+        chart: React__default.ComponentType<{
+            config: ContentChartConfig;
+            data: any[];
+            className?: string;
+        }>;
+        table: React__default.ComponentType<{
+            title?: string;
+            columns: any[];
+            data: any[];
+            className?: string;
+        }>;
+    }>;
+}
+/**
+ * Routes content to the appropriate renderer based on content_type and ui_content_type.
+ */
+declare function Content({ item, className, components }: ContentProps): string | number | bigint | boolean | Iterable<React__default.ReactNode> | Promise<string | number | bigint | boolean | React__default.ReactPortal | React__default.ReactElement<unknown, string | React__default.JSXElementConstructor<any>> | Iterable<React__default.ReactNode> | null | undefined> | react_jsx_runtime.JSX.Element | null | undefined;
+
+interface TextContentProps {
+    content: string;
+    className?: string;
+}
+declare function TextContent({ content, className }: TextContentProps): react_jsx_runtime.JSX.Element | null;
+
+interface JsonContentProps {
+    content: string | object;
+    className?: string;
+}
+declare function JsonContent({ content, className }: JsonContentProps): react_jsx_runtime.JSX.Element | null;
+
+interface MarkdownContentProps {
+    /** The markdown text to render */
+    text: string;
+    /** Additional CSS class names */
+    className?: string;
+}
+/**
+ * Renders markdown content with GitHub Flavored Markdown support.
+ *
+ * @example
+ * ```tsx
+ * <MarkdownContent text="# Hello\n\nThis is **bold** text." />
+ * ```
+ */
+declare function MarkdownContent({ text, className }: MarkdownContentProps): react_jsx_runtime.JSX.Element | null;
+
+interface TableColumn {
+    column_name: string;
+    key: string;
+    format?: string;
+    value_type?: 'number' | 'category' | 'date';
+}
+interface TableContentProps {
+    title?: string;
+    columns: TableColumn[];
+    data: any[];
+    className?: string;
+    maxRows?: number;
+}
+declare function TableContent({ title, columns, data, className, maxRows }: TableContentProps): react_jsx_runtime.JSX.Element;
+
+interface ZoomState {
+    refAreaLeft: number | null;
+    refAreaRight: number | null;
+    refAreaTop: number | null;
+    refAreaBottom: number | null;
+    zooming: boolean;
+}
+interface Domain {
+    x: [number | string | null, number | string | null];
+    y: [number | string | null, number | string | null];
+}
+interface ZoomEvent {
+    chartX: number;
+    chartY: number;
+    xValue: number;
+    yValue: number;
+}
+interface UseChartZoomProps {
+    onZoomChange?: (domain: {
+        x: [number | null, number | null];
+        y: [number | null, number | null];
+    }) => void;
+}
+declare function useChartZoom({ onZoomChange }?: UseChartZoomProps): {
+    zoomState: ZoomState;
+    customDomain: Domain;
+    handlers: {
+        onZoomStart: (e: ZoomEvent) => void;
+        onZoomMove: (e: ZoomEvent) => void;
+        onZoomEnd: () => void;
+        onResetZoom: () => void;
+    };
+};
+
+/**
+ * Hook to fetch contents of a single dataset.
+ *
+ * @param datasetSlug - The slug/identifier of the dataset
+ * @param invocationId - The invocation ID context
+ * @returns React Query result with dataset contents
+ *
+ * @example
+ * ```tsx
+ * const { data, isLoading, error } = useDatasetContents('my-dataset', invocationId);
+ * ```
+ */
+declare function useDatasetContents(datasetSlug: string, invocationId: string): UseQueryResult<any[], Error>;
+/**
+ * Hook to fetch contents of multiple datasets in parallel.
+ *
+ * @param datasetSlugs - Array of dataset slugs/identifiers
+ * @param invocationId - The invocation ID context
+ * @returns Array of React Query results, one per dataset
+ *
+ * @example
+ * ```tsx
+ * const results = useMultipleDatasetContents(['dataset-1', 'dataset-2'], invocationId);
+ * const isLoading = results.some(r => r.isLoading);
+ * const allData = results.map(r => r.data || []);
+ * ```
+ */
+declare function useMultipleDatasetContents(datasetSlugs: string[], invocationId: string): UseQueryResult<any[], Error>[];
+
+interface UseInvocationOptions {
+    /** Called for each SSE event received during streaming */
+    onEvent?: (event: SSEEvent) => void;
+    /** Called when invocation completes successfully */
+    onFinish?: (result: InvokeResult) => void;
+    /** Called if an error occurs */
+    onError?: (error: Error) => void;
+}
+interface UseInvocationReturn {
+    /** Current invocation result (updates during streaming) */
+    result: InvokeResult | null;
+    /** Whether an invocation is currently in progress */
+    isStreaming: boolean;
+    /** Error if the last invocation failed */
+    error: Error | null;
+    /** Function to start a new invocation */
+    invoke: (botKey: string, params: InvokeParams) => Promise<InvokeResult>;
+    /** Function to cancel the current invocation */
+    cancel: () => void;
+}
+/**
+ * Hook for invoking Erdo bots and streaming results.
+ *
+ * Requires ErdoProvider with a client configured.
+ *
+ * @example
+ * ```tsx
+ * function MyComponent() {
+ *   const { result, isStreaming, invoke } = useInvocation({
+ *     onEvent: (event) => console.log('Event:', event),
+ *     onFinish: (result) => console.log('Done:', result),
+ *   });
+ *
+ *   const handleAnalyze = async () => {
+ *     await invoke('org.my-bot', {
+ *       messages: [{ role: 'user', content: 'Analyze sales data' }],
+ *       datasets: ['sales-2024'],
+ *     });
+ *   };
+ *
+ *   return (
+ *     <div>
+ *       <button onClick={handleAnalyze} disabled={isStreaming}>
+ *         {isStreaming ? 'Analyzing...' : 'Analyze'}
+ *       </button>
+ *       {result && <div>Result: {JSON.stringify(result)}</div>}
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+declare function useInvocation(options?: UseInvocationOptions): UseInvocationReturn;
+
+/**
+ * Format a value based on its type and specified format pattern
+ */
+declare function formatValue(value: any, format?: string | null, valueType?: 'number' | 'category' | 'date' | null): string;
+/**
+ * Parse a value to a Date object
+ */
+declare function parseToDate(value: any): Date | null;
+
+declare function cn(...inputs: ClassValue[]): string;
+
+/**
+ * Utility functions for resolving data keys across different naming conventions.
+ * Used by dataset visualization components (charts, tables, etc.) to handle
+ * mismatches between config keys and actual data keys.
+ */
+/**
+ * Convert PascalCase or camelCase to snake_case
+ * Examples: ActiveUsers -> active_users, userName -> user_name
+ */
+declare function toSnakeCase(str: string): string;
+/**
+ * Resolve the actual key from data objects by trying multiple patterns.
+ * This handles common naming convention mismatches between config and data.
+ *
+ * Tries in order:
+ * 1. Exact match
+ * 2. Lowercase (Date -> date)
+ * 3. Snake case (ActiveUsers -> active_users)
+ * 4. Normalized (case-insensitive, underscore-insensitive)
+ *
+ * @param dataRows - Array of data objects to search
+ * @param configKey - The key from the configuration
+ * @returns The resolved key that exists in the data, or the original key if not found
+ */
+declare function resolveKeyFromData(dataRows: any[], configKey: string): string;
+
+/**
+ * JSON streaming parser utilities.
+ * Used for parsing potentially incomplete JSON during SSE streaming.
+ */
+type JSONValue = string | number | boolean | null | {
+    [key: string]: JSONValue;
+    [parsingSymbol]?: boolean;
+} | (JSONValue[] & {
+    [parsingSymbol]?: boolean;
+});
+type ParserState = 'START' | 'IN_OBJECT' | 'IN_ARRAY' | 'IN_OBJECT_KEY' | 'AFTER_KEY' | 'IN_OBJECT_VALUE' | 'IN_STRING' | 'IN_NUMBER' | 'IN_TRUE' | 'IN_FALSE' | 'IN_NULL' | 'IN_UNICODE' | 'END';
+declare const parsingSymbol: unique symbol;
+declare class JSONStreamParser {
+    result: JSONValue | undefined;
+    private stack;
+    private key;
+    state: ParserState;
+    private stringBuffer;
+    private numberBuffer;
+    private quoteBuffer;
+    private escapeNext;
+    private unicode;
+    private isInTripleQuotes;
+    constructor();
+    private reset;
+    parse(jsonString: string): JSONValue | undefined;
+    add(chunk: string): JSONValue | undefined;
+    private processChar;
+    private handleStartState;
+    private error;
+    private handleObjectState;
+    private handleArrayState;
+    private handleObjectKeyState;
+    private handleAfterKeyState;
+    private handleObjectValueState;
+    private handleStringState;
+    private handleNumberState;
+    private handleLiteralState;
+    private handleUnicodeState;
+    private handleEscapeChar;
+    private startObject;
+    private endObject;
+    private startArray;
+    private endArray;
+    private startValue;
+    private endString;
+    private endNumber;
+    private endLiteral;
+    private addValueToParent;
+    private updateValueInParent;
+    private isWhitespace;
+    private getParentState;
+}
+/**
+ * Parse a complete JSON string, with fallback to streaming parser for malformed JSON.
+ */
+declare function parseCompleteJson(content: string): any;
+type ContentChunk = {
+    content: string | Record<string, any>;
+    type: 'json' | 'text';
+};
+declare function isWhitespaceChar(char: string): boolean;
+/**
+ * Parse mixed content that may contain JSON objects embedded in text.
+ * Handles both markdown code blocks (```json...```) and inline JSON.
+ */
+declare function parseMixedJson(content: string | any[] | Record<string, any>): ContentChunk[] | any[] | Record<string, any>;
+declare function isParsingComplete(value: any): boolean;
+declare function isParsingInProgress(value: any): boolean;
+
+/**
+ * SSE Event Types for parsing streaming invocation results.
+ *
+ * These types are standalone and don't depend on any generated client types.
+ * They represent the structure of entities that can be built from SSE events.
+ */
+
+type ContentType = 'text' | 'json' | 'xml' | 'thinking' | 'redacted_thinking';
+declare function isJsonLike(contentType: ContentType, uiContentType: string): boolean;
+type EntityType = 'message' | 'message_content' | 'invocation' | 'output' | 'output_content' | 'step' | 'result_handler' | 'status' | 'log';
+type MessageStreamingState = 'in_progress' | 'completed';
+interface SSEEventData {
+    payload: Record<string, any> | string;
+    metadata: {
+        path: string;
+        content_type?: ContentType;
+        history_content_type?: string;
+        ui_content_type?: string;
+        invocation_id?: string;
+        message_id?: string;
+        message_content_id?: string;
+        user_visibility?: string;
+        bot_visibility?: string;
+        visibility?: string;
+        output_id?: string;
+        output_content_id?: string;
+        step_id?: string;
+        result_handler_id?: string;
+        status_id?: string;
+        [key: string]: any;
+    };
+}
+interface BaseContentFields {
+    botInvocation?: BotInvocation;
+    parsedJson?: ContentChunk[];
+    _currentContent?: ContentChunk;
+    _jsonParser?: JSONStreamParser;
+    _isInJson?: boolean;
+    _charBuffer?: string;
+    state: MessageStreamingState;
+    invocation_id: string;
+}
+interface Message {
+    id: string;
+    thread_id: string;
+    author_id: string;
+    author_entity_type: string;
+    created_at: string;
+    updated_at: string;
+    role: string;
+    avatar?: string;
+}
+interface MessageContent extends BaseContentFields {
+    _type: 'message_content';
+    id: string;
+    message_id: string;
+    content_type: ContentType;
+    content: string;
+    created_by_invocation_id?: string;
+    user_visibility: string;
+    bot_visibility: string;
+    created_at: string;
+    updated_at: string;
+    content_params: {
+        RawMessage: any;
+        Valid: boolean;
+    };
+    history_content_type: {
+        String: string;
+        Valid: boolean;
+    };
+    ui_content_type: {
+        String: string;
+        Valid: boolean;
+    };
+}
+interface MessageWithContents {
+    _type: 'message';
+    message: Message;
+    state: MessageStreamingState;
+    contents: MessageContent[];
+    contentsByID: Record<string, MessageContent>;
+    contentIDToIdx: Record<string, number>;
+}
+interface Output {
+    id: string;
+    invocation_id?: string;
+    path?: string;
+    created_at: string;
+    updated_at: string;
+}
+interface OutputContent extends BaseContentFields {
+    _type: 'output_content';
+    id: string;
+    output_id: string;
+    content: string;
+    content_type: ContentType;
+    user_visibility: string;
+    bot_visibility: string;
+    created_at: string;
+    updated_at: string;
+    content_params: {
+        RawMessage: any;
+        Valid: boolean;
+    };
+    history_content_type: {
+        String: string;
+        Valid: boolean;
+    };
+    ui_content_type: {
+        String: string;
+        Valid: boolean;
+    };
+    output: OutputWithContents | null;
+}
+interface OutputWithContents {
+    _type: 'output';
+    id: string;
+    step_id?: string;
+    output: Output;
+    state: MessageStreamingState;
+    contents: OutputContent[];
+    contentsByID: Record<string, OutputContent>;
+    contentIDToIdx: Record<string, number>;
+}
+interface Step {
+    _type: 'step';
+    id: string;
+    invocation_id: string;
+    step_id: string;
+    created_at: string;
+    updated_at: string;
+    current_status_id: string;
+    path: {
+        String: string;
+        Valid: boolean;
+    };
+    action_type: {
+        String: string;
+        Valid: boolean;
+    };
+    key: {
+        String: string;
+        Valid: boolean;
+    };
+    bot_id?: string;
+    result_handler_id: string;
+    step_order: {
+        Int32: number;
+        Valid: boolean;
+    };
+    output_content_type: {
+        String: string;
+        Valid: boolean;
+    };
+    execution_mode: {
+        String: string;
+        Valid: boolean;
+    };
+    output_behaviour: {
+        String: string;
+        Valid: boolean;
+    };
+    user_output_visibility: {
+        String: string;
+        Valid: boolean;
+    };
+    output_channels: string[];
+    running_message: {
+        String: string;
+        Valid: boolean;
+    };
+    finished_message: {
+        String: string;
+        Valid: boolean;
+    };
+    depends_on: string[];
+    eventsByID: Record<string, InvocationEvent>;
+    currentStatus: Status | null;
+}
+interface ResultHandler {
+    _type: 'result_handler';
+    id: string;
+    invocation_id: string;
+    result_handler_id: string;
+    step_invocation_id: string;
+    type: string;
+    if_conditions: Record<string, any>;
+    created_at: string;
+    updated_at: string;
+    output_content_type: string;
+    result_handler_order: number;
+    eventsByID: Record<string, InvocationEvent>;
+}
+declare enum InvocationStatus {
+    Pending = "pending",
+    Running = "running",
+    Success = "success",
+    Error = "error",
+    RequiresInfo = "requires info",
+    GoToStep = "go to step",
+    Skipped = "skipped",
+    Break = "break"
+}
+declare enum ExecutionStatus {
+    Initializing = "initializing",
+    Running = "running",
+    ProcessingDatasets = "processing datasets",
+    Completed = "completed",
+    Failed = "failed"
+}
+interface StatusEvent {
+    status: ExecutionStatus | InvocationStatus | string;
+    message?: string;
+    details?: Record<string, any>;
+}
+interface Status {
+    _type: 'status';
+    id: string;
+    status: string;
+    message: {
+        String: string;
+        Valid: boolean;
+    };
+    Details: StatusEvent;
+    created_at?: string;
+}
+interface BotInvocationData {
+    id: string;
+    bot_id: string;
+    bot_name?: string;
+    created_by_user_id?: string;
+    current_state_id: string;
+    parent_invocation_id: string;
+    branch_init_state_id: string;
+    current_status_id: string;
+    organization_id: string;
+    created_at: string;
+    updated_at: string;
+}
+interface BotInvocation {
+    _type: 'invocation';
+    bot_invocation: BotInvocationData;
+    eventsByID: Record<string, InvocationEvent>;
+    currentStatus: Status | null;
+    current_status: Status | null;
+    step_invocations: any[];
+    step_invocation_states: any[];
+    resources: any[];
+    outputs: any[];
+    statuses: any[];
+}
+interface InvocationEvent {
+    id?: string;
+    type?: EntityType;
+    created_at?: string;
+    _type: 'invocation_event';
+    Output: OutputWithContents | null;
+    Message: MessageWithContents | null;
+    Status: Status | null;
+    ResultHandler: ResultHandler | null;
+    Step: Step | null;
+}
+type Entity = MessageWithContents | MessageContent | BotInvocation | OutputWithContents | OutputContent | Step | ResultHandler | Status;
+
+/**
+ * SSE Event Handler
+ *
+ * Handles Server-Sent Events from Erdo invocations and builds up the
+ * message/invocation tree structure for rendering.
+ */
+
+/**
+ * Handles incremental parsing of mixed JSON/text content as it streams in.
+ *
+ * This function is called each time new content arrives during streaming.
+ * It parses the content to detect JSON blocks interspersed with text,
+ * updating the outputContent's parsed_blocks array as complete JSON
+ * objects are detected.
+ *
+ * @param outputContent - The message or output content to update
+ * @param content - The full accumulated content string so far
+ * @returns The updated content object with parsed_blocks populated
+ */
+declare function handleIncrementalMixedJsonParsing(outputContent: MessageContent | OutputContent, content: string): MessageContent | OutputContent;
+/**
+ * Handles different types of SSE events and updates the message tree accordingly.
+ *
+ * Returns the updated entity at the root level (typically a message or message_content),
+ * or null if no update was performed (e.g., for message finished events).
+ *
+ * Note: Only message or message_content types can be returned as root objects.
+ * Other entity types like invocation, step, output, etc. will be nested inside
+ * a message_content entity.
+ *
+ * @param eventType - The type of SSE event (e.g., 'bot started', 'message content delta')
+ * @param event - The SSE event data
+ * @param path - The path to the entity being updated
+ * @param threadID - The thread ID for creating messages
+ * @param activeMessagesByID - Map of active messages by ID
+ * @param currentEntity - The current entity being processed
+ * @param parents - Parent entities in the tree
+ * @param entityIds - Map of entity type to ID for context
+ * @returns The updated entity or null if no update was performed
+ */
+declare function handleSSEEvent(eventType: string, event: SSEEventData, path: string[], threadID: string, activeMessagesByID: Record<string, MessageWithContents>, currentEntity?: Entity | null, parents?: Entity[], entityIds?: Record<string, string>): Entity | null;
+
+export { BarChart, type BaseChartProps, type BotInvocation, type BotInvocationData, Chart, type ChartConfig, ChartContainer, ChartContent, type ChartContentProps, ChartLegend, ChartLegendContent, ChartStyle, ChartTooltip, ChartTooltipContent, Content, type ContentChartConfig, type ContentChunk, type ContentProps, type ContentType, type DataFetcher, DatasetChart, type DatasetChartProps, type Entity, type EntityType, ErdoProvider, type ErdoProviderConfig, type ErdoProviderProps, ErrorBoundary, ExecutionStatus, HeatmapChart, type InvocationEvent, InvocationStatus, JSONStreamParser, type JSONValue, JsonContent, type JsonContentProps, LineChart, MarkdownContent, type MarkdownContentProps, type Message, type MessageContent, type MessageStreamingState, type MessageWithContents, type Output, type OutputContent, type OutputWithContents, PieChart, type ResultHandler, type SSEEventData, ScatterChart, type Status, type StatusEvent, type Step, TableContent, type TableContentProps, TextContent, type TextContentProps, type UseInvocationOptions, type UseInvocationReturn, cn, formatValue, handleIncrementalMixedJsonParsing, handleSSEEvent, isJsonLike, isParsingComplete, isParsingInProgress, isWhitespaceChar, parseCompleteJson, parseMixedJson, parseToDate, resolveKeyFromData, toSnakeCase, useChartZoom, useDatasetContents, useErdoConfig, useErdoConfigOptional, useInvocation, useMultipleDatasetContents };