@sybilion/uilib 1.0.20

package/dist/esm/types/src/components/ui/ChartAreaInteractive/overlays/IntervalsOverlay/IntervalsOverlay.d.ts

@@ -0,0 +1,17 @@
+import { BaseChartWrapperProps } from '#uilib/components/ui/Chart/components/BaseChartWrapper';
+import type { ForecastData } from '#uilib/types/forecast-data';
+import { Analysis } from '../../ChartAreaInteractive.types';
+interface IntervalsOverlayProps {
+    baseChartProps: BaseChartWrapperProps;
+    selectedForecast?: Analysis;
+    className?: string;
+    upperQuantiles?: string[];
+    lowerQuantiles?: string[];
+    selectedLowerQuantile?: string | null;
+    selectedUpperQuantile?: string | null;
+    onLowerQuantileChange?: (quantile: string | null) => void;
+    onUpperQuantileChange?: (quantile: string | null) => void;
+    overlayForecastData: Record<number, ForecastData>;
+}
+export declare function IntervalsOverlay({ baseChartProps, selectedForecast, className, upperQuantiles: propUpperQuantiles, lowerQuantiles: propLowerQuantiles, selectedLowerQuantile: propSelectedLowerQuantile, selectedUpperQuantile: propSelectedUpperQuantile, onLowerQuantileChange, onUpperQuantileChange, overlayForecastData: forecastData, }: IntervalsOverlayProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/esm/types/src/components/ui/ChartAreaInteractive/overlays/IntervalsOverlay/IntervalsOverlay.hooks.d.ts

@@ -0,0 +1,15 @@
+import { RefObject } from 'react';
+export declare function useQuantileButton({ buttonRef, overlayContainerRef, quantiles, selectedQuantile, onQuantileChange, calculateQuantilePosition, yMin, yMax, minPercent, maxPercent, }: {
+    buttonRef: RefObject<HTMLButtonElement>;
+    overlayContainerRef: RefObject<HTMLDivElement>;
+    quantiles: string[];
+    selectedQuantile: string | null | undefined;
+    onQuantileChange?: (quantile: string | null) => void;
+    calculateQuantilePosition: (quantile: string, yMin: number, yMax: number) => number;
+    yMin: number;
+    yMax: number;
+    minPercent?: number;
+    maxPercent?: number;
+}): {
+    isDragging: boolean;
+};

package/dist/esm/types/src/components/ui/ChartAreaInteractive/overlays/PinOverlay/PinOverlay.d.ts

@@ -0,0 +1,10 @@
+import { BaseChartWrapperProps } from '#uilib/components/ui/Chart/components/BaseChartWrapper';
+interface PinOverlayProps {
+    baseChartProps: BaseChartWrapperProps;
+    pinMonth: string | undefined;
+    onPinMonthChange: (month: string | undefined) => void;
+    onPreviewMonthChange?: (month: string | undefined) => void;
+    className?: string;
+}
+export declare function PinOverlay({ baseChartProps, pinMonth, onPinMonthChange, onPreviewMonthChange, className, }: PinOverlayProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/esm/types/src/components/ui/ChartAreaInteractive/overlays/ThresholdsOverlay/ThresholdsOverlay.d.ts

@@ -0,0 +1,19 @@
+import { BaseChartWrapperProps } from '#uilib/components/ui/Chart/components/BaseChartWrapper';
+import type { ForecastData } from '#uilib/types/forecast-data';
+import { Analysis } from '../../ChartAreaInteractive.types';
+interface ThresholdsOverlayProps {
+    baseChartProps: BaseChartWrapperProps;
+    selectedForecast?: Analysis;
+    className?: string;
+    lowerThreshold?: number;
+    upperThreshold?: number;
+    onLowerThresholdChange?: (value: number) => void;
+    onUpperThresholdChange?: (value: number) => void;
+    discreteThresholdValues?: {
+        lower: number[];
+        upper: number[];
+    };
+    overlayForecastData: Record<number, ForecastData>;
+}
+export declare function ThresholdsOverlay({ baseChartProps, selectedForecast, className, lowerThreshold, upperThreshold, onLowerThresholdChange, onUpperThresholdChange, discreteThresholdValues, overlayForecastData: forecastData, }: ThresholdsOverlayProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/esm/types/src/components/ui/ChartAreaInteractive/overlays/ThresholdsOverlay/ThresholdsOverlay.hooks.d.ts

@@ -0,0 +1,15 @@
+import { RefObject } from 'react';
+export declare function useThresholdButton({ lineRef, overlayContainerRef, initialValue, minValue, maxValue, yMin, yMax, onValueChange, discreteValues, }: {
+    lineRef: RefObject<HTMLDivElement>;
+    gradientRef?: RefObject<HTMLDivElement>;
+    overlayContainerRef: RefObject<HTMLDivElement>;
+    initialValue: number;
+    minValue: number;
+    maxValue: number;
+    yMin: number;
+    yMax: number;
+    onValueChange: (value: number) => void;
+    discreteValues?: number[];
+}): {
+    isDragging: boolean;
+};

package/dist/esm/types/src/components/ui/ChartAreaInteractive/overlays/index.d.ts

@@ -0,0 +1,3 @@
+export { PinOverlay } from './PinOverlay/PinOverlay';
+export { IntervalsOverlay } from './IntervalsOverlay/IntervalsOverlay';
+export { ThresholdsOverlay } from './ThresholdsOverlay/ThresholdsOverlay';

package/dist/esm/types/src/components/ui/ChartAreaInteractive/overlays/useChartYRange.d.ts

@@ -0,0 +1,18 @@
+import { BaseChartWrapperProps } from '#uilib/components/ui/Chart/components/BaseChartWrapper';
+import { ChartDataPoint } from '#uilib/components/ui/ChartAreaInteractive/ChartAreaInteractive.types';
+interface UseChartYRangeOptions {
+    baseChartProps: BaseChartWrapperProps;
+    chartData?: ChartDataPoint[];
+    disableRescaleWhenQuantileChanges?: boolean;
+    excludeQuantileBands?: boolean;
+    selectedForecastId?: number;
+}
+/**
+ * Hook to calculate yMin and yMax from chart data
+ * Optionally includes quantile values from forecast data
+ */
+export declare function useChartYRange({ baseChartProps, chartData, disableRescaleWhenQuantileChanges, excludeQuantileBands, selectedForecastId, }: UseChartYRangeOptions): {
+    yMin: number;
+    yMax: number;
+};
+export {};

package/dist/esm/types/src/components/ui/ChartAreaInteractive/overlays/useForecastColor.d.ts

@@ -0,0 +1,10 @@
+import { Analysis } from '../ChartAreaInteractive.types';
+import { ForecastItemData } from '../ChartLines';
+/**
+ * Hook to get the forecast color using the same logic as ChartLines
+ * Finds the forecast in forecastData array and returns its color or a color from forecastColors array
+ */
+export declare function useForecastColor(selectedForecast: Analysis | undefined, forecastData: ForecastItemData[]): {
+    lineColor: string;
+    quantileBandColor: string;
+};

package/dist/esm/types/src/components/ui/ChartAreaInteractive/overlays/useQuantileBands.d.ts

@@ -0,0 +1,22 @@
+import type { QuantileBandConfig } from '#uilib/components/ui/Chart/chartForecastVisualization.types';
+import { ChartDataPoint } from '#uilib/components/ui/ChartAreaInteractive/ChartAreaInteractive.types';
+import type { ForecastData } from '#uilib/types/forecast-data';
+interface UseQuantileBandOptions {
+    color?: string;
+    chartData: ChartDataPoint[];
+    selectedForecastId?: number;
+    forecastData: {
+        [key: string]: ForecastData;
+    };
+    bandKey: string;
+    getBandValues: (date: string, dateIndex: number, allQuantiles: Record<string, number[]>) => [number, number] | null;
+    getBandConfig: (bandKey: string, forecastColor?: string) => QuantileBandConfig;
+}
+/**
+ * Hook to transform chart data and create quantile band configuration
+ */
+export declare function useQuantileBands({ color, chartData, selectedForecastId, forecastData, bandKey, getBandValues, getBandConfig, }: UseQuantileBandOptions): {
+    transformedChartData: ChartDataPoint[];
+    quantileBands: QuantileBandConfig[];
+};
+export {};

package/dist/esm/types/src/components/ui/Chat/Chat.d.ts

@@ -0,0 +1,12 @@
+import { ChatPresets } from '#uilib/components/ui/Chat/ChatPresets';
+import type { ChatProps } from './Chat.types';
+import { ChatEmptyState } from './ChatEmptyState/ChatEmptyState';
+import { ChatMessage } from './ChatMessage';
+import { ChatPrompt } from './ChatPrompt';
+export declare function Chat({ children, className, isEmpty, ...props }: ChatProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace Chat {
+    var Prompt: typeof ChatPrompt;
+    var Message: typeof ChatMessage;
+    var Presets: typeof ChatPresets;
+    var EmptyState: typeof ChatEmptyState;
+}

package/dist/esm/types/src/components/ui/Chat/Chat.types.d.ts

@@ -0,0 +1,80 @@
+import type { HTMLAttributes, ReactNode } from 'react';
+import type { PresetScriptGraph } from './ChatMessage/presetScript';
+export declare enum MessageRole {
+    USER = "user",
+    ASSISTANT = "assistant",
+    SYSTEM = "system"
+}
+/** System placeholder while dashboard generation runs (must match ChatSheet `addMessage` text). */
+export declare const GENERATING_DASHBOARD_SYSTEM_TEXT = "Generating dashboard\u2026";
+export interface Message {
+    id: string;
+    role: MessageRole;
+    text: string;
+    timestamp: number;
+}
+export interface Chat {
+    session_id: string;
+    name: string;
+    messages: Message[];
+}
+export interface ChatPreset {
+    id: string;
+    /** Button label and exact user message text when the preset is sent (used to detect “used” presets). */
+    text: string;
+    answer?: string;
+    /**
+     * Local demo: linear `string[]` (each line may end with ` [Button label]`), or a graph with
+     * `initialMessage` + branch keys (slugs or numeric strings) for `[Label|branchKey]` buttons.
+     */
+    script?: string[] | PresetScriptGraph;
+    /**
+     * Local demo: assistant text may include `[Label]` buttons; clicking sends the label as user
+     * text and appends `replies[label]` as the next assistant message (can include more `[…]`).
+     */
+    replies?: Record<string, string>;
+    /**
+     * Local graph: maps step id → next graph key after the user sends a free-text reply (no chip).
+     * Use virtual step `initial` after `initialMessage`; other ids match the branch key whose
+     * assistant bubble is on screen (e.g. `q_company`, `p_rev`).
+     */
+    freeformNext?: Record<string, string>;
+}
+export type ScriptCompletePayload = {
+    presetId: string;
+    answers: Record<string, string>;
+};
+export interface ChatPromptProps {
+    className?: string;
+    id: string;
+    onSubmit: (message: string) => void;
+    placeholder?: string;
+    presets?: ChatPreset[];
+    disabled?: boolean;
+    footer?: ReactNode;
+    onChatDeleted?: (sessionId: string) => void;
+    /** Deep link `?prompt=` — one-shot composer pre-fill (see useChatPanelChromeModel). */
+    prefillMessage?: string | null;
+}
+export interface ChatMessageProps {
+    role: MessageRole;
+    text: string;
+    onQuickReply?: (branchKey: string, displayLabel: string) => void;
+    /** Branch keys already taken (e.g. from chat history); hide quick-reply buttons for these. */
+    suppressedQuickReplyKeys?: ReadonlySet<string>;
+    quickReplyDisabled?: boolean;
+    /** When false, bracket quick-replies render as plain text (no button). */
+    isLastMessage?: boolean;
+    /** Preset script continuation (last message only); not sent to LLM. */
+    scriptContinue?: {
+        label: string;
+    };
+    onScriptContinue?: () => void;
+    /** Renders `[CHART]` placeholder in assistant messages (app supplies dataset chart). */
+    renderMessageChart?: () => ReactNode;
+}
+export interface ChatProps extends HTMLAttributes<HTMLDivElement> {
+    children: ReactNode;
+    className?: string;
+    isEmpty?: boolean;
+}

package/dist/esm/types/src/components/ui/Chat/ChatChrome/ChatChrome.d.ts

@@ -0,0 +1,2 @@
+import type { ChatChromeProps } from './ChatChrome.types';
+export declare function ChatChrome({ showResizeHandle, resizeHandle, onClose, isEmpty, renderPresets, messages, onQuickReply, suppressedQuickReplyKeys, isLoading, scriptContinueLabel, onScriptContinue, renderMessageChart, showBranchActionsRow, showSyntheticBranchButtons, unusedBranchKeys, isScriptComplete, onGenerateDashboard, generatingDashboard, onGenerateDashboardClick, showInlinePresets, isLastMessageFromUser, scrollRef, effectiveScopeId, onPromptSubmit, onChatDeleted, promptPrefill, variant, footerClassName, emptyState, }: ChatChromeProps): import("react/jsx-runtime").JSX.Element;

package/dist/esm/types/src/components/ui/Chat/ChatChrome/ChatChrome.types.d.ts

@@ -0,0 +1,45 @@
+import type { RefObject } from 'react';
+import type { Message } from '#uilib/components/ui/Chat/Chat.types';
+import type { ChatEmptyStateProps } from '#uilib/components/ui/Chat/ChatEmptyState/ChatEmptyState.types';
+import type { ChatPresetsLayout } from '#uilib/components/ui/Chat/ChatPresets';
+import type { ScrollRef } from '@homecode/ui';
+export type ChatChromeResizeHandleConfig = {
+    isActive: boolean;
+    startWidthPx: number;
+    getShellWidth: () => number;
+    onDragWidth: (rawPx: number) => void;
+    onDragComplete: (finalRawPx: number) => void;
+};
+export interface ChatChromeProps {
+    showResizeHandle: boolean;
+    resizeHandle: ChatChromeResizeHandleConfig | undefined;
+    onClose: (() => void) | undefined;
+    isEmpty: boolean;
+    renderPresets: (layout: ChatPresetsLayout) => React.ReactNode;
+    /** Message list for the scroll area; use `[]` when empty. */
+    messages: Message[];
+    onQuickReply: (branchKey: string, displayLabel: string) => void;
+    suppressedQuickReplyKeys: ReadonlySet<string>;
+    isLoading: boolean;
+    scriptContinueLabel: string | undefined;
+    onScriptContinue: (() => void) | undefined;
+    renderMessageChart?: () => React.ReactNode;
+    showBranchActionsRow: boolean;
+    showSyntheticBranchButtons: boolean;
+    unusedBranchKeys: string[];
+    isScriptComplete: boolean;
+    onGenerateDashboard: ((transcript: string) => void | Promise<void>) | undefined;
+    generatingDashboard: boolean;
+    onGenerateDashboardClick: () => void;
+    showInlinePresets: boolean;
+    isLastMessageFromUser: boolean;
+    scrollRef: RefObject<ScrollRef | null>;
+    effectiveScopeId: string;
+    onPromptSubmit: (message: string) => void | Promise<void>;
+    onChatDeleted: (sessionId: string) => void;
+    /** `?prompt=` deep link text for one-shot composer pre-fill. */
+    promptPrefill?: string | null;
+    variant?: 'default' | 'sidebar';
+    footerClassName?: string;
+    emptyState?: ChatEmptyStateProps;
+}

package/dist/esm/types/src/components/ui/Chat/ChatChrome/index.d.ts

@@ -0,0 +1,2 @@
+export { ChatChrome } from './ChatChrome';
+export type { ChatChromeProps, ChatChromeResizeHandleConfig, } from './ChatChrome.types';

package/dist/esm/types/src/components/ui/Chat/ChatEmptyState/ChatEmptyState.d.ts

@@ -0,0 +1,2 @@
+import type { ChatEmptyStateProps } from './ChatEmptyState.types';
+export declare function ChatEmptyState({ icon, title, description, }: ChatEmptyStateProps): import("react/jsx-runtime").JSX.Element;

package/dist/esm/types/src/components/ui/Chat/ChatEmptyState/ChatEmptyState.types.d.ts

@@ -0,0 +1,5 @@
+export interface ChatEmptyStateProps {
+    icon?: React.ReactNode;
+    title?: string;
+    description?: string;
+}

package/dist/esm/types/src/components/ui/Chat/ChatMessage/AgentMessageContent.d.ts

@@ -0,0 +1,13 @@
+import { type ReactNode } from 'react';
+export declare function AgentMessageContent({ text, onQuickReply, suppressedQuickReplyKeys, quickReplyDisabled, isLastMessage, scriptContinue, onScriptContinue, renderMessageChart, }: {
+    text: string;
+    onQuickReply?: (branchKey: string, displayLabel: string) => void;
+    suppressedQuickReplyKeys?: ReadonlySet<string>;
+    quickReplyDisabled?: boolean;
+    isLastMessage?: boolean;
+    scriptContinue?: {
+        label: string;
+    };
+    onScriptContinue?: () => void;
+    renderMessageChart?: () => ReactNode;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/esm/types/src/components/ui/Chat/ChatMessage/AgentMessageContent.helpers.d.ts

@@ -0,0 +1,31 @@
+import React from 'react';
+declare const injectHeaders: (content: string) => {
+    elem: import("react/jsx-runtime").JSX.Element;
+    index: number;
+    length: number;
+};
+declare const injectBold: (content: string) => {
+    elem: import("react/jsx-runtime").JSX.Element;
+    index: number;
+    length: number;
+};
+declare const injectBullet: (content: string) => {
+    elem: import("react/jsx-runtime").JSX.Element;
+    index: number;
+    length: number;
+};
+declare const injectNewlines: (content: string) => {
+    elem: import("react/jsx-runtime").JSX.Element;
+    index: number;
+    length: number;
+};
+declare const convertMarkdownTableToHTML: (text: string) => string;
+type Injector = (content: string) => {
+    elem: React.ReactNode;
+    index: number;
+    length: number;
+} | null;
+declare const injectAnchor: Injector;
+declare const applyFormatting: (text: string) => React.ReactNode[];
+declare const applyFormattingInline: (text: string) => React.ReactNode[];
+export { injectHeaders, injectAnchor, injectBold, injectBullet, injectNewlines, convertMarkdownTableToHTML, applyFormatting, applyFormattingInline, };

package/dist/esm/types/src/components/ui/Chat/ChatMessage/ChatDatasetApplicationLink.d.ts

@@ -0,0 +1,5 @@
+export declare function ChatDatasetApplicationLink({ datasetId, analysisId, label, }: {
+    datasetId: number;
+    analysisId?: number;
+    label?: string;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/esm/types/src/components/ui/Chat/ChatMessage/ChatMessage.d.ts

@@ -0,0 +1,2 @@
+import { type ChatMessageProps } from '../Chat.types';
+export declare function ChatMessage({ role, text, onQuickReply, suppressedQuickReplyKeys, quickReplyDisabled, isLastMessage, scriptContinue, onScriptContinue, renderMessageChart, }: ChatMessageProps): import("react/jsx-runtime").JSX.Element;

package/dist/esm/types/src/components/ui/Chat/ChatMessage/MessageChart.d.ts

@@ -0,0 +1,9 @@
+import type { ChartDataPoint } from '#uilib/components/ui/ChartAreaInteractive/ChartAreaInteractive.types';
+import type { ForecastItemData } from '#uilib/components/ui/ChartAreaInteractive/ChartLines';
+export interface MessageChartProps {
+    chartData: ChartDataPoint[];
+    forecastData: ForecastItemData[];
+    loading: boolean;
+    isDarkTheme?: boolean;
+}
+export declare function MessageChart({ chartData, forecastData, loading, isDarkTheme, }: MessageChartProps): import("react/jsx-runtime").JSX.Element;

package/dist/esm/types/src/components/ui/Chat/ChatMessage/icons/DocIcon.d.ts

@@ -0,0 +1,3 @@
+export declare function DocIcon({ size }: {
+    size?: number;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/esm/types/src/components/ui/Chat/ChatMessage/icons/XlsIcon.d.ts

@@ -0,0 +1,3 @@
+export declare function XlsIcon({ size }: {
+    size?: number;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/esm/types/src/components/ui/Chat/ChatMessage/index.d.ts

@@ -0,0 +1 @@
+export { ChatMessage } from './ChatMessage';

package/dist/esm/types/src/components/ui/Chat/ChatMessage/presetScript.d.ts

@@ -0,0 +1,55 @@
+import type { Message } from '../Chat.types';
+/** Branching demo: `initialMessage` + string-keyed nodes; buttons use `[Label|branchKey]`. */
+export type PresetScriptGraph = {
+    initialMessage: string;
+} & Record<string, string>;
+export declare function isPresetScriptGraph(script: string[] | string | PresetScriptGraph | undefined): script is PresetScriptGraph;
+/**
+ * Parse Script field: branching graph as JSON (full `{ ... }` or inner `"key": "value",` list),
+ * or linear script as newline-separated lines. Empty input → undefined.
+ */
+export declare function parsePresetScriptFieldInput(raw: string, existing?: string[] | string | PresetScriptGraph): PresetScriptGraph | string[] | undefined;
+/** Branch map for quick-reply lookup (all keys except `initialMessage`). */
+export declare function branchesFromPresetScriptGraph(graph: PresetScriptGraph): Record<string, string>;
+/** Trailing ` [label]` defines the continue button; the rest is assistant body. */
+export declare function parseScriptLine(line: string): {
+    displayBody: string;
+    buttonLabel?: string;
+};
+export declare function textHasQuickReplyMarkers(text: string): boolean;
+/** Preset graph/linear step is done when assistant text has no `[Label|branchKey]` navigation. */
+export declare function isTerminalPresetScriptAssistantText(text: string): boolean;
+/**
+ * Graph intake: complete after this assistant bubble only when it is the `complete`
+ * node, or when `freeformNext` has no continuation for this key. Freeform prompts
+ * (e.g. p_mar “last question”) have no markers — do not treat as terminal via
+ * {@link isTerminalPresetScriptAssistantText} alone.
+ */
+export declare function isGraphIntakeAssistantStepComplete(shownScriptKey: string, freeformNext: Record<string, string>, assistantBody: string): boolean;
+export declare function humanizeBranchKey(key: string): string;
+/** Pairs from `[Label|branchKey]` (same rules as AgentMessageContent). */
+export declare function extractQuickReplyLabelKeyPairsFromText(text: string): Array<{
+    label: string;
+    key: string;
+}>;
+/**
+ * If `userText` matches a `[label|key]` pair on the assistant message (trimmed NFC), return it.
+ */
+export declare function matchUserTextToQuickReply(assistantText: string, userText: string): {
+    key: string;
+    label: string;
+} | null;
+/** First label seen in chat (assistant order) for a branch key; for synthetic row copy. */
+export declare function displayLabelForBranchKeyFromMessages(branchKey: string, messages: Message[] | undefined): string | undefined;
+/**
+ * Branch keys the user picked: USER line matches `[label|key]` on the **immediately
+ * preceding** assistant only (avoids suppressing the same label re-offered on a later bubble).
+ */
+export declare function branchKeysUsedFromChatHistory(messages: Message[] | undefined): string[];
+/**
+ * User's last branch choice that led to the final assistant message: match the user
+ * line before last to `[label|key]` on the nearest preceding assistant bubble.
+ */
+export declare function entryBranchKeyBeforeLastAssistant(messages: Message[] | undefined): string | undefined;
+/** Infer used branch keys from USER lines vs assistant `[label|key]` + humanized slug fallback. */
+export declare function branchKeysUsedByUserMessages(messages: Message[] | undefined, validBranchKeys: string[]): string[];

package/dist/esm/types/src/components/ui/Chat/ChatPresets/ChatPresets.d.ts

@@ -0,0 +1,11 @@
+import type { ChatPreset } from '../Chat.types';
+export type ChatPresetsLayout = 'fixed' | 'inline';
+export interface ChatPresetsProps {
+    chatId: string;
+    items: ChatPreset[];
+    usedItemIds?: string[];
+    layout?: ChatPresetsLayout;
+    onSelect?: (preset: ChatPreset) => void;
+    onItemUsed?: (id: string) => void;
+}
+export declare function ChatPresets({ chatId, items, usedItemIds, layout, onSelect, onItemUsed, }: ChatPresetsProps): import("react/jsx-runtime").JSX.Element;

package/dist/esm/types/src/components/ui/Chat/ChatPresets/index.d.ts

@@ -0,0 +1,2 @@
+export { ChatPresets } from './ChatPresets';
+export type { ChatPresetsLayout, ChatPresetsProps } from './ChatPresets';

package/dist/esm/types/src/components/ui/Chat/ChatPrompt/ChatPrompt.d.ts

@@ -0,0 +1,2 @@
+import type { ChatPromptProps } from '../Chat.types';
+export declare function ChatPrompt({ onSubmit, placeholder, className, footer, id, onChatDeleted, prefillMessage, }: ChatPromptProps): import("react/jsx-runtime").JSX.Element;

package/dist/esm/types/src/components/ui/Chat/ChatPrompt/index.d.ts

@@ -0,0 +1 @@
+export { ChatPrompt } from './ChatPrompt';

package/dist/esm/types/src/components/ui/Chat/ChatSheet/ChatSelector.d.ts

@@ -0,0 +1,5 @@
+export interface ChatSelectorProps {
+    id: string;
+    className?: string;
+}
+export declare function ChatSelector({ id, className }: ChatSelectorProps): import("react/jsx-runtime").JSX.Element;

package/dist/esm/types/src/components/ui/Chat/ChatSheet/ChatSettings.d.ts

@@ -0,0 +1,5 @@
+export interface ChatSettingsProps {
+    /** Dataset id for chat sessions; required when not using app dataset context. */
+    id?: string | null;
+}
+export declare function ChatSettings({ id }?: ChatSettingsProps): import("react/jsx-runtime").JSX.Element;

package/dist/esm/types/src/components/ui/Chat/ChatSheet/ChatSheet.d.ts

@@ -0,0 +1,22 @@
+import { type UseChatPanelChromeModelInput } from './useChatPanelChromeModel';
+export type ChatSheetActions = {
+    open: () => void;
+    /** Starts a new chat session and opens the panel (same as the new-chat keyboard shortcut). */
+    openNewChat: () => void;
+};
+export interface ChatSheetProps extends Omit<UseChatPanelChromeModelInput, 'embedAsPage'> {
+    title?: string;
+    /** Imperative open / new-chat for triggers outside `renderTrigger` (e.g. sidebar). */
+    actionsRef?: React.MutableRefObject<ChatSheetActions | null>;
+    renderTrigger?: (toggleOpen: () => void) => React.ReactNode;
+    triggerLabel?: React.ReactNode;
+    /** aria-label for icon-only trigger (required when trigger has no visible text) */
+    triggerAriaLabel?: string;
+    label?: string;
+    /**
+     * Render chat panel in place (no trigger, no portal, no `?chat=` URL, no shell chat slot).
+     * Prefer composing `ChatChrome` with `useChatPanelChromeModel({ embedAsPage: true, ... })` on the page.
+     */
+    inline?: boolean;
+}
+export declare function ChatSheet({ triggerLabel, triggerAriaLabel, actionsRef, renderTrigger, presets, scopeId, onMessage, onScriptComplete, onGenerateDashboard, renderMessageChart, inline, }: ChatSheetProps): import("react/jsx-runtime").JSX.Element;

package/dist/esm/types/src/components/ui/Chat/ChatSheet/index.d.ts

@@ -0,0 +1,3 @@
+export { ChatSheet } from './ChatSheet';
+export type { ChatSheetActions, ChatSheetProps } from './ChatSheet';
+export { useChatPanelChromeModel, type UseChatPanelChromeModelInput, type UseChatPanelChromeModelResult, } from './useChatPanelChromeModel';

package/dist/esm/types/src/components/ui/Chat/ChatSheet/useChatPanelChromeModel.d.ts

@@ -0,0 +1,25 @@
+import { ChatPreset, type ScriptCompletePayload } from '#uilib/components/ui/Chat/Chat.types';
+import type { ChatChromeProps } from '../ChatChrome';
+export type UseChatPanelChromeModelInput = {
+    /** When true, skip sidebar chat slot, URL `?chat=`, and portal behavior (e.g. page main content). */
+    embedAsPage: boolean;
+    presets?: ChatPreset[];
+    /** Composite chat scope (e.g. `${userId}-${datasetId}`, `${userId}-dashboard`, `${userId}-report-${reportId}`). */
+    scopeId?: string | null;
+    onMessage?: (message: string) => void;
+    /** Fires when a preset script has no further `[Label|branchKey]` steps (graph leaf or linear script end). */
+    onScriptComplete?: (payload: ScriptCompletePayload) => void;
+    /** After intake script completes, user can generate a dashboard from the full transcript (e.g. Decision board). */
+    onGenerateDashboard?: (transcript: string) => void | Promise<void>;
+    /** Renders `[CHART]` tokens in assistant messages. */
+    renderMessageChart?: () => React.ReactNode;
+};
+export type UseChatPanelChromeModelResult = {
+    chromeProps: ChatChromeProps;
+    isOpen: boolean;
+    onOpenChange: (open: boolean) => void;
+    toggleOpen: () => void;
+    newChat: () => void;
+    chatPanelContainer: HTMLElement | null;
+};
+export declare function useChatPanelChromeModel({ embedAsPage, presets, scopeId, onMessage, onScriptComplete, onGenerateDashboard, renderMessageChart, }: UseChatPanelChromeModelInput): UseChatPanelChromeModelResult;

package/dist/esm/types/src/components/ui/Chat/chat-preset-utils.d.ts

@@ -0,0 +1,6 @@
+import type { ChatPreset, Message } from './Chat.types';
+/** Full chat text for dashboard / downstream tools (role-prefixed lines). */
+export declare function formatChatTranscript(messages: Message[]): string;
+/** Match button label (`preset.text`) to user message body; normalize to avoid trivial mismatches. */
+export declare function normalizePresetMatchText(s: string): string;
+export declare function usedPresetIdsFromMessages(messages: Message[] | undefined, presets: ChatPreset[] | undefined): string[];

package/dist/esm/types/src/components/ui/Chat/index.d.ts

@@ -0,0 +1,13 @@
+export { Chat } from './Chat';
+export { usedPresetIdsFromMessages } from './chat-preset-utils';
+export { ChatChrome } from './ChatChrome';
+export type { ChatChromeProps, ChatChromeResizeHandleConfig, } from './ChatChrome';
+export { ChatSheet } from './ChatSheet/ChatSheet';
+export { useChatPanelChromeModel } from './ChatSheet/useChatPanelChromeModel';
+export type { ChatSheetActions, ChatSheetProps } from './ChatSheet/ChatSheet';
+export type { UseChatPanelChromeModelInput, UseChatPanelChromeModelResult, } from './ChatSheet/useChatPanelChromeModel';
+export { ChatMessage } from './ChatMessage';
+export { ChatPrompt } from './ChatPrompt';
+export { ChatPresets } from './ChatPresets';
+export type { Chat as ChatType, Message, ChatProps, ChatPreset as ChatPresetType, } from './Chat.types';
+export { MessageRole } from './Chat.types';

package/dist/esm/types/src/components/ui/Checkbox/Checkbox.d.ts

@@ -0,0 +1,3 @@
+import type { CheckboxProps } from './Checkbox.types';
+declare function Checkbox({ className, ...props }: CheckboxProps): import("react/jsx-runtime").JSX.Element;
+export { Checkbox };

package/dist/esm/types/src/components/ui/Checkbox/Checkbox.types.d.ts

@@ -0,0 +1,3 @@
+import * as CheckboxPrimitive from '@radix-ui/react-checkbox';
+export interface CheckboxProps extends React.ComponentProps<typeof CheckboxPrimitive.Root> {
+}

package/dist/esm/types/src/components/ui/Checkbox/index.d.ts

@@ -0,0 +1,2 @@
+export { Checkbox } from './Checkbox';
+export type { CheckboxProps } from './Checkbox.types';

package/dist/esm/types/src/components/ui/Dialog/Dialog.d.ts

@@ -0,0 +1,3 @@
+import type { DialogProps } from './Dialog.types';
+export declare function Dialog({ open, onOpenChange, disabled, trigger, title, subtitle, disableCloseButton, icon, content, contentClassName, footer, footerClassName, footerAlignment, size, className, noScroll, maxHeight, autoScrollBottom, width, }: DialogProps): import("react/jsx-runtime").JSX.Element;
+export { default as DialogStyles } from './Dialog.styl';

package/dist/esm/types/src/components/ui/Dialog/Dialog.types.d.ts

@@ -0,0 +1,26 @@
+import { CSSProperties, ReactNode } from 'react';
+export interface DialogProps {
+    open: boolean;
+    disabled?: boolean;
+    /** When true, the header close control is hidden. */
+    disableCloseButton?: boolean;
+    onOpenChange: (isOpen: boolean) => void;
+    trigger?: ReactNode;
+    triggerClassName?: string;
+    title?: ReactNode;
+    titleClassName?: string;
+    subtitle?: ReactNode;
+    subtitleClassName?: string;
+    icon?: ReactNode;
+    content?: ReactNode;
+    contentClassName?: string;
+    footer?: ReactNode;
+    footerClassName?: string;
+    footerAlignment?: 'left' | 'center' | 'right' | 'between';
+    size?: 'login' | 'wide' | 'default';
+    className?: string;
+    noScroll?: boolean;
+    autoScrollBottom?: boolean;
+    maxHeight?: CSSProperties['maxHeight'];
+    width?: CSSProperties['width'];
+}

package/dist/esm/types/src/components/ui/Dialog/index.d.ts

@@ -0,0 +1,2 @@
+export { Dialog, DialogStyles } from './Dialog';
+export type { DialogProps } from './Dialog.types';

package/dist/esm/types/src/components/ui/DraggingButton/DraggingButton.d.ts

@@ -0,0 +1,12 @@
+import React, { ReactNode } from 'react';
+interface DraggingButtonProps extends Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, 'style' | 'title' | 'className'> {
+    top?: string;
+    left?: string;
+    className?: string;
+    icon: ReactNode;
+    title: string;
+    isDragging: boolean;
+    size?: 'sm' | 'md' | 'lg';
+}
+export declare const DraggingButton: React.ForwardRefExoticComponent<DraggingButtonProps & React.RefAttributes<HTMLButtonElement>>;
+export {};