@yarvelle/ui 0.0.0-stage → 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,706 @@
+export { UiColorToken, UiRadiusToken, UiShadowToken, UiSpaceToken, UiTextSizeToken, UiZIndexToken } from './tokens/index.js';
+export { default as yarvellePreset } from './tokens/tailwind-preset.js';
+import * as React from 'react';
+import React__default from 'react';
+import { C as ChatMessage, a as ChatAttachment, b as ChatSlotHooks, R as RiskLevel, T as ToolCallTrace, E as ExecutionPlanStep, P as ProfileMember, S as ScopePermission, V as ViewerInviteData, c as ShareBundleData } from './index-DLbrj3Po.js';
+export { A as ApprovalRequest, M as MessageRole, d as MessageStatus, e as ProfileRole, f as createMockChatMessage, g as createMockProfile, h as createMockSlotContribution } from './index-DLbrj3Po.js';
+import { S as SlotContribution, a as SlotProps } from './types-CP_CDg6G.js';
+export { A as AudienceBand, F as FilterSlotsOptions, I as IconId, M as MessageId, P as PackUi, b as ScopeId, c as SlotId, d as definePackUi, f as filterSlotContributions, i as isScopeSatisfied, m as matchesScopePattern } from './types-CP_CDg6G.js';
+export { SlotRenderer, SlotRendererProps } from './slots/index.js';
+export { cn } from './lib/cn.js';
+export { getScopedItem, getStorageKey, removeScopedItem, setScopedItem } from './lib/storage-namespace.js';
+import 'tailwindcss';
+import 'clsx';
+
+type ButtonVariant = 'primary' | 'secondary' | 'ghost' | 'danger' | 'outline';
+type ButtonSize = 'sm' | 'md' | 'lg';
+interface ButtonProps extends React.ButtonHTMLAttributes<HTMLButtonElement> {
+    variant?: ButtonVariant;
+    size?: ButtonSize;
+    loading?: boolean;
+    leftIcon?: React.ReactNode;
+    rightIcon?: React.ReactNode;
+}
+declare const Button: React.ForwardRefExoticComponent<ButtonProps & React.RefAttributes<HTMLButtonElement>>;
+
+interface DialogProps {
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    children: React.ReactNode;
+}
+declare function Dialog({ open: controlledOpen, defaultOpen, onOpenChange, children, }: DialogProps): React.JSX.Element;
+interface DialogTriggerProps extends React.ButtonHTMLAttributes<HTMLButtonElement> {
+    asChild?: boolean;
+}
+declare const DialogTrigger: React.ForwardRefExoticComponent<DialogTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+interface DialogContentProps extends React.HTMLAttributes<HTMLDivElement> {
+    onCloseAutoFocus?: (event: Event) => void;
+}
+declare const DialogContent: React.ForwardRefExoticComponent<DialogContentProps & React.RefAttributes<HTMLDivElement>>;
+declare const DialogHeader: React.FC<React.HTMLAttributes<HTMLDivElement>>;
+declare const DialogFooter: React.FC<React.HTMLAttributes<HTMLDivElement>>;
+declare const DialogTitle: React.FC<React.HTMLAttributes<HTMLHeadingElement>>;
+declare const DialogDescription: React.FC<React.HTMLAttributes<HTMLParagraphElement>>;
+interface DialogCloseProps extends React.ButtonHTMLAttributes<HTMLButtonElement> {
+    asChild?: boolean;
+}
+declare const DialogClose: React.FC<DialogCloseProps>;
+
+type SheetSide = 'bottom' | 'start' | 'end';
+interface SheetProps {
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    side?: SheetSide;
+    children: React.ReactNode;
+}
+declare function Sheet({ open: controlledOpen, defaultOpen, onOpenChange, side, children, }: SheetProps): React.JSX.Element;
+interface SheetTriggerProps extends React.ButtonHTMLAttributes<HTMLButtonElement> {
+    asChild?: boolean;
+}
+declare const SheetTrigger: React.ForwardRefExoticComponent<SheetTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+interface SheetContentProps extends React.HTMLAttributes<HTMLDivElement> {
+    side?: SheetSide;
+}
+declare const SheetContent: React.ForwardRefExoticComponent<SheetContentProps & React.RefAttributes<HTMLDivElement>>;
+declare const SheetHeader: React.FC<React.HTMLAttributes<HTMLDivElement>>;
+declare const SheetFooter: React.FC<React.HTMLAttributes<HTMLDivElement>>;
+declare const SheetTitle: React.FC<React.HTMLAttributes<HTMLHeadingElement>>;
+declare const SheetDescription: React.FC<React.HTMLAttributes<HTMLParagraphElement>>;
+declare const SheetClose: React.FC<React.ButtonHTMLAttributes<HTMLButtonElement>>;
+
+interface CardProps extends React.HTMLAttributes<HTMLDivElement> {
+    variant?: 'default' | 'muted' | 'interactive';
+}
+declare const Card: React.ForwardRefExoticComponent<CardProps & React.RefAttributes<HTMLDivElement>>;
+declare const CardHeader: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+declare const CardTitle: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLHeadingElement> & React.RefAttributes<HTMLHeadingElement>>;
+declare const CardDescription: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLParagraphElement> & React.RefAttributes<HTMLParagraphElement>>;
+declare const CardContent: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+declare const CardFooter: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+
+type BadgeVariant = 'default' | 'primary' | 'neutral' | 'info' | 'warn' | 'danger' | 'success' | 'outline';
+interface BadgeProps extends React.HTMLAttributes<HTMLSpanElement> {
+    variant?: BadgeVariant;
+}
+declare const Badge: React.FC<BadgeProps>;
+
+type AvatarSize = 'sm' | 'md' | 'lg' | 'xl';
+type MemberColorSlot = '1' | '2' | '3' | '4' | '5';
+interface AvatarProps extends React.HTMLAttributes<HTMLDivElement> {
+    src?: string | null;
+    alt?: string;
+    name?: string;
+    size?: AvatarSize;
+    colorSlot?: MemberColorSlot;
+    children?: React.ReactNode;
+}
+declare const Avatar: React.FC<AvatarProps>;
+interface AvatarImageProps extends React.ImgHTMLAttributes<HTMLImageElement> {
+}
+declare const AvatarImage: React.FC<AvatarImageProps>;
+interface AvatarFallbackProps extends React.HTMLAttributes<HTMLSpanElement> {
+}
+declare const AvatarFallback: React.FC<AvatarFallbackProps>;
+
+type ChipScope = 'health' | 'finance' | 'education' | 'household' | 'default';
+interface ChipProps extends React.ButtonHTMLAttributes<HTMLButtonElement> {
+    selected?: boolean;
+    scope?: ChipScope;
+    onRemove?: () => void;
+    startIcon?: React.ReactNode;
+}
+declare const Chip: React.FC<ChipProps>;
+
+interface MenuProps {
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    children: React.ReactNode;
+}
+declare function Menu({ open: controlledOpen, defaultOpen, onOpenChange, children }: MenuProps): React.JSX.Element;
+interface MenuTriggerProps extends React.ButtonHTMLAttributes<HTMLButtonElement> {
+}
+declare const MenuTrigger: React.ForwardRefExoticComponent<MenuTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+interface MenuContentProps extends React.HTMLAttributes<HTMLDivElement> {
+    align?: 'start' | 'end' | 'center';
+}
+declare const MenuContent: React.ForwardRefExoticComponent<MenuContentProps & React.RefAttributes<HTMLDivElement>>;
+interface MenuItemProps extends React.ButtonHTMLAttributes<HTMLButtonElement> {
+    destructive?: boolean;
+}
+declare const MenuItem: React.ForwardRefExoticComponent<MenuItemProps & React.RefAttributes<HTMLButtonElement>>;
+declare const MenuSeparator: React.FC<React.HTMLAttributes<HTMLDivElement>>;
+
+interface PopoverProps {
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    children: React.ReactNode;
+}
+declare function Popover({ open: controlledOpen, defaultOpen, onOpenChange, children }: PopoverProps): React.JSX.Element;
+interface PopoverTriggerProps extends React.ButtonHTMLAttributes<HTMLButtonElement> {
+}
+declare const PopoverTrigger: React.ForwardRefExoticComponent<PopoverTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+interface PopoverContentProps extends React.HTMLAttributes<HTMLDivElement> {
+    align?: 'start' | 'end' | 'center';
+}
+declare const PopoverContent: React.ForwardRefExoticComponent<PopoverContentProps & React.RefAttributes<HTMLDivElement>>;
+
+interface TabsProps extends React.HTMLAttributes<HTMLDivElement> {
+    value?: string;
+    defaultValue?: string;
+    onValueChange?: (value: string) => void;
+}
+declare function Tabs({ value: controlledValue, defaultValue, onValueChange, children, className, ...props }: TabsProps): React.JSX.Element;
+interface TabsListProps extends React.HTMLAttributes<HTMLDivElement> {
+}
+declare const TabsList: React.ForwardRefExoticComponent<TabsListProps & React.RefAttributes<HTMLDivElement>>;
+interface TabsTriggerProps extends React.ButtonHTMLAttributes<HTMLButtonElement> {
+    value: string;
+}
+declare const TabsTrigger: React.ForwardRefExoticComponent<TabsTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+interface TabsContentProps extends React.HTMLAttributes<HTMLDivElement> {
+    value: string;
+}
+declare const TabsContent: React.ForwardRefExoticComponent<TabsContentProps & React.RefAttributes<HTMLDivElement>>;
+
+interface SegmentedOption {
+    value: string;
+    label: React.ReactNode;
+    icon?: React.ReactNode;
+    disabled?: boolean;
+}
+interface SegmentedControlProps {
+    options: SegmentedOption[];
+    value?: string;
+    defaultValue?: string;
+    onChange?: (value: string) => void;
+    className?: string;
+    size?: 'sm' | 'md';
+}
+declare function SegmentedControl({ options, value: controlledValue, defaultValue, onChange, className, size, }: SegmentedControlProps): React.JSX.Element;
+
+interface EmptyStateProps extends Omit<React.HTMLAttributes<HTMLDivElement>, 'title'> {
+    icon?: React.ReactNode;
+    title: React.ReactNode;
+    description?: React.ReactNode;
+    action?: React.ReactNode;
+}
+declare const EmptyState: React.ForwardRefExoticComponent<EmptyStateProps & React.RefAttributes<HTMLDivElement>>;
+
+interface SkeletonProps extends React.HTMLAttributes<HTMLDivElement> {
+}
+declare const Skeleton: React.ForwardRefExoticComponent<SkeletonProps & React.RefAttributes<HTMLDivElement>>;
+
+interface InlineErrorProps extends React.HTMLAttributes<HTMLDivElement> {
+    message?: React.ReactNode;
+    icon?: React.ReactNode;
+}
+declare const InlineError: React.ForwardRefExoticComponent<InlineErrorProps & React.RefAttributes<HTMLDivElement>>;
+
+interface ToastItem {
+    id: string;
+    title: React.ReactNode;
+    description?: React.ReactNode;
+    variant?: 'info' | 'success' | 'warn' | 'danger';
+    duration?: number;
+}
+interface ToastContextValue {
+    toasts: ToastItem[];
+    addToast: (toast: Omit<ToastItem, 'id'>) => string;
+    removeToast: (id: string) => void;
+}
+declare function useToast(): ToastContextValue;
+declare function ToastProvider({ children }: {
+    children: React.ReactNode;
+}): React.JSX.Element;
+interface ToasterProps {
+    className?: string;
+    position?: 'top-start' | 'top-end' | 'bottom-start' | 'bottom-end';
+}
+declare function Toaster({ className, position }: ToasterProps): React.JSX.Element;
+
+interface ChatContextValue {
+    messages: ChatMessage[];
+    onSendMessage: (content: string, attachments?: ChatAttachment[]) => Promise<void> | void;
+    loading: boolean;
+    activeAttachments: ChatAttachment[];
+    setActiveAttachments: React.Dispatch<React.SetStateAction<ChatAttachment[]>>;
+    slotHooks?: ChatSlotHooks;
+}
+declare function useChatContext(): ChatContextValue;
+interface ChatRootProps {
+    messages: ChatMessage[];
+    onSendMessage: (content: string, attachments?: ChatAttachment[]) => Promise<void> | void;
+    loading?: boolean;
+    slotHooks?: ChatSlotHooks;
+    children: React.ReactNode;
+    className?: string;
+}
+declare function ChatRoot({ messages, onSendMessage, loading, slotHooks, children, className, }: ChatRootProps): React.JSX.Element;
+interface ChatThreadProps {
+    className?: string;
+    emptyTitle?: string;
+    emptyDescription?: string;
+}
+declare function ChatThread({ className, emptyTitle, emptyDescription, }: ChatThreadProps): React.JSX.Element;
+interface ChatMessageProps {
+    message: ChatMessage;
+    className?: string;
+}
+declare function ChatMessageItem({ message, className }: ChatMessageProps): React.JSX.Element;
+declare function ChatAttachments({ className }: {
+    className?: string;
+}): React.JSX.Element | null;
+interface ChatComposerProps {
+    placeholder?: string;
+    className?: string;
+}
+declare function ChatComposer({ placeholder, className, }: ChatComposerProps): React.JSX.Element;
+declare const Chat: {
+    Root: typeof ChatRoot;
+    Thread: typeof ChatThread;
+    Message: typeof ChatMessageItem;
+    Composer: typeof ChatComposer;
+    Attachments: typeof ChatAttachments;
+};
+
+interface ChatConnectedProps {
+    threadId: string;
+    initialMessages?: ChatMessage[];
+    slotHooks?: ChatSlotHooks;
+    className?: string;
+    onMessageSent?: (msg: ChatMessage) => void;
+}
+declare function ChatConnected({ threadId, initialMessages, slotHooks, className, onMessageSent, }: ChatConnectedProps): React.JSX.Element;
+
+interface ApprovalCardProps {
+    id: string;
+    level: RiskLevel;
+    label: string;
+    details?: Record<string, unknown>;
+    onDecide?: (id: string, decision: 'approved' | 'rejected') => Promise<void> | void;
+    status?: 'pending' | 'approved' | 'rejected';
+    className?: string;
+}
+declare function ApprovalCard({ id, level, label, details, onDecide, status, className, }: ApprovalCardProps): React.JSX.Element;
+
+interface ToolTraceCardProps {
+    trace: ToolCallTrace;
+    className?: string;
+    defaultExpanded?: boolean;
+}
+declare function ToolTraceCard({ trace, className, defaultExpanded, }: ToolTraceCardProps): React.JSX.Element;
+
+interface ExecutionPlanCardProps {
+    steps: ExecutionPlanStep[];
+    className?: string;
+    title?: string;
+}
+declare function ExecutionPlanCard({ steps, className, title, }: ExecutionPlanCardProps): React.JSX.Element | null;
+
+interface ThinkingIndicatorProps {
+    label?: string;
+    reasoning?: string;
+    className?: string;
+}
+declare function ThinkingIndicator({ label, reasoning, className, }: ThinkingIndicatorProps): React.JSX.Element;
+
+interface CodeBlockProps {
+    code: string;
+    language?: string;
+    className?: string;
+}
+declare function CodeBlock({ code, language, className }: CodeBlockProps): React.JSX.Element;
+
+interface MermaidDiagramProps {
+    chart: string;
+    className?: string;
+}
+declare function MermaidDiagram({ chart, className }: MermaidDiagramProps): React.JSX.Element;
+
+interface ChatMarkdownProps {
+    content: string;
+    className?: string;
+}
+declare function ChatMarkdown({ content, className }: ChatMarkdownProps): React.JSX.Element;
+
+interface MessageToolbarProps {
+    content: string;
+    onRetry?: () => void;
+    onFeedback?: (rating: 'positive' | 'negative') => void;
+    className?: string;
+}
+declare function MessageToolbar({ content, onRetry, onFeedback, className, }: MessageToolbarProps): React.JSX.Element;
+
+interface ActivityLogDrawerProps {
+    traces: ToolCallTrace[];
+    open?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    trigger?: React.ReactNode;
+}
+declare function ActivityLogDrawer({ traces, open, onOpenChange, trigger, }: ActivityLogDrawerProps): React.JSX.Element;
+
+interface ModelOption {
+    id: string;
+    name: string;
+    description?: string;
+    provider?: string;
+}
+interface ModelSelectorProps {
+    models: ModelOption[];
+    selectedModelId?: string;
+    onSelectModel?: (modelId: string) => void;
+    className?: string;
+}
+declare function ModelSelector({ models, selectedModelId, onSelectModel, className, }: ModelSelectorProps): React.JSX.Element;
+
+interface NoteItem {
+    id: string;
+    title: string;
+    content: string;
+    createdAt: string;
+    updatedAt: string;
+    tags?: string[];
+    pinned?: boolean;
+    authorId?: string;
+}
+interface NoteFilterOption {
+    id: string;
+    label: string;
+    count?: number;
+}
+
+interface RecordSearchProps {
+    searchQuery: string;
+    onSearchChange: (query: string) => void;
+    selectedFilter: string;
+    onFilterChange: (filterId: string) => void;
+    filterOptions?: NoteFilterOption[];
+    placeholder?: string;
+    className?: string;
+}
+declare function RecordSearch({ searchQuery, onSearchChange, selectedFilter, onFilterChange, filterOptions, placeholder, className, }: RecordSearchProps): React.JSX.Element;
+
+interface NotesListProps {
+    notes: NoteItem[];
+    selectedNoteId?: string;
+    onSelectNote: (note: NoteItem) => void;
+    className?: string;
+    emptyTitle?: string;
+    emptyDescription?: string;
+}
+declare function NotesList({ notes, selectedNoteId, onSelectNote, className, emptyTitle, emptyDescription, }: NotesListProps): React.JSX.Element;
+
+interface NoteViewProps {
+    note: NoteItem;
+    onEdit?: (note: NoteItem) => void;
+    onDelete?: (noteId: string) => void;
+    onTogglePin?: (noteId: string) => void;
+    className?: string;
+}
+declare function NoteView({ note, onEdit, onDelete, onTogglePin, className, }: NoteViewProps): React.JSX.Element;
+
+type CalendarViewMode = 'month' | 'week' | 'agenda';
+interface CalendarEvent {
+    id: string;
+    title: string;
+    start: Date | string;
+    end: Date | string;
+    allDay?: boolean;
+    location?: string;
+    conflict?: boolean;
+    recurrenceRule?: string;
+    description?: string;
+}
+interface ReminderItem {
+    id: string;
+    title: string;
+    dueAt: string;
+    rrule?: string;
+    snoozedUntil?: string;
+    completed?: boolean;
+    category?: string;
+}
+interface RoutineItem {
+    id: string;
+    title: string;
+    frequency: 'daily' | 'weekdays' | 'weekends' | 'weekly';
+    timeOfDay: string;
+    durationMinutes?: number;
+    active: boolean;
+}
+interface TimelineEvent {
+    id: string;
+    title: string;
+    timestamp: string;
+    description?: string;
+    status?: 'info' | 'success' | 'warn' | 'danger';
+    icon?: string;
+}
+
+interface CalendarProps {
+    events: CalendarEvent[];
+    selectedDate?: Date;
+    onSelectDate?: (date: Date) => void;
+    onSelectEvent?: (event: CalendarEvent) => void;
+    viewMode?: CalendarViewMode;
+    onViewModeChange?: (view: CalendarViewMode) => void;
+    className?: string;
+}
+declare function Calendar({ events, selectedDate, onSelectDate, onSelectEvent, viewMode, onViewModeChange, className, }: CalendarProps): React.JSX.Element;
+
+interface ScheduleAgendaProps {
+    events: CalendarEvent[];
+    onSelectEvent?: (event: CalendarEvent) => void;
+    className?: string;
+}
+declare function ScheduleAgenda({ events, onSelectEvent, className, }: ScheduleAgendaProps): React.JSX.Element;
+
+interface RemindersProps {
+    reminders: ReminderItem[];
+    onComplete?: (id: string, completed: boolean) => void;
+    onSnooze?: (id: string, minutes: number) => void;
+    className?: string;
+}
+declare function Reminders({ reminders, onComplete, onSnooze, className, }: RemindersProps): React.JSX.Element;
+
+interface RoutinesProps {
+    routines: RoutineItem[];
+    onToggleActive?: (id: string, active: boolean) => void;
+    className?: string;
+}
+declare function Routines({ routines, onToggleActive, className, }: RoutinesProps): React.JSX.Element;
+
+interface ActivityTimelineProps {
+    events: TimelineEvent[];
+    className?: string;
+}
+declare function ActivityTimeline({ events, className }: ActivityTimelineProps): React.JSX.Element;
+
+interface ProfileSwitcherProps {
+    members: ProfileMember[];
+    activeMemberId: string;
+    onSelectMember: (memberId: string) => void;
+    className?: string;
+}
+declare function ProfileSwitcher({ members, activeMemberId, onSelectMember, className, }: ProfileSwitcherProps): React.JSX.Element;
+
+interface MemberCardProps {
+    member: ProfileMember;
+    onEdit?: (member: ProfileMember) => void;
+    className?: string;
+}
+declare function MemberCard({ member, onEdit, className }: MemberCardProps): React.JSX.Element;
+
+interface ProfileEditModalProps {
+    member?: ProfileMember | null;
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    onSave: (updated: ProfileMember) => void;
+}
+declare function ProfileEditModal({ member, open, onOpenChange, onSave, }: ProfileEditModalProps): React.JSX.Element;
+
+interface RoleMatrixProps {
+    permissions: ScopePermission[];
+    onChange?: (permissions: ScopePermission[]) => void;
+    readOnly?: boolean;
+    className?: string;
+}
+declare function RoleMatrix({ permissions, onChange, readOnly, className, }: RoleMatrixProps): React.JSX.Element;
+
+interface ViewerInviteProps {
+    availableScopes?: string[];
+    onSendInvite?: (data: ViewerInviteData) => Promise<void> | void;
+    className?: string;
+}
+declare function ViewerInvite({ availableScopes, onSendInvite, className, }: ViewerInviteProps): React.JSX.Element;
+
+interface ShareBundleProps {
+    availableScopes?: string[];
+    onCreateBundle?: (bundle: Omit<ShareBundleData, 'id'>) => Promise<string> | void;
+    className?: string;
+}
+declare function ShareBundle({ availableScopes, onCreateBundle, className, }: ShareBundleProps): React.JSX.Element;
+
+interface TeenHandoverBannerProps {
+    memberName: string;
+    handoverDate: string;
+    onInitiateHandover?: () => void;
+    onDismiss?: () => void;
+    className?: string;
+}
+declare function TeenHandoverBanner({ memberName, handoverDate, onInitiateHandover, onDismiss, className, }: TeenHandoverBannerProps): React.JSX.Element;
+
+type TaskPriority = 'low' | 'medium' | 'high';
+interface TaskItemData {
+    id: string;
+    title: string;
+    description?: string;
+    completed: boolean;
+    priority?: TaskPriority;
+    dueAt?: string;
+    tags?: string[];
+}
+
+interface TaskItemProps {
+    task: TaskItemData;
+    onToggleComplete?: (id: string, completed: boolean) => void;
+    onDelete?: (id: string) => void;
+    className?: string;
+}
+declare function TaskItem({ task, onToggleComplete, onDelete, className, }: TaskItemProps): React.JSX.Element;
+
+interface TaskListProps {
+    tasks: TaskItemData[];
+    onToggleComplete?: (id: string, completed: boolean) => void;
+    onAddTask?: (title: string) => void;
+    onDeleteTask?: (id: string) => void;
+    className?: string;
+    emptyTitle?: string;
+    emptyDescription?: string;
+}
+declare function TaskList({ tasks, onToggleComplete, onAddTask, onDeleteTask, className, emptyTitle, emptyDescription, }: TaskListProps): React.JSX.Element;
+
+type NotificationLevel = 'info' | 'warn' | 'danger' | 'success';
+interface NotificationMessage {
+    id: string;
+    title: string;
+    description?: string;
+    timestamp: string;
+    read: boolean;
+    level?: NotificationLevel;
+    actionUrl?: string;
+}
+
+interface NotificationCenterProps {
+    notifications: NotificationMessage[];
+    onMarkAllRead?: () => void;
+    onDismiss?: (id: string) => void;
+    onSelectNotification?: (notification: NotificationMessage) => void;
+    className?: string;
+}
+declare function NotificationCenter({ notifications, onMarkAllRead, onDismiss, onSelectNotification, className, }: NotificationCenterProps): React.JSX.Element;
+
+interface SettingsSection {
+    id: string;
+    title: string;
+    description?: string;
+    icon?: React.ReactNode;
+    order?: number;
+    component?: React.ComponentType;
+    slotContribution?: SlotContribution;
+}
+
+interface SettingsLayoutProps {
+    sections: SettingsSection[];
+    activeSectionId?: string;
+    onSelectSection?: (id: string) => void;
+    contributions?: SlotContribution[];
+    slotProps?: SlotProps;
+    children?: React.ReactNode;
+    className?: string;
+}
+declare function SettingsLayout({ sections, activeSectionId, onSelectSection, contributions, slotProps, children, className, }: SettingsLayoutProps): React.JSX.Element;
+
+interface SettingsSectionSlotRendererProps {
+    contributions: SlotContribution[];
+    slotProps: SlotProps;
+    className?: string;
+}
+declare function SettingsSectionSlotRenderer({ contributions, slotProps, className, }: SettingsSectionSlotRendererProps): React.JSX.Element;
+
+interface RailItem {
+    id: string;
+    label: string;
+    icon?: React.ReactNode;
+    route?: string;
+    badge?: number | string;
+    active?: boolean;
+    onClick?: () => void;
+    slotContribution?: SlotContribution;
+}
+
+interface AppRailProps {
+    items: RailItem[];
+    contributions?: SlotContribution[];
+    activeItemId?: string;
+    onSelectItem?: (item: RailItem) => void;
+    brand?: React.ReactNode;
+    footer?: React.ReactNode;
+    collapsed?: boolean;
+    className?: string;
+}
+declare function AppRail({ items, contributions, activeItemId, onSelectItem, brand, footer, collapsed, className, }: AppRailProps): React.JSX.Element;
+
+interface MobileTopBarProps {
+    title?: React.ReactNode;
+    startSlot?: React.ReactNode;
+    endSlot?: React.ReactNode;
+    leftSlot?: React.ReactNode;
+    rightSlot?: React.ReactNode;
+    className?: string;
+}
+declare function MobileTopBar({ title, startSlot, endSlot, leftSlot, rightSlot, className, }: MobileTopBarProps): React.JSX.Element;
+
+interface MobileTabBarProps {
+    items: RailItem[];
+    activeItemId?: string;
+    onSelectItem?: (item: RailItem) => void;
+    className?: string;
+}
+declare function MobileTabBar({ items, activeItemId, onSelectItem, className, }: MobileTabBarProps): React.JSX.Element;
+
+interface AppLayoutProps {
+    items: RailItem[];
+    contributions?: SlotContribution[];
+    activeItemId?: string;
+    onSelectItem?: (item: RailItem) => void;
+    brand?: React.ReactNode;
+    railFooter?: React.ReactNode;
+    mobileTopLeft?: React.ReactNode;
+    mobileTopRight?: React.ReactNode;
+    children: React.ReactNode;
+    className?: string;
+}
+declare function AppLayout({ items, contributions, activeItemId, onSelectItem, brand, railFooter, mobileTopLeft, mobileTopRight, children, className, }: AppLayoutProps): React.JSX.Element;
+
+type ThemeMode = 'light' | 'dark' | 'system';
+interface ProductConfig {
+    name: string;
+    logo?: React__default.ReactNode;
+}
+interface I18nContextValue {
+    locale: string;
+    t: (id: string, defaultText?: string) => string;
+}
+interface UiContextValue {
+    theme: ThemeMode;
+    resolvedTheme: 'light' | 'dark';
+    setTheme: (mode: ThemeMode) => void;
+    product: ProductConfig;
+    storageNamespace: string;
+    i18n: I18nContextValue;
+}
+interface UiProviderProps {
+    children: React__default.ReactNode;
+    defaultTheme?: ThemeMode;
+    product?: ProductConfig;
+    storageNamespace?: string;
+    locale?: string;
+    messages?: Record<string, string>;
+}
+declare const UiProvider: React__default.FC<UiProviderProps>;
+declare const useUi: () => UiContextValue;
+declare const useTheme: () => {
+    theme: ThemeMode;
+    resolvedTheme: "light" | "dark";
+    setTheme: (mode: ThemeMode) => void;
+};
+declare const useProduct: () => ProductConfig;
+declare const useStorageNamespace: () => string;
+declare const useI18n: () => I18nContextValue;
+
+export { ActivityLogDrawer, type ActivityLogDrawerProps, ActivityTimeline, type ActivityTimelineProps, AppLayout, type AppLayoutProps, AppRail, type AppRailProps, ApprovalCard, type ApprovalCardProps, Avatar, AvatarFallback, type AvatarFallbackProps, AvatarImage, type AvatarImageProps, type AvatarProps, type AvatarSize, Badge, type BadgeProps, type BadgeVariant, Button, type ButtonProps, type ButtonSize, type ButtonVariant, Calendar, type CalendarEvent, type CalendarProps, type CalendarViewMode, Card, CardContent, CardDescription, CardFooter, CardHeader, type CardProps, CardTitle, Chat, ChatAttachment, ChatAttachments, ChatComposer, type ChatComposerProps, ChatConnected, type ChatConnectedProps, ChatMarkdown, type ChatMarkdownProps, ChatMessage, ChatMessageItem, type ChatMessageProps, ChatRoot, type ChatRootProps, ChatSlotHooks, ChatThread, type ChatThreadProps, Chip, type ChipProps, type ChipScope, CodeBlock, type CodeBlockProps, Dialog, DialogClose, type DialogCloseProps, DialogContent, type DialogContentProps, DialogDescription, DialogFooter, DialogHeader, type DialogProps, DialogTitle, DialogTrigger, type DialogTriggerProps, EmptyState, type EmptyStateProps, ExecutionPlanCard, type ExecutionPlanCardProps, ExecutionPlanStep, type I18nContextValue, InlineError, type InlineErrorProps, MemberCard, type MemberCardProps, type MemberColorSlot, Menu, MenuContent, type MenuContentProps, MenuItem, type MenuItemProps, type MenuProps, MenuSeparator, MenuTrigger, type MenuTriggerProps, MermaidDiagram, type MermaidDiagramProps, MessageToolbar, type MessageToolbarProps, MobileTabBar, type MobileTabBarProps, MobileTopBar, type MobileTopBarProps, type ModelOption, ModelSelector, type ModelSelectorProps, type NoteFilterOption, type NoteItem, NoteView, type NoteViewProps, NotesList, type NotesListProps, NotificationCenter, type NotificationCenterProps, type NotificationLevel, type NotificationMessage, Popover, PopoverContent, type PopoverContentProps, type PopoverProps, PopoverTrigger, type PopoverTriggerProps, type ProductConfig, ProfileEditModal, type ProfileEditModalProps, ProfileMember, ProfileSwitcher, type ProfileSwitcherProps, type RailItem, RecordSearch, type RecordSearchProps, type ReminderItem, Reminders, type RemindersProps, RiskLevel, RoleMatrix, type RoleMatrixProps, type RoutineItem, Routines, type RoutinesProps, ScheduleAgenda, type ScheduleAgendaProps, ScopePermission, SegmentedControl, type SegmentedControlProps, type SegmentedOption, SettingsLayout, type SettingsLayoutProps, type SettingsSection, SettingsSectionSlotRenderer, type SettingsSectionSlotRendererProps, ShareBundle, ShareBundleData, type ShareBundleProps, Sheet, SheetClose, SheetContent, type SheetContentProps, SheetDescription, SheetFooter, SheetHeader, type SheetProps, type SheetSide, SheetTitle, SheetTrigger, type SheetTriggerProps, Skeleton, type SkeletonProps, SlotContribution, SlotProps, Tabs, TabsContent, type TabsContentProps, TabsList, type TabsListProps, type TabsProps, TabsTrigger, type TabsTriggerProps, TaskItem, type TaskItemData, type TaskItemProps, TaskList, type TaskListProps, type TaskPriority, TeenHandoverBanner, type TeenHandoverBannerProps, type ThemeMode, ThinkingIndicator, type ThinkingIndicatorProps, type TimelineEvent, type ToastItem, ToastProvider, Toaster, type ToasterProps, ToolCallTrace, ToolTraceCard, type ToolTraceCardProps, type UiContextValue, UiProvider, type UiProviderProps, ViewerInvite, ViewerInviteData, type ViewerInviteProps, useChatContext, useI18n, useProduct, useStorageNamespace, useTheme, useToast, useUi };