@moving-walls/design-system 1.0.0

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

@@ -0,0 +1,44 @@
+export interface SelectProps extends React.SelectHTMLAttributes<HTMLSelectElement> {
+    label?: string;
+    description?: string;
+    error?: string;
+    options: Array<{
+        value: string;
+        label: string;
+        disabled?: boolean;
+    }>;
+    placeholder?: string;
+}
+export declare const Select: import("react").ForwardRefExoticComponent<SelectProps & import("react").RefAttributes<HTMLSelectElement>>;
+export interface SelectTriggerProps extends React.ButtonHTMLAttributes<HTMLButtonElement> {
+    children?: React.ReactNode;
+}
+export declare const SelectTrigger: import("react").ForwardRefExoticComponent<SelectTriggerProps & import("react").RefAttributes<HTMLButtonElement>>;
+export interface SelectValueProps {
+    placeholder?: string;
+    children?: React.ReactNode;
+}
+export declare function SelectValue({ placeholder, children }: SelectValueProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace SelectValue {
+    var displayName: string;
+}
+export interface SelectContentProps extends React.HTMLAttributes<HTMLDivElement> {
+    children?: React.ReactNode;
+}
+export declare const SelectContent: import("react").ForwardRefExoticComponent<SelectContentProps & import("react").RefAttributes<HTMLDivElement>>;
+export interface SelectItemProps extends React.HTMLAttributes<HTMLDivElement> {
+    value: string;
+    children?: React.ReactNode;
+}
+export declare const SelectItem: import("react").ForwardRefExoticComponent<SelectItemProps & import("react").RefAttributes<HTMLDivElement>>;
+export interface SelectGroupProps extends React.HTMLAttributes<HTMLDivElement> {
+    children?: React.ReactNode;
+}
+export declare const SelectGroup: import("react").ForwardRefExoticComponent<SelectGroupProps & import("react").RefAttributes<HTMLDivElement>>;
+export interface SelectLabelProps extends React.HTMLAttributes<HTMLDivElement> {
+    children?: React.ReactNode;
+}
+export declare const SelectLabel: import("react").ForwardRefExoticComponent<SelectLabelProps & import("react").RefAttributes<HTMLDivElement>>;
+export interface SelectSeparatorProps extends React.HTMLAttributes<HTMLDivElement> {
+}
+export declare const SelectSeparator: import("react").ForwardRefExoticComponent<SelectSeparatorProps & import("react").RefAttributes<HTMLDivElement>>;

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

@@ -0,0 +1,6 @@
+export interface SeparatorProps extends React.HTMLAttributes<HTMLDivElement> {
+    orientation?: 'horizontal' | 'vertical';
+    variant?: 'default' | 'dashed' | 'dotted';
+    spacing?: 'none' | 'sm' | 'md' | 'lg';
+}
+export declare const Separator: import("react").ForwardRefExoticComponent<SeparatorProps & import("react").RefAttributes<HTMLDivElement>>;

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

@@ -0,0 +1,41 @@
+import React from "react";
+export interface SheetProps {
+    open?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    children: React.ReactNode;
+}
+export interface SheetTriggerProps extends React.HTMLAttributes<HTMLElement> {
+    asChild?: boolean;
+    children: React.ReactNode;
+}
+export interface SheetContentProps extends React.HTMLAttributes<HTMLDivElement> {
+    side?: "top" | "right" | "bottom" | "left";
+    size?: "sm" | "md" | "lg" | "xl" | "2xl" | "3xl" | "full";
+    children: React.ReactNode;
+}
+export interface SheetHeaderProps extends React.HTMLAttributes<HTMLDivElement> {
+    children: React.ReactNode;
+}
+export interface SheetFooterProps extends React.HTMLAttributes<HTMLDivElement> {
+    children: React.ReactNode;
+}
+export interface SheetTitleProps extends React.HTMLAttributes<HTMLHeadingElement> {
+    children: React.ReactNode;
+}
+export interface SheetDescriptionProps extends React.HTMLAttributes<HTMLParagraphElement> {
+    children: React.ReactNode;
+}
+export declare function Sheet({ open, onOpenChange, children }: SheetProps): import("react/jsx-runtime").JSX.Element;
+export declare function SheetTrigger({ asChild, children, onClick, ...props }: SheetTriggerProps): import("react/jsx-runtime").JSX.Element;
+export declare function SheetContent({ side, size, className, children, ...props }: SheetContentProps): React.ReactPortal | null;
+export declare function SheetHeader({ children, className, ...props }: SheetHeaderProps): import("react/jsx-runtime").JSX.Element;
+export declare function SheetFooter({ children, className, ...props }: SheetFooterProps): import("react/jsx-runtime").JSX.Element;
+export declare function SheetTitle({ children, className, ...props }: SheetTitleProps): import("react/jsx-runtime").JSX.Element;
+export declare function SheetDescription({ children, className, ...props }: SheetDescriptionProps): import("react/jsx-runtime").JSX.Element;
+export declare function useSheet(): {
+    open: boolean;
+    setOpen: React.Dispatch<React.SetStateAction<boolean>>;
+    onOpenChange: React.Dispatch<React.SetStateAction<boolean>>;
+    close: () => void;
+    toggle: () => void;
+};

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

@@ -0,0 +1,91 @@
+import React from 'react';
+type SidebarState = 'expanded' | 'collapsed';
+interface SidebarContextValue {
+    state: SidebarState;
+    isCollapsed: boolean;
+    toggle: () => void;
+    expand: () => void;
+    collapse: () => void;
+}
+export declare function useSidebar(): SidebarContextValue;
+export declare function useSidebarSafe(): SidebarContextValue | null;
+export interface SidebarProviderProps {
+    children: React.ReactNode;
+    defaultCollapsed?: boolean;
+    onStateChange?: (state: SidebarState) => void;
+}
+export declare function SidebarProvider({ children, defaultCollapsed, onStateChange, }: SidebarProviderProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace SidebarProvider {
+    var displayName: string;
+}
+export interface SidebarProps extends React.HTMLAttributes<HTMLElement> {
+    children: React.ReactNode;
+    variant?: 'default' | 'persistent' | 'overlay';
+}
+export declare function Sidebar({ children, className, variant, ...props }: SidebarProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace Sidebar {
+    var displayName: string;
+}
+export interface SidebarHeaderProps extends React.HTMLAttributes<HTMLDivElement> {
+    children: React.ReactNode;
+}
+export declare function SidebarHeader({ children, className, ...props }: SidebarHeaderProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace SidebarHeader {
+    var displayName: string;
+}
+export interface SidebarContentProps extends React.HTMLAttributes<HTMLDivElement> {
+    children: React.ReactNode;
+}
+export declare function SidebarContent({ children, className, ...props }: SidebarContentProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace SidebarContent {
+    var displayName: string;
+}
+export interface SidebarFooterProps extends React.HTMLAttributes<HTMLDivElement> {
+    children: React.ReactNode;
+}
+export declare function SidebarFooter({ children, className, ...props }: SidebarFooterProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace SidebarFooter {
+    var displayName: string;
+}
+export interface SidebarNavProps extends React.HTMLAttributes<HTMLElement> {
+    children: React.ReactNode;
+}
+export declare function SidebarNav({ children, className, ...props }: SidebarNavProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace SidebarNav {
+    var displayName: string;
+}
+export interface SidebarGroupProps extends React.HTMLAttributes<HTMLDivElement> {
+    title?: string;
+    children: React.ReactNode;
+}
+export declare function SidebarGroup({ title, children, className, ...props }: SidebarGroupProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace SidebarGroup {
+    var displayName: string;
+}
+export interface SidebarItemProps extends React.HTMLAttributes<HTMLElement> {
+    icon?: React.ReactNode;
+    label: string;
+    isActive?: boolean;
+    href?: string;
+    onClick?: () => void;
+    as?: React.ElementType;
+}
+export declare function SidebarItem({ icon, label, isActive, href, onClick, as, className, ...props }: SidebarItemProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace SidebarItem {
+    var displayName: string;
+}
+export interface SidebarCollapseToggleProps extends React.ButtonHTMLAttributes<HTMLButtonElement> {
+    expandLabel?: string;
+    collapseLabel?: string;
+}
+export declare function SidebarCollapseToggle({ expandLabel, collapseLabel, className, ...props }: SidebarCollapseToggleProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace SidebarCollapseToggle {
+    var displayName: string;
+}
+export interface SidebarTriggerProps extends React.ButtonHTMLAttributes<HTMLButtonElement> {
+}
+export declare function SidebarTrigger({ className, ...props }: SidebarTriggerProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace SidebarTrigger {
+    var displayName: string;
+}
+export {};

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

@@ -0,0 +1,8 @@
+export interface SkeletonProps extends React.HTMLAttributes<HTMLDivElement> {
+    variant?: 'text' | 'circular' | 'rectangular';
+    width?: string | number;
+    height?: string | number;
+    lines?: number;
+    animation?: 'pulse' | 'wave' | 'none';
+}
+export declare const Skeleton: import("react").ForwardRefExoticComponent<SkeletonProps & import("react").RefAttributes<HTMLDivElement>>;

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

@@ -0,0 +1,12 @@
+export interface SliderProps extends Omit<React.InputHTMLAttributes<HTMLInputElement>, 'type' | 'onChange'> {
+    label?: string;
+    min?: number;
+    max?: number;
+    step?: number;
+    value?: number;
+    defaultValue?: number;
+    onChange?: (value: number) => void;
+    showValue?: boolean;
+    formatValue?: (value: number) => string;
+}
+export declare function Slider({ className, label, min, max, step, value, defaultValue, onChange, showValue, formatValue, disabled, ...props }: SliderProps): import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,42 @@
+import React from 'react';
+export type SnackbarType = 'success' | 'error' | 'warning' | 'info';
+export type SnackbarPosition = 'top' | 'top-right' | 'top-left' | 'bottom' | 'bottom-right' | 'bottom-left';
+export interface SnackbarOptions {
+    id?: string;
+    type?: SnackbarType;
+    title?: string;
+    message: string;
+    duration?: number;
+    persistent?: boolean;
+    action?: {
+        label: string;
+        onClick: () => void;
+    };
+    onClose?: () => void;
+}
+interface SnackbarState extends Required<Omit<SnackbarOptions, 'action' | 'onClose'>> {
+    action?: SnackbarOptions['action'];
+    onClose?: SnackbarOptions['onClose'];
+    timestamp: number;
+}
+interface SnackbarContextValue {
+    snackbars: SnackbarState[];
+    show: (options: SnackbarOptions) => string;
+    dismiss: (id: string) => void;
+    dismissAll: () => void;
+}
+interface SnackbarProviderProps {
+    children: React.ReactNode;
+    position?: SnackbarPosition;
+    maxSnackbars?: number;
+    defaultDuration?: number;
+}
+export declare function SnackbarProvider({ children, position, maxSnackbars, defaultDuration }: SnackbarProviderProps): import("react/jsx-runtime").JSX.Element;
+export declare function useSnackbar(): SnackbarContextValue;
+export declare function useSnackbarHelpers(): {
+    success: (message: string, options?: Omit<SnackbarOptions, "message" | "type">) => string;
+    error: (message: string, options?: Omit<SnackbarOptions, "message" | "type">) => string;
+    warning: (message: string, options?: Omit<SnackbarOptions, "message" | "type">) => string;
+    info: (message: string, options?: Omit<SnackbarOptions, "message" | "type">) => string;
+};
+export {};

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

@@ -0,0 +1,12 @@
+export interface SpinnerProps extends React.HTMLAttributes<HTMLDivElement> {
+    size?: 'sm' | 'md' | 'lg' | 'xl';
+    variant?: 'default' | 'primary' | 'white';
+}
+export declare function Spinner({ className, size, variant, ...props }: SpinnerProps): import("react/jsx-runtime").JSX.Element;
+export interface LoadingProps extends React.HTMLAttributes<HTMLDivElement> {
+    size?: 'sm' | 'md' | 'lg' | 'xl';
+    variant?: 'default' | 'primary' | 'white';
+    text?: string;
+    overlay?: boolean;
+}
+export declare function Loading({ className, size, variant, text, overlay, ...props }: LoadingProps): import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,10 @@
+import React from 'react';
+export interface StatusBadgeProps {
+    status: 'active' | 'inactive' | 'pending' | 'success' | 'error' | 'warning' | 'info' | string;
+    children?: React.ReactNode;
+    className?: string;
+}
+export declare function StatusBadge({ status, children, className }: StatusBadgeProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace StatusBadge {
+    var displayName: string;
+}

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

@@ -0,0 +1,12 @@
+interface StepperProps {
+    steps: Array<{
+        title: string;
+        description?: string;
+        completed?: boolean;
+        current?: boolean;
+    }>;
+    orientation?: 'horizontal' | 'vertical';
+    className?: string;
+}
+export declare function Stepper({ steps, orientation, className }: StepperProps): import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,25 @@
+export interface SwitchProps extends Omit<React.InputHTMLAttributes<HTMLInputElement>, 'size'> {
+    label?: string;
+    description?: string;
+    error?: string;
+    size?: 'sm' | 'md' | 'lg';
+    variant?: 'default' | 'success' | 'warning' | 'danger';
+    loading?: boolean;
+    showIcons?: boolean;
+    onLabel?: string;
+    offLabel?: string;
+    thumbIcon?: React.ReactNode;
+    trackIcon?: React.ReactNode;
+    animate?: boolean;
+    immediate?: boolean;
+}
+export declare const Switch: import("react").ForwardRefExoticComponent<SwitchProps & import("react").RefAttributes<HTMLInputElement>>;
+interface SwitchGroupProps {
+    label?: string;
+    description?: string;
+    children: React.ReactNode;
+    orientation?: 'horizontal' | 'vertical';
+    className?: string;
+}
+export declare function SwitchGroup({ label, description, children, orientation, className }: SwitchGroupProps): import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,32 @@
+export interface TableProps extends React.HTMLAttributes<HTMLTableElement> {
+    striped?: boolean;
+    hoverable?: boolean;
+    size?: 'sm' | 'md' | 'lg';
+}
+export interface TableHeaderProps extends React.HTMLAttributes<HTMLTableSectionElement> {
+}
+export interface TableBodyProps extends React.HTMLAttributes<HTMLTableSectionElement> {
+}
+export interface TableRowProps extends React.HTMLAttributes<HTMLTableRowElement> {
+}
+export interface TableHeadProps extends React.HTMLAttributes<HTMLTableCellElement> {
+    sortable?: boolean;
+    sortDirection?: 'asc' | 'desc' | 'none';
+    onSort?: () => void;
+}
+export interface TableCellProps extends React.HTMLAttributes<HTMLTableCellElement> {
+}
+export declare function Table({ className, striped, hoverable, size, children, ...props }: TableProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace Table {
+    var Header: typeof TableHeader;
+    var Body: typeof TableBody;
+    var Row: typeof TableRow;
+    var Head: typeof TableHead;
+    var Cell: typeof TableCell;
+}
+export declare function TableHeader({ className, children, ...props }: TableHeaderProps): import("react/jsx-runtime").JSX.Element;
+export declare function TableBody({ className, children, ...props }: TableBodyProps): import("react/jsx-runtime").JSX.Element;
+export declare function TableRow({ className, children, ...props }: TableRowProps): import("react/jsx-runtime").JSX.Element;
+export declare function TableHead({ className, sortable, sortDirection, onSort, children, ...props }: TableHeadProps): import("react/jsx-runtime").JSX.Element;
+export declare function TableCell({ className, children, ...props }: TableCellProps): import("react/jsx-runtime").JSX.Element;
+export default Table;

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

@@ -0,0 +1,27 @@
+import React from 'react';
+export interface TabsProps {
+    defaultValue?: string;
+    value?: string;
+    onValueChange?: (value: string) => void;
+    children: React.ReactNode;
+    className?: string;
+}
+export interface TabsListProps {
+    children: React.ReactNode;
+    className?: string;
+}
+export interface TabsTriggerProps {
+    value: string;
+    children: React.ReactNode;
+    className?: string;
+    disabled?: boolean;
+}
+export interface TabsContentProps {
+    value: string;
+    children: React.ReactNode;
+    className?: string;
+}
+export declare function Tabs({ defaultValue, value, onValueChange, children, className }: TabsProps): import("react/jsx-runtime").JSX.Element;
+export declare function TabsList({ children, className }: TabsListProps): import("react/jsx-runtime").JSX.Element;
+export declare function TabsTrigger({ value, children, className, disabled }: TabsTriggerProps): import("react/jsx-runtime").JSX.Element;
+export declare function TabsContent({ value, children, className }: TabsContentProps): import("react/jsx-runtime").JSX.Element | null;

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

@@ -0,0 +1,7 @@
+export interface TextareaProps extends React.TextareaHTMLAttributes<HTMLTextAreaElement> {
+    label?: string;
+    error?: string;
+    helpText?: string;
+    resize?: 'none' | 'vertical' | 'horizontal' | 'both';
+}
+export declare const Textarea: import("react").ForwardRefExoticComponent<TextareaProps & import("react").RefAttributes<HTMLTextAreaElement>>;

package/dist/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/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/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/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/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/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/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/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/components/ui/Typography.d.ts

@@ -0,0 +1,36 @@
+import React from 'react';
+export interface HeadingProps extends React.HTMLAttributes<HTMLHeadingElement> {
+    level?: 1 | 2 | 3 | 4 | 5 | 6;
+    children: React.ReactNode;
+    className?: string;
+}
+export declare function Heading({ level, children, className, ...props }: HeadingProps): import("react/jsx-runtime").JSX.Element;
+type TextBaseProps = {
+    size?: '2xs' | 'xs' | 'sm' | 'base' | 'lg' | 'xl';
+    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 {};