@papermap/papermap 1.0.1

package/dist/index.d.mts

@@ -0,0 +1,920 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import * as React$1 from 'react';
+import React__default, { RefObject } from 'react';
+import * as class_variance_authority_types from 'class-variance-authority/types';
+import { VariantProps } from 'class-variance-authority';
+import * as zustand from 'zustand';
+import * as axios from 'axios';
+import { AxiosInstance } from 'axios';
+import { Layout } from 'react-grid-layout';
+
+interface PapermapChatProps {
+    token?: string;
+    workspaceId?: string;
+    dashboardId?: string;
+    apiUrl?: string;
+    /**
+     * Called whenever the toolbar height changes (including multiline expansion).
+     * Host apps can use this to add bottom padding/margin to their chart area,
+     * mirroring how the main app dashboard layout reacts to toolbar height.
+     */
+    onToolbarHeightChange?: (height: number) => void;
+    placeholder?: string;
+    shortcutKey?: string;
+    autoFade?: boolean;
+    fadeDelay?: number;
+    className?: string;
+    /**
+     * Controls whether the fixed bottom chat toolbar (input + quick actions) is rendered.
+     * Defaults to `true`.
+     */
+    showToolbar?: boolean;
+}
+declare function PapermapChat({ token, workspaceId, dashboardId, apiUrl, onToolbarHeightChange, showToolbar, ...uiProps }: PapermapChatProps): react_jsx_runtime.JSX.Element;
+
+type TChartMeta$1 = {
+    title?: string;
+    subtitle?: string;
+    description?: string;
+    footer?: string;
+    showLegend?: boolean;
+    variant?: string;
+    [key: string]: any;
+};
+type TChartResponse = {
+    llm_data_chat_id: string;
+    name: string;
+    dashboard_id?: string;
+    chart_response?: {
+        chart_type: string;
+        error?: boolean;
+        data: any[];
+        response_type: string;
+        text_response?: string;
+        schema_hints: {
+            x_key: string;
+            y_key: string;
+            label_key: string;
+        };
+        visualization_config: {
+            colors: string[];
+            width: number;
+            height: number;
+            title?: string;
+            [key: string]: any;
+        };
+    };
+    meta: TChartMeta$1;
+    pin: boolean;
+    status?: string;
+    isFetching?: boolean;
+    isLoading?: boolean;
+};
+interface ChartDataPoint {
+    type: string;
+    count: number;
+}
+interface SchemaHints {
+    x_key: string;
+    y_key: string;
+    label_key: string;
+}
+interface VisualizationConfig {
+    colors: string[];
+    width: number;
+    height: number;
+    title: string;
+    [key: string]: any;
+}
+interface ChartResponse {
+    response_type: string;
+    text_response: string;
+    status: string | null;
+    data: ChartDataPoint[];
+    code: string | null;
+    chart_type: string;
+    schema_hints: SchemaHints;
+    visualization_config: VisualizationConfig;
+}
+type ConversationHistory = Omit<TChartResponse, 'chart_response'> & {
+    created_at: string;
+    latest_user_name?: string | null;
+};
+
+interface PapermapChartCardProps {
+    /**
+     * Connection details for API calls. Optional when the card is rendered inside
+     * `PapermapProvider` with the same values (or use props to override provider defaults).
+     */
+    token?: string;
+    workspaceId?: string;
+    dashboardId?: string;
+    apiUrl?: string;
+    /**
+     * Stable id owned by the host (layout slot, widget key, etc.). It is **not** a backend chat id.
+     * On successful load, the card persists `{ id, chatId }` to localStorage; on later mounts, that
+     * `chatId` is used for API fetches (see `resolveChartFetchChatId` in `chart-card-storage`).
+     */
+    id?: string;
+    /**
+     * Called after chart state is successfully loaded or when a preloaded `chart` prop
+     * is applied with a valid `llm_data_chat_id`. Errors from the host callback are caught
+     * and logged only.
+     */
+    onSave?: (chart: TChartResponse) => void;
+    /**
+     * The chat ID to load a chart for. When provided, the component will
+     * fetch the latest chart for this chat on mount (overrides `id` → localStorage map).
+     */
+    chartId?: string;
+    /**
+     * Pre-loaded chart data. When provided, the component will render this
+     * chart instead of fetching from the API.
+     */
+    chart?: TChartResponse;
+    /**
+     * Visual theme for the chart card. When set, renders in the specified
+     * mode independent of the host app. Omit to inherit the host page's theme.
+     */
+    theme?: 'light' | 'dark';
+    /**
+     * Called when the user clicks the edit button on the chart card.
+     * In streaming variant, if not provided, the built-in StreamingChartDialog opens.
+     */
+    onEditClick?: (chartId: string) => void;
+    /**
+     * Called when the user confirms chart deletion.
+     */
+    onDelete?: (chartId: string) => void;
+    /**
+     * Called when the pin state of the chart changes.
+     */
+    onPinChange?: (chartId: string, pinned: boolean) => void;
+    /**
+     * When true, suppress destructive actions like delete.
+     * (Used by viewer mode dashboards.)
+     */
+    isViewer?: boolean;
+    /**
+     * When true, the chart card will be rendered in wide mode suitable for
+     * table-type charts that need more horizontal space.
+     */
+    wide?: boolean;
+    /** Hide the chart variation selector. Defaults to true. */
+    hideVariants?: boolean;
+    /** Show the toolbar with edit/delete/maximize buttons. Defaults to true. */
+    showToolbar?: boolean;
+    /** When true, chart toolbar actions are visually disabled during layout editing. */
+    isEditMode?: boolean;
+    /** When true, show resize affordance and disable toolbar actions. */
+    /** Optional stable identifier for standalone resize handle instrumentation. */
+    className?: string;
+    /**
+     * Card variant. When `"streaming"`, clicking the edit icon opens an
+     * expanded chart+conversation view (StreamingChartDialog) instead of
+     * just calling onEditClick or opening the toolbar chat.
+     */
+    variant?: 'default' | 'streaming';
+}
+declare function PapermapChartCard({ token: tokenProp, workspaceId: workspaceIdProp, dashboardId: dashboardIdProp, apiUrl: apiUrlProp, id, onSave, chartId, chart: chartProp, theme, onEditClick, onDelete, isViewer, wide, hideVariants, showToolbar, isEditMode, className, variant, }: PapermapChartCardProps): react_jsx_runtime.JSX.Element;
+
+declare function ChatAssistant(): react_jsx_runtime.JSX.Element;
+
+interface AgentThought {
+    type: 'agent_thought';
+    content: string;
+    is_complete: boolean;
+    iteration: number;
+    timestamp: string;
+}
+interface FinalResponse {
+    type: 'final_response';
+    response_data: {
+        response_type: string;
+        generated_text: string;
+        chart_type?: string;
+        data?: any[];
+        pandas_code?: string;
+        thoughts?: string;
+        [key: string]: any;
+    };
+    llm_data_id: string;
+    total_iterations: number;
+    total_duration_ms: number;
+    token_usage?: {
+        prompt_tokens: number;
+        completion_tokens: number;
+        total_tokens: number;
+    };
+    timestamp: string;
+}
+interface ToolCall {
+    tool_name: string;
+    tool_display_name: string;
+    args_preview: string;
+    status: 'announced' | 'streaming' | 'ready' | 'executing' | 'success' | 'error';
+    output?: string;
+    code?: string;
+    isStreamingArgs?: boolean;
+    hasPrivateArgs?: boolean;
+    hasPrivateOutput?: boolean;
+    duration_ms?: number;
+    error_message?: string;
+    tool_call_id?: string;
+    timestamp: string;
+}
+interface TimelineEvent {
+    type: 'thought' | 'tool';
+    timestamp: string;
+    iteration?: number;
+    thoughtData?: AgentThought;
+    toolData?: ToolCall;
+}
+interface StreamState {
+    thoughts: AgentThought[];
+    toolCalls: ToolCall[];
+    timeline: TimelineEvent[];
+    currentPhase: string;
+    error: string | null;
+    finalResponse: any | null;
+    isComplete: boolean;
+    isConnected: boolean;
+    isStreaming: boolean;
+}
+
+declare function StreamingTimeline({ timeline, collapseThreshold, recentFullCount, }: {
+    timeline: TimelineEvent[];
+    collapseThreshold?: number;
+    recentFullCount?: number;
+}): react_jsx_runtime.JSX.Element | null;
+
+interface AgentThoughtDisplayProps {
+    thoughts: AgentThought[];
+    className?: string;
+    showOnlyLast?: boolean;
+    maxThoughts?: number;
+}
+declare function AgentThoughtDisplay({ thoughts, className, showOnlyLast, maxThoughts }: AgentThoughtDisplayProps): react_jsx_runtime.JSX.Element | null;
+
+interface ToolCallDisplayProps {
+    toolCalls: ToolCall[];
+    className?: string;
+    showAll?: boolean;
+    isLatest?: boolean;
+}
+declare function ToolCallDisplay({ toolCalls, className, showAll, isLatest, }: ToolCallDisplayProps): react_jsx_runtime.JSX.Element | null;
+
+declare function RecentConversations(): react_jsx_runtime.JSX.Element;
+
+declare function ChartHistory(): react_jsx_runtime.JSX.Element;
+
+declare function SavedMemory(): react_jsx_runtime.JSX.Element;
+
+interface TChartMeta {
+    title?: string;
+    subtitle?: string;
+    footer?: string;
+    variant?: string;
+    showLegend?: boolean;
+}
+interface ChartViewProps {
+    data: any[];
+    chartMeta: TChartMeta;
+    error?: boolean;
+    chartType: string;
+    variant?: string;
+    className?: string;
+    containerClassName?: string;
+    visualizationConfig?: Record<string, any>;
+    previewMode?: boolean;
+    onMetaChange?: (key: 'title' | 'description' | 'footer' | 'subtitle', value: string) => void;
+    chartId?: string;
+    onClose?: () => void;
+    isDialog?: boolean;
+    onMaximize?: () => void;
+    showIcons?: boolean;
+    hideTitleAndSubtitle?: boolean;
+    hideVariants?: boolean;
+    pin?: boolean;
+    /** Called when the user clicks the edit action on the chart header. */
+    onEditClick?: () => void;
+    /**
+     * Override the built-in save-to-dashboard handler. When provided, this
+     * callback is invoked instead of the internal pin+meta-update logic.
+     */
+    onSaveToDashboard?: () => void;
+    /**
+     * Render the save button as a compact pill in the chart header instead
+     * of the default bottom-left outline button. Used in streaming layouts.
+     */
+    compactSave?: boolean;
+}
+declare function ChartView(props: ChartViewProps): react_jsx_runtime.JSX.Element;
+
+interface ChartDialogProps {
+    token?: string;
+    workspaceId?: string;
+    dashboardId?: string;
+    apiUrl?: string;
+    isOpen: boolean;
+    onOpenChange: (open: boolean) => void;
+    title?: string;
+    data: any[];
+    chartId: string;
+    chartMeta: TChartMeta;
+    chartType: string;
+    visualizationConfig: Record<string, any>;
+    onMetaChange: (key: 'title' | 'description' | 'footer' | 'subtitle', value: string) => void;
+    variant?: string;
+    onClose?: () => void;
+}
+declare function ChartDialog(props: ChartDialogProps): react_jsx_runtime.JSX.Element;
+
+interface StreamingChartDialogProps {
+    isOpen: boolean;
+    onOpenChange: (open: boolean) => void;
+    chartId: string;
+    onClose?: () => void;
+    /** After a successful Save-to-dashboard (pin) from this dialog; errors from the host are caught and logged. */
+    onSave?: (chart: TChartResponse) => void;
+}
+declare function StreamingChartDialog({ isOpen, onOpenChange, chartId, onClose, onSave, }: StreamingChartDialogProps): React$1.ReactPortal;
+
+interface DataTableProps {
+    data: any[];
+    dashboardTheme?: any;
+}
+declare function DataTable({ data, dashboardTheme }: DataTableProps): react_jsx_runtime.JSX.Element;
+
+declare const buttonVariants: (props?: ({
+    variant?: "default" | "link" | "destructive" | "outline" | "secondary" | "ghost" | null | undefined;
+    size?: "default" | "sm" | "lg" | "icon" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface ButtonProps extends React$1.ButtonHTMLAttributes<HTMLButtonElement>, VariantProps<typeof buttonVariants> {
+    asChild?: boolean;
+    loading?: boolean;
+}
+
+type ButtonWithTooltipProps = {
+    onClick: () => void;
+    children: React__default.ReactNode;
+    tooltipText: string;
+    className?: string;
+} & ButtonProps;
+declare function ButtonWithTooltip({ onClick, children, tooltipText, className, ...props }: ButtonWithTooltipProps): react_jsx_runtime.JSX.Element;
+
+interface BookmarkButtonProps {
+    isBookmarked: boolean;
+    onToggle: () => void;
+    isLoading?: boolean;
+}
+declare function BookmarkButton({ isBookmarked, onToggle, isLoading }: BookmarkButtonProps): react_jsx_runtime.JSX.Element;
+
+interface BranchButtonProps {
+    onBranch: () => void;
+    isLoading?: boolean;
+    tooltipText?: string;
+}
+declare function BranchButton({ onBranch, isLoading, tooltipText }: BranchButtonProps): react_jsx_runtime.JSX.Element;
+
+interface FeedbackButtonsProps {
+    onFeedback: (type: 'positive' | 'negative') => void;
+    className?: string;
+    isLoading?: boolean;
+    selectedFeedback?: 'positive' | 'negative' | null;
+    loadingType?: 'positive' | 'negative' | null;
+}
+declare function FeedbackButtons({ onFeedback, className, isLoading, selectedFeedback, loadingType, }: FeedbackButtonsProps): react_jsx_runtime.JSX.Element;
+
+declare function ModelSelector(): react_jsx_runtime.JSX.Element;
+
+interface StreamingChatPanelProps {
+    className?: string;
+    /**
+     * When true, message rows use full available width below `sm`. Use in the streaming chart
+     * dialog when the chart column is hidden so chat isn’t artificially narrow.
+     */
+    expandMessageColumnOnMobile?: boolean;
+    /** Auto-focuses the prompt input when this panel mounts (used by dialog hosts). */
+    autoFocusInput?: boolean;
+    /** Optional action rendered beside submit button in the input row. */
+    inputAction?: React__default.ReactNode;
+}
+declare function StreamingChatPanel({ className, expandMessageColumnOnMobile, autoFocusInput, inputAction, }: StreamingChatPanelProps): react_jsx_runtime.JSX.Element;
+
+interface LogoStandAloneProps {
+    className?: string;
+}
+declare const LogoStandAlone: ({ className }: LogoStandAloneProps) => react_jsx_runtime.JSX.Element;
+
+interface MorphGradientProps {
+    className?: string;
+}
+declare function MorphGradient({ className }: MorphGradientProps): react_jsx_runtime.JSX.Element | null;
+
+type StreamChartWithSSEData = {
+    prompt: string;
+    workspace_id: string;
+    chat_id: string;
+    request_id: string;
+    llm_model?: string;
+    use_search?: boolean;
+    stream_execution?: boolean;
+};
+type EditMessageWithSSEData = StreamChartWithSSEData & {
+    llm_data_id: string;
+};
+declare function createStreamingService(client: AxiosInstance): {
+    streamChartWithSSE: (data: StreamChartWithSSEData) => Promise<axios.AxiosResponse<any, any>>;
+    editMessageWithSSE: (data: EditMessageWithSSEData) => Promise<axios.AxiosResponse<any, any>>;
+    cancelChartRequest: (request_id: string, reason?: string) => Promise<any>;
+};
+
+type ResizeHandle = 'n' | 's' | 'e' | 'w' | 'ne' | 'nw' | 'se' | 'sw';
+type TLayout = Layout & {
+    resizeHandles?: ResizeHandle[];
+};
+type PapermapGridDashboardLayouts = {
+    [key: string]: TLayout[];
+};
+interface DashboardTheme {
+    primary: string;
+    secondary: string;
+    interactive: string;
+    container: string;
+    module: string;
+    accent: string;
+    outline: string;
+    dialog: string;
+    fontFamily: string;
+    borderRadius: number;
+    cardBg?: string;
+    dashboardBg?: string;
+    cardIcons?: string;
+    cardText?: string;
+    cardTitle?: string;
+    buttonPrimary?: string;
+    buttonSecondary?: string;
+    buttonText?: string;
+}
+
+declare function createChartService(client: AxiosInstance): {
+    getDashboards: (params: {
+        workspace_id: string;
+    }) => Promise<any>;
+    updateDashboardLayout: (dashboardId: string, layout: TLayout[]) => Promise<any>;
+    createChat: (data: {
+        name: string;
+        dashboard_id: string;
+    }) => Promise<any>;
+    getCharts: (params: {
+        dashboard_id: string;
+        page?: number;
+        per_page?: number;
+        pin?: boolean;
+    }) => Promise<any>;
+    getConversations: (params: {
+        chat_id: string;
+        per_page?: number;
+        page?: number;
+    }) => Promise<any>;
+    getLatestChart: (chat_id: string) => Promise<any>;
+    getConversationHistory: (params: {
+        dashboard_id?: string;
+        per_page?: number;
+        page?: number;
+    }) => Promise<any>;
+    deleteChart: (chatId: string) => Promise<any>;
+    getChartHistory: (params: {
+        chat_id: string;
+        per_page?: number;
+        page?: number;
+    }) => Promise<any>;
+    getChartById: (chartId: string) => Promise<any>;
+    updateChartMeta: (chatId: string, meta: Record<string, any>) => Promise<any>;
+    updateChartPin: (chatId: string, pin: boolean) => Promise<any>;
+    bookmarkConversation: (data: {
+        llm_data_id: string;
+        dashboard_id: string;
+    }) => Promise<any>;
+    removeBookmark: (bookmarkId: string) => Promise<any>;
+    updateResponseLabel: (llm_data_id: string, label: "positive" | "negative") => Promise<any>;
+    branchConversation: (dashboard_id: string, llm_data_id: string) => Promise<any>;
+    getModels: () => Promise<any>;
+    generateProactiveDashboard: (payload: {
+        workspace_id: string;
+        dashboard_id?: string;
+        color_scheme?: string;
+    }) => Promise<any>;
+};
+
+declare function createWorkspaceService(client: AxiosInstance): {
+    getWorkspace: (workspaceId: string) => Promise<any>;
+    updateWorkspace: (workspaceId: string, workspace: Record<string, any>) => Promise<any>;
+};
+
+type PapermapHttpServices = {
+    authHeaders: Record<string, string>;
+    streamingSvc: ReturnType<typeof createStreamingService>;
+    chartSvc: ReturnType<typeof createChartService>;
+    workspaceSvc: ReturnType<typeof createWorkspaceService>;
+    baseUrl: string;
+};
+declare function createPapermapServices(config: {
+    token: string;
+    apiUrl?: string;
+}): PapermapHttpServices;
+
+interface Message {
+    id?: string;
+    llm_data_id?: string;
+    content: string;
+    role: 'user' | 'assistant' | 'error' | 'branch';
+    status?: 'thinking' | 'done';
+    thought?: string;
+    code?: string;
+    openThought?: boolean;
+    bookmarked?: boolean;
+    bookmark_id?: string;
+    is_inherited?: boolean;
+    is_rundown?: boolean;
+    rundown_turn_label?: string;
+    noIcons?: boolean;
+    feedback?: 'positive' | 'negative' | null;
+    progress_events?: {
+        event_type?: string;
+        data?: Record<string, any>;
+    }[];
+    originalContent?: string;
+    [key: string]: any;
+}
+
+declare const CHAT_MODAL_TAB: {
+    readonly CHAT: "CHAT";
+    readonly SAVED_MEMORY: "SAVED_MEMORY";
+    readonly RECENT_CONVERSATIONS: "RECENT_CONVERSATIONS";
+    readonly CHAT_HISTORY: "CHAT_HISTORY";
+};
+type ChatModalTabType = (typeof CHAT_MODAL_TAB)[keyof typeof CHAT_MODAL_TAB];
+interface PapermapStoreConfig {
+    token: string;
+    workspaceId: string;
+    dashboardId: string;
+    apiUrl?: string;
+    /**
+     * Optional: use your own state (e.g. Redux) to control the selected model.
+     * When provided, this value is used as the initial model instead of sessionStorage.
+     */
+    initialModel?: string | null;
+    /**
+     * Optional: called whenever the selected model changes.
+     * Ideal place to dispatch a Redux action in the host app.
+     */
+    onModelChange?: (model: string | null) => void;
+}
+type Services = PapermapHttpServices;
+interface Refs {
+    inputRef: {
+        current: HTMLInputElement | null;
+    };
+    textareaRef: {
+        current: HTMLTextAreaElement | null;
+    };
+    scrollRef: {
+        current: HTMLDivElement | null;
+    };
+    messagesEndRef: {
+        current: HTMLDivElement | null;
+    };
+    activeChatIdRef: {
+        current: string | null;
+    };
+    loadedConversationChatIdRef: {
+        current: string | null;
+    };
+}
+interface PapermapState {
+    messages: Message[];
+    isLoading: boolean;
+    isBranching: boolean;
+    isFocused: boolean;
+    isOpen: boolean;
+    inputValue: string;
+    isMultiline: boolean;
+    chatId: string | null;
+    editChatId: string | null;
+    currentRequestId: string | null;
+    chatModalTab: ChatModalTabType;
+    browserUse: boolean;
+    selectedModel: string | null;
+    viewExecution: boolean;
+    chartData: any[];
+    allMeta: TChartMeta$1;
+    selectedChartType: string;
+    chartVisuals: Record<string, any>;
+    totalPages: number;
+    currentPage: number;
+    isLoadingMore: boolean;
+    useSSEStreaming: boolean;
+    sseRequestId: string | null;
+    sseChatId: string | null;
+    sseThoughts: AgentThought[];
+    sseToolCalls: ToolCall[];
+    sseTimeline: TimelineEvent[];
+    ssePhase: string | undefined;
+    sseIsConnected: boolean;
+    sseIsStreaming: boolean;
+    sseIsComplete: boolean;
+    sseError: string | null;
+}
+interface PapermapActions {
+    setMessages: (messages: Message[] | ((prev: Message[]) => Message[])) => void;
+    setIsLoading: (v: boolean) => void;
+    setIsBranching: (v: boolean) => void;
+    setIsFocused: (v: boolean) => void;
+    setIsOpen: (v: boolean) => void;
+    setInputValue: (v: string | ((prev: string) => string)) => void;
+    setIsMultiline: (v: boolean) => void;
+    setIsLoadingMore: (v: boolean) => void;
+    setChatId: (v: string | null) => void;
+    setEditChatId: (v: string | null) => void;
+    setChatModalTab: (v: ChatModalTabType) => void;
+    setBrowserUse: (v: boolean) => void;
+    updateBrowserUse: (v: boolean) => void;
+    setSelectedModel: (v: string | null) => void;
+    setViewExecution: (v: boolean) => void;
+    updateChartData: (data: any[]) => void;
+    updateAllMeta: (meta: TChartMeta$1) => void;
+    updateChartType: (v: string) => void;
+    updateChartVisuals: (v: Record<string, any>) => void;
+    updateLatestChart: (result: any) => void;
+    clearLatestChart: () => void;
+    setUseSSEStreaming: (v: boolean) => void;
+    setSseRequestId: (v: string | null) => void;
+    setSseChatId: (v: string | null) => void;
+    clearStreamingState: () => void;
+    syncSseDisplay: (data: {
+        thoughts: AgentThought[];
+        toolCalls: ToolCall[];
+        timeline: TimelineEvent[];
+        phase: string | undefined;
+        isConnected: boolean;
+        isStreaming: boolean;
+        isComplete: boolean;
+        error: string | null;
+    }) => void;
+    shouldShowSSE: () => boolean;
+    handleSubmit: (userMessage: string) => Promise<void>;
+    handleCancel: () => Promise<void>;
+    handleNewChat: () => void;
+    handleScroll: (event: React.UIEvent<HTMLDivElement>) => Promise<void>;
+    scrollToBottom: () => void;
+    loadConversations: () => Promise<void>;
+    getRefs: () => Refs;
+    getServices: () => Services;
+    getConfig: () => PapermapStoreConfig;
+}
+type PapermapStore = PapermapState & PapermapActions;
+declare function createPapermapStore(config: PapermapStoreConfig, injectedServices?: PapermapHttpServices): zustand.StoreApi<PapermapStore>;
+type PapermapStoreApi = ReturnType<typeof createPapermapStore>;
+interface OpenPapermapChatAssistantOptions {
+    /** When provided, opens the assistant in edit mode for this chart/chat. */
+    editChartId?: string | null;
+    /**
+     * Full chart to prime the store with (like main app openEditChartModal).
+     * When provided, sets meta, chart data, type, and visuals immediately so
+     * variant and chart display correctly before loadConversations/getLatestChart run.
+     */
+    chart?: TChartResponse | null;
+    /**
+     * When true, do not open/focus the floating PapermapChat assistant.
+     * This is useful for streaming variants that render their own embedded
+     * chart+conversation panel instead of the global UI.
+     */
+    suppressOpen?: boolean;
+}
+/**
+ * Opens the chart assistant (chat modal) from outside React, e.g. when the user
+ * clicks the Edit Chart icon. Call with the store API from a component that has
+ * access to it (e.g. via usePapermapStoreApi). Optionally pass editChartId to
+ * open in edit mode for that chart.
+ *
+ * When chart is provided (e.g. from ChartCard), primes the store like the main
+ * app openEditChartModal: setMessages([]), updateAllMeta(chart.meta),
+ * updateChartData/Type/Visuals(chart.chart_response), then set editChatId and open.
+ * ConversationLoader still runs loadConversations() for messages; variant shows
+ * immediately from chart.meta.
+ */
+declare function openPapermapChatAssistant(storeApi: PapermapStoreApi, options?: OpenPapermapChatAssistantOptions): void;
+
+type PapermapConnectionValue = {
+    token: string;
+    workspaceId: string;
+    dashboardId: string;
+    apiUrl?: string;
+    services: PapermapHttpServices;
+};
+interface PapermapProviderProps extends PapermapStoreConfig {
+    children: React__default.ReactNode;
+}
+declare function PapermapProvider({ children, token, workspaceId, dashboardId, apiUrl, initialModel, onModelChange, }: PapermapProviderProps): react_jsx_runtime.JSX.Element;
+declare function usePapermapStore<T>(selector: (state: PapermapStore) => T): T;
+/**
+ * Access the raw store API (for refs, services, imperative calls).
+ * Does NOT subscribe to re-renders -- use usePapermapStore for reactive state.
+ */
+declare function usePapermapStoreApi(): PapermapStoreApi;
+/**
+ * Like usePapermapStoreApi but returns null when outside a provider.
+ * Use this to detect if a component is already inside a PapermapProvider
+ * (e.g. to avoid nesting a second provider and share the same store).
+ */
+declare function usePapermapStoreApiOptional(): PapermapStoreApi | null;
+declare function usePapermapConnection(): PapermapConnectionValue;
+declare function usePapermapConnectionOptional(): PapermapConnectionValue | null;
+
+interface KeyboardShortcutHandlers {
+    onToggle?: () => void;
+    onEscape?: () => void;
+    shortcutKey?: string;
+}
+declare function useKeyboardShortcuts({ onToggle, onEscape, shortcutKey, }: KeyboardShortcutHandlers): void;
+
+declare function useAutoResize(textareaRef: RefObject<HTMLTextAreaElement | null>, minHeight?: number, maxHeight?: number): {
+    resize: () => void;
+};
+
+declare function useAutoFade(enabled: boolean, delay?: number, suppressWhen?: boolean): {
+    isFaded: boolean;
+    resetFadeTimer: () => void;
+};
+
+interface UseAnalyticsStreamOptions {
+    onComplete?: (data: any) => void;
+    onError?: (error: string) => void;
+    onThought?: (thought: AgentThought) => void;
+    onToolCall?: (toolCall: ToolCall) => void;
+}
+/**
+ * Adapted from papermap's useAnalyticsStream.
+ * Instead of Redux for auth, receives `authHeaders` and `apiUrl` directly.
+ */
+declare function useAnalyticsStream(requestId: string | null, authHeaders: Record<string, string>, apiUrl: string, options?: UseAnalyticsStreamOptions): {
+    disconnect: () => void;
+    markRequestAsCompleted: (reqId: string) => void;
+    thoughts: AgentThought[];
+    toolCalls: ToolCall[];
+    timeline: TimelineEvent[];
+    currentPhase: string;
+    error: string | null;
+    finalResponse: any | null;
+    isComplete: boolean;
+    isConnected: boolean;
+    isStreaming: boolean;
+};
+
+interface DecodedToken {
+    api_key_id: string;
+    workspace_id: string;
+    valid_until: number;
+    signature: string;
+    dashboard_id?: string;
+    tenant_id?: string;
+}
+declare function decodeToken(token: string): DecodedToken;
+declare function buildAuthHeaders(decoded: DecodedToken): Record<string, string>;
+declare function createApiClient(token: string, apiUrl?: string): {
+    client: axios.AxiosInstance;
+    decoded: DecodedToken;
+    authHeaders: Record<string, string>;
+};
+
+interface PapermapGridDashboardProps {
+    token?: string;
+    workspaceId?: string;
+    dashboardId?: string;
+    apiUrl?: string;
+    charts?: TChartResponse[];
+    layouts?: PapermapGridDashboardLayouts;
+    onLayoutsChange?: (layouts: PapermapGridDashboardLayouts) => void;
+    isEditMode?: boolean;
+    showToolbar?: boolean;
+    showScreenshot?: boolean;
+    showGenerateDashboard?: boolean;
+    editLayout?: boolean;
+    isViewer?: boolean;
+    onEditChart?: (chartId: string) => void;
+    onDeleteChart?: (chartId: string) => void;
+    onPinChange?: (chartId: string, pinned: boolean) => void;
+    onGenerateDashboard?: () => void;
+    isGenerating?: boolean;
+    onTakeScreenshot?: () => void;
+    onThemeModalOpen?: () => void;
+    /**
+     * Custom content inside the theme dialog. When omitted, the built-in
+     * `ThemeCustomizationSettings` UI is used; save updates local theme and calls
+     * `onDashboardThemeChange` when provided.
+     */
+    renderThemeModal?: (close: () => void) => React__default.ReactNode;
+    /**
+     * Called after a successful save from the built-in theme modal (or local-only save when
+     * `persistWorkspaceTheme` is false). `undefined` means the user saved the app-default preset.
+     */
+    onDashboardThemeChange?: (theme: DashboardTheme | undefined) => void;
+    /**
+     * When true (default), saving from the built-in theme UI GET/PUTs workspace `meta.theme`
+     * for this `dashboardId`, matching the main Papermap app.
+     */
+    persistWorkspaceTheme?: boolean;
+    /** Custom dashboard theme. Sets CSS variables and scoped overrides on the grid container. */
+    dashboardTheme?: DashboardTheme;
+    showHeader?: boolean;
+    enableFetch?: boolean;
+    showChatAssistant?: boolean;
+    variant?: 'default' | 'streaming';
+}
+declare function PapermapGridDashboard({ token, workspaceId, dashboardId, apiUrl, ...rest }: PapermapGridDashboardProps): react_jsx_runtime.JSX.Element;
+
+type ThemePreset = 'default' | 'lime' | 'blue' | 'green' | 'purple' | 'ocean' | 'sunset' | 'dark' | 'minimal';
+
+type ThemeSaveMeta = {
+    selectedPreset: ThemePreset | 'custom';
+};
+interface ThemeCustomizationSettingsProps {
+    /** Current theme to edit. Falls back to the default preset when omitted. */
+    initialTheme?: DashboardTheme;
+    /**
+     * Called when the user clicks Save. `selectedPreset` is `'default` when saving
+     * app default theme (workspace should drop this dashboard from `meta.theme`).
+     */
+    onSave?: (theme: DashboardTheme, meta: ThemeSaveMeta) => void | Promise<void>;
+    /** Called when the user clicks Close / X without saving. */
+    onClose?: () => void;
+    /** Show a saving spinner while the host persists. */
+    isSaving?: boolean;
+}
+declare function ThemeCustomizationSettings({ initialTheme, onSave, onClose, isSaving, }: ThemeCustomizationSettingsProps): react_jsx_runtime.JSX.Element;
+
+declare const defaultTheme: DashboardTheme;
+declare const themePresets: Record<ThemePreset, DashboardTheme>;
+declare const themePresetList: ThemePreset[];
+declare const presetDisplayNames: Record<ThemePreset, string>;
+
+/**
+ * Same resolution order as main-app `useDashboardTheme` (embedded + in-app dashboard):
+ * 1. `meta.apply_theme_to_all_dashboards` + `meta.default_theme`
+ * 2. `meta.theme[dashboardId]` (falls back to `default_dashboard` when `dashboardId` is empty)
+ */
+declare function resolveDashboardThemeFromWorkspace(workspace: {
+    meta?: Record<string, any>;
+    default_dashboard?: string;
+} | null | undefined, dashboardId: string): DashboardTheme | undefined;
+
+/**
+ * Persistent link between a host-owned stable id (`id` on {@link PapermapChartCard})
+ * and the Papermap backend `chat_id` (`llm_data_chat_id`).
+ *
+ * Stored in localStorage under a single key to avoid per-card key explosion and to allow
+ * future schema upgrades (version field) without breaking hosts.
+ */
+declare const CHART_CARD_CHAT_MAP_KEY = "papermap.plugin.chartCardChatMap";
+type ChartCardStorageNamespace = {
+    workspaceId?: string;
+    dashboardId?: string;
+};
+/** Canonical link record returned to callers and accepted on upsert. */
+type ChartCardIdLink = {
+    /** Host key (stable widget / layout / route id). */
+    id: string;
+    /** Backend chat id used exclusively for chart API calls — never use `id` as a chat id. */
+    chatId: string;
+};
+/**
+ * Returns the persisted link for `id` only if a valid `{ chatId }` entry exists.
+ * Does not interpret `id` as a chat id.
+ */
+declare function getChartCardIdLink(id: string, namespace?: ChartCardStorageNamespace): ChartCardIdLink | null;
+/**
+ * Saves or updates the mapping `id` → `chatId`. Call after loads that yield a reliable backend chat id.
+ */
+declare function upsertChartCardIdLink(link: ChartCardIdLink, namespace?: ChartCardStorageNamespace): void;
+/**
+ * Removes the entry for `id`. If `expectedChatId` is set, removal happens only when it matches
+ * the stored chat id (avoids clearing another conversation after stale swaps).
+ */
+declare function removeChartCardIdLink(id: string, expectedChatId?: string, namespace?: ChartCardStorageNamespace): void;
+/**
+ * Resolves which **chat id** to pass to chart HTTP APIs.
+ *
+ * Order (host override first):
+ * 1. `chartId` prop — treated as an explicit backend chat id.
+ * 2. Persisted link for `cardId` — only `entry.chatId` is used for fetch; `cardId` itself is never sent as chat id.
+ */
+declare function resolveChartFetchChatId(params: {
+    chartIdProp?: string;
+    cardId?: string;
+    workspaceId?: string;
+    dashboardId?: string;
+}): string | undefined;
+
+export { type AgentThought, AgentThoughtDisplay, BookmarkButton, BranchButton, ButtonWithTooltip, CHART_CARD_CHAT_MAP_KEY, CHAT_MODAL_TAB, type ChartCardIdLink, type ChartCardStorageNamespace, ChartDialog, ChartHistory, type ChartResponse, ChartView, ChatAssistant, type ChatModalTabType, type ConversationHistory, type DashboardTheme, DataTable, type DecodedToken, FeedbackButtons, type FinalResponse, LogoStandAlone, type Message, ModelSelector, MorphGradient, type OpenPapermapChatAssistantOptions, type PapermapActions, PapermapChartCard, type PapermapChartCardProps, PapermapChat, type PapermapChatProps, PapermapProvider as PapermapConfigProvider, type PapermapConnectionValue, PapermapGridDashboard, type PapermapGridDashboardLayouts, type TLayout as PapermapGridLayoutItem, type PapermapHttpServices, PapermapProvider, type PapermapState, type PapermapStore, type PapermapStoreApi, type PapermapStoreConfig, RecentConversations, SavedMemory, type StreamState, StreamingChartDialog, StreamingChatPanel, StreamingTimeline, type TChartMeta$1 as TChartMeta, type TChartResponse, ThemeCustomizationSettings, type ThemeCustomizationSettingsProps, type ThemePreset, type ThemeSaveMeta, type TimelineEvent, type ToolCall, ToolCallDisplay, buildAuthHeaders, createApiClient, createPapermapServices, createPapermapStore, decodeToken, defaultTheme, getChartCardIdLink, openPapermapChatAssistant, presetDisplayNames, removeChartCardIdLink, resolveChartFetchChatId, resolveDashboardThemeFromWorkspace, themePresetList, themePresets, upsertChartCardIdLink, useAnalyticsStream, useAutoFade, useAutoResize, useKeyboardShortcuts, usePapermapConnection, usePapermapConnectionOptional, usePapermapStore, usePapermapStoreApi, usePapermapStoreApiOptional };