@vitalityip.ai/shopping-widget 0.3.0

package/dist/components/ai-elements/speech-input.d.ts

@@ -0,0 +1,15 @@
+import { Button } from '../ui/button';
+import { ComponentProps } from 'react';
+
+export type SpeechInputProps = ComponentProps<typeof Button> & {
+    onTranscriptionChange?: (text: string) => void;
+    /**
+     * Callback for when audio is recorded using MediaRecorder fallback.
+     * This is called in browsers that don't support the Web Speech API (Firefox, Safari).
+     * The callback receives an audio Blob that should be sent to a transcription service.
+     * Return the transcribed text, which will be passed to onTranscriptionChange.
+     */
+    onAudioRecorded?: (audioBlob: Blob) => Promise<string>;
+    lang?: string;
+};
+export declare const SpeechInput: ({ className, onTranscriptionChange, onAudioRecorded, lang, ...props }: SpeechInputProps) => import("react/jsx-runtime").JSX.Element;

package/dist/components/ai-elements/stack-trace.d.ts

@@ -0,0 +1,38 @@
+import { Button } from '../ui/button';
+import { CollapsibleContent, CollapsibleTrigger } from '../ui/collapsible';
+import { ComponentProps } from 'react';
+
+export type StackTraceProps = ComponentProps<"div"> & {
+    trace: string;
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    onFilePathClick?: (filePath: string, line?: number, column?: number) => void;
+};
+export declare const StackTrace: import('react').MemoExoticComponent<({ trace, className, open, defaultOpen, onOpenChange, onFilePathClick, children, ...props }: StackTraceProps) => import("react/jsx-runtime").JSX.Element>;
+export type StackTraceHeaderProps = ComponentProps<typeof CollapsibleTrigger>;
+export declare const StackTraceHeader: import('react').MemoExoticComponent<({ className, children, ...props }: StackTraceHeaderProps) => import("react/jsx-runtime").JSX.Element>;
+export type StackTraceErrorProps = ComponentProps<"div">;
+export declare const StackTraceError: import('react').MemoExoticComponent<({ className, children, ...props }: StackTraceErrorProps) => import("react/jsx-runtime").JSX.Element>;
+export type StackTraceErrorTypeProps = ComponentProps<"span">;
+export declare const StackTraceErrorType: import('react').MemoExoticComponent<({ className, children, ...props }: StackTraceErrorTypeProps) => import("react/jsx-runtime").JSX.Element>;
+export type StackTraceErrorMessageProps = ComponentProps<"span">;
+export declare const StackTraceErrorMessage: import('react').MemoExoticComponent<({ className, children, ...props }: StackTraceErrorMessageProps) => import("react/jsx-runtime").JSX.Element>;
+export type StackTraceActionsProps = ComponentProps<"div">;
+export declare const StackTraceActions: import('react').MemoExoticComponent<({ className, children, ...props }: StackTraceActionsProps) => import("react/jsx-runtime").JSX.Element>;
+export type StackTraceCopyButtonProps = ComponentProps<typeof Button> & {
+    onCopy?: () => void;
+    onError?: (error: Error) => void;
+    timeout?: number;
+};
+export declare const StackTraceCopyButton: import('react').MemoExoticComponent<({ onCopy, onError, timeout, className, children, ...props }: StackTraceCopyButtonProps) => import("react/jsx-runtime").JSX.Element>;
+export type StackTraceExpandButtonProps = ComponentProps<"div">;
+export declare const StackTraceExpandButton: import('react').MemoExoticComponent<({ className, ...props }: StackTraceExpandButtonProps) => import("react/jsx-runtime").JSX.Element>;
+export type StackTraceContentProps = ComponentProps<typeof CollapsibleContent> & {
+    maxHeight?: number;
+};
+export declare const StackTraceContent: import('react').MemoExoticComponent<({ className, maxHeight, children, ...props }: StackTraceContentProps) => import("react/jsx-runtime").JSX.Element>;
+export type StackTraceFramesProps = ComponentProps<"div"> & {
+    showInternalFrames?: boolean;
+};
+export declare const StackTraceFrames: import('react').MemoExoticComponent<({ className, showInternalFrames, ...props }: StackTraceFramesProps) => import("react/jsx-runtime").JSX.Element>;

package/dist/components/ai-elements/suggestion.d.ts

@@ -0,0 +1,11 @@
+import { Button } from '../ui/button';
+import { ScrollArea } from '../ui/scroll-area';
+import { ComponentProps } from 'react';
+
+export type SuggestionsProps = ComponentProps<typeof ScrollArea>;
+export declare const Suggestions: ({ className, children, ...props }: SuggestionsProps) => import("react/jsx-runtime").JSX.Element;
+export type SuggestionProps = Omit<ComponentProps<typeof Button>, "onClick"> & {
+    suggestion: string;
+    onClick?: (suggestion: string) => void;
+};
+export declare const Suggestion: ({ suggestion, onClick, className, variant, size, children, ...props }: SuggestionProps) => import("react/jsx-runtime").JSX.Element;

package/dist/components/ai-elements/task.d.ts

@@ -0,0 +1,15 @@
+import { Collapsible, CollapsibleContent, CollapsibleTrigger } from '../ui/collapsible';
+import { ComponentProps } from 'react';
+
+export type TaskItemFileProps = ComponentProps<"div">;
+export declare const TaskItemFile: ({ children, className, ...props }: TaskItemFileProps) => import("react/jsx-runtime").JSX.Element;
+export type TaskItemProps = ComponentProps<"div">;
+export declare const TaskItem: ({ children, className, ...props }: TaskItemProps) => import("react/jsx-runtime").JSX.Element;
+export type TaskProps = ComponentProps<typeof Collapsible>;
+export declare const Task: ({ defaultOpen, className, ...props }: TaskProps) => import("react/jsx-runtime").JSX.Element;
+export type TaskTriggerProps = ComponentProps<typeof CollapsibleTrigger> & {
+    title: string;
+};
+export declare const TaskTrigger: ({ children, className, title, ...props }: TaskTriggerProps) => import("react/jsx-runtime").JSX.Element;
+export type TaskContentProps = ComponentProps<typeof CollapsibleContent>;
+export declare const TaskContent: ({ children, className, ...props }: TaskContentProps) => import("react/jsx-runtime").JSX.Element;

package/dist/components/ai-elements/terminal.d.ts

@@ -0,0 +1,28 @@
+import { Button } from '../ui/button';
+import { ComponentProps, HTMLAttributes } from 'react';
+
+export type TerminalProps = HTMLAttributes<HTMLDivElement> & {
+    output: string;
+    isStreaming?: boolean;
+    autoScroll?: boolean;
+    onClear?: () => void;
+};
+export declare const Terminal: ({ output, isStreaming, autoScroll, onClear, className, children, ...props }: TerminalProps) => import("react/jsx-runtime").JSX.Element;
+export type TerminalHeaderProps = HTMLAttributes<HTMLDivElement>;
+export declare const TerminalHeader: ({ className, children, ...props }: TerminalHeaderProps) => import("react/jsx-runtime").JSX.Element;
+export type TerminalTitleProps = HTMLAttributes<HTMLDivElement>;
+export declare const TerminalTitle: ({ className, children, ...props }: TerminalTitleProps) => import("react/jsx-runtime").JSX.Element;
+export type TerminalStatusProps = HTMLAttributes<HTMLDivElement>;
+export declare const TerminalStatus: ({ className, children, ...props }: TerminalStatusProps) => import("react/jsx-runtime").JSX.Element | null;
+export type TerminalActionsProps = HTMLAttributes<HTMLDivElement>;
+export declare const TerminalActions: ({ className, children, ...props }: TerminalActionsProps) => import("react/jsx-runtime").JSX.Element;
+export type TerminalCopyButtonProps = ComponentProps<typeof Button> & {
+    onCopy?: () => void;
+    onError?: (error: Error) => void;
+    timeout?: number;
+};
+export declare const TerminalCopyButton: ({ onCopy, onError, timeout, children, className, ...props }: TerminalCopyButtonProps) => import("react/jsx-runtime").JSX.Element;
+export type TerminalClearButtonProps = ComponentProps<typeof Button>;
+export declare const TerminalClearButton: ({ children, className, ...props }: TerminalClearButtonProps) => import("react/jsx-runtime").JSX.Element | null;
+export type TerminalContentProps = HTMLAttributes<HTMLDivElement>;
+export declare const TerminalContent: ({ className, children, ...props }: TerminalContentProps) => import("react/jsx-runtime").JSX.Element;

package/dist/components/ai-elements/test-results.d.ts

@@ -0,0 +1,59 @@
+import { Collapsible, CollapsibleContent, CollapsibleTrigger } from '../ui/collapsible';
+import { ComponentProps, HTMLAttributes } from 'react';
+
+type TestStatus = "passed" | "failed" | "skipped" | "running";
+interface TestResultsSummary {
+    passed: number;
+    failed: number;
+    skipped: number;
+    total: number;
+    duration?: number;
+}
+export type TestResultsProps = HTMLAttributes<HTMLDivElement> & {
+    summary?: TestResultsSummary;
+};
+export declare const TestResults: ({ summary, className, children, ...props }: TestResultsProps) => import("react/jsx-runtime").JSX.Element;
+export type TestResultsHeaderProps = HTMLAttributes<HTMLDivElement>;
+export declare const TestResultsHeader: ({ className, children, ...props }: TestResultsHeaderProps) => import("react/jsx-runtime").JSX.Element;
+export type TestResultsSummaryProps = HTMLAttributes<HTMLDivElement>;
+export declare const TestResultsSummary: ({ className, children, ...props }: TestResultsSummaryProps) => import("react/jsx-runtime").JSX.Element | null;
+export type TestResultsDurationProps = HTMLAttributes<HTMLSpanElement>;
+export declare const TestResultsDuration: ({ className, children, ...props }: TestResultsDurationProps) => import("react/jsx-runtime").JSX.Element | null;
+export type TestResultsProgressProps = HTMLAttributes<HTMLDivElement>;
+export declare const TestResultsProgress: ({ className, children, ...props }: TestResultsProgressProps) => import("react/jsx-runtime").JSX.Element | null;
+export type TestResultsContentProps = HTMLAttributes<HTMLDivElement>;
+export declare const TestResultsContent: ({ className, children, ...props }: TestResultsContentProps) => import("react/jsx-runtime").JSX.Element;
+export type TestSuiteProps = ComponentProps<typeof Collapsible> & {
+    name: string;
+    status: TestStatus;
+};
+export declare const TestSuite: ({ name, status, className, children, ...props }: TestSuiteProps) => import("react/jsx-runtime").JSX.Element;
+export type TestSuiteNameProps = ComponentProps<typeof CollapsibleTrigger>;
+export declare const TestSuiteName: ({ className, children, ...props }: TestSuiteNameProps) => import("react/jsx-runtime").JSX.Element;
+export type TestSuiteStatsProps = HTMLAttributes<HTMLDivElement> & {
+    passed?: number;
+    failed?: number;
+    skipped?: number;
+};
+export declare const TestSuiteStats: ({ passed, failed, skipped, className, children, ...props }: TestSuiteStatsProps) => import("react/jsx-runtime").JSX.Element;
+export type TestSuiteContentProps = ComponentProps<typeof CollapsibleContent>;
+export declare const TestSuiteContent: ({ className, children, ...props }: TestSuiteContentProps) => import("react/jsx-runtime").JSX.Element;
+export type TestProps = HTMLAttributes<HTMLDivElement> & {
+    name: string;
+    status: TestStatus;
+    duration?: number;
+};
+export declare const Test: ({ name, status, duration, className, children, ...props }: TestProps) => import("react/jsx-runtime").JSX.Element;
+export type TestStatusProps = HTMLAttributes<HTMLSpanElement>;
+export declare const TestStatus: ({ className, children, ...props }: TestStatusProps) => import("react/jsx-runtime").JSX.Element;
+export type TestNameProps = HTMLAttributes<HTMLSpanElement>;
+export declare const TestName: ({ className, children, ...props }: TestNameProps) => import("react/jsx-runtime").JSX.Element;
+export type TestDurationProps = HTMLAttributes<HTMLSpanElement>;
+export declare const TestDuration: ({ className, children, ...props }: TestDurationProps) => import("react/jsx-runtime").JSX.Element | null;
+export type TestErrorProps = HTMLAttributes<HTMLDivElement>;
+export declare const TestError: ({ className, children, ...props }: TestErrorProps) => import("react/jsx-runtime").JSX.Element;
+export type TestErrorMessageProps = HTMLAttributes<HTMLParagraphElement>;
+export declare const TestErrorMessage: ({ className, children, ...props }: TestErrorMessageProps) => import("react/jsx-runtime").JSX.Element;
+export type TestErrorStackProps = HTMLAttributes<HTMLPreElement>;
+export declare const TestErrorStack: ({ className, children, ...props }: TestErrorStackProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/ai-elements/tool.d.ts

@@ -0,0 +1,25 @@
+import { Collapsible, CollapsibleContent } from '../ui/collapsible';
+import { ToolUIPart } from 'ai';
+import { ComponentProps } from 'react';
+
+export type ToolProps = ComponentProps<typeof Collapsible>;
+export declare const Tool: ({ className, ...props }: ToolProps) => import("react/jsx-runtime").JSX.Element;
+export type ToolHeaderProps = {
+    title?: string;
+    type: ToolUIPart["type"];
+    state: ToolUIPart["state"];
+    className?: string;
+};
+export declare const getStatusBadge: (status: ToolUIPart["state"]) => import("react/jsx-runtime").JSX.Element;
+export declare const ToolHeader: ({ className, title, type, state, ...props }: ToolHeaderProps) => import("react/jsx-runtime").JSX.Element;
+export type ToolContentProps = ComponentProps<typeof CollapsibleContent>;
+export declare const ToolContent: ({ className, ...props }: ToolContentProps) => import("react/jsx-runtime").JSX.Element;
+export type ToolInputProps = ComponentProps<"div"> & {
+    input: ToolUIPart["input"];
+};
+export declare const ToolInput: ({ className, input, ...props }: ToolInputProps) => import("react/jsx-runtime").JSX.Element;
+export type ToolOutputProps = ComponentProps<"div"> & {
+    output: ToolUIPart["output"];
+    errorText: ToolUIPart["errorText"];
+};
+export declare const ToolOutput: ({ className, output, errorText, ...props }: ToolOutputProps) => import("react/jsx-runtime").JSX.Element | null;

package/dist/components/ai-elements/toolbar.d.ts

@@ -0,0 +1,6 @@
+import { NodeToolbar } from '@xyflow/react';
+import { ComponentProps } from 'react';
+
+type ToolbarProps = ComponentProps<typeof NodeToolbar>;
+export declare const Toolbar: ({ className, ...props }: ToolbarProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/ai-elements/transcription.d.ts

@@ -0,0 +1,17 @@
+import { Experimental_TranscriptionResult as TranscriptionResult } from 'ai';
+import { ComponentProps, ReactNode } from 'react';
+
+type TranscriptionSegment = TranscriptionResult["segments"][number];
+export type TranscriptionProps = Omit<ComponentProps<"div">, "children"> & {
+    segments: TranscriptionSegment[];
+    currentTime?: number;
+    onSeek?: (time: number) => void;
+    children: (segment: TranscriptionSegment, index: number) => ReactNode;
+};
+export declare const Transcription: ({ segments, currentTime: externalCurrentTime, onSeek, className, children, ...props }: TranscriptionProps) => import("react/jsx-runtime").JSX.Element;
+export type TranscriptionSegmentProps = ComponentProps<"button"> & {
+    segment: TranscriptionSegment;
+    index: number;
+};
+export declare const TranscriptionSegment: ({ segment, index, className, onClick, ...props }: TranscriptionSegmentProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/ai-elements/voice-selector.d.ts

@@ -0,0 +1,64 @@
+import { CommandDialog, CommandEmpty, CommandGroup, CommandInput, CommandItem, CommandList, CommandSeparator, CommandShortcut } from '../ui/command';
+import { Dialog, DialogContent, DialogTrigger } from '../ui/dialog';
+import { ComponentProps, ReactNode } from 'react';
+
+interface VoiceSelectorContextValue {
+    value: string | undefined;
+    setValue: (value: string | undefined) => void;
+    open: boolean;
+    setOpen: (open: boolean) => void;
+}
+export declare const useVoiceSelector: () => VoiceSelectorContextValue;
+export type VoiceSelectorProps = ComponentProps<typeof Dialog> & {
+    value?: string;
+    defaultValue?: string;
+    onValueChange?: (value: string | undefined) => void;
+};
+export declare const VoiceSelector: ({ value: valueProp, defaultValue, onValueChange, open: openProp, defaultOpen, onOpenChange, children, ...props }: VoiceSelectorProps) => import("react/jsx-runtime").JSX.Element;
+export type VoiceSelectorTriggerProps = ComponentProps<typeof DialogTrigger>;
+export declare const VoiceSelectorTrigger: (props: VoiceSelectorTriggerProps) => import("react/jsx-runtime").JSX.Element;
+export type VoiceSelectorContentProps = ComponentProps<typeof DialogContent> & {
+    title?: ReactNode;
+};
+export declare const VoiceSelectorContent: ({ className, children, title, ...props }: VoiceSelectorContentProps) => import("react/jsx-runtime").JSX.Element;
+export type VoiceSelectorDialogProps = ComponentProps<typeof CommandDialog>;
+export declare const VoiceSelectorDialog: (props: VoiceSelectorDialogProps) => import("react/jsx-runtime").JSX.Element;
+export type VoiceSelectorInputProps = ComponentProps<typeof CommandInput>;
+export declare const VoiceSelectorInput: ({ className, ...props }: VoiceSelectorInputProps) => import("react/jsx-runtime").JSX.Element;
+export type VoiceSelectorListProps = ComponentProps<typeof CommandList>;
+export declare const VoiceSelectorList: (props: VoiceSelectorListProps) => import("react/jsx-runtime").JSX.Element;
+export type VoiceSelectorEmptyProps = ComponentProps<typeof CommandEmpty>;
+export declare const VoiceSelectorEmpty: (props: VoiceSelectorEmptyProps) => import("react/jsx-runtime").JSX.Element;
+export type VoiceSelectorGroupProps = ComponentProps<typeof CommandGroup>;
+export declare const VoiceSelectorGroup: (props: VoiceSelectorGroupProps) => import("react/jsx-runtime").JSX.Element;
+export type VoiceSelectorItemProps = ComponentProps<typeof CommandItem>;
+export declare const VoiceSelectorItem: ({ className, ...props }: VoiceSelectorItemProps) => import("react/jsx-runtime").JSX.Element;
+export type VoiceSelectorShortcutProps = ComponentProps<typeof CommandShortcut>;
+export declare const VoiceSelectorShortcut: (props: VoiceSelectorShortcutProps) => import("react/jsx-runtime").JSX.Element;
+export type VoiceSelectorSeparatorProps = ComponentProps<typeof CommandSeparator>;
+export declare const VoiceSelectorSeparator: (props: VoiceSelectorSeparatorProps) => import("react/jsx-runtime").JSX.Element;
+export type VoiceSelectorGenderProps = ComponentProps<"span"> & {
+    value?: "male" | "female" | "transgender" | "androgyne" | "non-binary" | "intersex";
+};
+export declare const VoiceSelectorGender: ({ className, value, children, ...props }: VoiceSelectorGenderProps) => import("react/jsx-runtime").JSX.Element;
+export type VoiceSelectorAccentProps = ComponentProps<"span"> & {
+    value?: "american" | "british" | "australian" | "canadian" | "irish" | "scottish" | "indian" | "south-african" | "new-zealand" | "spanish" | "french" | "german" | "italian" | "portuguese" | "brazilian" | "mexican" | "argentinian" | "japanese" | "chinese" | "korean" | "russian" | "arabic" | "dutch" | "swedish" | "norwegian" | "danish" | "finnish" | "polish" | "turkish" | "greek" | string;
+};
+export declare const VoiceSelectorAccent: ({ className, value, children, ...props }: VoiceSelectorAccentProps) => import("react/jsx-runtime").JSX.Element;
+export type VoiceSelectorAgeProps = ComponentProps<"span">;
+export declare const VoiceSelectorAge: ({ className, ...props }: VoiceSelectorAgeProps) => import("react/jsx-runtime").JSX.Element;
+export type VoiceSelectorNameProps = ComponentProps<"span">;
+export declare const VoiceSelectorName: ({ className, ...props }: VoiceSelectorNameProps) => import("react/jsx-runtime").JSX.Element;
+export type VoiceSelectorDescriptionProps = ComponentProps<"span">;
+export declare const VoiceSelectorDescription: ({ className, ...props }: VoiceSelectorDescriptionProps) => import("react/jsx-runtime").JSX.Element;
+export type VoiceSelectorAttributesProps = ComponentProps<"div">;
+export declare const VoiceSelectorAttributes: ({ className, children, ...props }: VoiceSelectorAttributesProps) => import("react/jsx-runtime").JSX.Element;
+export type VoiceSelectorBulletProps = ComponentProps<"span">;
+export declare const VoiceSelectorBullet: ({ className, ...props }: VoiceSelectorBulletProps) => import("react/jsx-runtime").JSX.Element;
+export type VoiceSelectorPreviewProps = Omit<ComponentProps<"button">, "children"> & {
+    playing?: boolean;
+    loading?: boolean;
+    onPlay?: () => void;
+};
+export declare const VoiceSelectorPreview: ({ className, playing, loading, onPlay, onClick, ...props }: VoiceSelectorPreviewProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/ai-elements/web-preview.d.ts

@@ -0,0 +1,35 @@
+import { Button } from '../ui/button';
+import { Input } from '../ui/input';
+import { ComponentProps, ReactNode } from 'react';
+
+export type WebPreviewContextValue = {
+    url: string;
+    setUrl: (url: string) => void;
+    consoleOpen: boolean;
+    setConsoleOpen: (open: boolean) => void;
+};
+export type WebPreviewProps = ComponentProps<"div"> & {
+    defaultUrl?: string;
+    onUrlChange?: (url: string) => void;
+};
+export declare const WebPreview: ({ className, children, defaultUrl, onUrlChange, ...props }: WebPreviewProps) => import("react/jsx-runtime").JSX.Element;
+export type WebPreviewNavigationProps = ComponentProps<"div">;
+export declare const WebPreviewNavigation: ({ className, children, ...props }: WebPreviewNavigationProps) => import("react/jsx-runtime").JSX.Element;
+export type WebPreviewNavigationButtonProps = ComponentProps<typeof Button> & {
+    tooltip?: string;
+};
+export declare const WebPreviewNavigationButton: ({ onClick, disabled, tooltip, children, ...props }: WebPreviewNavigationButtonProps) => import("react/jsx-runtime").JSX.Element;
+export type WebPreviewUrlProps = ComponentProps<typeof Input>;
+export declare const WebPreviewUrl: ({ value, onChange, onKeyDown, ...props }: WebPreviewUrlProps) => import("react/jsx-runtime").JSX.Element;
+export type WebPreviewBodyProps = ComponentProps<"iframe"> & {
+    loading?: ReactNode;
+};
+export declare const WebPreviewBody: ({ className, loading, src, ...props }: WebPreviewBodyProps) => import("react/jsx-runtime").JSX.Element;
+export type WebPreviewConsoleProps = ComponentProps<"div"> & {
+    logs?: Array<{
+        level: "log" | "warn" | "error";
+        message: string;
+        timestamp: Date;
+    }>;
+};
+export declare const WebPreviewConsole: ({ className, logs, children, ...props }: WebPreviewConsoleProps) => import("react/jsx-runtime").JSX.Element;

package/dist/components/chat/ChatHeader.d.ts

@@ -0,0 +1,22 @@
+import { Persona } from '@vitalityip.ai/shopping-widget-core';
+export type { Persona } from '@vitalityip.ai/shopping-widget-core';
+export interface ChatHeaderProps {
+    /** Title shown in the header */
+    title: string;
+    /** Subtitle shown below the title */
+    subtitle?: string;
+    /** Avatar URL for the assistant */
+    avatarUrl?: string;
+    /** List of available personas */
+    personas?: Persona[];
+    /** Currently selected persona ID */
+    currentPersonaId?: string;
+    /** Callback when persona changes */
+    onPersonaChange?: (personaId: string) => void;
+    /** Callback to close the widget */
+    onClose?: () => void;
+}
+/**
+ * Header banner component for the chat window with avatar, title, subtitle, and close button
+ */
+export declare function ChatHeader({ title, subtitle, avatarUrl, personas, currentPersonaId, onClose, }: ChatHeaderProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/chat/ChatInput.d.ts

@@ -0,0 +1,32 @@
+import { ChangeEvent, FormEvent } from 'react';
+import { FileAttachment } from '@vitalityip.ai/shopping-widget-core';
+
+export interface ChatInputProps {
+    /** Current input value */
+    value: string;
+    /** Callback when input changes */
+    onChange: (e: ChangeEvent<HTMLInputElement | HTMLTextAreaElement>) => void;
+    /** Callback when form is submitted */
+    onSubmit: (e: FormEvent<HTMLFormElement>) => void;
+    /** Whether a message is being processed */
+    isLoading: boolean;
+    /** Placeholder text */
+    placeholder?: string;
+    /** Whether to show the powered by link */
+    showPoweredBy?: boolean;
+    /** Pending file attachments */
+    pendingFiles?: FileAttachment[];
+    /** Callback to upload a file */
+    onFileUpload?: (file: File) => Promise<FileAttachment | null>;
+    /** Callback to remove a pending file */
+    onFileRemove?: (fileId: string) => void;
+    /** Whether file upload is in progress */
+    isUploadingFile?: boolean;
+    /** Whether to enable file attachments */
+    enableFileAttachments?: boolean;
+}
+/**
+ * Chat input form with auto-resizing textarea and file attachment support
+ * Uses AI Elements Attachments component for file previews
+ */
+export declare function ChatInput({ value, onChange, onSubmit, isLoading, placeholder, showPoweredBy, pendingFiles, onFileUpload, onFileRemove, isUploadingFile, enableFileAttachments, }: ChatInputProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/chat/ChatMessages.d.ts

@@ -0,0 +1,18 @@
+import { Message, CatalogRenderers } from '@vitalityip.ai/shopping-widget-core';
+
+export interface ChatMessagesProps {
+    /** Array of messages to display */
+    messages: Message[];
+    /** Whether a response is being generated */
+    isLoading: boolean;
+    /** Catalog renderers for product/recipe cards */
+    catalogRenderers?: CatalogRenderers;
+    /** Callback to send a message (for suggestions) */
+    onSendMessage?: (text: string) => void;
+    /** Suggestions to show in empty state */
+    suggestions?: string[];
+}
+/**
+ * Message list component with auto-scroll and markdown rendering
+ */
+export declare function ChatMessages({ messages, isLoading, catalogRenderers, onSendMessage, suggestions, }: ChatMessagesProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/chat/ReasoningBox.d.ts

@@ -0,0 +1,10 @@
+export interface ReasoningBoxProps {
+    /** The reasoning text content */
+    reasoning: string;
+    /** Whether the model is still thinking */
+    isThinking: boolean;
+}
+/**
+ * Collapsible box showing the model's reasoning/thinking process
+ */
+export declare function ReasoningBox({ reasoning, isThinking }: ReasoningBoxProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/chat/TypingIndicator.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Animated typing indicator shown while assistant is generating a response
+ */
+export declare function TypingIndicator(): import("react/jsx-runtime").JSX.Element;

package/dist/components/chat/index.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Chat subcomponents
+ *
+ * These components are used internally by ChatWindow but can also
+ * be used directly for custom implementations.
+ */
+export { ChatHeader } from './ChatHeader';
+export type { ChatHeaderProps, Persona } from './ChatHeader';
+export { ChatInput } from './ChatInput';
+export type { ChatInputProps } from './ChatInput';
+export { ChatMessages } from './ChatMessages';
+export type { ChatMessagesProps } from './ChatMessages';
+export { ReasoningBox } from './ReasoningBox';
+export type { ReasoningBoxProps } from './ReasoningBox';
+export { TypingIndicator } from './TypingIndicator';

package/dist/components/ui/accordion.d.ts

@@ -0,0 +1,7 @@
+import { Accordion as AccordionPrimitive } from 'radix-ui';
+import * as React from "react";
+declare function Accordion({ ...props }: React.ComponentProps<typeof AccordionPrimitive.Root>): import("react/jsx-runtime").JSX.Element;
+declare function AccordionItem({ className, ...props }: React.ComponentProps<typeof AccordionPrimitive.Item>): import("react/jsx-runtime").JSX.Element;
+declare function AccordionTrigger({ className, children, ...props }: React.ComponentProps<typeof AccordionPrimitive.Trigger>): import("react/jsx-runtime").JSX.Element;
+declare function AccordionContent({ className, children, ...props }: React.ComponentProps<typeof AccordionPrimitive.Content>): import("react/jsx-runtime").JSX.Element;
+export { Accordion, AccordionItem, AccordionTrigger, AccordionContent };

package/dist/components/ui/alert.d.ts

@@ -0,0 +1,9 @@
+import { VariantProps } from 'class-variance-authority';
+import * as React from "react";
+declare const alertVariants: (props?: ({
+    variant?: "default" | "destructive" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+declare function Alert({ className, variant, ...props }: React.ComponentProps<"div"> & VariantProps<typeof alertVariants>): import("react/jsx-runtime").JSX.Element;
+declare function AlertTitle({ className, ...props }: React.ComponentProps<"div">): import("react/jsx-runtime").JSX.Element;
+declare function AlertDescription({ className, ...props }: React.ComponentProps<"div">): import("react/jsx-runtime").JSX.Element;
+export { Alert, AlertTitle, AlertDescription };

package/dist/components/ui/avatar.d.ts

@@ -0,0 +1,11 @@
+import { Avatar as AvatarPrimitive } from 'radix-ui';
+import * as React from "react";
+declare function Avatar({ className, size, ...props }: React.ComponentProps<typeof AvatarPrimitive.Root> & {
+    size?: "default" | "sm" | "lg";
+}): import("react/jsx-runtime").JSX.Element;
+declare function AvatarImage({ className, ...props }: React.ComponentProps<typeof AvatarPrimitive.Image>): import("react/jsx-runtime").JSX.Element;
+declare function AvatarFallback({ className, ...props }: React.ComponentProps<typeof AvatarPrimitive.Fallback>): import("react/jsx-runtime").JSX.Element;
+declare function AvatarBadge({ className, ...props }: React.ComponentProps<"span">): import("react/jsx-runtime").JSX.Element;
+declare function AvatarGroup({ className, ...props }: React.ComponentProps<"div">): import("react/jsx-runtime").JSX.Element;
+declare function AvatarGroupCount({ className, ...props }: React.ComponentProps<"div">): import("react/jsx-runtime").JSX.Element;
+export { Avatar, AvatarImage, AvatarFallback, AvatarBadge, AvatarGroup, AvatarGroupCount, };

package/dist/components/ui/badge.d.ts

@@ -0,0 +1,9 @@
+import { VariantProps } from 'class-variance-authority';
+import * as React from "react";
+declare const badgeVariants: (props?: ({
+    variant?: "default" | "destructive" | "outline" | "secondary" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+declare function Badge({ className, variant, asChild, ...props }: React.ComponentProps<"span"> & VariantProps<typeof badgeVariants> & {
+    asChild?: boolean;
+}): import("react/jsx-runtime").JSX.Element;
+export { Badge, badgeVariants };

package/dist/components/ui/button-group.d.ts

@@ -0,0 +1,12 @@
+import { VariantProps } from 'class-variance-authority';
+import { Separator } from './separator';
+
+declare const buttonGroupVariants: (props?: ({
+    orientation?: "horizontal" | "vertical" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+declare function ButtonGroup({ className, orientation, ...props }: React.ComponentProps<"div"> & VariantProps<typeof buttonGroupVariants>): import("react/jsx-runtime").JSX.Element;
+declare function ButtonGroupText({ className, asChild, ...props }: React.ComponentProps<"div"> & {
+    asChild?: boolean;
+}): import("react/jsx-runtime").JSX.Element;
+declare function ButtonGroupSeparator({ className, orientation, ...props }: React.ComponentProps<typeof Separator>): import("react/jsx-runtime").JSX.Element;
+export { ButtonGroup, ButtonGroupSeparator, ButtonGroupText, buttonGroupVariants, };

package/dist/components/ui/button.d.ts

@@ -0,0 +1,10 @@
+import { VariantProps } from 'class-variance-authority';
+import * as React from "react";
+declare const buttonVariants: (props?: ({
+    variant?: "default" | "link" | "destructive" | "outline" | "secondary" | "ghost" | null | undefined;
+    size?: "default" | "icon" | "sm" | "lg" | "icon-sm" | "icon-lg" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+declare function Button({ className, variant, size, asChild, ...props }: React.ComponentProps<"button"> & VariantProps<typeof buttonVariants> & {
+    asChild?: boolean;
+}): import("react/jsx-runtime").JSX.Element;
+export { Button, buttonVariants };

package/dist/components/ui/card.d.ts

@@ -0,0 +1,9 @@
+import * as React from "react";
+declare function Card({ className, ...props }: React.ComponentProps<"div">): import("react/jsx-runtime").JSX.Element;
+declare function CardHeader({ className, ...props }: React.ComponentProps<"div">): import("react/jsx-runtime").JSX.Element;
+declare function CardTitle({ className, ...props }: React.ComponentProps<"div">): import("react/jsx-runtime").JSX.Element;
+declare function CardDescription({ className, ...props }: React.ComponentProps<"div">): import("react/jsx-runtime").JSX.Element;
+declare function CardAction({ className, ...props }: React.ComponentProps<"div">): import("react/jsx-runtime").JSX.Element;
+declare function CardContent({ className, ...props }: React.ComponentProps<"div">): import("react/jsx-runtime").JSX.Element;
+declare function CardFooter({ className, ...props }: React.ComponentProps<"div">): import("react/jsx-runtime").JSX.Element;
+export { Card, CardHeader, CardFooter, CardTitle, CardAction, CardDescription, CardContent, };

package/dist/components/ui/carousel.d.ts

@@ -0,0 +1,19 @@
+import { default as useEmblaCarousel, UseEmblaCarouselType } from 'embla-carousel-react';
+import { Button } from './button';
+import * as React from "react";
+type CarouselApi = UseEmblaCarouselType[1];
+type UseCarouselParameters = Parameters<typeof useEmblaCarousel>;
+type CarouselOptions = UseCarouselParameters[0];
+type CarouselPlugin = UseCarouselParameters[1];
+type CarouselProps = {
+    opts?: CarouselOptions;
+    plugins?: CarouselPlugin;
+    orientation?: "horizontal" | "vertical";
+    setApi?: (api: CarouselApi) => void;
+};
+declare function Carousel({ orientation, opts, setApi, plugins, className, children, ...props }: React.ComponentProps<"div"> & CarouselProps): import("react/jsx-runtime").JSX.Element;
+declare function CarouselContent({ className, ...props }: React.ComponentProps<"div">): import("react/jsx-runtime").JSX.Element;
+declare function CarouselItem({ className, ...props }: React.ComponentProps<"div">): import("react/jsx-runtime").JSX.Element;
+declare function CarouselPrevious({ className, variant, size, ...props }: React.ComponentProps<typeof Button>): import("react/jsx-runtime").JSX.Element;
+declare function CarouselNext({ className, variant, size, ...props }: React.ComponentProps<typeof Button>): import("react/jsx-runtime").JSX.Element;
+export { type CarouselApi, Carousel, CarouselContent, CarouselItem, CarouselPrevious, CarouselNext, };

package/dist/components/ui/collapsible.d.ts

@@ -0,0 +1,5 @@
+import * as CollapsiblePrimitive from "@radix-ui/react-collapsible";
+declare function Collapsible({ ...props }: React.ComponentProps<typeof CollapsiblePrimitive.Root>): import("react/jsx-runtime").JSX.Element;
+declare function CollapsibleTrigger({ ...props }: React.ComponentProps<typeof CollapsiblePrimitive.CollapsibleTrigger>): import("react/jsx-runtime").JSX.Element;
+declare function CollapsibleContent({ ...props }: React.ComponentProps<typeof CollapsiblePrimitive.CollapsibleContent>): import("react/jsx-runtime").JSX.Element;
+export { Collapsible, CollapsibleTrigger, CollapsibleContent };

package/dist/components/ui/command.d.ts

@@ -0,0 +1,18 @@
+import { Command as CommandPrimitive } from 'cmdk';
+import { Dialog } from './dialog';
+import * as React from "react";
+declare function Command({ className, ...props }: React.ComponentProps<typeof CommandPrimitive>): import("react/jsx-runtime").JSX.Element;
+declare function CommandDialog({ title, description, children, className, showCloseButton, ...props }: React.ComponentProps<typeof Dialog> & {
+    title?: string;
+    description?: string;
+    className?: string;
+    showCloseButton?: boolean;
+}): import("react/jsx-runtime").JSX.Element;
+declare function CommandInput({ className, ...props }: React.ComponentProps<typeof CommandPrimitive.Input>): import("react/jsx-runtime").JSX.Element;
+declare function CommandList({ className, ...props }: React.ComponentProps<typeof CommandPrimitive.List>): import("react/jsx-runtime").JSX.Element;
+declare function CommandEmpty({ ...props }: React.ComponentProps<typeof CommandPrimitive.Empty>): import("react/jsx-runtime").JSX.Element;
+declare function CommandGroup({ className, ...props }: React.ComponentProps<typeof CommandPrimitive.Group>): import("react/jsx-runtime").JSX.Element;
+declare function CommandSeparator({ className, ...props }: React.ComponentProps<typeof CommandPrimitive.Separator>): import("react/jsx-runtime").JSX.Element;
+declare function CommandItem({ className, ...props }: React.ComponentProps<typeof CommandPrimitive.Item>): import("react/jsx-runtime").JSX.Element;
+declare function CommandShortcut({ className, ...props }: React.ComponentProps<"span">): import("react/jsx-runtime").JSX.Element;
+export { Command, CommandDialog, CommandInput, CommandList, CommandEmpty, CommandGroup, CommandItem, CommandShortcut, CommandSeparator, };

package/dist/components/ui/dialog.d.ts

@@ -0,0 +1,15 @@
+import * as React from "react";
+import * as DialogPrimitive from "@radix-ui/react-dialog";
+declare function Dialog({ ...props }: React.ComponentProps<typeof DialogPrimitive.Root>): import("react/jsx-runtime").JSX.Element;
+declare function DialogTrigger({ ...props }: React.ComponentProps<typeof DialogPrimitive.Trigger>): import("react/jsx-runtime").JSX.Element;
+declare function DialogPortal({ ...props }: React.ComponentProps<typeof DialogPrimitive.Portal>): import("react/jsx-runtime").JSX.Element;
+declare function DialogClose({ ...props }: React.ComponentProps<typeof DialogPrimitive.Close>): import("react/jsx-runtime").JSX.Element;
+declare function DialogOverlay({ className, ...props }: React.ComponentProps<typeof DialogPrimitive.Overlay>): import("react/jsx-runtime").JSX.Element;
+declare function DialogContent({ className, children, showCloseButton, ...props }: React.ComponentProps<typeof DialogPrimitive.Content> & {
+    showCloseButton?: boolean;
+}): import("react/jsx-runtime").JSX.Element;
+declare function DialogHeader({ className, ...props }: React.ComponentProps<"div">): import("react/jsx-runtime").JSX.Element;
+declare function DialogFooter({ className, ...props }: React.ComponentProps<"div">): import("react/jsx-runtime").JSX.Element;
+declare function DialogTitle({ className, ...props }: React.ComponentProps<typeof DialogPrimitive.Title>): import("react/jsx-runtime").JSX.Element;
+declare function DialogDescription({ className, ...props }: React.ComponentProps<typeof DialogPrimitive.Description>): import("react/jsx-runtime").JSX.Element;
+export { Dialog, DialogClose, DialogContent, DialogDescription, DialogFooter, DialogHeader, DialogOverlay, DialogPortal, DialogTitle, DialogTrigger, };