@moving-walls/design-system 2.0.0 → 2.0.2

package/dist/src/components/ui/Thumbnail.d.ts

@@ -0,0 +1,57 @@
+import React from 'react';
+type ThumbnailType = 'image' | 'video' | 'document' | 'audio' | 'file';
+interface ThumbnailProps {
+    src: string;
+    alt?: string;
+    type?: ThumbnailType;
+    title?: string;
+    subtitle?: string;
+    size?: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+    aspectRatio?: 'square' | 'video' | 'wide' | 'tall' | 'auto';
+    hover?: boolean;
+    clickable?: boolean;
+    selected?: boolean;
+    badge?: React.ReactNode;
+    overlay?: React.ReactNode;
+    actions?: Array<{
+        icon: React.ReactNode;
+        label: string;
+        onClick: () => void;
+    }>;
+    showPreview?: boolean;
+    className?: string;
+    onSelect?: () => void;
+    onClick?: () => void;
+    onPreview?: () => void;
+    onDownload?: () => void;
+    onLoad?: () => void;
+    onError?: () => void;
+    loading?: boolean;
+    error?: boolean;
+    placeholder?: React.ReactNode;
+}
+interface VideoThumbnailProps extends ThumbnailProps {
+    duration?: string;
+    autoPlay?: boolean;
+    muted?: boolean;
+}
+interface ImageThumbnailProps extends ThumbnailProps {
+    lazy?: boolean;
+    fallback?: string;
+}
+export declare function Thumbnail({ src, alt, type, title, subtitle, size, aspectRatio, hover, clickable, selected, badge, overlay, actions, showPreview, className, onSelect, onClick, onPreview, onDownload, onLoad, onError, loading, error, placeholder }: ThumbnailProps): import("react/jsx-runtime").JSX.Element;
+export declare function VideoThumbnail({ duration, autoPlay, muted, ...props }: VideoThumbnailProps): import("react/jsx-runtime").JSX.Element;
+export declare function ImageThumbnail({ lazy, fallback, ...props }: ImageThumbnailProps): import("react/jsx-runtime").JSX.Element;
+interface ThumbnailGalleryProps {
+    items: Array<ThumbnailProps & {
+        id: string;
+    }>;
+    columns?: number;
+    gap?: 'sm' | 'md' | 'lg';
+    selectable?: boolean;
+    selectedIds?: string[];
+    onSelectionChange?: (selectedIds: string[]) => void;
+    className?: string;
+}
+export declare function ThumbnailGallery({ items, columns, gap, selectable, selectedIds, onSelectionChange, className }: ThumbnailGalleryProps): import("react/jsx-runtime").JSX.Element;
+export default Thumbnail;

package/dist/src/components/ui/TimePicker.d.ts

@@ -0,0 +1,16 @@
+interface TimePickerProps {
+    value?: string;
+    onChange?: (time: string) => void;
+    format?: '12h' | '24h';
+    showSeconds?: boolean;
+    disabled?: boolean;
+    label?: string;
+    error?: string;
+    helpText?: string;
+    placeholder?: string;
+    className?: string;
+    size?: 'sm' | 'md' | 'lg';
+    step?: number;
+}
+export declare function TimePicker({ value, onChange, format, showSeconds, disabled, label, error, helpText, placeholder, className, size, step }: TimePickerProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/src/components/ui/TimeRangePicker.d.ts

@@ -0,0 +1,23 @@
+interface TimeRange {
+    from: string | null;
+    to: string | null;
+}
+interface TimeRangePickerProps {
+    value?: TimeRange;
+    onChange?: (range: TimeRange) => void;
+    placeholder?: string;
+    disabled?: boolean;
+    required?: boolean;
+    clearable?: boolean;
+    format?: '12' | '24';
+    minuteStep?: number;
+    minTime?: string;
+    maxTime?: string;
+    className?: string;
+    presets?: Array<{
+        label: string;
+        range: TimeRange;
+    }>;
+}
+export declare function TimeRangePicker({ value, onChange, placeholder, disabled, required, clearable, format, minuteStep, minTime, maxTime, className, presets }: TimeRangePickerProps): import("react/jsx-runtime").JSX.Element;
+export default TimeRangePicker;

package/dist/src/components/ui/Timeline.d.ts

@@ -0,0 +1,22 @@
+import React from 'react';
+interface TimelineItem {
+    title: string;
+    description?: string;
+    time?: string;
+    status?: 'completed' | 'current' | 'pending';
+    icon?: React.ReactNode;
+}
+interface TimelineProps {
+    items: TimelineItem[];
+    className?: string;
+}
+export declare function Timeline({ items, className }: TimelineProps): import("react/jsx-runtime").JSX.Element;
+interface TimelineItemProps {
+    children: React.ReactNode;
+    status?: 'completed' | 'current' | 'pending';
+    icon?: React.ReactNode;
+    time?: string;
+    isLast?: boolean;
+}
+export declare function TimelineItem({ children, status, icon, time, isLast }: TimelineItemProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/src/components/ui/Toast.d.ts

@@ -0,0 +1,21 @@
+export interface Toast {
+    id: string;
+    title?: string;
+    description?: string;
+    variant?: 'default' | 'success' | 'error' | 'warning' | 'info';
+    duration?: number;
+    action?: {
+        label: string;
+        onClick: () => void;
+    };
+}
+interface ToastContextType {
+    toasts: Toast[];
+    addToast: (toast: Omit<Toast, 'id'>) => void;
+    removeToast: (id: string) => void;
+}
+export declare function useToast(): ToastContextType;
+export declare function ToastProvider({ children }: {
+    children: React.ReactNode;
+}): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/src/components/ui/ToggleGroup.d.ts

@@ -0,0 +1,24 @@
+import React from 'react';
+export interface ToggleGroupProps {
+    type: 'single' | 'multiple';
+    value?: string | string[];
+    onValueChange?: (value: string | string[]) => void;
+    defaultValue?: string | string[];
+    disabled?: boolean;
+    size?: 'sm' | 'md' | 'lg';
+    variant?: 'default' | 'outline';
+    children: React.ReactNode;
+    className?: string;
+}
+export interface ToggleGroupItemProps extends React.HTMLAttributes<HTMLButtonElement> {
+    value: string;
+    disabled?: boolean;
+    children: React.ReactNode;
+}
+export declare function ToggleGroup({ type, value, onValueChange, defaultValue, disabled, size, variant, className, children, ...props }: ToggleGroupProps): import("react/jsx-runtime").JSX.Element;
+export declare function ToggleGroupItem({ value, disabled, className, children, onClick, ...props }: ToggleGroupItemProps): import("react/jsx-runtime").JSX.Element;
+export declare function useToggleGroup(type: 'single' | 'multiple'): {
+    value: string | string[];
+    setValue: React.Dispatch<React.SetStateAction<string | string[]>>;
+    onValueChange: React.Dispatch<React.SetStateAction<string | string[]>>;
+};

package/dist/src/components/ui/Tooltip.d.ts

@@ -0,0 +1,13 @@
+export interface TooltipProps {
+    content: React.ReactNode;
+    children: React.ReactNode;
+    position?: 'top' | 'bottom' | 'left' | 'right';
+    className?: string;
+}
+export interface TooltipProviderProps {
+    children: React.ReactNode;
+    delayDuration?: number;
+}
+export declare function TooltipProvider({ children, delayDuration }: TooltipProviderProps): import("react/jsx-runtime").JSX.Element;
+export declare function Tooltip({ content, children, position, className }: TooltipProps): import("react/jsx-runtime").JSX.Element;
+export default Tooltip;

package/dist/src/components/ui/TreeView.d.ts

@@ -0,0 +1,28 @@
+import React from 'react';
+interface TreeNode {
+    id: string;
+    label: string;
+    children?: TreeNode[];
+    icon?: React.ReactNode;
+    disabled?: boolean;
+    selectable?: boolean;
+    data?: any;
+}
+interface TreeViewProps {
+    data: TreeNode[];
+    selectedIds?: string[];
+    expandedIds?: string[];
+    onSelect?: (selectedIds: string[], node: TreeNode) => void;
+    onExpand?: (expandedIds: string[]) => void;
+    multiple?: boolean;
+    defaultExpanded?: string[];
+    defaultSelected?: string[];
+    showIcons?: boolean;
+    showLines?: boolean;
+    className?: string;
+}
+export declare function TreeView({ data, selectedIds: controlledSelectedIds, expandedIds: controlledExpandedIds, onSelect, onExpand, multiple, defaultExpanded, defaultSelected, showIcons, showLines, className }: TreeViewProps): import("react/jsx-runtime").JSX.Element;
+export declare function findTreeNode(data: TreeNode[], nodeId: string): TreeNode | null;
+export declare function getAllNodeIds(data: TreeNode[]): string[];
+export declare function getParentIds(data: TreeNode[], targetId: string): string[];
+export {};

package/dist/src/components/ui/Typography.d.ts

@@ -0,0 +1,43 @@
+import React from 'react';
+export interface DisplayProps extends React.HTMLAttributes<HTMLHeadingElement> {
+    size?: 'large' | 'medium' | 'small';
+    children: React.ReactNode;
+    className?: string;
+}
+export declare function Display({ size, children, className, ...props }: DisplayProps): import("react/jsx-runtime").JSX.Element;
+export interface HeadingProps extends React.HTMLAttributes<HTMLHeadingElement> {
+    level?: 1 | 2 | 3 | 4 | 5 | 6;
+    weight?: 'normal' | 'medium' | 'semibold' | 'bold';
+    children: React.ReactNode;
+    className?: string;
+}
+export declare function Heading({ level, weight, children, className, ...props }: HeadingProps): import("react/jsx-runtime").JSX.Element;
+type TextBaseProps = {
+    size?: '2xs' | 'xs' | 'sm' | 'base' | 'lg' | 'xl' | '2xl' | '3xl' | '4xl';
+    variant?: 'primary' | 'secondary' | 'muted' | 'error' | 'success' | 'info' | 'warning';
+    weight?: 'normal' | 'medium' | 'semibold' | 'bold';
+    children: React.ReactNode;
+    className?: string;
+};
+type TextAsParagraph = TextBaseProps & {
+    as?: 'p';
+} & Omit<React.HTMLAttributes<HTMLParagraphElement>, keyof TextBaseProps>;
+type TextAsSpan = TextBaseProps & {
+    as: 'span';
+} & Omit<React.HTMLAttributes<HTMLSpanElement>, keyof TextBaseProps>;
+type TextAsDiv = TextBaseProps & {
+    as: 'div';
+} & Omit<React.HTMLAttributes<HTMLDivElement>, keyof TextBaseProps>;
+type TextAsLabel = TextBaseProps & {
+    as: 'label';
+} & Omit<React.LabelHTMLAttributes<HTMLLabelElement>, keyof TextBaseProps>;
+export type TextProps = TextAsParagraph | TextAsSpan | TextAsDiv | TextAsLabel;
+export declare function Text({ size, variant, weight, children, className, as, ...props }: TextProps): import("react/jsx-runtime").JSX.Element;
+export interface LabelProps extends React.LabelHTMLAttributes<HTMLLabelElement> {
+    required?: boolean;
+    disabled?: boolean;
+    children: React.ReactNode;
+    className?: string;
+}
+export declare function Label({ required, disabled, children, className, ...props }: LabelProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/src/components/ui/index.d.ts

@@ -0,0 +1,96 @@
+export { Icon, ChevronDownIcon, ChevronUpIcon, ChevronLeftIcon, ChevronRightIcon, SearchIcon, CloseIcon, CheckIcon, PlusIcon, MinusIcon, InfoIcon, AlertTriangleIcon, AlertCircleIcon } from './Icon';
+export { Button } from './Button';
+export { Input } from './Input';
+export { Textarea } from './Textarea';
+export { Checkbox, Radio } from './Checkbox';
+export { Switch, SwitchGroup } from './Switch';
+export { Select, SimpleSelect, SelectRoot, SelectTrigger, SelectValue, SelectContent, SelectItem, SelectGroup, SelectLabel, SelectSeparator, SelectScrollUpButton, SelectScrollDownButton } from './Select';
+export { Slider } from './Slider';
+export { DatePicker } from './DatePicker';
+export { DateRangePicker } from './DateRangePicker';
+export { TimePicker } from './TimePicker';
+export { TimeRangePicker } from './TimeRangePicker';
+export { Rating } from './Rating';
+export { ToggleGroup, ToggleGroupItem } from './ToggleGroup';
+export { Form, FormSection, FormGroup, FormField, FormItem, FormLabel, FormControl, FormDescription, FormError, FormMessage, FormActions, Fieldset, useFormContext } from './Form';
+export { FileUpload } from './FileUpload';
+export { SearchBar, SearchResults } from './SearchBar';
+export { Autocomplete } from './Autocomplete';
+export { MultiSelect } from './MultiSelect';
+export type { MultiSelectOption, MultiSelectProps } from './MultiSelect';
+export { ScheduleGrid } from './ScheduleGrid';
+export type { ScheduleRule, ScheduleGridProps } from './ScheduleGrid';
+export { Filter } from './Filter';
+export type { FilterRule, FilterField, FilterOperator, FilterType } from './Filter';
+export { RichTextEditor } from './RichTextEditor';
+export { DocumentEditor } from './DocumentEditor';
+export { MetricCard } from './MetricCard';
+export type { MetricCardProps, MetricCardChange } from './MetricCard';
+export { ProgressBar } from './ProgressBar';
+export type { ProgressBarProps } from './ProgressBar';
+export { Card, CardHeader, CardContent, CardFooter, CardTitle, CardDescription } from './Card';
+export { Badge } from './Badge';
+export { Alert } from './Alert';
+export { Avatar, AvatarGroup, AvatarImage, AvatarFallback } from './Avatar';
+export { Progress } from './Progress';
+export { Skeleton } from './Skeleton';
+export { Separator } from './Separator';
+export { Table, TableHeader, TableBody, TableRow, TableHead, TableCell } from './Table';
+export { AdvancedTable } from './AdvancedTable';
+export type { AdvancedTableColumn, AdvancedTableSort, AdvancedTableFilter, AdvancedTableSelection, AdvancedTablePagination, AdvancedTableRowAction, AdvancedTableBulkAction, AdvancedTableToolbarAction, AdvancedTableState } from './AdvancedTable';
+export { EmptyState, NoDataEmptyState, NoResultsEmptyState } from './EmptyState';
+export { Chip, Tag } from './Chip';
+export { CollapsibleCode } from './CollapsibleCode';
+export { List, ListItem, DescriptionList, NavigationList } from './List';
+export { Carousel, CarouselSlide, ImageCarousel } from './Carousel';
+export { Container, ResponsiveContainer, GridContainer, FlexContainer, Stack, HStack } from './Container';
+export { Tabs, TabsList, TabsTrigger, TabsContent } from './Tabs';
+export { Accordion, AccordionItem, AccordionTrigger, AccordionContent } from './Accordion';
+export { Collapsible, CollapsibleTrigger, CollapsibleContent } from './Collapsible';
+export { ScrollArea } from './ScrollArea';
+export { Stepper } from './Stepper';
+export { Timeline, TimelineItem } from './Timeline';
+export { Sidebar, SidebarProvider, SidebarHeader, SidebarContent, SidebarFooter, SidebarNav, SidebarGroup, SidebarItem, SidebarCollapseToggle, SidebarTrigger, useSidebar, useSidebarSafe } from './Sidebar';
+export type { SidebarProps, SidebarProviderProps, SidebarHeaderProps, SidebarContentProps, SidebarFooterProps, SidebarNavProps, SidebarGroupProps, SidebarItemProps, SidebarCollapseToggleProps, SidebarTriggerProps } from './Sidebar';
+export { Spinner, Loading } from './Spinner';
+export { MWLoader, MWDotsLoader, MWProgressiveLoader, MWHeartbeatLoader, MWMatrixLoader, MWBounceLoader, MWBrandLoader } from './MWLoader';
+export { Breadcrumb, BreadcrumbItem, BreadcrumbSeparator } from './Breadcrumb';
+export { Pagination } from './Pagination';
+export { Menu, MenuItem, MenuSeparator, MenuGroup, MenuCheckboxItem, MenuRadioGroup, MenuRadioItem } from './Menu';
+export { DropdownMenu, DropdownMenuTrigger, DropdownMenuContent, DropdownMenuItem, DropdownMenuSeparator, DropdownMenuLabel, } from './DropdownMenu';
+export { RadioGroup, RadioGroupItem } from './RadioGroup';
+export type { RadioGroupProps, RadioGroupItemProps } from './RadioGroup';
+export { StatusBadge } from './StatusBadge';
+export type { StatusBadgeProps } from './StatusBadge';
+export { TreeView, findTreeNode, getAllNodeIds, getParentIds } from './TreeView';
+export { Modal, ModalHeader, ModalBody, ModalFooter } from './Modal';
+export { Dialog, DialogContent, DialogHeader, DialogFooter, DialogTitle, DialogDescription, DialogTrigger } from './Dialog';
+export { Sheet, SheetContent, SheetHeader, SheetFooter, SheetTitle, SheetDescription, SheetTrigger } from './Sheet';
+export { ConfirmSheet } from './ConfirmSheet';
+export type { ConfirmSheetProps } from './ConfirmSheet';
+export { Popover, PopoverTrigger, PopoverContent } from './Popover';
+export { Dropdown, DropdownTrigger, DropdownContent, DropdownItem, DropdownSeparator } from './Dropdown';
+export { Tooltip } from './Tooltip';
+export { ToastProvider, useToast } from './Toast';
+export type { Toast } from './Toast';
+export { Command, CommandGroup, CommandItem, CommandSeparator } from './Command';
+export { Calendar } from './Calendar';
+export { SnackbarProvider, useSnackbar, useSnackbarHelpers } from './Snackbar';
+export { PanelGroup, Panel, PanelResizer, PanelHeader, SplitPanel, StackPanel, SidebarPanel } from './Panel';
+export { Notification, NotificationList, NotificationBadge, NotificationBell } from './Notification';
+export { DataGrid } from './DataGrid';
+export type { DataGridColumn, DataGridSort, DataGridFilter, DataGridSelection } from './DataGrid';
+export { Thumbnail, VideoThumbnail, ImageThumbnail, ThumbnailGallery } from './Thumbnail';
+export { Image } from './Image';
+export type { ImageProps } from './Image';
+export { DragDrop, SortableList, useDragDrop } from './DragDrop';
+export { Heading, Text, Label, Display } from './Typography';
+export type { HeadingProps, TextProps, LabelProps, DisplayProps } from './Typography';
+export { AgGridTable } from './AgGridTable';
+export type { AgGridSortState, AgGridSortDirection, AgGridTableProps, AgGridTableServerSideConfig, ColDef } from './AgGridTable';
+export { PageHeader } from './PageHeader';
+export type { PageHeaderProps } from './PageHeader';
+export { AppHeader, SidebarToggleButton } from './AppHeader';
+export type { AppHeaderProps } from './AppHeader';
+export { ColumnCustomizationDrawer } from './ColumnCustomizationDrawer';
+export type { ColumnConfig, ColumnCustomizationDrawerProps } from './ColumnCustomizationDrawer';

package/dist/src/data/enhanced-icons.d.ts

@@ -0,0 +1,49 @@
+export interface EnhancedIconCategory {
+    name: string;
+    description: string;
+    icons: string[];
+    totalAvailable?: number;
+    priority: 'high' | 'medium' | 'low';
+}
+export interface PopularIcon {
+    name: string;
+    category: string;
+    usage: number;
+    trending: boolean;
+}
+export interface EnhancedIconsData {
+    curated: {
+        categories: Record<string, EnhancedIconCategory>;
+        totalIcons: number;
+        allIcons: string[];
+    };
+    popular: {
+        featured: string[];
+        byCategory: Record<string, string[]>;
+        trending: string[];
+    };
+    complete: {
+        totalIcons: number;
+        totalCategories: number;
+        categories: string[];
+        searchIndex?: any;
+    };
+    navigation: {
+        quickAccess: string[];
+        beginner: string[];
+        advanced: string[];
+    };
+}
+export declare function getEnhancedIconsData(): EnhancedIconsData;
+export declare function searchEnhancedIcons(query: string, scope?: 'curated' | 'popular' | 'complete', limit?: number): {
+    icons: string[];
+    scope: string;
+    total: number;
+};
+export declare function getIconsByCategory(categoryKey: string, level?: 'curated' | 'popular' | 'complete'): {
+    icons: string[];
+    hasMore: boolean;
+    total: number;
+};
+export declare function trackIconUsage(iconName: string, context: string): void;
+export declare function getIconRecommendations(currentIcons: string[], context?: string): string[];

package/dist/src/data/icons.d.ts

@@ -0,0 +1,17 @@
+export interface IconCategory {
+    name: string;
+    description: string;
+    icons: string[];
+}
+export interface IconsData {
+    categories: Record<string, IconCategory>;
+    totalIcons: number;
+    allIcons: string[];
+    metadata: {
+        totalIcons: number;
+    };
+}
+export declare function getIconsData(): IconsData;
+export declare function searchIcons(query: string, limit?: number): string[];
+export declare function getIconsByCategory(categoryId: string): string[];
+export declare function getIconCategory(iconName: string): IconCategory | null;

package/dist/src/hooks/index.d.ts

@@ -0,0 +1,2 @@
+export { useIconSearch } from './useIconSearch';
+export { useKeyboardShortcuts } from './useKeyboardShortcuts';

package/dist/src/hooks/useIconSearch.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Custom hook for searching icons with optimized performance
+ * Supports both technical names and formatted names
+ */
+export declare function useIconSearch(): {
+    searchIcons: (query: string, limit?: number) => string[];
+};

package/dist/src/hooks/useKeyboardShortcuts.d.ts

@@ -0,0 +1,38 @@
+export interface KeyboardShortcut {
+    key: string;
+    ctrlKey?: boolean;
+    metaKey?: boolean;
+    shiftKey?: boolean;
+    altKey?: boolean;
+    description: string;
+    action: () => void;
+}
+export interface ShortcutGroup {
+    name: string;
+    shortcuts: KeyboardShortcut[];
+}
+export declare function useKeyboardShortcuts(): {
+    shortcuts: KeyboardShortcut[];
+    isHelpOpen: boolean;
+    lastPressedKey: string;
+    addShortcut: (shortcut: KeyboardShortcut) => void;
+    removeShortcut: (key: string) => void;
+    clearShortcuts: () => void;
+    toggleHelp: () => void;
+    getShortcutGroups: () => ShortcutGroup[];
+};
+export declare function useIconKeyboardShortcuts({ onCopyAsSVG, onCopyAsJSX, onCopyAsImport, onDownload, onToggleFavorite, onToggleCustomization, onToggleHistory, onSearch, onEscape }: {
+    onCopyAsSVG?: () => void;
+    onCopyAsJSX?: () => void;
+    onCopyAsImport?: () => void;
+    onDownload?: () => void;
+    onToggleFavorite?: () => void;
+    onToggleCustomization?: () => void;
+    onToggleHistory?: () => void;
+    onSearch?: () => void;
+    onEscape?: () => void;
+}): {
+    getShortcutGroups: () => ShortcutGroup[];
+    isHelpOpen: boolean;
+    toggleHelp: () => void;
+};

package/dist/src/index.d.ts

@@ -0,0 +1,6 @@
+export * from './components';
+export * from './tokens';
+export { cn, formatIconName, generateIconCode, debounce, hexToRgb, generateColorVariations } from './utils';
+export { useIconSearch, useKeyboardShortcuts } from './hooks';
+export type * from './types';
+export declare const version = "1.0.0";

package/dist/src/lib/lucide-icons.d.ts

@@ -0,0 +1,83 @@
+export type LucideIconComponent = React.ComponentType<{
+    size?: number;
+    className?: string;
+    strokeWidth?: number;
+}> | React.ForwardRefExoticComponent<{
+    size?: number;
+    className?: string;
+    strokeWidth?: number;
+} & React.RefAttributes<SVGSVGElement>>;
+export interface LucideIconInfo {
+    name: string;
+    component: LucideIconComponent;
+    category: string;
+    keywords?: string[];
+}
+export interface LucideCategory {
+    name: string;
+    description: string;
+    icons: string[];
+}
+/**
+ * Get a Lucide icon component by name
+ */
+export declare function getLucideIcon(iconName: string): LucideIconComponent | null;
+/**
+ * Get all available Lucide icon names
+ */
+export declare function getAllLucideIconNames(): string[];
+/**
+ * Get Lucide icons by category
+ */
+export declare function getLucideIconsByCategory(categoryKey: string): string[];
+/**
+ * Get all Lucide categories
+ */
+export declare function getAllLucideCategories(): Record<string, LucideCategory>;
+/**
+ * Search Lucide icons by name or keywords
+ */
+export declare function searchLucideIcons(query: string, limit?: number): LucideIconInfo[];
+/**
+ * Get icon information including component and metadata
+ */
+export declare function getLucideIconInfo(iconName: string): LucideIconInfo | null;
+/**
+ * Check if an icon exists in the Lucide library
+ */
+export declare function isValidLucideIcon(iconName: string): boolean;
+/**
+ * Get random Lucide icons for showcase
+ */
+export declare function getRandomLucideIcons(count?: number): LucideIconInfo[];
+/**
+ * Get popular/featured icons from each category
+ */
+export declare function getFeaturedLucideIcons(): Record<string, LucideIconInfo[]>;
+/**
+ * Get Lucide library metadata
+ */
+export declare function getLucideMetadata(): {
+    totalIcons: number;
+    totalCategories: number;
+    version: string;
+    generatedAt: string;
+};
+/**
+ * Batch load icon components (for performance)
+ */
+export declare function preloadLucideIcons(iconNames: string[]): void;
+declare const _default: {
+    getAllLucideIconNames: typeof getAllLucideIconNames;
+    getLucideIcon: typeof getLucideIcon;
+    getLucideIconsByCategory: typeof getLucideIconsByCategory;
+    getAllLucideCategories: typeof getAllLucideCategories;
+    searchLucideIcons: typeof searchLucideIcons;
+    getLucideIconInfo: typeof getLucideIconInfo;
+    isValidLucideIcon: typeof isValidLucideIcon;
+    getRandomLucideIcons: typeof getRandomLucideIcons;
+    getFeaturedLucideIcons: typeof getFeaturedLucideIcons;
+    getLucideMetadata: typeof getLucideMetadata;
+    preloadLucideIcons: typeof preloadLucideIcons;
+};
+export default _default;

package/dist/src/stories/Button.d.ts

@@ -0,0 +1,15 @@
+import './button.css';
+export interface ButtonProps {
+    /** Is this the principal call to action on the page? */
+    primary?: boolean;
+    /** What background color to use */
+    backgroundColor?: string;
+    /** How large should the button be? */
+    size?: 'small' | 'medium' | 'large';
+    /** Button contents */
+    label: string;
+    /** Optional click handler */
+    onClick?: () => void;
+}
+/** Primary UI component for user interaction */
+export declare const Button: ({ primary, size, backgroundColor, label, ...props }: ButtonProps) => import("react/jsx-runtime").JSX.Element;

package/dist/src/stories/Header.d.ts

@@ -0,0 +1,12 @@
+import './header.css';
+type User = {
+    name: string;
+};
+export interface HeaderProps {
+    user?: User;
+    onLogin?: () => void;
+    onLogout?: () => void;
+    onCreateAccount?: () => void;
+}
+export declare const Header: ({ user, onLogin, onLogout, onCreateAccount }: HeaderProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/src/stories/Page.d.ts

@@ -0,0 +1,3 @@
+import React from 'react';
+import './page.css';
+export declare const Page: React.FC;

package/dist/src/test/setup.d.ts

@@ -0,0 +1 @@
+import '@testing-library/jest-dom';

package/dist/src/test/test-utils.d.ts

@@ -0,0 +1,5 @@
+import { ReactElement } from 'react';
+import { RenderOptions } from '@testing-library/react';
+declare function customRender(ui: ReactElement, options?: Omit<RenderOptions, 'wrapper'>): import("@testing-library/react").RenderResult<typeof import("@testing-library/dom/types/queries"), HTMLElement, HTMLElement>;
+export * from '@testing-library/react';
+export { customRender as render };