@erdoai/ui 0.1.9 → 0.1.10

package/dist/index.d.cts

@@ -0,0 +1,1174 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import * as React from 'react';
+import React__default from 'react';
+import { ErdoClient, ContentItem, LogEntry, ToolGroup, InvocationStatus as InvocationStatus$1, 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;
+}
+
+/** Props passed to all content components */
+interface ContentComponentProps {
+    content: ContentItem;
+    className?: string;
+}
+interface ContentProps {
+    content: ContentItem;
+    className?: string;
+    /**
+     * Override renderers for specific content types.
+     * Key is the content_type or ui_content_type string.
+     * Component receives { content, className, ...otherProps } props.
+     * Components can accept additional props beyond ContentComponentProps.
+     *
+     * @example
+     * ```tsx
+     * <Content
+     *   content={contentItem}
+     *   components={{
+     *     'bot_invocation': MyBotInvocation,
+     *     'authorize_integration': AuthorizeIntegration,
+     *     'my_custom_type': MyCustomRenderer,
+     *   }}
+     * />
+     * ```
+     */
+    components?: Record<string, React__default.ComponentType<any>>;
+}
+/**
+ * Routes content to the appropriate renderer based on content_type and ui_content_type.
+ *
+ * This is the main entry point for rendering content items from Erdo bot invocations.
+ * It checks for custom component overrides first, then falls back to built-in renderers.
+ *
+ * @example
+ * ```tsx
+ * // Basic usage - uses built-in renderers
+ * <Content content={contentItem} />
+ *
+ * // With custom overrides
+ * <Content
+ *   content={contentItem}
+ *   components={{
+ *     'bot_invocation': MyBotInvocation,
+ *     'authorize_integration': AuthorizeIntegration,
+ *   }}
+ * />
+ * ```
+ */
+declare function Content({ content, className, components }: ContentProps): react_jsx_runtime.JSX.Element | null;
+
+interface TextContentProps {
+    content: string;
+    className?: string;
+}
+declare function TextContent({ content, className }: TextContentProps): react_jsx_runtime.JSX.Element | null;
+
+interface JsonContentProps {
+    content: unknown;
+    className?: string;
+}
+declare function JsonContent({ content, className }: JsonContentProps): react_jsx_runtime.JSX.Element | null;
+
+interface MarkdownContentProps {
+    /** The markdown content to render */
+    content: string;
+    /** Additional CSS class names */
+    className?: string;
+}
+/**
+ * Renders markdown content with GitHub Flavored Markdown support.
+ *
+ * @example
+ * ```tsx
+ * <MarkdownContent content="# Hello\n\nThis is **bold** text." />
+ * ```
+ */
+declare function MarkdownContent({ content, 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 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 ThinkingContentProps {
+    item: ContentItem;
+    className?: string;
+}
+/**
+ * Renders Claude's thinking/reasoning content in a collapsible panel.
+ * Handles both regular thinking and redacted (encrypted) thinking.
+ */
+declare function ThinkingContent({ item, className }: ThinkingContentProps): react_jsx_runtime.JSX.Element;
+
+interface LogContentProps {
+    item: ContentItem;
+    className?: string;
+}
+interface LogProps {
+    log: LogEntry;
+}
+declare function Log({ log }: LogProps): react_jsx_runtime.JSX.Element;
+/**
+ * Renders log entries with level-based styling (info, error, requires_info).
+ */
+declare function LogContent({ item, className }: LogContentProps): react_jsx_runtime.JSX.Element;
+
+interface WebSearchContentProps {
+    item: ContentItem;
+    className?: string;
+}
+/**
+ * Renders web search results as a list of clickable cards.
+ */
+declare function WebSearchContent({ item, className }: WebSearchContentProps): react_jsx_runtime.JSX.Element | null;
+
+interface WebParseContentProps {
+    item: ContentItem;
+    className?: string;
+}
+/**
+ * Renders parsed web page content with title, description, and markdown body.
+ */
+declare function WebParseContent({ item, className }: WebParseContentProps): react_jsx_runtime.JSX.Element | null;
+
+type WrapperType = 'standard' | 'info' | 'warning';
+interface ExpandableOutputContentProps {
+    children: React__default.ReactNode;
+    defaultOpen?: boolean;
+    wrapperType?: WrapperType;
+    compact?: boolean;
+    className?: string;
+}
+/**
+ * An expandable container for code output with max-height and scroll.
+ */
+declare function ExpandableOutputContent({ children, defaultOpen, wrapperType, compact, className, }: ExpandableOutputContentProps): react_jsx_runtime.JSX.Element;
+interface OutputLineProps {
+    children: React__default.ReactNode;
+    timestamp?: string;
+}
+/**
+ * Standard output text line with optional timestamp.
+ */
+declare function StdoutText({ children, timestamp }: OutputLineProps): react_jsx_runtime.JSX.Element;
+/**
+ * Error/stderr output text line with info styling.
+ */
+declare function StderrText({ children, timestamp }: OutputLineProps): react_jsx_runtime.JSX.Element;
+/**
+ * Warning output text line with warning styling.
+ */
+declare function StdwarnText({ children, timestamp }: OutputLineProps): react_jsx_runtime.JSX.Element;
+
+interface CollapsibleCodeBlockProps {
+    language: string;
+    value: string;
+    defaultOpen?: boolean;
+    title?: string;
+    closeTitle?: string;
+    className?: string;
+    /** Theme: 'dark' | 'light' | 'auto'. Auto uses prefers-color-scheme. Default: 'auto' */
+    theme?: 'dark' | 'light' | 'auto';
+}
+/**
+ * A collapsible code block with syntax highlighting.
+ */
+declare function CollapsibleCodeBlock({ language, value, defaultOpen, title, closeTitle, className, theme, }: CollapsibleCodeBlockProps): react_jsx_runtime.JSX.Element;
+
+interface SqlContentProps {
+    item: ContentItem;
+    className?: string;
+}
+/**
+ * Renders SQL generation content with thinking text and collapsible SQL code.
+ */
+declare function SqlContent({ item, className }: SqlContentProps): react_jsx_runtime.JSX.Element | null;
+
+interface CodegenContentProps {
+    item: ContentItem;
+    className?: string;
+}
+/**
+ * Renders code generation content with step-by-step explanation, code, and warnings.
+ */
+declare function CodegenContent({ item, className }: CodegenContentProps): react_jsx_runtime.JSX.Element | null;
+
+interface CodeexecContentProps {
+    item: ContentItem;
+    className?: string;
+}
+/**
+ * Renders code execution output (stdout, stderr, warnings).
+ */
+declare function CodeexecContent({ item, className }: CodeexecContentProps): react_jsx_runtime.JSX.Element | null;
+
+interface ToolGroupContentProps {
+    /** The tool group data */
+    toolGroup: ToolGroup;
+    /** Optional Content component for rendering nested results (avoids circular imports) */
+    ContentComponent?: React__default.ComponentType<{
+        content: ContentItem;
+        className?: string;
+    }>;
+    className?: string;
+}
+/**
+ * Renders tool invocations and their results in a collapsible format.
+ */
+declare function ToolGroupContent({ toolGroup, ContentComponent, className, }: ToolGroupContentProps): react_jsx_runtime.JSX.Element;
+
+/** Content data for a bot invocation (passed in ContentItem.content) */
+interface BotInvocationContentData {
+    /** Unique invocation ID */
+    invocation_id: string;
+    /** Bot ID */
+    bot_id: string;
+    /** Bot display name */
+    bot_name: string;
+    /** Whether this invocation is transparent (embedded) */
+    transparent?: boolean;
+}
+/** Status information for a bot invocation */
+interface BotInvocationStatusInfo {
+    /** Current status of the invocation */
+    status: InvocationStatus$1 | string;
+    /** Optional status message */
+    message?: string | {
+        Valid: boolean;
+        String: string;
+    };
+}
+/** Event within a bot invocation */
+interface BotInvocationEventInfo {
+    /** Unique event ID */
+    id: string;
+    /** Event type (output, step, etc.) */
+    type: string;
+    /** When the event was created */
+    created_at?: string;
+    /** Event data - structure depends on type */
+    data?: unknown;
+}
+/** Resolved bot invocation with status and events */
+interface ResolvedBotInvocation {
+    /** Current status of the invocation */
+    currentStatus?: BotInvocationStatusInfo | null;
+    /** Map of events by ID */
+    eventsByID?: Record<string, BotInvocationEventInfo>;
+    /** Additional invocation details */
+    [key: string]: unknown;
+}
+interface BotInvocationContentProps {
+    /** The content data containing invocation_id, bot_id, bot_name */
+    content: BotInvocationContentData;
+    /** Resolved bot invocation data with events and status */
+    botInvocation?: ResolvedBotInvocation | null;
+    /** Whether the invocation is still loading */
+    isLoading?: boolean;
+    /** Whether this should be open by default */
+    defaultOpen?: boolean;
+    /** Optional admin link href (e.g., to agent designer) */
+    adminLinkHref?: string;
+    /** Optional admin link text */
+    adminLinkText?: string;
+    /** Whether to show the admin link */
+    showAdminLink?: boolean;
+    /** Callback when admin link is clicked */
+    onAdminClick?: (invocationId: string, botId: string) => void;
+    /** Callback when invocation is expanded */
+    onExpand?: (invocationId: string, botId: string, botName: string) => void;
+    /** Component for rendering nested events */
+    EventsComponent?: React__default.ComponentType<{
+        eventsByID: Record<string, BotInvocationEventInfo>;
+        defaultOpen?: boolean;
+    }>;
+    /** Component for rendering individual content items */
+    ContentComponent?: React__default.ComponentType<{
+        content: ContentItem;
+        className?: string;
+    }>;
+    className?: string;
+}
+/**
+ * Renders a bot invocation with status, collapsible events, and optional admin link.
+ *
+ * This component is designed to receive already-processed invocation data.
+ * Data fetching should be handled by the consuming application.
+ */
+declare function BotInvocationContent({ content, botInvocation, isLoading, defaultOpen, adminLinkHref, adminLinkText, showAdminLink, onAdminClick, onExpand, EventsComponent, ContentComponent: _ContentComponent, className, }: BotInvocationContentProps): react_jsx_runtime.JSX.Element | null;
+
+type SpinnerStatus = 'loading' | 'finished' | 'failed';
+interface StatusSpinnerProps {
+    status: SpinnerStatus;
+    /** Icon color - if not provided, auto-detects from theme (white for dark, black for light) */
+    color?: string;
+    /** Size in pixels - defaults to 16 */
+    size?: number;
+    className?: string;
+}
+/**
+ * Animated status spinner using Lordicon/Lottie animations.
+ * Shows a spinning loader when loading, checkmark when finished, and alert when failed.
+ */
+declare function StatusSpinner({ status, color, size, className }: StatusSpinnerProps): 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, BotInvocationContent, type BotInvocationContentData, type BotInvocationContentProps, type BotInvocationData, type BotInvocationEventInfo, type BotInvocationStatusInfo, Chart, type ChartConfig, ChartContainer, ChartContent, type ChartContentProps, ChartLegend, ChartLegendContent, ChartStyle, ChartTooltip, ChartTooltipContent, CodeexecContent, type CodeexecContentProps, CodegenContent, type CodegenContentProps, CollapsibleCodeBlock, type CollapsibleCodeBlockProps, Content, type ContentChartConfig, type ContentChunk, type ContentComponentProps, type ContentProps, type ContentType, type DataFetcher, DatasetChart, type DatasetChartProps, type Entity, type EntityType, ErdoProvider, type ErdoProviderConfig, type ErdoProviderProps, ErrorBoundary, ExecutionStatus, ExpandableOutputContent, type ExpandableOutputContentProps, HeatmapChart, type InvocationEvent, InvocationStatus, JSONStreamParser, type JSONValue, JsonContent, type JsonContentProps, LineChart, Log, LogContent, type LogContentProps, type LogProps, MarkdownContent, type MarkdownContentProps, type Message, type MessageContent, type MessageStreamingState, type MessageWithContents, type Output, type OutputContent, type OutputWithContents, PieChart, type ResolvedBotInvocation, type ResultHandler, type SSEEventData, ScatterChart, type SpinnerStatus, SqlContent, type SqlContentProps, type Status, type StatusEvent, StatusSpinner, type StatusSpinnerProps, StderrText, StdoutText, StdwarnText, type Step, TableContent, type TableContentProps, TextContent, type TextContentProps, ThinkingContent, type ThinkingContentProps, ToolGroupContent, type ToolGroupContentProps, type UseInvocationOptions, type UseInvocationReturn, WebParseContent, type WebParseContentProps, WebSearchContent, type WebSearchContentProps, type WrapperType, cn, formatValue, handleIncrementalMixedJsonParsing, handleSSEEvent, isJsonLike, isParsingComplete, isParsingInProgress, isWhitespaceChar, parseCompleteJson, parseMixedJson, parseToDate, resolveKeyFromData, toSnakeCase, useChartZoom, useDatasetContents, useErdoConfig, useErdoConfigOptional, useInvocation, useMultipleDatasetContents };