@usecrow/ui 0.1.0 → 0.1.1

package/dist/index.d.ts

@@ -1,42 +1,224 @@
 import * as react_jsx_runtime from 'react/jsx-runtime';
-import { CrowClientConfig, IdentifyOptions, ToolHandlers, CrowClient, StreamEvent, Message, Conversation } from '@usecrow/client';
-export { ActiveWorkflow, Citation, ContextData, Conversation, CrowClientConfig, IdentifyOptions, Message, StreamEvent, ToolHandler, ToolHandlers, ToolResult, WorkflowTodo } from '@usecrow/client';
+import { CrowClientConfig } from '@usecrow/client';
+import * as react from 'react';
+import react__default, { ReactNode } from 'react';
 
-interface CrowWidgetProps extends CrowClientConfig {
-    /** Agent name shown in header */
-    agentName?: string;
-    /** Initial collapsed state */
-    defaultCollapsed?: boolean;
-    /** Callback when user needs to be identified */
-    onIdentify?: (identify: (options: IdentifyOptions) => void) => void;
-    /** Client-side tool handlers */
-    tools?: ToolHandlers;
-    /** Custom class name for the widget container */
-    className?: string;
-    /** Z-index for the widget (default: 999999) */
-    zIndex?: number;
+/**
+ * Widget and Copilot Style Configuration Types
+ *
+ * These TypeScript interfaces define all customizable styling options
+ * for both the floating widget and the copilot sidebar.
+ */
+interface ColorsConfig {
+    /** Primary accent color */
+    primary?: string;
+    /** Main background color */
+    background?: string;
+    /** Primary text color */
+    text?: string;
+    /** Border color */
+    border?: string;
+    /** Bot message bubble background */
+    botBubble?: string;
+    /** Bot message text color */
+    botText?: string;
+    /** User message bubble background */
+    userBubble?: string;
+    /** User message text color */
+    userText?: string;
+    /** User message bubble border */
+    userBorder?: string;
+    /** Messages container background */
+    messagesBackground?: string;
+    /** Floating chat bubble background */
+    bubbleBackground?: string;
+    /** Floating chat bubble border */
+    bubbleBorder?: string;
+    /** Floating chat bubble icon color */
+    bubbleIcon?: string;
+}
+interface TypographyConfig {
+    /** Font family (e.g., "Inter, sans-serif") */
+    fontFamily?: string;
+    /** Base font size in pixels */
+    fontSize?: number;
+    /** Header font size in pixels */
+    headerFontSize?: number;
+}
+interface AnimationsConfig {
+    /** Animation duration in seconds */
+    duration?: number;
+    /** Easing function (e.g., "easeInOut") */
+    easing?: string;
+}
+interface WidgetDimensionsConfig {
+    /** Widget width in pixels */
+    width?: number;
+    /** Max height for floating widget in pixels */
+    maxHeight?: number;
+    /** Border radius in pixels */
+    borderRadius?: number;
+    /** Inner padding in pixels */
+    padding?: number;
+    /** Messages container max height in pixels */
+    messagesMaxHeight?: number;
+    /** Fixed height for preview/embedded mode in pixels */
+    previewHeight?: number;
+}
+interface WidgetPositionConfig {
+    /** Distance from right edge in pixels */
+    right?: number;
+    /** Distance from bottom in pixels */
+    bottom?: number;
+    /** Bubble distance from right in pixels */
+    bubbleRight?: number;
+    /** Bubble distance from bottom in pixels */
+    bubbleBottom?: number;
+}
+interface WidgetBubbleConfig {
+    /** Bubble button size in pixels */
+    size?: number;
+    /** Icon size inside bubble in pixels */
+    iconSize?: number;
+}
+interface WidgetShadowsConfig {
+    /** Widget container shadow (CSS box-shadow) */
+    widget?: string;
+    /** Chat bubble shadow (CSS box-shadow) */
+    bubble?: string;
+}
+interface WidgetBrandingConfig {
+    /** Show "Powered by" badge */
+    showPoweredBy?: boolean;
+    /** Custom "Powered by" text */
+    poweredByText?: string;
+    /** Show logo in badge */
+    showLogo?: boolean;
+    /** Custom logo URL */
+    logoUrl?: string;
+}
+/**
+ * Complete widget style configuration.
+ *
+ * All fields are optional - only specified fields override defaults.
+ * This allows partial updates and deep merging with defaults.
+ */
+interface WidgetStyleConfig {
+    colors?: ColorsConfig;
+    typography?: TypographyConfig;
+    animations?: AnimationsConfig;
+    dimensions?: WidgetDimensionsConfig;
+    position?: WidgetPositionConfig;
+    bubble?: WidgetBubbleConfig;
+    shadows?: WidgetShadowsConfig;
+    branding?: WidgetBrandingConfig;
+}
+interface CopilotDimensionsConfig {
+    /** Copilot width in pixels */
+    width?: number;
+    /** Header height in pixels */
+    headerHeight?: number;
+    /** Border radius in pixels */
+    borderRadius?: number;
+    /** Inner padding in pixels */
+    padding?: number;
+}
+interface CopilotPositionConfig {
+    /** Which side to show on */
+    side?: 'left' | 'right';
+}
+interface CopilotBrandingConfig {
+    /** Show "Powered by" badge */
+    showPoweredBy?: boolean;
+    /** Custom "Powered by" text */
+    poweredByText?: string;
+}
+/**
+ * Complete copilot style configuration.
+ *
+ * All fields are optional - only specified fields override defaults.
+ */
+interface CopilotStyleConfig {
+    colors?: ColorsConfig;
+    typography?: TypographyConfig;
+    animations?: AnimationsConfig;
+    dimensions?: CopilotDimensionsConfig;
+    position?: CopilotPositionConfig;
+    branding?: CopilotBrandingConfig;
+}
+/**
+ * Fully resolved widget styles with all defaults applied.
+ * This is what components actually use for rendering.
+ */
+interface ResolvedWidgetStyles {
+    colors: Required<ColorsConfig>;
+    typography: Required<TypographyConfig>;
+    animations: Required<AnimationsConfig>;
+    dimensions: Required<WidgetDimensionsConfig>;
+    position: Required<WidgetPositionConfig>;
+    bubble: Required<WidgetBubbleConfig>;
+    shadows: Required<WidgetShadowsConfig>;
+    branding: Required<WidgetBrandingConfig>;
+}
+/**
+ * Fully resolved copilot styles with all defaults applied.
+ */
+interface ResolvedCopilotStyles {
+    colors: Required<ColorsConfig>;
+    typography: Required<TypographyConfig>;
+    animations: Required<AnimationsConfig>;
+    dimensions: Required<CopilotDimensionsConfig>;
+    position: Required<CopilotPositionConfig>;
+    branding: Required<CopilotBrandingConfig>;
+}
+interface WidgetConfigResponse {
+    productId: string;
+    agentName: string;
+    widgetStyles: WidgetStyleConfig;
+    copilotStyles: CopilotStyleConfig;
 }
-declare function CrowWidget({ productId, apiUrl, model, agentName, defaultCollapsed, onIdentify, tools, className, zIndex, }: CrowWidgetProps): react_jsx_runtime.JSX.Element;
 
-interface CrowCopilotProps extends Partial<CrowClientConfig> {
+interface CrowWidgetProps {
+    /** Product ID for this widget */
+    productId: string;
+    /** API URL (defaults to relative path) */
+    apiUrl?: string;
+    /** Widget variant: floating (with bubble) or embedded (for preview) */
+    variant?: "floating" | "embedded";
+    /** Custom styles to override DB and default styles */
+    styles?: Partial<WidgetStyleConfig>;
+    /** Skip fetching styles from API (use for preview mode with local state) */
+    previewMode?: boolean;
+    /** Callback when widget is ready */
+    onReady?: () => void;
+}
+declare function CrowWidget({ productId, apiUrl, variant, styles: propStyles, previewMode, onReady, }: CrowWidgetProps): react_jsx_runtime.JSX.Element;
+
+interface CrowCopilotProps {
+    /** Product ID for this copilot */
+    productId: string;
+    /** API URL (defaults to relative path) */
+    apiUrl?: string;
     /** Title shown in header */
     title?: string;
     /** Position of the sidebar */
-    position?: 'left' | 'right';
+    position?: "left" | "right";
     /** Width of the sidebar */
     width?: number | string;
     /** Show close button */
     showClose?: boolean;
     /** Callback when close is clicked */
     onClose?: () => void;
-    /** Callback when user needs to be identified */
-    onIdentify?: (identify: (options: IdentifyOptions) => void) => void;
-    /** Client-side tool handlers */
-    tools?: ToolHandlers;
+    /** Custom styles to override DB and default styles */
+    styles?: Partial<CopilotStyleConfig>;
+    /** Skip fetching styles from API (use for preview mode) */
+    previewMode?: boolean;
     /** Custom class name */
     className?: string;
+    /** Callback when copilot is ready */
+    onReady?: () => void;
 }
-declare function CrowCopilot({ productId, apiUrl, model, title, position, width, showClose, onClose, onIdentify, tools, className, }: CrowCopilotProps): react_jsx_runtime.JSX.Element | null;
+declare function CrowCopilot({ productId, apiUrl, title, position, width, showClose, onClose, styles: propStyles, previewMode, className, onReady, }: CrowCopilotProps): react_jsx_runtime.JSX.Element;
 
 interface CrowProviderProps extends CrowClientConfig {
     children: React.ReactNode;
@@ -45,122 +227,543 @@ interface CrowProviderProps extends CrowClientConfig {
  * Provider component that creates and shares a CrowClient instance
  */
 declare function CrowProvider({ children, productId, apiUrl, model, }: CrowProviderProps): react_jsx_runtime.JSX.Element;
+
 /**
- * Hook to access the CrowClient from context
+ * Default Widget and Copilot Styles
+ *
+ * These are the default values used when no custom styles are provided.
+ * All values can be overridden via the Supabase database or SDK props.
  */
-declare function useCrowClient(): CrowClient;
+
+/**
+ * Default widget styles - matches the mature widget implementation
+ */
+declare const DEFAULT_WIDGET_STYLES: ResolvedWidgetStyles;
 /**
- * Hook to optionally access the CrowClient (returns null if not in provider)
+ * Default copilot styles
  */
-declare function useCrowClientOptional(): CrowClient | null;
+declare const DEFAULT_COPILOT_STYLES: ResolvedCopilotStyles;
 
 /**
- * useChat - React hook for chat functionality
+ * Style Merging Utilities
+ *
+ * Functions for deep merging style configurations with proper precedence:
+ * defaults < DB styles < SDK props
  */
 
+/**
+ * Merge widget styles with precedence: defaults < dbStyles < propStyles
+ *
+ * @param dbStyles - Styles fetched from the database (per product)
+ * @param propStyles - Styles passed via SDK props (developer overrides)
+ * @returns Fully resolved styles with all defaults applied
+ *
+ * @example
+ * ```tsx
+ * const styles = mergeWidgetStyles(
+ *   { colors: { primary: '#blue' } },  // from DB
+ *   { colors: { primary: '#red' } }    // from props - wins!
+ * );
+ * // styles.colors.primary === '#red'
+ * ```
+ */
+declare function mergeWidgetStyles(dbStyles?: WidgetStyleConfig, propStyles?: WidgetStyleConfig): ResolvedWidgetStyles;
+/**
+ * Merge copilot styles with precedence: defaults < dbStyles < propStyles
+ *
+ * @param dbStyles - Styles fetched from the database (per product)
+ * @param propStyles - Styles passed via SDK props (developer overrides)
+ * @returns Fully resolved styles with all defaults applied
+ */
+declare function mergeCopilotStyles(dbStyles?: CopilotStyleConfig, propStyles?: CopilotStyleConfig): ResolvedCopilotStyles;
+/**
+ * Convert styles to CSS custom properties for use with CSS variables
+ *
+ * @example
+ * ```tsx
+ * const cssVars = stylesToCSSVariables(styles);
+ * // { '--crow-primary': '#000', '--crow-bg': '#fff', ... }
+ * ```
+ */
+declare function stylesToCSSVariables(styles: ResolvedWidgetStyles | ResolvedCopilotStyles): Record<string, string | number>;
+
+/**
+ * Shared TypeScript interfaces for the widget and copilot
+ */
+interface Message {
+    id: string;
+    content: string;
+    isBot: boolean;
+    timestamp: Date;
+    citations?: Citation[];
+    thinking?: string;
+    thinkingComplete?: boolean;
+}
+interface Citation {
+    document_id: string;
+    filename: string;
+    similarity?: number;
+    image_url?: string;
+    page?: number;
+}
+interface Conversation {
+    id: string;
+    name: string | null;
+    created_at: string;
+    updated_at: string;
+}
+interface ToolCall {
+    id: string;
+    name: string;
+    arguments: Record<string, unknown>;
+    status: "executing" | "complete" | "error";
+    timestamp: Date;
+}
+interface WorkflowTodo {
+    id: string;
+    text: string;
+    status: "pending" | "completed";
+}
+interface ActiveWorkflow {
+    name: string;
+    todos: WorkflowTodo[];
+    isComplete?: boolean;
+}
+interface Model {
+    id: string;
+    name: string;
+    provider: "OpenAI" | "Anthropic";
+}
+interface WidgetProps {
+    productId: string;
+    apiUrl?: string;
+    agentName?: string;
+}
+interface JourneyEvent {
+    type: "run_started" | "step_started" | "step_completed" | "step_failed" | "needs_input" | "run_completed" | "error";
+    run_id?: string;
+    step_index?: number;
+    step_id?: string;
+    tool?: string;
+    description?: string;
+    output?: unknown;
+    error?: string;
+    missing_params?: Array<{
+        key: string;
+        description: string;
+    }>;
+}
+type ClientToolHandler = (args: Record<string, unknown>) => Promise<{
+    status: string;
+    data?: unknown;
+    error?: string;
+}> | {
+    status: string;
+    data?: unknown;
+    error?: string;
+};
+declare global {
+    interface Window {
+        crow: (command: string, options?: unknown) => void;
+        __crow_identity_token?: string;
+        __crow_public_metadata?: Record<string, unknown>;
+        __crow_journey_callback?: (event: JourneyEvent) => void;
+        __crow_client_tools?: Record<string, ClientToolHandler>;
+    }
+}
+
+interface WorkflowEvent {
+    type: "started" | "todo_updated" | "ended" | "complete_prompt";
+    name?: string;
+    todos?: Array<{
+        id: string;
+        text: string;
+        status: "pending" | "completed";
+    }>;
+    todoId?: string;
+    todoStatus?: "pending" | "completed";
+}
+interface ToolCallEvent {
+    type: "start" | "complete" | "client_call";
+    toolName: string;
+    arguments?: Record<string, unknown>;
+    success?: boolean;
+}
 interface UseChatOptions {
-    client: CrowClient;
-    onStreamEvent?: (event: StreamEvent) => void;
+    productId: string;
+    apiUrl?: string;
+    onVerificationStatus?: (isVerified: boolean) => void;
+    onConversationId?: (id: string) => void;
+    onWorkflowEvent?: (event: WorkflowEvent) => void;
+    onToolCall?: (toolCall: ToolCallEvent) => void;
+    onRestoredConversation?: (conversationId: string) => void;
 }
-interface UseChatReturn {
+declare function useChat({ productId, apiUrl, onVerificationStatus, onConversationId, onWorkflowEvent, onToolCall, onRestoredConversation, }: UseChatOptions): {
     messages: Message[];
     isLoading: boolean;
-    sendMessage: (content: string) => Promise<void>;
-    stop: () => void;
-    clearMessages: () => void;
+    activeToolCalls: ToolCall[];
+    conversationId: string | null;
+    selectedModel: string;
+    setSelectedModel: react.Dispatch<react.SetStateAction<string>>;
+    setConversationId: react.Dispatch<react.SetStateAction<string | null>>;
+    sendMessage: (content: string) => {
+        userMsgId: string;
+        botMsgId: string;
+    };
+    stopGeneration: () => void;
+    resetMessages: () => void;
+    loadMessages: (historyMessages: Message[]) => void;
+};
+
+/**
+ * useConversations - Manages conversation list and history
+ */
+
+interface UseConversationsOptions {
+    productId: string;
+    apiUrl?: string;
 }
+declare function useConversations({ productId, apiUrl }: UseConversationsOptions): {
+    conversations: Conversation[];
+    isLoadingHistory: boolean;
+    loadConversations: () => Promise<void>;
+    loadConversationHistory: (conversationId: string) => Promise<Message[]>;
+    loadAnonymousConversationHistory: (conversationId: string) => Promise<Message[]>;
+};
+
 /**
- * React hook that wraps CrowClient chat functionality
+ * useWorkflow - Manages workflow state and actions
  */
-declare function useChat({ client, onStreamEvent }: UseChatOptions): UseChatReturn;
 
+interface UseWorkflowOptions {
+    productId: string;
+    apiUrl?: string;
+    conversationId: string | null;
+    selectedModel: string;
+    onMessage?: (content: string) => void;
+}
+declare function useWorkflow({ productId, apiUrl, conversationId, selectedModel, onMessage, }: UseWorkflowOptions): {
+    activeWorkflow: ActiveWorkflow | null;
+    startWorkflow: (name: string, todos: ActiveWorkflow["todos"]) => void;
+    updateTodo: (todoId: string, status: "pending" | "completed") => void;
+    markComplete: () => void;
+    endWorkflow: (delay?: number) => void;
+    exitWorkflow: () => Promise<void>;
+};
+
+/**
+ * useCrowAPI - Sets up window.crow() API for identity and tools
+ */
+interface UseCrowAPIOptions {
+    onIdentified?: () => void;
+    onReset?: () => void;
+}
+declare function useCrowAPI({ onIdentified, onReset }?: UseCrowAPIOptions): {
+    executeClientTool: (toolName: string, args: Record<string, unknown>) => Promise<{
+        status: string;
+        data?: unknown;
+        error?: string;
+    }>;
+};
+
+/**
+ * useWidgetStyles Hook
+ *
+ * Fetches widget/copilot styles from the API and merges them with defaults and props.
+ * Handles caching to avoid redundant fetches.
+ */
+
+interface UseWidgetStylesOptions {
+    /** Product ID to fetch styles for */
+    productId: string;
+    /** API URL (defaults to relative path) */
+    apiUrl?: string;
+    /** Styles passed via props (override DB styles) */
+    propStyles?: WidgetStyleConfig;
+    /** Skip fetching from API (use for preview mode) */
+    skip?: boolean;
+    /** Cache key override (defaults to productId) */
+    cacheKey?: string;
+}
+interface UseWidgetStylesResult {
+    /** Fully resolved styles ready for use */
+    styles: ResolvedWidgetStyles;
+    /** Whether styles are currently loading */
+    isLoading: boolean;
+    /** Error if fetch failed */
+    error: Error | null;
+    /** Agent name from product config */
+    agentName: string;
+    /** Refetch styles from API */
+    refetch: () => Promise<void>;
+}
+interface UseCopilotStylesOptions {
+    /** Product ID to fetch styles for */
+    productId: string;
+    /** API URL (defaults to relative path) */
+    apiUrl?: string;
+    /** Styles passed via props (override DB styles) */
+    propStyles?: CopilotStyleConfig;
+    /** Skip fetching from API (use for preview mode) */
+    skip?: boolean;
+    /** Cache key override (defaults to productId) */
+    cacheKey?: string;
+}
+interface UseCopilotStylesResult {
+    /** Fully resolved styles ready for use */
+    styles: ResolvedCopilotStyles;
+    /** Whether styles are currently loading */
+    isLoading: boolean;
+    /** Error if fetch failed */
+    error: Error | null;
+    /** Agent name from product config */
+    agentName: string;
+    /** Refetch styles from API */
+    refetch: () => Promise<void>;
+}
+/**
+ * Hook to fetch and merge widget styles
+ *
+ * @example
+ * ```tsx
+ * const { styles, isLoading } = useWidgetStyles({
+ *   productId: 'my-product',
+ *   propStyles: { colors: { primary: '#blue' } },
+ * });
+ * ```
+ */
+declare function useWidgetStyles$1({ productId, apiUrl, propStyles, skip, cacheKey, }: UseWidgetStylesOptions): UseWidgetStylesResult;
 /**
- * useIdentity - React hook for identity management
+ * Hook to fetch and merge copilot styles
+ *
+ * @example
+ * ```tsx
+ * const { styles, isLoading } = useCopilotStyles({
+ *   productId: 'my-product',
+ *   propStyles: { position: { side: 'left' } },
+ * });
+ * ```
  */
+declare function useCopilotStyles$1({ productId, apiUrl, propStyles, skip, cacheKey, }: UseCopilotStylesOptions): UseCopilotStylesResult;
+/**
+ * Clear the style cache (useful for testing or forcing refetch)
+ */
+declare function clearStyleCache(productId?: string): void;
+/**
+ * Hook for preview mode - uses provided styles directly without fetching
+ *
+ * @example
+ * ```tsx
+ * // In dashboard style editor
+ * const { styles } = usePreviewStyles({
+ *   styles: localEditorState,
+ * });
+ * ```
+ */
+declare function usePreviewWidgetStyles(previewStyles: WidgetStyleConfig): {
+    styles: ResolvedWidgetStyles;
+};
+declare function usePreviewCopilotStyles(previewStyles: CopilotStyleConfig): {
+    styles: ResolvedCopilotStyles;
+};
 
-interface UseIdentityOptions {
-    client: CrowClient;
+interface WidgetStyleContextValue {
+    styles: ResolvedWidgetStyles;
+    agentName: string;
+    isLoading: boolean;
+    variant: 'floating' | 'embedded';
 }
-interface UseIdentityReturn {
-    isIdentified: boolean;
-    isVerified: boolean;
-    identify: (options: IdentifyOptions) => void;
-    resetUser: () => void;
+interface WidgetStyleProviderProps {
+    children: react__default.ReactNode;
+    styles: ResolvedWidgetStyles;
+    agentName?: string;
+    isLoading?: boolean;
+    variant?: 'floating' | 'embedded';
 }
 /**
- * React hook for managing user identity
+ * Provider for widget styles
+ */
+declare function WidgetStyleProvider({ children, styles, agentName, isLoading, variant, }: WidgetStyleProviderProps): react_jsx_runtime.JSX.Element;
+/**
+ * Hook to access widget styles from context
+ *
+ * @throws Error if used outside of WidgetStyleProvider
+ */
+declare function useWidgetStyleContext(): WidgetStyleContextValue;
+/**
+ * Hook to access widget styles, with fallback to defaults if not in context
+ *
+ * Use this in components that might be used both inside and outside the widget.
  */
-declare function useIdentity({ client }: UseIdentityOptions): UseIdentityReturn;
+declare function useWidgetStyles(): ResolvedWidgetStyles;
+interface CopilotStyleContextValue {
+    styles: ResolvedCopilotStyles;
+    agentName: string;
+    isLoading: boolean;
+}
+interface CopilotStyleProviderProps {
+    children: react__default.ReactNode;
+    styles: ResolvedCopilotStyles;
+    agentName?: string;
+    isLoading?: boolean;
+}
+/**
+ * Provider for copilot styles
+ */
+declare function CopilotStyleProvider({ children, styles, agentName, isLoading, }: CopilotStyleProviderProps): react_jsx_runtime.JSX.Element;
+/**
+ * Hook to access copilot styles from context
+ *
+ * @throws Error if used outside of CopilotStyleProvider
+ */
+declare function useCopilotStyleContext(): CopilotStyleContextValue;
+/**
+ * Hook to access copilot styles, with fallback to defaults if not in context
+ */
+declare function useCopilotStyles(): ResolvedCopilotStyles;
 
 /**
- * useConversations - React hook for conversation management
+ * Static configuration values
  */
 
-interface UseConversationsOptions {
-    client: CrowClient;
+declare const AVAILABLE_MODELS: Model[];
+declare const DEFAULT_MODEL = "claude-sonnet-4-5-20250929";
+declare const DEFAULT_WELCOME_MESSAGE = "Hi! How can I help you today?";
+declare const MESSAGES_CONTAINER_ID = "crow-messages-container";
+
+/**
+ * GlassCard - Glassmorphism card component
+ */
+interface GlassCardProps extends React.HTMLAttributes<HTMLDivElement> {
+    children: React.ReactNode;
 }
-interface UseConversationsReturn {
-    conversations: Conversation[];
-    isLoadingConversations: boolean;
-    isLoadingHistory: boolean;
-    currentConversationId: string | null;
-    loadConversations: () => Promise<void>;
-    loadHistory: (conversationId: string) => Promise<Message[]>;
-    switchConversation: (conversationId: string) => Promise<void>;
-    startNewConversation: () => void;
+declare const GlassCard: react.ForwardRefExoticComponent<GlassCardProps & react.RefAttributes<HTMLDivElement>>;
+
+/**
+ * StreamingText - Simple streaming text with blinking cursor
+ */
+interface StreamingTextProps {
+    content: string;
+    isStreaming?: boolean;
 }
+declare function StreamingText({ content, isStreaming, }: StreamingTextProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * ThinkingIndicator - Shimmer effect for thinking state
+ */
+declare function ThinkingIndicator(): react_jsx_runtime.JSX.Element;
+
 /**
- * React hook for managing conversations
+ * LoadingHistory - Loading animation for conversation history
  */
-declare function useConversations({ client, }: UseConversationsOptions): UseConversationsReturn;
+declare function LoadingHistory(): react_jsx_runtime.JSX.Element;
+
+interface ReasoningTraceProps {
+    thinking?: string;
+    isComplete?: boolean;
+    toolCalls?: ToolCall[];
+    isWaiting?: boolean;
+}
+declare function ReasoningTrace({ thinking, isComplete, toolCalls, isWaiting }: ReasoningTraceProps): react_jsx_runtime.JSX.Element | null;
 
 interface MessageBubbleProps {
     message: Message;
-    isStreaming?: boolean;
+    toolCalls?: ToolCall[];
+    isLoading?: boolean;
 }
-declare function MessageBubble({ message, isStreaming }: MessageBubbleProps): react_jsx_runtime.JSX.Element;
+declare function MessageBubble({ message, toolCalls, isLoading, }: MessageBubbleProps): react_jsx_runtime.JSX.Element;
 
 interface MessageListProps {
     messages: Message[];
-    isLoading?: boolean;
-    className?: string;
+    activeToolCalls: ToolCall[];
+    isLoadingHistory: boolean;
+    isGenerating?: boolean;
+}
+declare function MessageList({ messages, activeToolCalls, isLoadingHistory, isGenerating, }: MessageListProps): react_jsx_runtime.JSX.Element;
+
+interface MessagesContainerProps {
+    children: ReactNode;
+    maxHeight?: number;
+}
+declare const MessagesContainer: react.ForwardRefExoticComponent<MessagesContainerProps & react.RefAttributes<HTMLDivElement>>;
+
+interface ConversationListProps {
+    conversations: Conversation[];
+    currentConversationId: string | null;
+    onSelect: (id: string) => void;
+    onClose: () => void;
+}
+declare function ConversationList({ conversations, currentConversationId, onSelect, onClose, }: ConversationListProps): react_jsx_runtime.JSX.Element;
+
+interface WorkflowPanelProps {
+    workflow: ActiveWorkflow;
+    onExit: () => void;
+}
+declare function WorkflowPanel({ workflow, onExit }: WorkflowPanelProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * PoweredByBadge - Branding badge at bottom
+ */
+interface PoweredByBadgeProps {
+    apiUrl?: string;
 }
-declare function MessageList({ messages, isLoading, className }: MessageListProps): react_jsx_runtime.JSX.Element;
+declare function PoweredByBadge({ apiUrl }: PoweredByBadgeProps): react_jsx_runtime.JSX.Element | null;
 
 /**
- * PromptInput - Chat input component with send/stop button
+ * ModelSelector - Dropdown for selecting AI models
  */
-interface PromptInputProps {
-    onSend: (message: string) => void;
+
+interface ModelSelectorProps {
+    models: Model[];
+    selectedModel: string;
+    onModelChange: (modelId: string) => void;
+    disabled?: boolean;
+}
+declare const ModelSelector: react__default.FC<ModelSelectorProps>;
+
+/**
+ * PromptInputBox - Main input component for user messages
+ */
+
+interface PromptInputBoxProps {
+    onSend?: (message: string) => void;
     onStop?: () => void;
     isLoading?: boolean;
     placeholder?: string;
-    disabled?: boolean;
     className?: string;
+    selectedModel?: string;
+    onModelChange?: (model: string) => void;
+    availableModels?: Model[];
 }
-declare function PromptInput({ onSend, onStop, isLoading, placeholder, disabled, className, }: PromptInputProps): react_jsx_runtime.JSX.Element;
+declare const PromptInputBox: react__default.ForwardRefExoticComponent<PromptInputBoxProps & react__default.RefAttributes<HTMLDivElement>>;
 
 /**
- * ChatBubble - Floating action button to open/close widget
+ * ChatBubble - Floating button to toggle widget
  */
 interface ChatBubbleProps {
-    isOpen: boolean;
+    isExpanded: boolean;
     onClick: () => void;
+}
+declare function ChatBubble({ isExpanded, onClick }: ChatBubbleProps): react_jsx_runtime.JSX.Element;
+
+interface WidgetShellProps {
+    children: ReactNode;
     className?: string;
 }
-declare function ChatBubble({ isOpen, onClick, className }: ChatBubbleProps): react_jsx_runtime.JSX.Element;
+declare const WidgetShell: react.ForwardRefExoticComponent<WidgetShellProps & react.RefAttributes<HTMLDivElement>>;
 
 /**
- * WidgetHeader - Header bar for widget/copilot
+ * WidgetHeader - Header bar for widget
  */
 interface WidgetHeaderProps {
-    title?: string;
-    onNewChat?: () => void;
-    onClose?: () => void;
-    showNewChat?: boolean;
-    showClose?: boolean;
-    className?: string;
+    isVerifiedUser: boolean;
+    showConversationList: boolean;
+    onNewChat: () => void;
+    onToggleHistory: () => void;
+    showMinimize?: boolean;
+    isMinimized?: boolean;
+    onToggleMinimize?: () => void;
 }
-declare function WidgetHeader({ title, onNewChat, onClose, showNewChat, showClose, className, }: WidgetHeaderProps): react_jsx_runtime.JSX.Element;
+declare function WidgetHeader({ isVerifiedUser, showConversationList, onNewChat, onToggleHistory, showMinimize, isMinimized, onToggleMinimize, }: WidgetHeaderProps): react_jsx_runtime.JSX.Element;
 
-export { ChatBubble, CrowCopilot, type CrowCopilotProps, CrowProvider, type CrowProviderProps, CrowWidget, type CrowWidgetProps, MessageBubble, MessageList, PromptInput, WidgetHeader, useChat, useConversations, useCrowClient, useCrowClientOptional, useIdentity };
+export { AVAILABLE_MODELS, type ActiveWorkflow, type AnimationsConfig, ChatBubble, type Citation, type ClientToolHandler, type ColorsConfig, type Conversation, ConversationList, type CopilotBrandingConfig, type CopilotDimensionsConfig, type CopilotPositionConfig, type CopilotStyleConfig, CopilotStyleProvider, CrowCopilot, type CrowCopilotProps, CrowProvider, CrowWidget, type CrowWidgetProps, DEFAULT_COPILOT_STYLES, DEFAULT_MODEL, DEFAULT_WELCOME_MESSAGE, DEFAULT_WIDGET_STYLES, GlassCard, type JourneyEvent, LoadingHistory, MESSAGES_CONTAINER_ID, type Message, MessageBubble, MessageList, MessagesContainer, type Model, ModelSelector, PoweredByBadge, PromptInputBox, ReasoningTrace, type ResolvedCopilotStyles, type ResolvedWidgetStyles, StreamingText, ThinkingIndicator, type ToolCall, type TypographyConfig, type WidgetBrandingConfig, type WidgetBubbleConfig, type WidgetConfigResponse, type WidgetDimensionsConfig, WidgetHeader, type WidgetPositionConfig, type WidgetProps, type WidgetShadowsConfig, WidgetShell, type WidgetStyleConfig, WidgetStyleProvider, WorkflowPanel, type WorkflowTodo, clearStyleCache, mergeCopilotStyles, mergeWidgetStyles, stylesToCSSVariables, useChat, useConversations, useCopilotStyleContext, useCopilotStyles$1 as useCopilotStyles, useCopilotStyles as useCopilotStylesContext, useCrowAPI, usePreviewCopilotStyles, usePreviewWidgetStyles, useWidgetStyleContext, useWidgetStyles$1 as useWidgetStyles, useWidgetStyles as useWidgetStylesContext, useWorkflow };