@iota-uz/sdk 0.20.0 → 0.22.0

package/dist/chat-ui/components/QuestionStep.d.ts

@@ -0,0 +1,15 @@
+import { type JSX } from "solid-js";
+/**
+ * QuestionStep Component
+ * Displays a single question with options to select from
+ * Supports both single-select (radio) and multi-select (checkboxes)
+ * Includes automatic "Other" option for custom text input
+ */
+import { type Question, type QuestionAnswers, type QuestionAnswerData } from '../types';
+interface QuestionStepProps {
+    question: Question;
+    selectedAnswers: QuestionAnswers;
+    onAnswer: (answerData: QuestionAnswerData) => void;
+}
+export default function QuestionStep(solidProps1: QuestionStepProps): JSX.Element;
+export {};

package/dist/chat-ui/components/RetryActionArea.d.ts

@@ -0,0 +1,7 @@
+import { type JSX } from "solid-js";
+interface RetryActionAreaProps {
+    /** Callback when retry button is clicked */
+    onRetry: () => void;
+}
+export declare const RetryActionArea: (solidProps1: RetryActionAreaProps) => JSX.Element;
+export default RetryActionArea;

package/dist/chat-ui/components/ScreenReaderAnnouncer.d.ts

@@ -0,0 +1,22 @@
+import { type JSX } from "solid-js";
+interface ScreenReaderAnnouncerProps {
+    message: string;
+    politeness?: 'polite' | 'assertive';
+    clearAfter?: number;
+}
+/**
+ * Screen reader announcer component for live region updates
+ * Uses ARIA live regions to announce dynamic content changes
+ *
+ * @param message - The message to announce
+ * @param politeness - 'polite' (wait for pause) or 'assertive' (immediate)
+ * @param clearAfter - Optional milliseconds to clear message after announcement
+ *
+ * @example
+ * <ScreenReaderAnnouncer
+ *   message="New message received"
+ *   politeness="polite"
+ * />
+ */
+export default function ScreenReaderAnnouncer(solidProps1Input: ScreenReaderAnnouncerProps): JSX.Element;
+export {};

package/dist/chat-ui/components/ScrollToBottomButton.d.ts

@@ -0,0 +1,12 @@
+import { type JSX } from "solid-js";
+interface ScrollToBottomButtonProps {
+    show: boolean;
+    onClick: () => void;
+    unreadCount?: number;
+    disabled?: boolean;
+    /** When set, renders a pill-style button with this label (e.g. "New messages") */
+    label?: string;
+}
+declare function ScrollToBottomButton(solidProps1Input: ScrollToBottomButtonProps): JSX.Element;
+export { ScrollToBottomButton };
+export default ScrollToBottomButton;

package/dist/chat-ui/components/SearchInput.d.ts

@@ -0,0 +1,27 @@
+import { type JSX } from "solid-js";
+export interface SearchInputProps {
+    /** Current search value */
+    value: string;
+    /** Callback when value changes */
+    onChange: (value: string) => void;
+    /** Placeholder text */
+    placeholder?: string;
+    /** Auto-focus on mount */
+    autofocus?: boolean;
+    /** Callback when Enter is pressed */
+    onSubmit?: (value: string) => void;
+    /** Callback when Escape is pressed */
+    onEscape?: () => void;
+    /** Additional CSS classes for the container */
+    className?: string;
+    /** Size variant */
+    size?: 'sm' | 'md' | 'lg';
+    /** Disable the input */
+    disabled?: boolean;
+    /** ARIA label for accessibility */
+    ariaLabel?: string;
+}
+declare function SearchInput(solidProps1Input: SearchInputProps): JSX.Element;
+declare const MemoizedSearchInput: typeof SearchInput;
+export { MemoizedSearchInput as SearchInput };
+export default MemoizedSearchInput;

package/dist/chat-ui/components/SessionArtifactList.d.ts

@@ -0,0 +1,9 @@
+import { type JSX } from "solid-js";
+import type { SessionArtifact } from '../types';
+interface SessionArtifactListProps {
+    artifacts: SessionArtifact[];
+    selectedArtifactId?: string;
+    onSelect: (artifact: SessionArtifact) => void;
+}
+export declare function SessionArtifactList(solidProps2: SessionArtifactListProps): JSX.Element;
+export {};

package/dist/chat-ui/components/SessionArtifactPreview.d.ts

@@ -0,0 +1,7 @@
+import { type JSX } from "solid-js";
+import type { SessionArtifact } from '../types';
+interface SessionArtifactPreviewProps {
+    artifact: SessionArtifact;
+}
+export declare function SessionArtifactPreview(solidProps6: SessionArtifactPreviewProps): JSX.Element;
+export {};

package/dist/chat-ui/components/SessionArtifactPreviewModal.d.ts

@@ -0,0 +1,13 @@
+import { type JSX } from "solid-js";
+import type { SessionArtifact } from '../types';
+interface SessionArtifactPreviewModalProps {
+    isOpen: boolean;
+    artifact: SessionArtifact | null;
+    canRename?: boolean;
+    canDelete?: boolean;
+    onClose: () => void;
+    onRename?: (artifact: SessionArtifact, name: string) => Promise<void>;
+    onDelete?: (artifact: SessionArtifact) => Promise<void>;
+}
+export declare function SessionArtifactPreviewModal(solidProps1Input: SessionArtifactPreviewModalProps): JSX.Element;
+export {};

package/dist/chat-ui/components/SessionArtifactsPanel.d.ts

@@ -0,0 +1,13 @@
+import { type JSX } from "solid-js";
+import type { ChatDataSource } from '../types';
+interface SessionArtifactsPanelProps {
+    dataSource: ChatDataSource;
+    sessionId: string;
+    isStreaming: boolean;
+    allowDrop?: boolean;
+    className?: string;
+    /** When provided, used instead of useChatMessaging().artifactsInvalidationTrigger (allows use outside SDK ChatSessionProvider). */
+    artifactsInvalidationTrigger?: number;
+}
+export declare function SessionArtifactsPanel(solidProps1Input: SessionArtifactsPanelProps): JSX.Element;
+export {};

package/dist/chat-ui/components/SessionItem.d.ts

@@ -0,0 +1,18 @@
+import { type JSX } from "solid-js";
+import type { Session } from '../types';
+interface SessionItemProps {
+    session: Session;
+    isActive: boolean;
+    mode?: 'active' | 'archived';
+    onSelect: (sessionId: string) => void;
+    onArchive?: () => void;
+    onRestore?: () => void;
+    onPin?: () => void;
+    onRename?: (newTitle: string) => void;
+    onRegenerateTitle?: () => void;
+    onDelete?: () => void;
+    testIdPrefix?: string;
+    className?: string;
+}
+declare const SessionItem: (solidProps1Input: SessionItemProps) => JSX.Element;
+export default SessionItem;

package/dist/chat-ui/components/SessionMembersModal.d.ts

@@ -0,0 +1,10 @@
+import { type JSX } from "solid-js";
+import type { ChatDataSource } from '../types';
+export interface SessionMembersModalProps {
+    isOpen: boolean;
+    sessionId?: string;
+    dataSource: ChatDataSource;
+    onClose: () => void;
+}
+export declare function SessionMembersModal(solidProps2: SessionMembersModalProps): JSX.Element;
+export default SessionMembersModal;

package/dist/chat-ui/components/SessionSkeleton.d.ts

@@ -0,0 +1,6 @@
+import { type JSX } from "solid-js";
+interface SessionSkeletonProps {
+    count?: number;
+}
+export default function SessionSkeleton(solidProps1Input: SessionSkeletonProps): JSX.Element;
+export {};

package/dist/chat-ui/components/Sidebar.d.ts

@@ -0,0 +1,22 @@
+import { type JSX } from "solid-js";
+import type { ChatDataSource } from '../types';
+export type ActiveTab = 'my-chats' | 'all-chats';
+export interface SidebarProps {
+    dataSource: ChatDataSource;
+    onSessionSelect: (sessionId: string) => void;
+    onNewChat: () => void;
+    onArchivedView?: () => void;
+    activeSessionId?: string;
+    creating?: boolean;
+    showAllChatsTab?: boolean;
+    isOpen?: boolean;
+    onClose?: () => void;
+    headerSlot?: JSX.Element;
+    footerSlot?: JSX.Element;
+    className?: string;
+    /** Controlled active tab. When provided, overrides internal state. */
+    activeTab?: ActiveTab;
+    /** Called when tab changes. Use with activeTab for controlled mode. */
+    onTabChange?: (tab: ActiveTab) => void;
+}
+export default function Sidebar(solidProps2Input: SidebarProps): JSX.Element;

package/dist/chat-ui/components/Skeleton.d.ts

@@ -0,0 +1,63 @@
+import { type JSX } from "solid-js";
+/**
+ * Skeleton Component
+ * Reusable loading skeleton with multiple variants
+ */
+export interface SkeletonProps {
+    /** Skeleton variant */
+    variant?: 'text' | 'circular' | 'rectangular' | 'rounded';
+    /** Width (CSS value or number for pixels) */
+    width?: string | number;
+    /** Height (CSS value or number for pixels) */
+    height?: string | number;
+    /** Additional CSS classes */
+    className?: string;
+    /** Enable animation */
+    animate?: boolean;
+}
+export interface SkeletonGroupProps {
+    /** Number of skeleton items to render */
+    count?: number;
+    /** Gap between items */
+    gap?: 'sm' | 'md' | 'lg';
+    /** Additional CSS classes for the container */
+    className?: string;
+    /** Render function for each skeleton item */
+    children?: (index: number) => JSX.Element;
+}
+declare function Skeleton(solidProps1Input: SkeletonProps): JSX.Element;
+/**
+ * SkeletonGroup - Renders multiple skeleton items
+ */
+export declare function SkeletonGroup(solidProps2Input: SkeletonGroupProps): JSX.Element;
+/**
+ * SkeletonText - Text line skeleton with configurable width
+ */
+export declare function SkeletonText(solidProps3Input: {
+    lines?: number;
+    className?: string;
+}): JSX.Element;
+/**
+ * SkeletonAvatar - Circular avatar skeleton
+ */
+export declare function SkeletonAvatar(solidProps4Input: {
+    size?: number;
+    className?: string;
+}): JSX.Element;
+/**
+ * SkeletonCard - Card-shaped skeleton
+ */
+export declare function SkeletonCard(solidProps5Input: {
+    width?: string | number;
+    height?: string | number;
+    className?: string;
+}): JSX.Element;
+/**
+ * ListItemSkeleton - Common list item skeleton with icon and text
+ */
+export declare function ListItemSkeleton(solidProps6Input: {
+    className?: string;
+}): JSX.Element;
+declare const MemoizedSkeleton: typeof Skeleton;
+export { MemoizedSkeleton as Skeleton };
+export default MemoizedSkeleton;

package/dist/chat-ui/components/SkipLink.d.ts

@@ -0,0 +1,2 @@
+import { type JSX } from "solid-js";
+export default function SkipLink(): JSX.Element;

package/dist/chat-ui/components/SourcesPanel.d.ts

@@ -0,0 +1,7 @@
+import { type JSX } from "solid-js";
+import type { Citation } from '../types';
+interface SourcesPanelProps {
+    citations: Citation[];
+}
+export declare function SourcesPanel(solidProps1: SourcesPanelProps): JSX.Element;
+export {};

package/dist/chat-ui/components/StreamError.d.ts

@@ -0,0 +1,15 @@
+import { type JSX } from "solid-js";
+interface StreamErrorProps {
+    /** Error message to display */
+    error: string;
+    /** Callback to retry the failed operation */
+    onRetry?: () => void;
+    /** Callback to regenerate the message */
+    onRegenerate?: () => void;
+    /** Callback to dismiss the error */
+    onDismiss?: () => void;
+    /** Whether to show compact mode (less padding) */
+    compact?: boolean;
+}
+export declare function StreamError(solidProps1Input: StreamErrorProps): JSX.Element;
+export {};

package/dist/chat-ui/components/StreamingCursor.d.ts

@@ -0,0 +1,4 @@
+import { type JSX } from "solid-js";
+declare function StreamingCursor(): JSX.Element;
+export { StreamingCursor };
+export default StreamingCursor;

package/dist/chat-ui/components/SystemMessage.d.ts

@@ -0,0 +1,10 @@
+import { type JSX } from "solid-js";
+interface SystemMessageProps {
+    content: string;
+    createdAt: string;
+    onCopy?: (content: string) => Promise<void> | void;
+    hideActions?: boolean;
+    hideTimestamp?: boolean;
+}
+export declare function SystemMessage(solidProps1Input: SystemMessageProps): JSX.Element;
+export default SystemMessage;

package/dist/chat-ui/components/TabBar.d.ts

@@ -0,0 +1,15 @@
+import { type JSX } from "solid-js";
+interface TabBarProps {
+    tabs: Array<{
+        id: string;
+        label: string;
+    }>;
+    activeTab: string;
+    onTabChange: (tabId: string) => void;
+    /** Tighter padding for space-constrained contexts like fullscreen overlays. */
+    compact?: boolean;
+}
+declare function TabBar(solidProps1Input: TabBarProps): JSX.Element;
+declare const MemoizedTabBar: typeof TabBar;
+export { MemoizedTabBar as TabBar };
+export default MemoizedTabBar;

package/dist/chat-ui/components/TabbedChartGroup.d.ts

@@ -0,0 +1,6 @@
+import { type JSX } from "solid-js";
+import type { ChartData } from '../types';
+export interface TabbedChartGroupProps {
+    charts: ChartData[];
+}
+export declare const TabbedChartGroup: (solidProps1: TabbedChartGroupProps) => JSX.Element;

package/dist/chat-ui/components/TabbedTableGroup.d.ts

@@ -0,0 +1,8 @@
+import { type JSX } from "solid-js";
+import type { RenderTableData } from '../types';
+export interface TabbedTableGroupProps {
+    tables: RenderTableData[];
+    onSendMessage?: (content: string) => void;
+    sendDisabled?: boolean;
+}
+export declare const TabbedTableGroup: (solidProps1Input: TabbedTableGroupProps) => JSX.Element;

package/dist/chat-ui/components/TableExportButton.d.ts

@@ -0,0 +1,13 @@
+import { type JSX } from "solid-js";
+interface TableExportButtonProps {
+    /** Click handler for export action */
+    onClick: () => void;
+    /** Whether the button should be disabled */
+    disabled?: boolean;
+    /** Export button label (defaults to "Export") */
+    label?: string;
+    /** Disabled tooltip text */
+    disabledTooltip?: string;
+}
+export declare const TableExportButton: (solidProps1Input: TableExportButtonProps) => JSX.Element;
+export {};

package/dist/chat-ui/components/TableWithExport.d.ts

@@ -0,0 +1,15 @@
+import { type JSX } from "solid-js";
+interface TableWithExportProps {
+    /** The table content to render */
+    children: JSX.Element;
+    /** Function to send a message (from chat context) */
+    sendMessage?: (content: string) => void;
+    /** Whether sending is disabled (loading or streaming) */
+    disabled?: boolean;
+    /** Custom export message to send */
+    exportMessage?: string;
+    /** Export button label */
+    exportLabel?: string;
+}
+export declare const TableWithExport: (solidProps1Input: TableWithExportProps) => JSX.Element;
+export {};

package/dist/chat-ui/components/Toast.d.ts

@@ -0,0 +1,15 @@
+import { type JSX } from "solid-js";
+import type { ToastType, ToastAction } from '../hooks/useToast';
+export interface ToastProps {
+    id: string;
+    type: ToastType;
+    message: string;
+    duration?: number;
+    onDismiss: (id: string) => void;
+    /** Label for dismiss button (defaults to "Dismiss") */
+    dismissLabel?: string;
+    /** Optional action button rendered in the toast */
+    action?: ToastAction;
+}
+export declare function Toast(solidProps1Input: ToastProps): JSX.Element;
+export default Toast;

package/dist/chat-ui/components/ToastContainer.d.ts

@@ -0,0 +1,10 @@
+import { type JSX } from "solid-js";
+import type { ToastItem } from '../hooks/useToast';
+interface ToastContainerProps {
+    toasts: ToastItem[];
+    onDismiss: (id: string) => void;
+    /** Label for dismiss buttons */
+    dismissLabel?: string;
+}
+export declare function ToastContainer(solidProps1: ToastContainerProps): JSX.Element;
+export default ToastContainer;

package/dist/chat-ui/components/TouchContextMenu.d.ts

@@ -0,0 +1,18 @@
+type FC<P extends Record<string, any>> = import('solid-js').Component<P>;
+import { type JSX } from "solid-js";
+export interface ContextMenuItem {
+    id: string;
+    label: string;
+    icon?: JSX.Element;
+    onClick: () => void;
+    variant?: 'default' | 'danger';
+    disabled?: boolean;
+}
+interface TouchContextMenuProps {
+    items: ContextMenuItem[];
+    isOpen: boolean;
+    onClose: () => void;
+    anchorRect: DOMRect | null;
+}
+export declare const TouchContextMenu: FC<TouchContextMenuProps>;
+export {};

package/dist/chat-ui/components/Transition.d.ts

@@ -0,0 +1,11 @@
+import { type JSX } from 'solid-js';
+export declare function Transition(props: {
+    show: boolean;
+    children: JSX.Element;
+    enter?: string;
+    enterFrom?: string;
+    enterTo?: string;
+    leave?: string;
+    leaveFrom?: string;
+    leaveTo?: string;
+}): JSX.Element;

package/dist/chat-ui/components/TurnBubble.d.ts

@@ -0,0 +1,51 @@
+import { type JSX } from "solid-js";
+/**
+ * TurnBubble component (Layer 4 - Backward Compatible)
+ * Container for a conversation turn (user message + assistant response)
+ *
+ * Renders both the user's message and the assistant's response in a single
+ * visual grouping. If the assistant hasn't responded yet, only shows user message.
+ *
+ * For primitive-level control, use Turn from '@eai/chat-ui/primitives'
+ */
+import type { ConversationTurn } from '../types';
+import { type UserTurnViewProps } from './UserTurnView';
+import { type AssistantTurnViewProps } from './AssistantTurnView';
+import type { UserMessageSlots, UserMessageClassNames } from './UserMessage';
+import type { AssistantMessageSlots, AssistantMessageClassNames } from './AssistantMessage';
+export interface TurnBubbleClassNames {
+    /** Root container */
+    root?: string;
+    /** User turn wrapper */
+    userTurn?: string;
+    /** Assistant turn wrapper */
+    assistantTurn?: string;
+}
+export interface TurnBubbleProps {
+    /** The conversation turn containing user and optional assistant content */
+    turn: ConversationTurn;
+    /** When true, this turn is the last in the list (e.g. Regenerate shows only on last assistant message) */
+    isLastTurn?: boolean;
+    /** Custom render function for user turn (full control) */
+    renderUserTurn?: (turn: ConversationTurn) => JSX.Element;
+    /** Custom render function for assistant turn (full control) */
+    renderAssistantTurn?: (turn: ConversationTurn) => JSX.Element;
+    /** Props passed to UserTurnView (when not using custom renderer) */
+    userTurnProps?: Omit<UserTurnViewProps, 'turn'>;
+    /** Props passed to AssistantTurnView (when not using custom renderer) */
+    assistantTurnProps?: Omit<AssistantTurnViewProps, 'turn'>;
+    /** Slots for user message customization */
+    userMessageSlots?: UserMessageSlots;
+    /** Slots for assistant message customization */
+    assistantMessageSlots?: AssistantMessageSlots;
+    /** Class names for user message */
+    userMessageClassNames?: UserMessageClassNames;
+    /** Class names for assistant message */
+    assistantMessageClassNames?: AssistantMessageClassNames;
+    /** Class names for turn bubble container */
+    classNames?: TurnBubbleClassNames;
+    /** Whether assistant response is streaming */
+    isStreaming?: boolean;
+}
+export declare function TurnBubble(solidProps1Input: TurnBubbleProps): JSX.Element;
+export default TurnBubble;

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

@@ -0,0 +1,13 @@
+import { type JSX } from "solid-js";
+export interface TypingIndicatorProps {
+    /** Custom thinking verbs to rotate through */
+    verbs?: string[];
+    /** Verb rotation interval in ms (defaults to 3000) */
+    rotationInterval?: number;
+    /** Additional CSS classes */
+    className?: string;
+}
+declare function TypingIndicator(solidProps1Input: TypingIndicatorProps): JSX.Element;
+declare const MemoizedTypingIndicator: typeof TypingIndicator;
+export { MemoizedTypingIndicator as TypingIndicator };
+export default MemoizedTypingIndicator;

package/dist/chat-ui/components/UserAvatar.d.ts

@@ -0,0 +1,21 @@
+import { type JSX } from "solid-js";
+/**
+ * UserAvatar Component
+ * Displays user initials with deterministic color from a color palette
+ */
+export interface UserAvatarProps {
+    /** User's first name */
+    firstName: string;
+    /** User's last name */
+    lastName: string;
+    /** Override initials (defaults to first letters of first and last name) */
+    initials?: string;
+    /** Avatar size */
+    size?: 'xs' | 'sm' | 'md' | 'lg';
+    /** Additional CSS classes */
+    className?: string;
+}
+declare function UserAvatar(solidProps1Input: UserAvatarProps): JSX.Element;
+declare const MemoizedUserAvatar: typeof UserAvatar;
+export { MemoizedUserAvatar as UserAvatar };
+export default MemoizedUserAvatar;

package/dist/chat-ui/components/UserFilter.d.ts

@@ -0,0 +1,12 @@
+import { type JSX } from "solid-js";
+import type { SessionUser } from '../types';
+interface UserFilterProps {
+    users: SessionUser[];
+    selectedUser: SessionUser | null;
+    onUserChange: (user: SessionUser | null) => void;
+    loading?: boolean;
+}
+declare function UserFilter(solidProps1: UserFilterProps): JSX.Element;
+declare const MemoizedUserFilter: typeof UserFilter;
+export { MemoizedUserFilter as UserFilter };
+export default MemoizedUserFilter;

package/dist/chat-ui/components/UserMessage.d.ts

@@ -0,0 +1,86 @@
+import { type JSX } from "solid-js";
+import type { Attachment, UserTurn } from '../types';
+export interface UserMessageAvatarSlotProps {
+    /** Default initials */
+    initials: string;
+}
+export interface UserMessageContentSlotProps {
+    /** Message content text */
+    content: string;
+}
+export interface UserMessageAttachmentsSlotProps {
+    /** Message attachments */
+    attachments: Attachment[];
+    /** Handler to open image viewer */
+    onView: (index: number) => void;
+}
+export interface UserMessageActionsSlotProps {
+    /** Copy content to clipboard */
+    onCopy: () => void;
+    /** Edit message (if available) */
+    onEdit?: () => void;
+    /** Formatted timestamp */
+    timestamp: string;
+    /** Whether copy action is available */
+    canCopy: boolean;
+    /** Whether edit action is available */
+    canEdit: boolean;
+}
+export interface UserMessageSlots {
+    /** Custom avatar renderer */
+    avatar?: JSX.Element | ((props: UserMessageAvatarSlotProps) => JSX.Element);
+    /** Custom content renderer */
+    content?: JSX.Element | ((props: UserMessageContentSlotProps) => JSX.Element);
+    /** Custom attachments renderer */
+    attachments?: JSX.Element | ((props: UserMessageAttachmentsSlotProps) => JSX.Element);
+    /** Custom actions renderer */
+    actions?: JSX.Element | ((props: UserMessageActionsSlotProps) => JSX.Element);
+}
+export interface UserMessageClassNames {
+    /** Root container */
+    root?: string;
+    /** Inner content wrapper */
+    wrapper?: string;
+    /** Avatar container */
+    avatar?: string;
+    /** Message bubble */
+    bubble?: string;
+    /** Content text */
+    content?: string;
+    /** Attachments container */
+    attachments?: string;
+    /** Actions container */
+    actions?: string;
+    /** Action button */
+    actionButton?: string;
+    /** Timestamp */
+    timestamp?: string;
+}
+export interface UserMessageProps {
+    /** User turn data */
+    turn: UserTurn;
+    /** Turn ID for edit operations */
+    turnId?: string;
+    /** User initials for avatar */
+    initials?: string;
+    /** Optional sender name for shared/group chats */
+    authorName?: string;
+    /** Slot overrides */
+    slots?: UserMessageSlots;
+    /** Class name overrides */
+    classNames?: UserMessageClassNames;
+    /** Copy handler */
+    onCopy?: (content: string) => Promise<void> | void;
+    /** Edit handler */
+    onEdit?: (turnId: string, newContent: string) => void;
+    /** Hide avatar */
+    hideAvatar?: boolean;
+    /** Hide actions */
+    hideActions?: boolean;
+    /** Hide timestamp */
+    hideTimestamp?: boolean;
+    /** Whether edit action should be available */
+    allowEdit?: boolean;
+}
+export declare function UserMessage(solidProps2Input: UserMessageProps): JSX.Element;
+export default UserMessage;

package/dist/chat-ui/components/UserTurnView.d.ts

@@ -0,0 +1,25 @@
+import { type JSX } from "solid-js";
+import { type UserMessageSlots, type UserMessageClassNames } from './UserMessage';
+import type { ConversationTurn } from '../types';
+export interface UserTurnViewProps {
+    /** The conversation turn containing the user message */
+    turn: ConversationTurn;
+    /** Slot overrides for customization */
+    slots?: UserMessageSlots;
+    /** Class name overrides */
+    classNames?: UserMessageClassNames;
+    /** User initials for avatar */
+    initials?: string;
+    /** Hide avatar */
+    hideAvatar?: boolean;
+    /** Hide actions */
+    hideActions?: boolean;
+    /** Hide timestamp */
+    hideTimestamp?: boolean;
+    /** Whether edit action should be available */
+    allowEdit?: boolean;
+    /** Show sender identity label above the message bubble */
+    showAuthorName?: boolean;
+}
+export declare function UserTurnView(solidProps1Input: UserTurnViewProps): JSX.Element;
+export default UserTurnView;